| w_cvar '=' expr { do_assign(&$$, &$1, &$3 CLS_CC); }
| w_cvar '=' '&' w_cvar { do_assign_ref(&$$, &$1, &$4 CLS_CC); }
| w_cvar '=' T_NEW class_name { do_extended_fcall_begin(CLS_C); do_begin_new_object(&$2, &$1, &$3, &$4 CLS_CC); } ctor_arguments { do_end_new_object(&$4, &$3, &$6 CLS_CC); do_extended_fcall_end(CLS_C); $$ = $2;}
- | rw_cvar T_PLUS_EQUAL expr { do_binary_assign_op(T_ASSIGN_ADD, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_MINUS_EQUAL expr { do_binary_assign_op(T_ASSIGN_SUB, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_MUL_EQUAL expr { do_binary_assign_op(T_ASSIGN_MUL, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_DIV_EQUAL expr { do_binary_assign_op(T_ASSIGN_DIV, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_CONCAT_EQUAL expr { do_binary_assign_op(T_ASSIGN_CONCAT, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_MOD_EQUAL expr { do_binary_assign_op(T_ASSIGN_MOD, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_AND_EQUAL expr { do_binary_assign_op(T_ASSIGN_BW_AND, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_OR_EQUAL expr { do_binary_assign_op(T_ASSIGN_BW_OR, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar XT_OR_EQUAL expr { do_binary_assign_op(T_ASSIGN_BW_XOR, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_SL_EQUAL expr { do_binary_assign_op(T_ASSIGN_SL, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_SR_EQUAL expr { do_binary_assign_op(T_ASSIGN_SR, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_PLUS_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_MINUS_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_MUL_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_DIV_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_CONCAT_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_MOD_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_AND_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_OR_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar XT_OR_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_SL_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 CLS_CC); }
+ | rw_cvar T_SR_EQUAL expr { do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 CLS_CC); }
| rw_cvar T_INC { do_post_incdec(&$$, &$1, ZEND_POST_INC CLS_CC); }
| T_INC rw_cvar { do_pre_incdec(&$$, &$2, ZEND_PRE_INC CLS_CC); }
| rw_cvar T_DEC { do_post_incdec(&$$, &$1, ZEND_POST_DEC CLS_CC); }
| '-' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; $1.u.constant.refcount=1; do_binary_op(ZEND_SUB, &$$, &$1, &$2 CLS_CC); }
| '!' expr { do_unary_op(ZEND_BOOL_NOT, &$$, &$2 CLS_CC); }
| '~' expr { do_unary_op(ZEND_BW_NOT, &$$, &$2 CLS_CC); }
- | expr T_IS_EQUAL expr { do_binary_op(ZEND_T_IS_EQUAL, &$$, &$1, &$3 CLS_CC); }
- | expr T_IS_NOT_EQUAL expr { do_binary_op(ZEND_T_IS_NOT_EQUAL, &$$, &$1, &$3 CLS_CC); }
+ | expr T_IS_EQUAL expr { do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 CLS_CC); }
+ | expr T_IS_NOT_EQUAL expr { do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 CLS_CC); }
| expr '<' expr { do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 CLS_CC); }
- | expr T_IS_SMALLER_OR_EQUAL expr { do_binary_op(ZEND_T_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 CLS_CC); }
+ | expr T_IS_SMALLER_OR_EQUAL expr { do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 CLS_CC); }
| expr '>' expr { do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 CLS_CC); }
- | expr T_IS_GREATER_OR_EQUAL expr { do_binary_op(ZEND_T_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 CLS_CC); }
+ | expr T_IS_GREATER_OR_EQUAL expr { do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 CLS_CC); }
| '(' expr ')' { $$ = $2; }
| expr '?' { do_begin_qm_op(&$1, &$2 CLS_CC); }
expr ':' { do_qm_true(&$4, &$2, &$5 CLS_CC); }
#endif
-#ifndef YY_TLS_VARS
-/* NOTE, YY_TLS_VARS CANNOT have a semicolon after in
- in the code or it will break compilation in msvc5 */
-#define YY_TLS_VARS
-#endif
-
-#ifndef TLS_VARS /* just to make sure ;) */
-#define TLS_VARS
-#endif
-
#define HANDLE_NEWLINES(s,l) \
do { \
char *p = (s),*boundary = p+(l); \
/*
zval *data;
- if (zend_hash_find(GLOBAL(function_state.calling_symbol_table), "this", sizeof("this"), (void **)&data) == FAILURE) {
+ if (zend_hash_find(function_state.calling_symbol_table, "this", sizeof("this"), (void **)&data) == FAILURE) {
return FAILURE;
}
opline->result.op_type = IS_TMP_VAR;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
- opline->opcode = T_PRINT_OP;
+ opline->opcode = ZEND_PRINT;
opline->op1 = *arg;
SET_UNUSED(opline->op2);
*result = opline->result;
{
zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
- opline->opcode = T_ECHO_OP;
+ opline->opcode = ZEND_ECHO;
opline->op1 = *arg;
SET_UNUSED(opline->op2);
}
{
zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
- opline->opcode = T_ASSIGN;
+ opline->opcode = ZEND_ASSIGN;
opline->result.op_type = IS_VAR;
opline->result.u.EA.type = 0;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
{
zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
- opline->opcode = T_ASSIGN_REF;
+ opline->opcode = ZEND_ASSIGN_REF;
if (result) {
opline->result.op_type = IS_VAR;
opline->result.u.EA.type = 0;
switch (last_op->opcode) {
case ZEND_FETCH_R:
- last_op->opcode = T_UNSET_VAR;
+ last_op->opcode = ZEND_UNSET_VAR;
break;
case ZEND_FETCH_DIM_R:
case ZEND_FETCH_OBJ_R:
- last_op->opcode = T_UNSET_DIM_OBJ;
+ last_op->opcode = ZEND_UNSET_DIM_OBJ;
break;
}
{
int retval;
-#if 0
-#if (WIN32|WINNT)
- if (GLOBAL(wintimer) && !(++GLOBAL(wintimer_counter) & 0xff) && (GLOBAL(wintimer) < (unsigned int) clock())) {
- zend_error(E_WARNING, "PHP Timed out!<br>\n");
- }
-#endif
-#endif
-
zendlval->u.constant.type = IS_LONG;
retval = lex_scan(&zendlval->u.constant CLS_CC);
switch(retval) {
#define ZEND_BW_NOT 12
#define ZEND_BOOL_NOT 13
#define ZEND_BOOL_XOR 14
-#define ZEND_T_IS_EQUAL 15
-#define ZEND_T_IS_NOT_EQUAL 16
+#define ZEND_IS_EQUAL 15
+#define ZEND_IS_NOT_EQUAL 16
#define ZEND_IS_SMALLER 17
-#define ZEND_T_IS_SMALLER_OR_EQUAL 18
+#define ZEND_IS_SMALLER_OR_EQUAL 18
#define ZEND_CAST 19
#define ZEND_QM_ASSIGN 20
-#define T_ASSIGN_ADD 21
-#define T_ASSIGN_SUB 22
-#define T_ASSIGN_MUL 23
-#define T_ASSIGN_DIV 24
-#define T_ASSIGN_MOD 25
-#define T_ASSIGN_SL 26
-#define T_ASSIGN_SR 27
-#define T_ASSIGN_CONCAT 28
-#define T_ASSIGN_BW_OR 29
-#define T_ASSIGN_BW_AND 30
-#define T_ASSIGN_BW_XOR 31
+#define ZEND_ASSIGN_ADD 21
+#define ZEND_ASSIGN_SUB 22
+#define ZEND_ASSIGN_MUL 23
+#define ZEND_ASSIGN_DIV 24
+#define ZEND_ASSIGN_MOD 25
+#define ZEND_ASSIGN_SL 26
+#define ZEND_ASSIGN_SR 27
+#define ZEND_ASSIGN_CONCAT 28
+#define ZEND_ASSIGN_BW_OR 29
+#define ZEND_ASSIGN_BW_AND 30
+#define ZEND_ASSIGN_BW_XOR 31
#define ZEND_PRE_INC 32
#define ZEND_PRE_DEC 33
#define ZEND_POST_INC 34
#define ZEND_POST_DEC 35
-#define T_ASSIGN 36
-#define T_ASSIGN_REF 37
+#define ZEND_ASSIGN 36
+#define ZEND_ASSIGN_REF 37
-#define T_ECHO_OP 38
-#define T_PRINT_OP 39
+#define ZEND_ECHO 38
+#define ZEND_PRINT 39
#define ZEND_JMP 40
#define ZEND_JMPZ 41
#define ZEND_INCLUDE_OR_EVAL 70
-#define T_UNSET_VAR 71
-#define T_UNSET_DIM_OBJ 72
+#define ZEND_UNSET_VAR 71
+#define ZEND_UNSET_DIM_OBJ 72
#define ZEND_ISSET_ISEMPTY 73
#define ZEND_FE_RESET 74
case ZEND_CONCAT:
binary_op = concat_function;
goto binary_op_addr;
- case ZEND_T_IS_EQUAL:
+ case ZEND_IS_EQUAL:
binary_op = is_equal_function;
goto binary_op_addr;
- case ZEND_T_IS_NOT_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
binary_op = is_not_equal_function;
goto binary_op_addr;
case ZEND_IS_SMALLER:
binary_op = is_smaller_function;
goto binary_op_addr;
- case ZEND_T_IS_SMALLER_OR_EQUAL:
+ case ZEND_IS_SMALLER_OR_EQUAL:
binary_op = is_smaller_or_equal_function;
goto binary_op_addr;
case ZEND_BW_OR:
FREE_OP(&opline->op1, free_op1);
break;
- case T_ASSIGN_ADD:
+ case ZEND_ASSIGN_ADD:
binary_op = add_function;
goto binary_assign_op_addr;
- case T_ASSIGN_SUB:
+ case ZEND_ASSIGN_SUB:
binary_op = sub_function;
goto binary_assign_op_addr;
- case T_ASSIGN_MUL:
+ case ZEND_ASSIGN_MUL:
binary_op = mul_function;
goto binary_assign_op_addr;
- case T_ASSIGN_DIV:
+ case ZEND_ASSIGN_DIV:
binary_op = div_function;
goto binary_assign_op_addr;
- case T_ASSIGN_MOD:
+ case ZEND_ASSIGN_MOD:
binary_op = mod_function;
goto binary_assign_op_addr;
- case T_ASSIGN_SL:
+ case ZEND_ASSIGN_SL:
binary_op = shift_left_function;
goto binary_assign_op_addr;
- case T_ASSIGN_SR:
+ case ZEND_ASSIGN_SR:
binary_op = shift_right_function;
goto binary_assign_op_addr;
- case T_ASSIGN_CONCAT:
+ case ZEND_ASSIGN_CONCAT:
binary_op = concat_function;
goto binary_assign_op_addr;
- case T_ASSIGN_BW_OR:
+ case ZEND_ASSIGN_BW_OR:
binary_op = bitwise_or_function;
goto binary_assign_op_addr;
- case T_ASSIGN_BW_AND:
+ case ZEND_ASSIGN_BW_AND:
binary_op = bitwise_and_function;
goto binary_assign_op_addr;
- case T_ASSIGN_BW_XOR:
+ case ZEND_ASSIGN_BW_XOR:
binary_op = bitwise_xor_function;
/* Fall through */
binary_assign_op_addr: {
}
}
break;
- case T_PRINT_OP:
+ case ZEND_PRINT:
zend_print_variable(get_zval_ptr(&opline->op1, Ts, &free_op1, BP_VAR_R));
Ts[opline->result.u.var].tmp_var.value.lval = 1;
Ts[opline->result.u.var].tmp_var.type = IS_LONG;
FREE_OP(&opline->op1, free_op1);
break;
- case T_ECHO_OP:
+ case ZEND_ECHO:
zend_print_variable(get_zval_ptr(&opline->op1, Ts, &free_op1, BP_VAR_R));
FREE_OP(&opline->op1, free_op1);
break;
case ZEND_FETCH_DIM_TMP_VAR:
zend_fetch_dimension_address_from_tmp_var(&opline->result, &opline->op1, &opline->op2, Ts ELS_CC);
break;
- case T_ASSIGN: {
+ case ZEND_ASSIGN: {
zval *value = get_zval_ptr(&opline->op2, Ts, &free_op2, BP_VAR_R);
zend_assign_to_variable(&opline->result, &opline->op1, value, (free_op2?IS_TMP_VAR:opline->op2.op_type), Ts ELS_CC);
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
break;
- case T_ASSIGN_REF:
+ case ZEND_ASSIGN_REF:
zend_assign_to_variable_reference(&opline->result, get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_W), get_zval_ptr_ptr(&opline->op2, Ts, BP_VAR_W), Ts ELS_CC);
INC_AI_COUNT(&opline->result);
break;
FREE_OP(&opline->op1, free_op1);
}
break;
- case T_UNSET_VAR: {
+ case ZEND_UNSET_VAR: {
zval tmp, *variable = get_zval_ptr(&opline->op1, Ts, &free_op1, BP_VAR_R);
if (variable->type != IS_STRING) {
FREE_OP(&opline->op1, free_op1);
}
break;
- case T_UNSET_DIM_OBJ: {
+ case ZEND_UNSET_DIM_OBJ: {
zval **container = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_R);
zval *offset = get_zval_ptr(&opline->op2, Ts, &free_op2, BP_VAR_R);
{
switch (opcode) {
case ZEND_ADD:
- case T_ASSIGN_ADD:
+ case ZEND_ASSIGN_ADD:
return (void *) add_function;
break;
case ZEND_SUB:
- case T_ASSIGN_SUB:
+ case ZEND_ASSIGN_SUB:
return (void *) sub_function;
break;
case ZEND_MUL:
- case T_ASSIGN_MUL:
+ case ZEND_ASSIGN_MUL:
return (void *) mul_function;
break;
case ZEND_DIV:
- case T_ASSIGN_DIV:
+ case ZEND_ASSIGN_DIV:
return (void *) div_function;
break;
case ZEND_MOD:
- case T_ASSIGN_MOD:
+ case ZEND_ASSIGN_MOD:
return (void *) mod_function;
break;
case ZEND_SL:
- case T_ASSIGN_SL:
+ case ZEND_ASSIGN_SL:
return (void *) shift_left_function;
break;
case ZEND_SR:
- case T_ASSIGN_SR:
+ case ZEND_ASSIGN_SR:
return (void *) shift_right_function;
break;
case ZEND_CONCAT:
- case T_ASSIGN_CONCAT:
+ case ZEND_ASSIGN_CONCAT:
return (void *) concat_function;
break;
- case ZEND_T_IS_EQUAL:
+ case ZEND_IS_EQUAL:
return (void *) is_equal_function;
break;
- case ZEND_T_IS_NOT_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
return (void *) is_not_equal_function;
break;
case ZEND_IS_SMALLER:
return (void *) is_smaller_function;
break;
- case ZEND_T_IS_SMALLER_OR_EQUAL:
+ case ZEND_IS_SMALLER_OR_EQUAL:
return (void *) is_smaller_or_equal_function;
break;
case ZEND_BW_OR:
- case T_ASSIGN_BW_OR:
+ case ZEND_ASSIGN_BW_OR:
return (void *) bitwise_or_function;
break;
case ZEND_BW_AND:
- case T_ASSIGN_BW_AND:
+ case ZEND_ASSIGN_BW_AND:
return (void *) bitwise_and_function;
break;
case ZEND_BW_XOR:
- case T_ASSIGN_BW_XOR:
+ case ZEND_ASSIGN_BW_XOR:
return (void *) bitwise_xor_function;
break;
default:
projects / php / commitdiff