mirror of
https://github.com/php/php-src.git
synced 2024-10-01 23:06:11 +00:00
446 lines
15 KiB
C
446 lines
15 KiB
C
/* pass 1
|
|
* - substitute persistent constants (true, false, null, etc)
|
|
* - perform compile-time evaluation of constant binary and unary operations
|
|
* - optimize series of ADD_STRING and/or ADD_CHAR
|
|
* - convert CAST(IS_BOOL,x) into BOOL(x)
|
|
*/
|
|
|
|
if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
|
|
int i = 0;
|
|
zend_op *opline = op_array->opcodes;
|
|
zend_op *end = opline + op_array->last;
|
|
zend_bool collect_constants = (op_array == &script->main_op_array);
|
|
|
|
while (opline < end) {
|
|
switch (opline->opcode) {
|
|
case ZEND_ADD:
|
|
case ZEND_SUB:
|
|
case ZEND_MUL:
|
|
case ZEND_DIV:
|
|
case ZEND_MOD:
|
|
case ZEND_SL:
|
|
case ZEND_SR:
|
|
case ZEND_CONCAT:
|
|
case ZEND_IS_EQUAL:
|
|
case ZEND_IS_NOT_EQUAL:
|
|
case ZEND_IS_SMALLER:
|
|
case ZEND_IS_SMALLER_OR_EQUAL:
|
|
case ZEND_IS_IDENTICAL:
|
|
case ZEND_IS_NOT_IDENTICAL:
|
|
case ZEND_BW_OR:
|
|
case ZEND_BW_AND:
|
|
case ZEND_BW_XOR:
|
|
case ZEND_BOOL_XOR:
|
|
if (ZEND_OP1_TYPE(opline) == IS_CONST &&
|
|
ZEND_OP2_TYPE(opline) == IS_CONST) {
|
|
/* binary operation with constant operands */
|
|
int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC) = get_binary_op(opline->opcode);
|
|
zend_uint tv = ZEND_RESULT(opline).var; /* temporary variable */
|
|
zval result;
|
|
zend_op *tmp_opline;
|
|
int er;
|
|
|
|
if (opline->opcode == ZEND_DIV &&
|
|
Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_LONG &&
|
|
Z_LVAL(ZEND_OP2_LITERAL(opline)) == 0) {
|
|
/* div by 0 */
|
|
break;
|
|
}
|
|
er = EG(error_reporting);
|
|
EG(error_reporting) = 0;
|
|
/* evaluate constant expression */
|
|
if (binary_op(&result, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline) TSRMLS_CC) != SUCCESS) {
|
|
EG(error_reporting) = er;
|
|
break;
|
|
}
|
|
EG(error_reporting) = er;
|
|
PZ_SET_REFCOUNT_P(&result, 1);
|
|
PZ_UNSET_ISREF_P(&result);
|
|
|
|
literal_dtor(&ZEND_OP1_LITERAL(opline));
|
|
literal_dtor(&ZEND_OP2_LITERAL(opline));
|
|
MAKE_NOP(opline);
|
|
|
|
/* substitute the following TMP_VAR usage with constant */
|
|
for (tmp_opline = opline + 1; tmp_opline < end; tmp_opline++) {
|
|
if (ZEND_OP1_TYPE(tmp_opline) == IS_TMP_VAR &&
|
|
ZEND_OP1(tmp_opline).var == tv) {
|
|
if (tmp_opline->opcode == ZEND_FREE) {
|
|
MAKE_NOP(tmp_opline);
|
|
zval_dtor(&result);
|
|
} else {
|
|
ZEND_OP1_TYPE(tmp_opline) = IS_CONST;
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
|
|
tmp_opline->op1.constant = zend_optimizer_add_literal(op_array, &result TSRMLS_CC);
|
|
if (Z_TYPE(result) == IS_STRING) {
|
|
Z_HASH_P(&ZEND_OP1_LITERAL(tmp_opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(tmp_opline)), Z_STRLEN(ZEND_OP1_LITERAL(tmp_opline)) + 1);
|
|
if (tmp_opline->opcode == ZEND_INIT_STATIC_METHOD_CALL ||
|
|
tmp_opline->opcode == ZEND_DO_FCALL ||
|
|
tmp_opline->opcode == ZEND_CATCH ||
|
|
tmp_opline->opcode == ZEND_FETCH_CONSTANT) {
|
|
op_array->literals[tmp_opline->op1.constant].cache_slot = op_array->last_cache_slot++;
|
|
}
|
|
}
|
|
#else
|
|
ZEND_OP1_LITERAL(tmp_opline) = result;
|
|
#endif
|
|
}
|
|
/* TMP_VAR my be used only once */
|
|
break;
|
|
}
|
|
if (ZEND_OP2_TYPE(tmp_opline) == IS_TMP_VAR &&
|
|
ZEND_OP2(tmp_opline).var == tv) {
|
|
ZEND_OP2_TYPE(tmp_opline) = IS_CONST;
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
|
|
tmp_opline->op2.constant = zend_optimizer_add_literal(op_array, &result TSRMLS_CC);
|
|
if (Z_TYPE(result) == IS_STRING) {
|
|
Z_HASH_P(&ZEND_OP2_LITERAL(tmp_opline)) = zend_hash_func(Z_STRVAL(ZEND_OP2_LITERAL(tmp_opline)), Z_STRLEN(ZEND_OP2_LITERAL(tmp_opline)) + 1);
|
|
if (tmp_opline->opcode == ZEND_FETCH_R ||
|
|
tmp_opline->opcode == ZEND_FETCH_W ||
|
|
tmp_opline->opcode == ZEND_FETCH_RW ||
|
|
tmp_opline->opcode == ZEND_FETCH_IS ||
|
|
tmp_opline->opcode == ZEND_FETCH_UNSET ||
|
|
tmp_opline->opcode == ZEND_FETCH_FUNC_ARG ||
|
|
tmp_opline->opcode == ZEND_FETCH_CLASS ||
|
|
tmp_opline->opcode == ZEND_INIT_FCALL_BY_NAME ||
|
|
tmp_opline->opcode == ZEND_INIT_NS_FCALL_BY_NAME ||
|
|
tmp_opline->opcode == ZEND_UNSET_VAR ||
|
|
tmp_opline->opcode == ZEND_ISSET_ISEMPTY_VAR ||
|
|
tmp_opline->opcode == ZEND_ADD_INTERFACE ||
|
|
tmp_opline->opcode == ZEND_ADD_TRAIT) {
|
|
op_array->literals[tmp_opline->op2.constant].cache_slot = op_array->last_cache_slot++;
|
|
} else if (tmp_opline->opcode == ZEND_INIT_METHOD_CALL ||
|
|
tmp_opline->opcode == ZEND_INIT_STATIC_METHOD_CALL ||
|
|
tmp_opline->opcode == ZEND_FETCH_CONSTANT ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_OBJ ||
|
|
tmp_opline->opcode == ZEND_FETCH_OBJ_R ||
|
|
tmp_opline->opcode == ZEND_FETCH_OBJ_W ||
|
|
tmp_opline->opcode == ZEND_FETCH_OBJ_RW ||
|
|
tmp_opline->opcode == ZEND_FETCH_OBJ_IS ||
|
|
tmp_opline->opcode == ZEND_FETCH_OBJ_UNSET ||
|
|
tmp_opline->opcode == ZEND_FETCH_OBJ_FUNC_ARG ||
|
|
tmp_opline->opcode == ZEND_UNSET_OBJ ||
|
|
tmp_opline->opcode == ZEND_PRE_INC_OBJ ||
|
|
tmp_opline->opcode == ZEND_PRE_DEC_OBJ ||
|
|
tmp_opline->opcode == ZEND_POST_INC_OBJ ||
|
|
tmp_opline->opcode == ZEND_POST_DEC_OBJ ||
|
|
tmp_opline->opcode == ZEND_ISSET_ISEMPTY_PROP_OBJ) {
|
|
op_array->literals[tmp_opline->op2.constant].cache_slot = op_array->last_cache_slot;
|
|
op_array->last_cache_slot += 2;
|
|
} else if (tmp_opline->opcode == ZEND_ASSIGN_ADD ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_SUB ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_MUL ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_DIV ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_MOD ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_SL ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_SR ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_CONCAT ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_BW_OR ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_BW_AND ||
|
|
tmp_opline->opcode == ZEND_ASSIGN_BW_XOR) {
|
|
if (tmp_opline->extended_value == ZEND_ASSIGN_OBJ) {
|
|
op_array->literals[tmp_opline->op2.constant].cache_slot = op_array->last_cache_slot;
|
|
op_array->last_cache_slot += 2;
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
ZEND_OP2_LITERAL(tmp_opline) = result;
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ZEND_CAST:
|
|
if (ZEND_OP1_TYPE(opline) == IS_CONST &&
|
|
opline->extended_value != IS_ARRAY &&
|
|
opline->extended_value != IS_OBJECT &&
|
|
opline->extended_value != IS_RESOURCE) {
|
|
/* cast of constant operand */
|
|
zval res;
|
|
res = ZEND_OP1_LITERAL(opline);
|
|
zval_copy_ctor(&res);
|
|
switch (opline->extended_value) {
|
|
case IS_NULL:
|
|
convert_to_null(&res);
|
|
break;
|
|
case IS_BOOL:
|
|
convert_to_boolean(&res);
|
|
break;
|
|
case IS_LONG:
|
|
convert_to_long(&res);
|
|
break;
|
|
case IS_DOUBLE:
|
|
convert_to_double(&res);
|
|
break;
|
|
case IS_STRING:
|
|
convert_to_string(&res);
|
|
break;
|
|
}
|
|
literal_dtor(&ZEND_OP1_LITERAL(opline));
|
|
opline->opcode = ZEND_QM_ASSIGN;
|
|
opline->extended_value = 0;
|
|
ZEND_OP1_LITERAL(opline) = res;
|
|
SET_UNUSED(opline->op2);
|
|
} else if (opline->extended_value == IS_BOOL) {
|
|
/* T = CAST(X, IS_BOOL) => T = BOOL(X) */
|
|
opline->opcode = ZEND_BOOL;
|
|
opline->extended_value = 0;
|
|
}
|
|
break;
|
|
|
|
case ZEND_BW_NOT:
|
|
case ZEND_BOOL_NOT:
|
|
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
|
|
/* unary operation on constant operand */
|
|
unary_op_type unary_op = get_unary_op(opline->opcode);
|
|
zval result;
|
|
zend_op *tmp_opline;
|
|
zend_uint tv = ZEND_RESULT(opline).var; /* temporary variable */
|
|
int er;
|
|
|
|
er = EG(error_reporting);
|
|
EG(error_reporting) = 0;
|
|
#if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
|
|
if (unary_op(&result, &ZEND_OP1_LITERAL(opline)) != SUCCESS) {
|
|
#else
|
|
if (unary_op(&result, &ZEND_OP1_LITERAL(opline) TSRMLS_CC) != SUCCESS) {
|
|
#endif
|
|
EG(error_reporting) = er;
|
|
break;
|
|
}
|
|
EG(error_reporting) = er;
|
|
PZ_SET_REFCOUNT_P(&result, 1);
|
|
PZ_UNSET_ISREF_P(&result);
|
|
|
|
literal_dtor(&ZEND_OP1_LITERAL(opline));
|
|
MAKE_NOP(opline);
|
|
|
|
/* substitute the following TMP_VAR usage with constant */
|
|
for (tmp_opline = opline + 1; tmp_opline < end; tmp_opline++) {
|
|
if (ZEND_OP1_TYPE(tmp_opline) == IS_TMP_VAR &&
|
|
ZEND_OP1(tmp_opline).var == tv) {
|
|
if (tmp_opline->opcode == ZEND_FREE) {
|
|
MAKE_NOP(tmp_opline);
|
|
zval_dtor(&result);
|
|
} else {
|
|
ZEND_OP1_TYPE(tmp_opline) = IS_CONST;
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
|
|
tmp_opline->op1.constant = zend_optimizer_add_literal(op_array, &result TSRMLS_CC);
|
|
#else
|
|
ZEND_OP1_LITERAL(tmp_opline) = result;
|
|
#endif
|
|
}
|
|
break;
|
|
}
|
|
if (ZEND_OP2_TYPE(tmp_opline) == IS_TMP_VAR &&
|
|
ZEND_OP2(tmp_opline).var == tv) {
|
|
ZEND_OP2_TYPE(tmp_opline) = IS_CONST;
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
|
|
tmp_opline->op2.constant = zend_optimizer_add_literal(op_array, &result TSRMLS_CC);
|
|
#else
|
|
ZEND_OP2_LITERAL(tmp_opline) = result;
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ZEND_ADD_STRING:
|
|
case ZEND_ADD_CHAR:
|
|
{
|
|
zend_op *next_op = opline + 1;
|
|
int requires_conversion = (opline->opcode == ZEND_ADD_CHAR? 1 : 0);
|
|
size_t final_length = 0;
|
|
char *ptr;
|
|
zend_op *last_op;
|
|
|
|
/* There is always a ZEND_RETURN at the end
|
|
if (next_op>=end) {
|
|
break;
|
|
}
|
|
*/
|
|
while (next_op->opcode == ZEND_ADD_STRING || next_op->opcode == ZEND_ADD_CHAR) {
|
|
if (ZEND_RESULT(opline).var != ZEND_RESULT(next_op).var) {
|
|
break;
|
|
}
|
|
if (next_op->opcode == ZEND_ADD_CHAR) {
|
|
final_length += 1;
|
|
} else { /* ZEND_ADD_STRING */
|
|
final_length += ZEND_OP2_LITERAL(next_op).value.str.len;
|
|
}
|
|
next_op++;
|
|
}
|
|
if (final_length == 0) {
|
|
break;
|
|
}
|
|
last_op = next_op;
|
|
final_length += (requires_conversion? 1 : ZEND_OP2_LITERAL(opline).value.str.len);
|
|
ptr = (char *)emalloc(final_length + 1);
|
|
ptr[final_length] = '\0';
|
|
if (requires_conversion) { /* ZEND_ADD_CHAR */
|
|
char chval = (char)ZEND_OP2_LITERAL(opline).value.lval;
|
|
|
|
ZEND_OP2_LITERAL(opline).value.str.val = ptr;
|
|
ptr[0] = chval;
|
|
ZEND_OP2_LITERAL(opline).type = IS_STRING;
|
|
opline->opcode = ZEND_ADD_STRING;
|
|
ptr++;
|
|
} else { /* ZEND_ADD_STRING */
|
|
memcpy(ptr, Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)));
|
|
if (!IS_INTERNED(Z_STRVAL(ZEND_OP2_LITERAL(opline)))) {
|
|
efree(Z_STRVAL(ZEND_OP2_LITERAL(opline)));
|
|
}
|
|
Z_STRVAL(ZEND_OP2_LITERAL(opline)) = ptr;
|
|
ptr += Z_STRLEN(ZEND_OP2_LITERAL(opline));
|
|
}
|
|
ZEND_OP2_LITERAL(opline).value.str.len = final_length;
|
|
next_op = opline + 1;
|
|
while (next_op < last_op) {
|
|
if (next_op->opcode == ZEND_ADD_STRING) {
|
|
memcpy(ptr, ZEND_OP2_LITERAL(next_op).value.str.val, ZEND_OP2_LITERAL(next_op).value.str.len);
|
|
ptr += ZEND_OP2_LITERAL(next_op).value.str.len;
|
|
literal_dtor(&ZEND_OP2_LITERAL(next_op));
|
|
} else { /* ZEND_ADD_CHAR */
|
|
*ptr = (char)ZEND_OP2_LITERAL(next_op).value.lval;
|
|
ptr++;
|
|
}
|
|
MAKE_NOP(next_op);
|
|
next_op++;
|
|
}
|
|
if (!((ZEND_OPTIMIZER_PASS_5|ZEND_OPTIMIZER_PASS_10) & OPTIMIZATION_LEVEL)) {
|
|
/* NOP removal is disabled => insert JMP over NOPs */
|
|
if (last_op-opline >= 3) { /* If we have more than 2 NOPS then JMP over them */
|
|
(opline + 1)->opcode = ZEND_JMP;
|
|
ZEND_OP1(opline + 1).opline_num = last_op - op_array->opcodes; /* that's OK even for ZE2, since opline_num's are resolved in pass 2 later */
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ZEND_FETCH_CONSTANT:
|
|
if (ZEND_OP1_TYPE(opline) == IS_UNUSED &&
|
|
ZEND_OP2_TYPE(opline) == IS_CONST &&
|
|
Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING &&
|
|
Z_STRLEN(ZEND_OP2_LITERAL(opline)) == sizeof("__COMPILER_HALT_OFFSET__") - 1 &&
|
|
memcmp(Z_STRVAL(ZEND_OP2_LITERAL(opline)), "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1) == 0) {
|
|
/* substitute __COMPILER_HALT_OFFSET__ constant */
|
|
zend_bool orig_in_execution = EG(in_execution);
|
|
zend_op_array *orig_op_array = EG(active_op_array);
|
|
zval offset;
|
|
|
|
EG(in_execution) = 1;
|
|
EG(active_op_array) = op_array;
|
|
if (zend_get_constant("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1, &offset TSRMLS_CC)) {
|
|
literal_dtor(&ZEND_OP2_LITERAL(opline));
|
|
ZEND_OP1_TYPE(opline) = IS_CONST;
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
|
|
opline->op1.constant = zend_optimizer_add_literal(op_array, &offset TSRMLS_CC);
|
|
#else
|
|
ZEND_OP1_LITERAL(opline) = offset;
|
|
#endif
|
|
SET_UNUSED(opline->op2);
|
|
opline->opcode = ZEND_QM_ASSIGN;
|
|
}
|
|
EG(active_op_array) = orig_op_array;
|
|
EG(in_execution) = orig_in_execution;
|
|
break;
|
|
}
|
|
|
|
if (ZEND_OP1_TYPE(opline) == IS_UNUSED &&
|
|
ZEND_OP2_TYPE(opline) == IS_CONST &&
|
|
ZEND_OP2_LITERAL(opline).type == IS_STRING) {
|
|
/* substitute persistent constants */
|
|
zval c;
|
|
|
|
if (!zend_get_persistent_constant(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), &c, 1 TSRMLS_CC)) {
|
|
if (!*constants || !zend_optimizer_get_collected_constant(*constants, &ZEND_OP2_LITERAL(opline), &c)) {
|
|
break;
|
|
}
|
|
}
|
|
literal_dtor(&ZEND_OP2_LITERAL(opline));
|
|
ZEND_OP1_TYPE(opline) = IS_CONST;
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
|
|
opline->op1.constant = zend_optimizer_add_literal(op_array, &c TSRMLS_CC);
|
|
#else
|
|
ZEND_OP1_LITERAL(opline) = c;
|
|
#endif
|
|
SET_UNUSED(opline->op2);
|
|
opline->opcode = ZEND_QM_ASSIGN;
|
|
}
|
|
break;
|
|
|
|
case ZEND_DO_FCALL:
|
|
/* define("name", scalar); */
|
|
if (collect_constants &&
|
|
opline->extended_value == 2 &&
|
|
ZEND_OP1_TYPE(opline) == IS_CONST &&
|
|
Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING &&
|
|
Z_STRLEN(ZEND_OP1_LITERAL(opline)) == sizeof("define")-1 &&
|
|
zend_binary_strcasecmp(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)), "define", sizeof("define")-1) == 0 &&
|
|
(opline-1)->opcode == ZEND_SEND_VAL &&
|
|
ZEND_OP1_TYPE(opline-1) == IS_CONST &&
|
|
(Z_TYPE(ZEND_OP1_LITERAL(opline-1)) <= IS_BOOL ||
|
|
Z_TYPE(ZEND_OP1_LITERAL(opline-1)) == IS_STRING) &&
|
|
(opline-2)->opcode == ZEND_SEND_VAL &&
|
|
ZEND_OP1_TYPE(opline-2) == IS_CONST &&
|
|
Z_TYPE(ZEND_OP1_LITERAL(opline-2)) == IS_STRING) {
|
|
zend_optimizer_collect_constant(constants, &ZEND_OP1_LITERAL(opline-2), &ZEND_OP1_LITERAL(opline-1));
|
|
}
|
|
break;
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_2_X_API_NO
|
|
case ZEND_DECLARE_CONST:
|
|
if (collect_constants &&
|
|
Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING &&
|
|
(Z_TYPE(ZEND_OP2_LITERAL(opline)) <= IS_BOOL ||
|
|
Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING)) {
|
|
zend_optimizer_collect_constant(constants, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline));
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case ZEND_RETURN:
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
|
|
case ZEND_RETURN_BY_REF:
|
|
#endif
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_4_X_API_NO
|
|
case ZEND_GENERATOR_RETURN:
|
|
#endif
|
|
case ZEND_EXIT:
|
|
case ZEND_THROW:
|
|
case ZEND_CATCH:
|
|
case ZEND_BRK:
|
|
case ZEND_CONT:
|
|
#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
|
|
case ZEND_GOTO:
|
|
#endif
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_4_X_API_NO
|
|
case ZEND_FAST_CALL:
|
|
case ZEND_FAST_RET:
|
|
#endif
|
|
case ZEND_JMP:
|
|
case ZEND_JMPZNZ:
|
|
case ZEND_JMPZ:
|
|
case ZEND_JMPNZ:
|
|
case ZEND_JMPZ_EX:
|
|
case ZEND_JMPNZ_EX:
|
|
case ZEND_FE_RESET:
|
|
case ZEND_FE_FETCH:
|
|
case ZEND_NEW:
|
|
#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
|
|
case ZEND_JMP_SET:
|
|
#endif
|
|
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
|
|
case ZEND_JMP_SET_VAR:
|
|
#endif
|
|
collect_constants = 0;
|
|
break;
|
|
}
|
|
opline++;
|
|
i++;
|
|
}
|
|
}
|