Removed "_" from API functions.

dstogov · dstogov · commit ce18738a30b3 · 2017-11-16T17:09:01.000+03:00
diff --git a/Zend/zend.c b/Zend/zend.c
@@ -314,7 +314,7 @@ ZEND_API int zend_make_printable_zval(zval *expr, zval *expr_copy) /* {{{ */
 	if (Z_TYPE_P(expr) == IS_STRING) {
 		return 0;
 	} else {
-		ZVAL_STR(expr_copy, _zval_get_string_func(expr));
+		ZVAL_STR(expr_copy, zval_get_string_func(expr));
 		return 1;
 	}
 }
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
@@ -1096,7 +1096,7 @@ static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type
 				break;
 		}
 
-		offset = _zval_get_long_func(dim);
+		offset = zval_get_long_func(dim);
 	} else {
 		offset = Z_LVAL_P(dim);
 	}
@@ -1769,7 +1769,7 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z
 					break;
 			}
 
-			offset = _zval_get_long_func(dim);
+			offset = zval_get_long_func(dim);
 		} else {
 			offset = Z_LVAL_P(dim);
 		}
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
@@ -788,7 +788,7 @@ static zend_always_inline zend_long ZEND_FASTCALL _zval_get_long_func_ex(zval *o
 }
 /* }}} */
 
-ZEND_API zend_long ZEND_FASTCALL _zval_get_long_func(zval *op) /* {{{ */
+ZEND_API zend_long ZEND_FASTCALL zval_get_long_func(zval *op) /* {{{ */
 {
 	return _zval_get_long_func_ex(op, 1);
 }
@@ -800,7 +800,7 @@ static zend_long ZEND_FASTCALL _zval_get_long_func_noisy(zval *op) /* {{{ */
 }
 /* }}} */
 
-ZEND_API double ZEND_FASTCALL _zval_get_double_func(zval *op) /* {{{ */
+ZEND_API double ZEND_FASTCALL zval_get_double_func(zval *op) /* {{{ */
 {
 try_again:
 	switch (Z_TYPE_P(op)) {
@@ -839,7 +839,7 @@ ZEND_API double ZEND_FASTCALL _zval_get_double_func(zval *op) /* {{{ */
 }
 /* }}} */
 
-ZEND_API zend_string* ZEND_FASTCALL _zval_get_string_func(zval *op) /* {{{ */
+ZEND_API zend_string* ZEND_FASTCALL zval_get_string_func(zval *op) /* {{{ */
 {
 try_again:
 	switch (Z_TYPE_P(op)) {
diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
@@ -259,23 +259,27 @@ ZEND_API void multi_convert_to_long_ex(int argc, ...);
 ZEND_API void multi_convert_to_double_ex(int argc, ...);
 ZEND_API void multi_convert_to_string_ex(int argc, ...);
 
-ZEND_API zend_long    ZEND_FASTCALL _zval_get_long_func(zval *op);
-ZEND_API double       ZEND_FASTCALL _zval_get_double_func(zval *op);
-ZEND_API zend_string* ZEND_FASTCALL _zval_get_string_func(zval *op);
+ZEND_API zend_long    ZEND_FASTCALL zval_get_long_func(zval *op);
+ZEND_API double       ZEND_FASTCALL zval_get_double_func(zval *op);
+ZEND_API zend_string* ZEND_FASTCALL zval_get_string_func(zval *op);
 
-static zend_always_inline zend_long _zval_get_long(zval *op) {
-	return Z_TYPE_P(op) == IS_LONG ? Z_LVAL_P(op) : _zval_get_long_func(op);
+static zend_always_inline zend_long zval_get_long(zval *op) {
+	return EXPECTED(Z_TYPE_P(op) == IS_LONG) ? Z_LVAL_P(op) : zval_get_long_func(op);
 }
-static zend_always_inline double _zval_get_double(zval *op) {
-	return Z_TYPE_P(op) == IS_DOUBLE ? Z_DVAL_P(op) : _zval_get_double_func(op);
+static zend_always_inline double zval_get_double(zval *op) {
+	return EXPECTED(Z_TYPE_P(op) == IS_DOUBLE) ? Z_DVAL_P(op) : zval_get_double_func(op);
 }
-static zend_always_inline zend_string *_zval_get_string(zval *op) {
-	return Z_TYPE_P(op) == IS_STRING ? zend_string_copy(Z_STR_P(op)) : _zval_get_string_func(op);
+static zend_always_inline zend_string *zval_get_string(zval *op) {
+	return EXPECTED(Z_TYPE_P(op) == IS_STRING) ? zend_string_copy(Z_STR_P(op)) : zval_get_string_func(op);
 }
 
-#define zval_get_long(op) _zval_get_long((op))
-#define zval_get_double(op) _zval_get_double((op))
-#define zval_get_string(op) _zval_get_string((op))
+/* Compatibility macros for 7.2 and below */
+#define _zval_get_long(op) zval_get_long(op)
+#define _zval_get_double(op) zval_get_double(op)
+#define _zval_get_string(op) zval_get_string(op)
+#define _zval_get_long_func(op) zval_get_long_func(op)
+#define _zval_get_double_func(op) zval_get_double_func(op)
+#define _zval_get_string_func(op) zval_get_string_func(op)
 
 #define convert_to_cstring(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_cstring((op) ZEND_FILE_LINE_CC); }
 #define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op) ZEND_FILE_LINE_CC); }
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -1359,7 +1359,7 @@ ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMPVAR|CV, ANY)
 			zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
 		}
 	} else {
-		zend_string *str = _zval_get_string_func(z);
+		zend_string *str = zval_get_string_func(z);
 
 		if (ZSTR_LEN(str) != 0) {
 			zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
@@ -2769,7 +2769,7 @@ ZEND_VM_HANDLER(53, ZEND_FAST_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
 			GET_OP1_UNDEF_CV(op1, BP_VAR_R);
 		}
-		op1_str = _zval_get_string_func(op1);
+		op1_str = zval_get_string_func(op1);
 	}
 	if (OP2_TYPE == IS_CONST) {
 		op2_str = Z_STR_P(op2);
@@ -2779,7 +2779,7 @@ ZEND_VM_HANDLER(53, ZEND_FAST_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
 		if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
 			GET_OP2_UNDEF_CV(op2, BP_VAR_R);
 		}
-		op2_str = _zval_get_string_func(op2);
+		op2_str = zval_get_string_func(op2);
 	}
 	do {
 		if (OP1_TYPE != IS_CONST) {
@@ -2843,7 +2843,7 @@ ZEND_VM_HANDLER(54, ZEND_ROPE_INIT, UNUSED, CONST|TMPVAR|CV, NUM)
 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
 				GET_OP2_UNDEF_CV(var, BP_VAR_R);
 			}
-			rope[0] = _zval_get_string_func(var);
+			rope[0] = zval_get_string_func(var);
 			FREE_OP2();
 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 		}
@@ -2876,7 +2876,7 @@ ZEND_VM_HANDLER(55, ZEND_ROPE_ADD, TMP, CONST|TMPVAR|CV, NUM)
 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
 				GET_OP2_UNDEF_CV(var, BP_VAR_R);
 			}
-			rope[opline->extended_value] = _zval_get_string_func(var);
+			rope[opline->extended_value] = zval_get_string_func(var);
 			FREE_OP2();
 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 		}
@@ -2911,7 +2911,7 @@ ZEND_VM_HANDLER(56, ZEND_ROPE_END, TMP, CONST|TMPVAR|CV, NUM)
 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
 				GET_OP2_UNDEF_CV(var, BP_VAR_R);
 			}
-			rope[opline->extended_value] = _zval_get_string_func(var);
+			rope[opline->extended_value] = zval_get_string_func(var);
 			FREE_OP2();
 			if (UNEXPECTED(EG(exception))) {
 				for (i = 0; i <= opline->extended_value; i++) {
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h

Original file line number	Diff line number	Diff line change
`@@ -314,7 +314,7 @@ ZEND_API int zend_make_printable_zval(zval expr, zval expr_copy) /* {{{ */`
`314`	`314`	`if (Z_TYPE_P(expr) == IS_STRING) {`
`315`	`315`	`return 0;`
`316`	`316`	`} else {`
`317`		`- ZVAL_STR(expr_copy, _zval_get_string_func(expr));`
	`317`	`+ ZVAL_STR(expr_copy, zval_get_string_func(expr));`
`318`	`318`	`return 1;`
`319`	`319`	`}`
`320`	`320`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1096,7 +1096,7 @@ static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type`
`1096`	`1096`	`break;`
`1097`	`1097`	`}`
`1098`	`1098`
`1099`		`- offset = _zval_get_long_func(dim);`
	`1099`	`+ offset = zval_get_long_func(dim);`
`1100`	`1100`	`} else {`
`1101`	`1101`	`offset = Z_LVAL_P(dim);`
`1102`	`1102`	`}`
`@@ -1769,7 +1769,7 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z`
`1769`	`1769`	`break;`
`1770`	`1770`	`}`
`1771`	`1771`
`1772`		`- offset = _zval_get_long_func(dim);`
	`1772`	`+ offset = zval_get_long_func(dim);`
`1773`	`1773`	`} else {`
`1774`	`1774`	`offset = Z_LVAL_P(dim);`
`1775`	`1775`	`}`
Original file line number	Diff line number	Diff line change
`@@ -788,7 +788,7 @@ static zend_always_inline zend_long ZEND_FASTCALL _zval_get_long_func_ex(zval *o`
`788`	`788`	`}`
`789`	`789`	`/* }}} */`
`790`	`790`
`791`		`-ZEND_API zend_long ZEND_FASTCALL _zval_get_long_func(zval op) / {{{ */`
	`791`	`+ZEND_API zend_long ZEND_FASTCALL zval_get_long_func(zval op) / {{{ */`
`792`	`792`	`{`
`793`	`793`	`return _zval_get_long_func_ex(op, 1);`
`794`	`794`	`}`
`@@ -800,7 +800,7 @@ static zend_long ZEND_FASTCALL _zval_get_long_func_noisy(zval op) / {{{ */`
`800`	`800`	`}`
`801`	`801`	`/* }}} */`
`802`	`802`
`803`		`-ZEND_API double ZEND_FASTCALL _zval_get_double_func(zval op) / {{{ */`
	`803`	`+ZEND_API double ZEND_FASTCALL zval_get_double_func(zval op) / {{{ */`
`804`	`804`	`{`
`805`	`805`	`try_again:`
`806`	`806`	`switch (Z_TYPE_P(op)) {`
`@@ -839,7 +839,7 @@ ZEND_API double ZEND_FASTCALL _zval_get_double_func(zval op) / {{{ */`
`839`	`839`	`}`
`840`	`840`	`/* }}} */`
`841`	`841`
`842`		`-ZEND_API zend_string* ZEND_FASTCALL _zval_get_string_func(zval op) / {{{ */`
	`842`	`+ZEND_API zend_string* ZEND_FASTCALL zval_get_string_func(zval op) / {{{ */`
`843`	`843`	`{`
`844`	`844`	`try_again:`
`845`	`845`	`switch (Z_TYPE_P(op)) {`
Original file line number	Diff line number	Diff line change
`@@ -1359,7 +1359,7 @@ ZEND_VM_HANDLER(40, ZEND_ECHO, CONST\|TMPVAR\|CV, ANY)`
`1359`	`1359`	`zend_write(ZSTR_VAL(str), ZSTR_LEN(str));`
`1360`	`1360`	`}`
`1361`	`1361`	`} else {`
`1362`		`- zend_string *str = _zval_get_string_func(z);`
	`1362`	`+ zend_string *str = zval_get_string_func(z);`
`1363`	`1363`
`1364`	`1364`	`if (ZSTR_LEN(str) != 0) {`
`1365`	`1365`	`zend_write(ZSTR_VAL(str), ZSTR_LEN(str));`
`@@ -2769,7 +2769,7 @@ ZEND_VM_HANDLER(53, ZEND_FAST_CONCAT, CONST\|TMPVAR\|CV, CONST\|TMPVAR\|CV)`
`2769`	`2769`	`if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {`
`2770`	`2770`	`GET_OP1_UNDEF_CV(op1, BP_VAR_R);`
`2771`	`2771`	`}`
`2772`		`- op1_str = _zval_get_string_func(op1);`
	`2772`	`+ op1_str = zval_get_string_func(op1);`
`2773`	`2773`	`}`
`2774`	`2774`	`if (OP2_TYPE == IS_CONST) {`
`2775`	`2775`	`op2_str = Z_STR_P(op2);`
`@@ -2779,7 +2779,7 @@ ZEND_VM_HANDLER(53, ZEND_FAST_CONCAT, CONST\|TMPVAR\|CV, CONST\|TMPVAR\|CV)`
`2779`	`2779`	`if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {`
`2780`	`2780`	`GET_OP2_UNDEF_CV(op2, BP_VAR_R);`
`2781`	`2781`	`}`
`2782`		`- op2_str = _zval_get_string_func(op2);`
	`2782`	`+ op2_str = zval_get_string_func(op2);`
`2783`	`2783`	`}`
`2784`	`2784`	`do {`
`2785`	`2785`	`if (OP1_TYPE != IS_CONST) {`
`@@ -2843,7 +2843,7 @@ ZEND_VM_HANDLER(54, ZEND_ROPE_INIT, UNUSED, CONST\|TMPVAR\|CV, NUM)`
`2843`	`2843`	`if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {`
`2844`	`2844`	`GET_OP2_UNDEF_CV(var, BP_VAR_R);`
`2845`	`2845`	`}`
`2846`		`- rope[0] = _zval_get_string_func(var);`
	`2846`	`+ rope[0] = zval_get_string_func(var);`
`2847`	`2847`	`FREE_OP2();`
`2848`	`2848`	`ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();`
`2849`	`2849`	`}`
`@@ -2876,7 +2876,7 @@ ZEND_VM_HANDLER(55, ZEND_ROPE_ADD, TMP, CONST\|TMPVAR\|CV, NUM)`
`2876`	`2876`	`if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {`
`2877`	`2877`	`GET_OP2_UNDEF_CV(var, BP_VAR_R);`
`2878`	`2878`	`}`
`2879`		`- rope[opline->extended_value] = _zval_get_string_func(var);`
	`2879`	`+ rope[opline->extended_value] = zval_get_string_func(var);`
`2880`	`2880`	`FREE_OP2();`
`2881`	`2881`	`ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();`
`2882`	`2882`	`}`
`@@ -2911,7 +2911,7 @@ ZEND_VM_HANDLER(56, ZEND_ROPE_END, TMP, CONST\|TMPVAR\|CV, NUM)`
`2911`	`2911`	`if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {`
`2912`	`2912`	`GET_OP2_UNDEF_CV(var, BP_VAR_R);`
`2913`	`2913`	`}`
`2914`		`- rope[opline->extended_value] = _zval_get_string_func(var);`
	`2914`	`+ rope[opline->extended_value] = zval_get_string_func(var);`
`2915`	`2915`	`FREE_OP2();`
`2916`	`2916`	`if (UNEXPECTED(EG(exception))) {`
`2917`	`2917`	`for (i = 0; i <= opline->extended_value; i++) {`