# End Source File\r
# Begin Source File\r
\r
-SOURCE=.\zend_modules.h\r
-# End Source File\r
-# Begin Source File\r
-\r
SOURCE=.\zend.h\r
# End Source File\r
# Begin Source File\r
# End Source File\r
# Begin Source File\r
\r
+SOURCE=.\zend_modules.h\r
+# End Source File\r
+# Begin Source File\r
+\r
SOURCE=.\zend_operators.h\r
# End Source File\r
# Begin Source File\r
InputPath=.\zend_ini_parser.y\r
\r
BuildCmds= \\r
- bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y \\r
- \r
+ bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y\r
\r
"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
InputPath=".\zend_language_parser.y"\r
\r
BuildCmds= \\r
- bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \\r
- \r
+ bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y\r
\r
"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
InputPath=".\zend_language_parser.y"\r
\r
BuildCmds= \\r
- bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \\r
- \r
+ bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y\r
\r
"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
InputPath=".\zend_language_parser.y"\r
\r
BuildCmds= \\r
- bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \\r
- \r
+ bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y\r
\r
"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
# End Source File\r
# Begin Source File\r
\r
-SOURCE=.\zend_modules.h\r
-# End Source File\r
-# Begin Source File\r
-\r
SOURCE=.\zend.h\r
# End Source File\r
# Begin Source File\r
# End Source File\r
# Begin Source File\r
\r
+SOURCE=.\zend_modules.h\r
+# End Source File\r
+# Begin Source File\r
+\r
SOURCE=.\zend_operators.h\r
# End Source File\r
# Begin Source File\r
InputPath=.\zend_ini_parser.y\r
\r
BuildCmds= \\r
- bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y \\r
- \r
+ bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y\r
\r
"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
InputPath=.\zend_ini_parser.y\r
\r
BuildCmds= \\r
- bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y \\r
- \r
+ bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y\r
\r
"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
InputPath=.\zend_ini_parser.y\r
\r
BuildCmds= \\r
- bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y \\r
- \r
+ bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y\r
\r
"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
InputPath=".\zend_language_parser.y"\r
\r
BuildCmds= \\r
- bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \\r
- \r
+ bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y\r
\r
"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
InputPath=".\zend_language_parser.y"\r
\r
BuildCmds= \\r
- bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \\r
- \r
+ bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y\r
\r
"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
InputPath=".\zend_language_parser.y"\r
\r
BuildCmds= \\r
- bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \\r
- \r
+ bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y\r
\r
"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
$(BuildCmds)\r
}
-static void zend_set_default_compile_time_values(CLS_D)
+static void zend_set_default_compile_time_values(TSRMLS_D)
{
/* default compile-time values */
CG(asp_tags) = 0;
zend_hash_init_ex(compiler_globals->class_table, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
zend_hash_copy(compiler_globals->class_table, global_class_table, (copy_ctor_func_t) zend_class_add_ref, &tmp_class, sizeof(zend_class_entry));
- zend_set_default_compile_time_values(CLS_C);
+ zend_set_default_compile_time_values(TSRMLS_C);
CG(interactive) = 0;
}
}
-static void alloc_globals_ctor(zend_alloc_globals *alloc_globals TSRMLS_DC)
+static void alloc_globals_ctor(zend_alloc_globals *alloc_globals_p TSRMLS_DC)
{
- start_memory_manager(ALS_C);
+ start_memory_manager(TSRMLS_C);
}
#endif
ts_allocate_id(&alloc_globals_id, sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, NULL);
#else
- start_memory_manager(ALS_C);
+ start_memory_manager(TSRMLS_C);
#endif
#ifdef __FreeBSD__
GLOBAL_CONSTANTS_TABLE = EG(zend_constants);
#else
zend_startup_constants();
- zend_set_default_compile_time_values(CLS_C);
+ zend_set_default_compile_time_values(TSRMLS_C);
EG(user_error_handler) = NULL;
#endif
zend_register_standard_constants(TSRMLS_C);
BEGIN_EXTERN_C()
ZEND_API void _zend_bailout(char *filename, uint lineno)
{
- CLS_FETCH();
TSRMLS_FETCH();
if (!EG(bailout_set)) {
}
-void zend_activate(CLS_D TSRMLS_DC)
+void zend_activate(TSRMLS_D)
{
EG(bailout_set) = 0;
- init_compiler(CLS_C TSRMLS_CC);
- init_executor(CLS_C TSRMLS_CC);
- startup_scanner(CLS_C);
+ init_compiler(TSRMLS_C);
+ init_executor(TSRMLS_C);
+ startup_scanner(TSRMLS_C);
}
} zend_end_try();
}
-void zend_deactivate(CLS_D TSRMLS_DC)
+void zend_deactivate(TSRMLS_D)
{
/* we're no longer executing anything */
EG(opline_ptr) = NULL;
EG(active_symbol_table) = NULL;
zend_try {
- shutdown_scanner(CLS_C);
+ shutdown_scanner(TSRMLS_C);
} zend_end_try();
/* shutdown_executor() takes care of its own bailout handling */
shutdown_executor(TSRMLS_C);
zend_try {
- shutdown_compiler(CLS_C);
+ shutdown_compiler(TSRMLS_C);
} zend_end_try();
zend_try {
uint error_lineno;
zval *orig_user_error_handler;
TSRMLS_FETCH();
- CLS_FETCH();
/* Obtain relevant filename and lineno */
switch (type) {
case E_USER_WARNING:
case E_USER_NOTICE:
if (zend_is_compiling()) {
- error_filename = zend_get_compiled_filename(CLS_C);
- error_lineno = zend_get_compiled_lineno(CLS_C);
+ error_filename = zend_get_compiled_filename(TSRMLS_C);
+ error_lineno = zend_get_compiled_lineno(TSRMLS_C);
} else if (zend_is_executing()) {
error_filename = zend_get_executed_filename(TSRMLS_C);
error_lineno = zend_get_executed_lineno(TSRMLS_C);
va_end(args);
if (type==E_PARSE) {
- zend_init_compiler_data_structures(CLS_C);
+ zend_init_compiler_data_structures(TSRMLS_C);
}
}
}
-ZEND_API int zend_execute_scripts(int type CLS_DC TSRMLS_DC, int file_count, ...)
+ZEND_API int zend_execute_scripts(int type TSRMLS_DC, int file_count, ...)
{
va_list files;
int i;
if (!file_handle) {
continue;
}
- EG(active_op_array) = zend_compile_file(file_handle, ZEND_INCLUDE CLS_CC);
- zend_destroy_file_handle(file_handle CLS_CC);
+ EG(active_op_array) = zend_compile_file(file_handle, ZEND_INCLUDE TSRMLS_CC);
+ zend_destroy_file_handle(file_handle TSRMLS_CC);
if (EG(active_op_array)) {
zend_execute(EG(active_op_array) TSRMLS_CC);
zval_ptr_dtor(EG(return_value_ptr_ptr));
char *cur_filename;
int cur_lineno;
char *compiled_string_description;
- CLS_FETCH();
TSRMLS_FETCH();
if (zend_is_compiling()) {
- cur_filename = zend_get_compiled_filename(CLS_C);
- cur_lineno = zend_get_compiled_lineno(CLS_C);
+ cur_filename = zend_get_compiled_filename(TSRMLS_C);
+ cur_lineno = zend_get_compiled_lineno(TSRMLS_C);
} else if (zend_is_executing()) {
cur_filename = zend_get_executed_filename(TSRMLS_C);
cur_lineno = zend_get_executed_lineno(TSRMLS_C);
#define ZEND_VERSION "1.0.7"
-#include "../TSRM/TSRM.h"
-
#ifdef __cplusplus
#define BEGIN_EXTERN_C() extern "C" {
#define END_EXTERN_C() }
int count=0,unload=0;
HashTable *target_function_table = function_table;
int error_type;
- CLS_FETCH();
+ TSRMLS_FETCH();
if (type==MODULE_PERSISTENT) {
error_type = E_CORE_WARNING;
zend_function_entry *ptr = functions;
int i=0;
HashTable *target_function_table = function_table;
- CLS_FETCH();
+ TSRMLS_FETCH();
if (!target_function_table) {
target_function_table = CG(function_table);
ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name)
{
zend_class_entry *register_class;
- CLS_FETCH();
+ TSRMLS_FETCH();
if (!parent_ce && parent_name) {
if (zend_hash_find(CG(class_table), parent_name, strlen(parent_name)+1, (void **) &parent_ce)==FAILURE) {
{
zend_class_entry *register_class;
char *lowercase_name = zend_strndup(class_entry->name, class_entry->name_length);
- CLS_FETCH();
+ TSRMLS_FETCH();
zend_str_tolower(lowercase_name, class_entry->name_length);
ZEND_API int zend_disable_function(char *function_name, uint function_name_length)
{
- CLS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_del(CG(function_table), function_name, function_name_length+1)==FAILURE) {
return FAILURE;
{
zend_mem_header *p;
DECLARE_CACHE_VARS();
- ALS_FETCH();
+ TSRMLS_FETCH();
CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size);
{
zend_mem_header *p = (zend_mem_header *) ((char *)ptr - sizeof(zend_mem_header) - MEM_HEADER_PADDING);
DECLARE_CACHE_VARS();
- ALS_FETCH();
+ TSRMLS_FETCH();
#if defined(ZTS) && TSRM_DEBUG
if (p->thread_id != tsrm_thread_id()) {
zend_mem_header *p;
zend_mem_header *orig;
DECLARE_CACHE_VARS();
- ALS_FETCH();
+ TSRMLS_FETCH();
if (!ptr) {
return _emalloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
ZEND_API int zend_set_memory_limit(unsigned int memory_limit)
{
#if MEMORY_LIMIT
- ALS_FETCH();
+ TSRMLS_FETCH();
AG(memory_limit) = memory_limit;
return SUCCESS;
}
-ZEND_API void start_memory_manager(ALS_D)
+ZEND_API void start_memory_manager(TSRMLS_D)
{
#if 0
#ifndef ZTS
int had_leaks = 0;
#endif
zend_fast_cache_list_entry *fast_cache_list_entry, *next_fast_cache_list_entry;
- ALS_FETCH();
+ TSRMLS_FETCH();
for (fci=0; fci<MAX_FAST_CACHE_TYPES; fci++) {
fast_cache_list_entry = AG(fast_cache_list_head)[fci];
{
zend_mem_header *p;
int errors=0;
- ALS_FETCH();
+ TSRMLS_FETCH();
p = AG(head);
ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
{
zend_mem_header *p = (zend_mem_header *) ((char *)ptr-sizeof(zend_mem_header)-MEM_HEADER_PADDING);
- ALS_FETCH();
+ TSRMLS_FETCH();
#if ZEND_DEBUG
_mem_block_check(ptr, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
#include <stdio.h>
-#ifdef ZTS
#include "../TSRM/TSRM.h"
-#endif
-
#include "zend_globals_macros.h"
#define MEM_BLOCK_START_MAGIC 0x7312F8DCL
ZEND_API int zend_set_memory_limit(unsigned int memory_limit);
-ZEND_API void start_memory_manager(ALS_D);
+ZEND_API void start_memory_manager(TSRMLS_D);
ZEND_API void shutdown_memory_manager(int silent, int clean_cache);
#if ZEND_DEBUG
zval **z_function_args, **z_function_code;
int retval;
char *eval_name;
- CLS_FETCH();
if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &z_function_args, &z_function_code)==FAILURE) {
ZEND_WRONG_PARAM_COUNT();
sprintf(eval_code, "function " LAMBDA_TEMP_FUNCNAME "(%s){%s}", Z_STRVAL_PP(z_function_args), Z_STRVAL_PP(z_function_code));
eval_name = zend_make_compiled_string_description("runtime-created function");
- retval = zend_eval_string(eval_code, NULL, eval_name CLS_CC TSRMLS_CC);
+ retval = zend_eval_string(eval_code, NULL, eval_name TSRMLS_CC);
efree(eval_code);
efree(eval_name);
#include "zend_fast_cache.h"
-ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type CLS_DC);
+ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
#ifndef ZTS
#endif
-static void build_runtime_defined_function_key(zval *result, zval *name, zend_op *opline CLS_DC)
+static void build_runtime_defined_function_key(zval *result, zval *name, zend_op *opline TSRMLS_DC)
{
char lineno_buf[32];
uint lineno_len;
}
-static void init_compiler_declarables(CLS_D)
+static void init_compiler_declarables(TSRMLS_D)
{
CG(declarables).ticks.type = IS_LONG;
CG(declarables).ticks.value.lval = 0;
-void zend_init_compiler_data_structures(CLS_D)
+void zend_init_compiler_data_structures(TSRMLS_D)
{
zend_stack_init(&CG(bp_stack));
zend_stack_init(&CG(function_call_stack));
zend_stack_init(&CG(list_stack));
CG(handle_op_arrays) = 1;
CG(in_compilation) = 0;
- init_compiler_declarables(CLS_C);
+ init_compiler_declarables(TSRMLS_C);
}
-void init_compiler(CLS_D TSRMLS_DC)
+void init_compiler(TSRMLS_D)
{
- zend_init_compiler_data_structures(CLS_C);
+ zend_init_compiler_data_structures(TSRMLS_C);
zend_init_rsrc_list(TSRMLS_C);
zend_hash_init(&CG(filenames_table), 5, NULL, (dtor_func_t) free_estring, 0);
zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) zend_file_handle_dtor, 0);
}
-void shutdown_compiler(CLS_D)
+void shutdown_compiler(TSRMLS_D)
{
zend_stack_destroy(&CG(bp_stack));
zend_stack_destroy(&CG(function_call_stack));
{
char **pp, *p;
int length = strlen(new_compiled_filename);
- CLS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_find(&CG(filenames_table), new_compiled_filename, length+1, (void **) &pp)==SUCCESS) {
CG(compiled_filename) = *pp;
ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename)
{
- CLS_FETCH();
+ TSRMLS_FETCH();
CG(compiled_filename) = original_compiled_filename;
}
-ZEND_API char *zend_get_compiled_filename(CLS_D)
+ZEND_API char *zend_get_compiled_filename(TSRMLS_D)
{
return CG(compiled_filename);
}
-ZEND_API int zend_get_compiled_lineno(CLS_D)
+ZEND_API int zend_get_compiled_lineno(TSRMLS_D)
{
return CG(zend_lineno);
}
ZEND_API zend_bool zend_is_compiling()
{
- CLS_FETCH();
+ TSRMLS_FETCH();
return CG(in_compilation);
}
}
-void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = op;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_unary_op(int op, znode *result, znode *op1 CLS_DC)
+void zend_do_unary_op(int op, znode *result, znode *op1 TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = op;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = op;
opline->result.op_type = IS_VAR;
-void zend_do_fetch_globals(znode *varname CLS_DC)
+void zend_do_fetch_globals(znode *varname TSRMLS_DC)
{
if (!CG(active_op_array)->uses_globals
&& varname->op_type == IS_CONST
}
}
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op CLS_DC)
+void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op TSRMLS_DC)
{
zend_op opline;
zend_op *opline_ptr;
if (bp) {
opline_ptr = &opline;
- init_op(opline_ptr CLS_CC);
+ init_op(opline_ptr TSRMLS_CC);
} else {
- opline_ptr = get_next_op(CG(active_op_array) CLS_CC);
+ opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC);
}
opline_ptr->opcode = op;
}
}
-void fetch_simple_variable(znode *result, znode *varname, int bp CLS_DC)
+void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC)
{
/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
- fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W CLS_CC);
+ fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC);
}
-void fetch_array_begin(znode *result, znode *varname, znode *first_dim CLS_DC)
+void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC)
{
- fetch_simple_variable(result, varname, 1 CLS_CC);
+ fetch_simple_variable(result, varname, 1 TSRMLS_CC);
- fetch_array_dim(result, result, first_dim CLS_CC);
+ fetch_array_dim(result, result, first_dim TSRMLS_CC);
}
-void fetch_array_dim(znode *result, znode *parent, znode *dim CLS_DC)
+void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC)
{
zend_op opline;
zend_llist *fetch_list_ptr;
- init_op(&opline CLS_CC);
+ init_op(&opline TSRMLS_CC);
opline.opcode = ZEND_FETCH_DIM_W; /* the backpatching routine assumes W */
opline.result.op_type = IS_VAR;
opline.result.u.EA.type = 0;
}
-void fetch_string_offset(znode *result, znode *parent, znode *offset CLS_DC)
+void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC)
{
- fetch_array_dim(result, parent, offset CLS_CC);
+ fetch_array_dim(result, parent, offset TSRMLS_CC);
}
-void zend_do_print(znode *result, znode *arg CLS_DC)
+void zend_do_print(znode *result, znode *arg TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->result.op_type = IS_TMP_VAR;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
}
-void zend_do_echo(znode *arg CLS_DC)
+void zend_do_echo(znode *arg TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ECHO;
opline->op1 = *arg;
}
-void zend_do_assign(znode *result, znode *variable, znode *value CLS_DC)
+void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ASSIGN;
opline->result.op_type = IS_VAR;
}
-void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar CLS_DC)
+void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ASSIGN_REF;
if (result) {
}
-static inline void do_begin_loop(CLS_D)
+static inline void do_begin_loop(TSRMLS_D)
{
zend_brk_cont_element *brk_cont_element;
int parent;
}
-static inline void do_end_loop(int cont_addr CLS_DC)
+static inline void do_end_loop(int cont_addr TSRMLS_DC)
{
CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].cont = cont_addr;
CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].brk = get_next_op_number(CG(active_op_array));
}
-void zend_do_while_cond(znode *expr, znode *close_bracket_token CLS_DC)
+void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC)
{
int while_cond_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPZ;
opline->op1 = *expr;
close_bracket_token->u.opline_num = while_cond_op_number;
SET_UNUSED(opline->op2);
- do_begin_loop(CLS_C);
+ do_begin_loop(TSRMLS_C);
INC_BPC(CG(active_op_array));
}
-void zend_do_while_end(znode *while_token, znode *close_bracket_token CLS_DC)
+void zend_do_while_end(znode *while_token, znode *close_bracket_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
/* add unconditional jump */
opline->opcode = ZEND_JMP;
/* update while's conditional jmp */
CG(active_op_array)->opcodes[close_bracket_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
- do_end_loop(while_token->u.opline_num CLS_CC);
+ do_end_loop(while_token->u.opline_num TSRMLS_CC);
DEC_BPC(CG(active_op_array));
}
-void zend_do_for_cond(znode *expr, znode *second_semicolon_token CLS_DC)
+void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC)
{
int for_cond_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPZNZ;
opline->op1 = *expr; /* the conditional expression */
}
-void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token CLS_DC)
+void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMP;
opline->op1.u.opline_num = cond_start->u.opline_num;
SET_UNUSED(opline->op1);
SET_UNUSED(opline->op2);
- do_begin_loop(CLS_C);
+ do_begin_loop(TSRMLS_C);
INC_BPC(CG(active_op_array));
}
-void zend_do_for_end(znode *second_semicolon_token CLS_DC)
+void zend_do_for_end(znode *second_semicolon_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMP;
opline->op1.u.opline_num = second_semicolon_token->u.opline_num+1;
SET_UNUSED(opline->op1);
SET_UNUSED(opline->op2);
- do_end_loop(second_semicolon_token->u.opline_num+1 CLS_CC);
+ do_end_loop(second_semicolon_token->u.opline_num+1 TSRMLS_CC);
DEC_BPC(CG(active_op_array));
}
-void zend_do_pre_incdec(znode *result, znode *op1, int op CLS_DC)
+void zend_do_pre_incdec(znode *result, znode *op1, int op TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = op;
opline->result.op_type = IS_VAR;
}
-void zend_do_post_incdec(znode *result, znode *op1, int op CLS_DC)
+void zend_do_post_incdec(znode *result, znode *op1, int op TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = op;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_if_cond(znode *cond, znode *closing_bracket_token CLS_DC)
+void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC)
{
int if_cond_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPZ;
opline->op1 = *cond;
}
-void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize CLS_DC)
+void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize TSRMLS_DC)
{
int if_end_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
zend_llist *jmp_list_ptr;
opline->opcode = ZEND_JMP;
}
-void zend_do_if_end(CLS_D)
+void zend_do_if_end(TSRMLS_D)
{
int next_op_number = get_next_op_number(CG(active_op_array));
zend_llist *jmp_list_ptr;
}
-void zend_do_begin_variable_parse(CLS_D)
+void zend_do_begin_variable_parse(TSRMLS_D)
{
zend_llist fetch_list;
}
-void zend_do_end_variable_parse(int type, int arg_offset CLS_DC)
+void zend_do_end_variable_parse(int type, int arg_offset TSRMLS_DC)
{
zend_llist *fetch_list_ptr;
zend_llist_element *le;
while (le) {
opline_ptr = (zend_op *)le->data;
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
memcpy(opline, opline_ptr, sizeof(zend_op));
switch (type) {
case BP_VAR_R:
}
-static zend_bool is_method_call(CLS_D)
+static zend_bool is_method_call(TSRMLS_D)
{
zend_llist *fetch_list_ptr;
zend_llist_element *cur;
}
-void zend_do_init_string(znode *result CLS_DC)
+void zend_do_init_string(znode *result TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_INIT_STRING;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_add_char(znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_add_char(znode *result, znode *op1, znode *op2 TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ADD_CHAR;
opline->op1 = *op1;
}
-void zend_do_add_string(znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ADD_STRING;
opline->op1 = *op1;
}
-void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC)
{
zend_op *opline;
if (op1->op_type == IS_CONST) {
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_INIT_STRING;
opline->result.op_type = IS_TMP_VAR;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
SET_UNUSED(opline->op2);
if (op1->u.constant.value.str.len>0) {
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ADD_STRING;
opline->result = *result;
opline->op1 = *result;
*result = *op1;
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ADD_VAR;
opline->result = *result;
opline->op1 = *result;
}
-void zend_do_free(znode *op1 CLS_DC)
+void zend_do_free(znode *op1 TSRMLS_DC)
{
if (op1->op_type==IS_TMP_VAR) {
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_FREE;
opline->op1 = *op1;
}
-void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference CLS_DC)
+void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference TSRMLS_DC)
{
zend_op_array op_array;
char *name = function_name->u.constant.value.str.val;
function_token->u.op_array = CG(active_op_array);
zend_str_tolower(name, name_len);
- init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE CLS_CC);
+ init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
op_array.function_name = name;
op_array.arg_types = NULL;
if (is_method) {
zend_hash_update(&CG(active_class_entry)->function_table, name, name_len+1, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
} else {
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_DECLARE_FUNCTION_OR_CLASS;
opline->op1.op_type = IS_CONST;
- build_runtime_defined_function_key(&opline->op1.u.constant, &function_name->u.constant, opline CLS_CC);
+ build_runtime_defined_function_key(&opline->op1.u.constant, &function_name->u.constant, opline TSRMLS_CC);
opline->op2.op_type = IS_CONST;
opline->op2.u.constant.type = IS_STRING;
opline->op2.u.constant.value.str.val = estrndup(name, name_len);
}
if (CG(extended_info)) {
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_EXT_NOP;
opline->lineno = function_begin_line;
}
-void zend_do_end_function_declaration(znode *function_token CLS_DC)
+void zend_do_end_function_declaration(znode *function_token TSRMLS_DC)
{
- zend_do_extended_info(CLS_C);
- zend_do_return(NULL, 0 CLS_CC);
+ zend_do_extended_info(TSRMLS_C);
+ zend_do_return(NULL, 0 TSRMLS_CC);
pass_two(CG(active_op_array));
CG(active_op_array) = function_token->u.op_array;
}
-void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type CLS_DC)
+void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = op;
opline->result = *var;
}
-int zend_do_begin_function_call(znode *function_name CLS_DC)
+int zend_do_begin_function_call(znode *function_name TSRMLS_DC)
{
zend_function *function;
znode tmp = *function_name;
zval_copy_ctor(&tmp.u.constant);
- zend_do_begin_dynamic_function_call(&tmp CLS_CC);
+ zend_do_begin_dynamic_function_call(&tmp TSRMLS_CC);
return 1; /* Dynamic */
}
}
break;
}
- zend_do_extended_fcall_begin(CLS_C);
+ zend_do_extended_fcall_begin(TSRMLS_C);
return 0;
}
-void zend_do_begin_dynamic_function_call(znode *function_name CLS_DC)
+void zend_do_begin_dynamic_function_call(znode *function_name TSRMLS_DC)
{
unsigned char *ptr = NULL;
int last_op_number;
zend_op *last_op;
- if (function_name->op_type != IS_CONST && is_method_call(CLS_C)) {
- zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC);
+ if (function_name->op_type != IS_CONST && is_method_call(TSRMLS_C)) {
+ zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC);
last_op_number = get_next_op_number(CG(active_op_array))-1;
last_op = &CG(active_op_array)->opcodes[last_op_number];
last_op->opcode = ZEND_INIT_FCALL_BY_NAME;
zend_op *opline;
if (function_name->op_type != IS_CONST) {
- zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_INIT_FCALL_BY_NAME;
opline->op2 = *function_name;
opline->extended_value = 0;
SET_UNUSED(opline->op1);
}
zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
- zend_do_extended_fcall_begin(CLS_C);
+ zend_do_extended_fcall_begin(TSRMLS_C);
}
-void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name CLS_DC)
+void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name TSRMLS_DC)
{
unsigned char *ptr = NULL;
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_INIT_FCALL_BY_NAME;
zend_str_tolower(class_name->u.constant.value.str.val, class_name->u.constant.value.str.len);
}
-void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall CLS_DC)
+void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
if (function_name->op_type==IS_CONST && !is_method && !is_dynamic_fcall) {
opline->opcode = ZEND_DO_FCALL;
}
-void zend_do_pass_param(znode *param, int op, int offset CLS_DC)
+void zend_do_pass_param(znode *param, int op, int offset TSRMLS_DC)
{
zend_op *opline;
unsigned char *arg_types;
if (original_op == ZEND_SEND_VAR) {
switch(op) {
case ZEND_SEND_VAR_NO_REF:
- zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
break;
case ZEND_SEND_VAR:
if (function_ptr) {
- zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
} else {
- zend_do_end_variable_parse(BP_VAR_FUNC_ARG, offset CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_FUNC_ARG, offset TSRMLS_CC);
}
break;
case ZEND_SEND_REF:
- zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC);
break;
}
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
if (op == ZEND_SEND_VAR_NO_REF) {
if (function_ptr) {
}
-static int generate_free_switch_expr(zend_switch_entry *switch_entry CLS_DC)
+static int generate_free_switch_expr(zend_switch_entry *switch_entry TSRMLS_DC)
{
zend_op *opline;
return 1;
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_SWITCH_FREE;
opline->op1 = switch_entry->cond;
return 0;
}
-static int generate_free_foreach_copy(znode *foreach_copy CLS_DC)
+static int generate_free_foreach_copy(znode *foreach_copy TSRMLS_DC)
{
zend_op *opline;
return 1;
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_SWITCH_FREE;
opline->op1 = *foreach_copy;
return 0;
}
-void zend_do_return(znode *expr, int do_end_vparse CLS_DC)
+void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC)
{
zend_op *opline;
if (do_end_vparse) {
if (CG(active_op_array)->return_reference) {
- zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC);
} else {
- zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
}
#if 0
} else if (expr && CG(active_op_array)->return_reference) {
}
#ifdef ZTS
- zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr CLS_CC);
- zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy CLS_CC);
+ zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC);
+ zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC);
#else
zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr);
zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy);
#endif
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_RETURN;
}
-void zend_do_early_binding(CLS_D)
+void zend_do_early_binding(TSRMLS_D)
{
zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
HashTable *table;
}
-void zend_do_boolean_or_begin(znode *expr1, znode *op_token CLS_DC)
+void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC)
{
int next_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPNZ_EX;
if (expr1->op_type == IS_TMP_VAR) {
}
-void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC)
+void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
*result = *expr1; /* we saved the original result in expr1 */
opline->opcode = ZEND_BOOL;
}
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token CLS_DC)
+void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC)
{
int next_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPZ_EX;
if (expr1->op_type == IS_TMP_VAR) {
}
-void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC)
+void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
*result = *expr1; /* we saved the original result in expr1 */
opline->opcode = ZEND_BOOL;
}
-void zend_do_do_while_begin(CLS_D)
+void zend_do_do_while_begin(TSRMLS_D)
{
- do_begin_loop(CLS_C);
+ do_begin_loop(TSRMLS_C);
INC_BPC(CG(active_op_array));
}
-void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr CLS_DC)
+void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPNZ;
opline->op1 = *expr;
opline->op2.u.opline_num = do_token->u.opline_num;
SET_UNUSED(opline->op2);
- do_end_loop(expr_open_bracket->u.opline_num CLS_CC);
+ do_end_loop(expr_open_bracket->u.opline_num TSRMLS_CC);
DEC_BPC(CG(active_op_array));
}
-void zend_do_brk_cont(int op, znode *expr CLS_DC)
+void zend_do_brk_cont(int op, znode *expr TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = op;
opline->op1.u.opline_num = CG(active_op_array)->current_brk_cont;
}
-void zend_do_switch_cond(znode *cond CLS_DC)
+void zend_do_switch_cond(znode *cond TSRMLS_DC)
{
zend_switch_entry switch_entry;
zend_op *opline;
/* Initialize the conditional value */
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_BOOL;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
opline->result.op_type = IS_TMP_VAR;
switch_entry.control_var = opline->result.u.var;
zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry));
- do_begin_loop(CLS_C);
+ do_begin_loop(TSRMLS_C);
INC_BPC(CG(active_op_array));
}
-void zend_do_switch_end(znode *case_list CLS_DC)
+void zend_do_switch_end(znode *case_list TSRMLS_DC)
{
zend_op *opline;
zend_switch_entry *switch_entry_ptr;
/* add code to jmp to default case */
if (switch_entry_ptr->default_case != -1) {
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPZ;
opline->op1.op_type = IS_TMP_VAR;
opline->op1.u.var = switch_entry_ptr->control_var;
if (switch_entry_ptr->cond.op_type==IS_VAR || switch_entry_ptr->cond.op_type==IS_TMP_VAR) {
/* emit free for the switch condition*/
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_SWITCH_FREE;
opline->op1 = switch_entry_ptr->cond;
SET_UNUSED(opline->op2);
}
-void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr CLS_DC)
+void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
int next_op_number;
zend_switch_entry *switch_entry_ptr;
znode result;
result = opline->result;
next_op_number = get_next_op_number(CG(active_op_array));
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPZ;
opline->op1 = result;
SET_UNUSED(opline->op2);
}
-void zend_do_case_after_statement(znode *result, znode *case_token CLS_DC)
+void zend_do_case_after_statement(znode *result, znode *case_token TSRMLS_DC)
{
int next_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMP;
SET_UNUSED(opline->op1);
-void zend_do_default_before_statement(znode *case_list, znode *default_token CLS_DC)
+void zend_do_default_before_statement(znode *case_list, znode *default_token TSRMLS_DC)
{
int next_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
zend_switch_entry *switch_entry_ptr;
zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr);
default_token->u.opline_num = next_op_number;
next_op_number = get_next_op_number(CG(active_op_array));
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_BOOL;
opline->result.u.var = switch_entry_ptr->control_var;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name CLS_DC)
+void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
int runtime_inheritance = 0;
if (CG(active_class_entry)) {
opline->opcode = ZEND_DECLARE_FUNCTION_OR_CLASS;
opline->op1.op_type = IS_CONST;
- build_runtime_defined_function_key(&opline->op1.u.constant, &class_name->u.constant, opline CLS_CC);
+ build_runtime_defined_function_key(&opline->op1.u.constant, &class_name->u.constant, opline TSRMLS_CC);
opline->op2.op_type = IS_CONST;
opline->op2.u.constant.type = IS_STRING;
opline->op2.u.constant.refcount = 1;
}
-void zend_do_end_class_declaration(CLS_D)
+void zend_do_end_class_declaration(TSRMLS_D)
{
do_inherit_parent_constructor(CG(active_class_entry));
CG(active_class_entry) = NULL;
}
-void zend_do_declare_property(znode *var_name, znode *value CLS_DC)
+void zend_do_declare_property(znode *var_name, znode *value TSRMLS_DC)
{
if (value) {
zval *property;
}
-void zend_do_fetch_property(znode *result, znode *object, znode *property CLS_DC)
+void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC)
{
zend_op opline;
zend_llist *fetch_list_ptr;
- init_op(&opline CLS_CC);
+ init_op(&opline TSRMLS_CC);
opline.opcode = ZEND_FETCH_OBJ_W; /* the backpatching routine assumes W */
opline.result.op_type = IS_VAR;
opline.result.u.EA.type = 0;
}
-void zend_do_push_object(znode *object CLS_DC)
+void zend_do_push_object(znode *object TSRMLS_DC)
{
zend_stack_push(&CG(object_stack), object, sizeof(znode));
}
-void zend_do_pop_object(znode *object CLS_DC)
+void zend_do_pop_object(znode *object TSRMLS_DC)
{
znode *tmp;
}
-void zend_do_begin_new_object(znode *new_token, znode *class_name CLS_DC)
+void zend_do_begin_new_object(znode *new_token, znode *class_name TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
unsigned char *ptr = NULL;
opline->opcode = ZEND_NEW;
SET_UNUSED(opline->op2);
new_token->u.opline_num = get_next_op_number(CG(active_op_array));
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMP_NO_CTOR;
opline->op1 = (opline-1)->result;
SET_UNUSED(opline->op2);
if (class_name->op_type == IS_CONST) {
zval_copy_ctor(&class_name->u.constant);
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_INIT_FCALL_BY_NAME;
opline->op1 = (opline-2)->result;
opline->op2 = *class_name;
}
-void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list CLS_DC)
+void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list TSRMLS_DC)
{
znode ctor_result;
if (class_name->op_type == IS_CONST) {
zval_copy_ctor(&class_name->u.constant);
}
- zend_do_end_function_call(class_name, &ctor_result, argument_list, 1, 0 CLS_CC);
- zend_do_free(&ctor_result CLS_CC);
+ zend_do_end_function_call(class_name, &ctor_result, argument_list, 1, 0 TSRMLS_CC);
+ zend_do_free(&ctor_result TSRMLS_CC);
CG(active_op_array)->opcodes[new_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
*result = CG(active_op_array)->opcodes[new_token->u.opline_num].op1;
}
-void zend_do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC)
+void zend_do_fetch_constant(znode *result, znode *constant_name, int mode TSRMLS_DC)
{
switch (mode) {
case ZEND_CT:
result->u.constant.type = IS_CONSTANT;
break;
case ZEND_RT: {
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_FETCH_CONSTANT;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_shell_exec(znode *result, znode *cmd CLS_DC)
+void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
switch (cmd->op_type) {
case IS_TMP_VAR:
opline->extended_value = ZEND_DO_FCALL;
SET_UNUSED(opline->op2);
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_DO_FCALL;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
opline->result.op_type = IS_VAR;
-void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref CLS_DC)
+void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_INIT_ARRAY;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
}
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref CLS_DC)
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ADD_ARRAY_ELEMENT;
opline->result = *result;
}
-void zend_do_add_list_element(znode *element CLS_DC)
+void zend_do_add_list_element(znode *element TSRMLS_DC)
{
list_llist_element lle;
}
-void zend_do_new_list_begin(CLS_D)
+void zend_do_new_list_begin(TSRMLS_D)
{
int current_dimension = 0;
zend_llist_add_element(&CG(dimension_llist), ¤t_dimension);
}
-void zend_do_new_list_end(CLS_D)
+void zend_do_new_list_end(TSRMLS_D)
{
zend_llist_remove_tail(&CG(dimension_llist));
(*((int *)CG(dimension_llist).tail->data))++;
}
-void zend_do_list_init(CLS_D)
+void zend_do_list_init(TSRMLS_D)
{
zend_stack_push(&CG(list_stack), &CG(list_llist), sizeof(zend_llist));
zend_stack_push(&CG(list_stack), &CG(dimension_llist), sizeof(zend_llist));
zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
- zend_do_new_list_begin(CLS_C);
+ zend_do_new_list_begin(TSRMLS_C);
}
-void zend_do_list_end(znode *result, znode *expr CLS_DC)
+void zend_do_list_end(znode *result, znode *expr TSRMLS_DC)
{
zend_llist_element *le;
zend_llist_element *dimension;
zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions;
dimension = tmp_dimension_llist->head;
while (dimension) {
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
if (dimension == tmp_dimension_llist->head) { /* first */
last_container = *expr;
switch(expr->op_type) {
}
((list_llist_element *) le->data)->value = last_container;
zend_llist_destroy(&((list_llist_element *) le->data)->dimensions);
- zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC);
- zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC);
+ zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC);
CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
le = le->next;
}
}
-void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type CLS_DC)
+void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
znode lval;
znode result;
if (varname->op_type == IS_CONST) {
zval_copy_ctor(&varname->u.constant);
}
- fetch_simple_variable(&lval, varname, 0 CLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
+ fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
- zend_do_assign_ref(NULL, &lval, &result CLS_CC);
+ zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
}
-void zend_do_cast(znode *result, znode *expr, int type CLS_DC)
+void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_CAST;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_include_or_eval(int type, znode *result, znode *op1 CLS_DC)
+void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC)
{
- zend_do_extended_fcall_begin(CLS_C);
+ zend_do_extended_fcall_begin(TSRMLS_C);
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_INCLUDE_OR_EVAL;
opline->result.op_type = IS_VAR;
opline->result.u.EA.type |= EXT_TYPE_UNUSED;
}
}
- zend_do_extended_fcall_end(CLS_C);
+ zend_do_extended_fcall_end(TSRMLS_C);
}
-void zend_do_indirect_references(znode *result, znode *num_references, znode *variable CLS_DC)
+void zend_do_indirect_references(znode *result, znode *num_references, znode *variable TSRMLS_DC)
{
int i;
- zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
for (i=1; i<num_references->u.constant.value.lval; i++) {
- fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R CLS_CC);
+ fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC);
*variable = *result;
}
- zend_do_begin_variable_parse(CLS_C);
- fetch_simple_variable(result, variable, 1 CLS_CC);
+ zend_do_begin_variable_parse(TSRMLS_C);
+ fetch_simple_variable(result, variable, 1 TSRMLS_CC);
}
-void zend_do_unset(znode *variable CLS_DC)
+void zend_do_unset(znode *variable TSRMLS_DC)
{
zend_op *last_op;
}
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC)
+void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC)
{
zend_op *opline;
- zend_do_end_variable_parse(BP_VAR_IS, 0 CLS_CC);
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_do_end_variable_parse(BP_VAR_IS, 0 TSRMLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ISSET_ISEMPTY;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable CLS_DC)
+void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
/* Preform array reset */
opline->opcode = ZEND_FE_RESET;
/* save the location of the beginning of the loop (array fetching) */
foreach_token->u.opline_num = get_next_op_number(CG(active_op_array));
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_FE_FETCH;
opline->result.op_type = IS_TMP_VAR;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
}
-void zend_do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC)
+void zend_do_foreach_cont(znode *value, znode *key, znode *as_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
znode result_value, result_key, dummy;
if (key->op_type != IS_UNUSED) {
result_value = opline->result;
if (key->op_type != IS_UNUSED) {
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
opline->result.op_type = IS_VAR;
opline->result.u.EA.type = 0;
result_key = opline->result;
}
- zend_do_assign(&dummy, value, &result_value CLS_CC);
+ zend_do_assign(&dummy, value, &result_value TSRMLS_CC);
CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
if (key->op_type != IS_UNUSED) {
- zend_do_assign(&dummy, key, &result_key CLS_CC);
+ zend_do_assign(&dummy, key, &result_key TSRMLS_CC);
CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
}
- zend_do_free(as_token CLS_CC);
+ zend_do_free(as_token TSRMLS_CC);
- do_begin_loop(CLS_C);
+ do_begin_loop(TSRMLS_C);
INC_BPC(CG(active_op_array));
}
-void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC)
+void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMP;
opline->op1.u.opline_num = foreach_token->u.opline_num;
CG(active_op_array)->opcodes[foreach_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
- do_end_loop(foreach_token->u.opline_num CLS_CC);
+ do_end_loop(foreach_token->u.opline_num TSRMLS_CC);
- generate_free_foreach_copy(open_brackets_token CLS_CC);
+ generate_free_foreach_copy(open_brackets_token TSRMLS_CC);
zend_stack_del_top(&CG(foreach_copy_stack));
}
-void zend_do_declare_begin(CLS_D)
+void zend_do_declare_begin(TSRMLS_D)
{
zend_stack_push(&CG(declare_stack), &CG(declarables), sizeof(zend_declarables));
}
-void zend_do_declare_stmt(znode *var, znode *val CLS_DC)
+void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC)
{
convert_to_string(&var->u.constant);
}
-void zend_do_declare_end(CLS_D)
+void zend_do_declare_end(TSRMLS_D)
{
zend_declarables *declarables;
}
-void zend_do_end_heredoc(CLS_D)
+void zend_do_end_heredoc(TSRMLS_D)
{
int opline_num = get_next_op_number(CG(active_op_array))-1;
zend_op *opline = &CG(active_op_array)->opcodes[opline_num];
}
-void zend_do_exit(znode *result, znode *message CLS_DC)
+void zend_do_exit(znode *result, znode *message TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_EXIT;
opline->op1 = *message;
}
-void zend_do_begin_silence(znode *strudel_token CLS_DC)
+void zend_do_begin_silence(znode *strudel_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_BEGIN_SILENCE;
opline->result.op_type = IS_TMP_VAR;
}
-void zend_do_end_silence(znode *strudel_token CLS_DC)
+void zend_do_end_silence(znode *strudel_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_END_SILENCE;
opline->op1 = *strudel_token;
}
-void zend_do_begin_qm_op(znode *cond, znode *qm_token CLS_DC)
+void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC)
{
int jmpz_op_number = get_next_op_number(CG(active_op_array));
zend_op *opline;
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMPZ;
opline->op1 = *cond;
}
-void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token CLS_DC)
+void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
CG(active_op_array)->opcodes[qm_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */
*qm_token = opline->result;
colon_token->u.opline_num = get_next_op_number(CG(active_op_array));
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_JMP;
SET_UNUSED(opline->op1);
SET_UNUSED(opline->op2);
}
-void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token CLS_DC)
+void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token TSRMLS_DC)
{
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_QM_ASSIGN;
opline->result = *qm_token;
}
-void zend_do_extended_info(CLS_D)
+void zend_do_extended_info(TSRMLS_D)
{
zend_op *opline;
return;
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_EXT_STMT;
SET_UNUSED(opline->op1);
}
-void zend_do_extended_fcall_begin(CLS_D)
+void zend_do_extended_fcall_begin(TSRMLS_D)
{
zend_op *opline;
return;
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_EXT_FCALL_BEGIN;
SET_UNUSED(opline->op1);
}
-void zend_do_extended_fcall_end(CLS_D)
+void zend_do_extended_fcall_end(TSRMLS_D)
{
zend_op *opline;
return;
}
- opline = get_next_op(CG(active_op_array) CLS_CC);
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_EXT_FCALL_END;
SET_UNUSED(opline->op1);
SET_UNUSED(opline->op2);
}
-void zend_do_ticks(CLS_D)
+void zend_do_ticks(TSRMLS_D)
{
if (CG(declarables).ticks.value.lval) {
- zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+ zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_TICKS;
opline->op1.u.constant = CG(declarables).ticks;
}
-int zendlex(znode *zendlval CLS_DC)
+int zendlex(znode *zendlval TSRMLS_DC)
{
int retval;
zendlval->u.constant.type = IS_LONG;
- retval = lex_scan(&zendlval->u.constant CLS_CC);
+ retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
switch(retval) {
case T_COMMENT:
case T_OPEN_TAG:
case T_WHITESPACE:
- retval = zendlex(zendlval CLS_CC);
+ retval = zendlex(zendlval TSRMLS_CC);
break;
case T_CLOSE_TAG:
retval = ';'; /* implicit ; */
#define INC_BPC(op_array) if (CG(interactive)) { ((op_array)->backpatch_count++); }
#define DEC_BPC(op_array) if (CG(interactive)) { ((op_array)->backpatch_count--); }
-#define HANDLE_INTERACTIVE() if (CG(interactive)) { execute_new_code(CLS_C); }
+#define HANDLE_INTERACTIVE() if (CG(interactive)) { execute_new_code(TSRMLS_C); }
typedef struct _zend_op_array zend_op_array;
BEGIN_EXTERN_C()
-void init_compiler(CLS_D TSRMLS_DC);
-void shutdown_compiler(CLS_D);
-void zend_init_compiler_data_structures(CLS_D);
+void init_compiler(TSRMLS_D);
+void shutdown_compiler(TSRMLS_D);
+void zend_init_compiler_data_structures(TSRMLS_D);
-extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type CLS_DC);
+extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
-void zend_activate(CLS_D TSRMLS_DC);
-void zend_deactivate(CLS_D TSRMLS_DC);
+void zend_activate(TSRMLS_D);
+void zend_deactivate(TSRMLS_D);
void zend_activate_modules(void);
void zend_deactivate_modules(void);
-int lex_scan(zval *zendlval CLS_DC);
-void startup_scanner(CLS_D);
-void shutdown_scanner(CLS_D);
+int lex_scan(zval *zendlval TSRMLS_DC);
+void startup_scanner(TSRMLS_D);
+void shutdown_scanner(TSRMLS_D);
ZEND_API char *zend_set_compiled_filename(char *new_compiled_filename);
ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename);
-ZEND_API char *zend_get_compiled_filename(CLS_D);
-ZEND_API int zend_get_compiled_lineno(CLS_D);
+ZEND_API char *zend_get_compiled_filename(TSRMLS_D);
+ZEND_API int zend_get_compiled_lineno(TSRMLS_D);
#ifdef ZTS
-const char *zend_get_zendtext(CLS_D);
-int zend_get_zendleng(CLS_D);
+const char *zend_get_zendtext(TSRMLS_D);
+int zend_get_zendleng(TSRMLS_D);
#endif
/* parser-driven code generators */
-void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_unary_op(int op, znode *result, znode *op1 CLS_DC);
-void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_assign(znode *result, znode *variable, znode *value CLS_DC);
-void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar CLS_DC);
-void fetch_simple_variable(znode *result, znode *varname, int bp CLS_DC);
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op CLS_DC);
-void zend_do_indirect_references(znode *result, znode *num_references, znode *variable CLS_DC);
-void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type CLS_DC);
-void zend_do_fetch_globals(znode *varname CLS_DC);
-
-void fetch_array_begin(znode *result, znode *varname, znode *first_dim CLS_DC);
-void fetch_array_dim(znode *result, znode *parent, znode *dim CLS_DC);
-void fetch_string_offset(znode *result, znode *parent, znode *offset CLS_DC);
-void zend_do_print(znode *result, znode *arg CLS_DC);
-void zend_do_echo(znode *arg CLS_DC);
+void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_unary_op(int op, znode *result, znode *op1 TSRMLS_DC);
+void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC);
+void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC);
+void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC);
+void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op TSRMLS_DC);
+void zend_do_indirect_references(znode *result, znode *num_references, znode *variable TSRMLS_DC);
+void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC);
+void zend_do_fetch_globals(znode *varname TSRMLS_DC);
+
+void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC);
+void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC);
+void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC);
+void zend_do_print(znode *result, znode *arg TSRMLS_DC);
+void zend_do_echo(znode *arg TSRMLS_DC);
typedef int (*unary_op_type)(zval *, zval *);
ZEND_API unary_op_type get_unary_op(int opcode);
ZEND_API void *get_binary_op(int opcode);
-void zend_do_while_cond(znode *expr, znode *close_bracket_token CLS_DC);
-void zend_do_while_end(znode *while_token, znode *close_bracket_token CLS_DC);
-void zend_do_do_while_begin(CLS_D);
-void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr CLS_DC);
+void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC);
+void zend_do_while_end(znode *while_token, znode *close_bracket_token TSRMLS_DC);
+void zend_do_do_while_begin(TSRMLS_D);
+void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr TSRMLS_DC);
-void zend_do_if_cond(znode *cond, znode *closing_bracket_token CLS_DC);
-void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize CLS_DC);
-void zend_do_if_end(CLS_D);
+void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC);
+void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize TSRMLS_DC);
+void zend_do_if_end(TSRMLS_D);
-void zend_do_for_cond(znode *expr, znode *second_semicolon_token CLS_DC);
-void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token CLS_DC);
-void zend_do_for_end(znode *second_semicolon_token CLS_DC);
+void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC);
+void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token TSRMLS_DC);
+void zend_do_for_end(znode *second_semicolon_token TSRMLS_DC);
-void zend_do_pre_incdec(znode *result, znode *op1, int op CLS_DC);
-void zend_do_post_incdec(znode *result, znode *op1, int op CLS_DC);
+void zend_do_pre_incdec(znode *result, znode *op1, int op TSRMLS_DC);
+void zend_do_post_incdec(znode *result, znode *op1, int op TSRMLS_DC);
-void zend_do_begin_variable_parse(CLS_D);
-void zend_do_end_variable_parse(int type, int arg_offset CLS_DC);
+void zend_do_begin_variable_parse(TSRMLS_D);
+void zend_do_end_variable_parse(int type, int arg_offset TSRMLS_DC);
-void zend_do_free(znode *op1 CLS_DC);
+void zend_do_free(znode *op1 TSRMLS_DC);
-void zend_do_init_string(znode *result CLS_DC);
-void zend_do_add_char(znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_add_string(znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC);
+void zend_do_init_string(znode *result TSRMLS_DC);
+void zend_do_add_char(znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference CLS_DC);
-void zend_do_end_function_declaration(znode *function_token CLS_DC);
-void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type CLS_DC);
-int zend_do_begin_function_call(znode *function_name CLS_DC);
-void zend_do_begin_dynamic_function_call(znode *function_name CLS_DC);
-void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name CLS_DC);
-void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall CLS_DC);
-void zend_do_return(znode *expr, int do_end_vparse CLS_DC);
+void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference TSRMLS_DC);
+void zend_do_end_function_declaration(znode *function_token TSRMLS_DC);
+void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type TSRMLS_DC);
+int zend_do_begin_function_call(znode *function_name TSRMLS_DC);
+void zend_do_begin_dynamic_function_call(znode *function_name TSRMLS_DC);
+void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name TSRMLS_DC);
+void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall TSRMLS_DC);
+void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC);
ZEND_API int do_bind_function_or_class(zend_op *opline, HashTable *function_table, HashTable *class_table, int compile_time);
void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce);
-void zend_do_early_binding(CLS_D);
+void zend_do_early_binding(TSRMLS_D);
-void zend_do_pass_param(znode *param, int op, int offset CLS_DC);
+void zend_do_pass_param(znode *param, int op, int offset TSRMLS_DC);
-void zend_do_boolean_or_begin(znode *expr1, znode *op_token CLS_DC);
-void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token CLS_DC);
-void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
+void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC);
+void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC);
+void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC);
+void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC);
-void zend_do_brk_cont(int op, znode *expr CLS_DC);
+void zend_do_brk_cont(int op, znode *expr TSRMLS_DC);
-void zend_do_switch_cond(znode *cond CLS_DC);
-void zend_do_switch_end(znode *case_list CLS_DC);
-void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr CLS_DC);
-void zend_do_case_after_statement(znode *result, znode *case_token CLS_DC);
-void zend_do_default_before_statement(znode *case_list, znode *default_token CLS_DC);
+void zend_do_switch_cond(znode *cond TSRMLS_DC);
+void zend_do_switch_end(znode *case_list TSRMLS_DC);
+void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC);
+void zend_do_case_after_statement(znode *result, znode *case_token TSRMLS_DC);
+void zend_do_default_before_statement(znode *case_list, znode *default_token TSRMLS_DC);
-void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name CLS_DC);
-void zend_do_end_class_declaration(CLS_D);
-void zend_do_declare_property(znode *var_name, znode *value CLS_DC);
+void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name TSRMLS_DC);
+void zend_do_end_class_declaration(TSRMLS_D);
+void zend_do_declare_property(znode *var_name, znode *value TSRMLS_DC);
-void zend_do_fetch_property(znode *result, znode *object, znode *property CLS_DC);
+void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC);
-void zend_do_push_object(znode *object CLS_DC);
-void zend_do_pop_object(znode *object CLS_DC);
+void zend_do_push_object(znode *object TSRMLS_DC);
+void zend_do_pop_object(znode *object TSRMLS_DC);
-void zend_do_begin_new_object(znode *new_token, znode *class_name CLS_DC);
-void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list CLS_DC);
+void zend_do_begin_new_object(znode *new_token, znode *class_name TSRMLS_DC);
+void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list TSRMLS_DC);
-void zend_do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC);
+void zend_do_fetch_constant(znode *result, znode *constant_name, int mode TSRMLS_DC);
-void zend_do_shell_exec(znode *result, znode *cmd CLS_DC);
+void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC);
-void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
+void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC);
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC);
void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr);
-void zend_do_list_init(CLS_D);
-void zend_do_list_end(znode *result, znode *expr CLS_DC);
-void zend_do_add_list_element(znode *element CLS_DC);
-void zend_do_new_list_begin(CLS_D);
-void zend_do_new_list_end(CLS_D);
+void zend_do_list_init(TSRMLS_D);
+void zend_do_list_end(znode *result, znode *expr TSRMLS_DC);
+void zend_do_add_list_element(znode *element TSRMLS_DC);
+void zend_do_new_list_begin(TSRMLS_D);
+void zend_do_new_list_end(TSRMLS_D);
-void zend_do_cast(znode *result, znode *expr, int type CLS_DC);
-void zend_do_include_or_eval(int type, znode *result, znode *op1 CLS_DC);
+void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC);
+void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC);
-void zend_do_unset(znode *variable CLS_DC);
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC);
+void zend_do_unset(znode *variable TSRMLS_DC);
+void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC);
-void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable CLS_DC);
-void zend_do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC);
-void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC);
+void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable TSRMLS_DC);
+void zend_do_foreach_cont(znode *value, znode *key, znode *as_token TSRMLS_DC);
+void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token TSRMLS_DC);
-void zend_do_declare_begin(CLS_D);
-void zend_do_declare_stmt(znode *var, znode *val CLS_DC);
-void zend_do_declare_end(CLS_D);
+void zend_do_declare_begin(TSRMLS_D);
+void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC);
+void zend_do_declare_end(TSRMLS_D);
-void zend_do_end_heredoc(CLS_D);
+void zend_do_end_heredoc(TSRMLS_D);
-void zend_do_exit(znode *result, znode *message CLS_DC);
+void zend_do_exit(znode *result, znode *message TSRMLS_DC);
-void zend_do_begin_silence(znode *strudel_token CLS_DC);
-void zend_do_end_silence(znode *strudel_token CLS_DC);
+void zend_do_begin_silence(znode *strudel_token TSRMLS_DC);
+void zend_do_end_silence(znode *strudel_token TSRMLS_DC);
-void zend_do_begin_qm_op(znode *cond, znode *qm_token CLS_DC);
-void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token CLS_DC);
-void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token CLS_DC);
+void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC);
+void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC);
+void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token TSRMLS_DC);
-void zend_do_extended_info(CLS_D);
-void zend_do_extended_fcall_begin(CLS_D);
-void zend_do_extended_fcall_end(CLS_D);
+void zend_do_extended_info(TSRMLS_D);
+void zend_do_extended_fcall_begin(TSRMLS_D);
+void zend_do_extended_fcall_end(TSRMLS_D);
-void zend_do_ticks(CLS_D);
+void zend_do_ticks(TSRMLS_D);
ZEND_API void function_add_ref(zend_function *function);
/* helper functions in zend_language_scanner.l */
-ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS_DC);
-ZEND_API zend_op_array *compile_string(zval *source_string, char *filename CLS_DC);
-ZEND_API zend_op_array *compile_filename(int type, zval *filename CLS_DC TSRMLS_DC);
-ZEND_API int zend_execute_scripts(int type CLS_DC TSRMLS_DC, int file_count, ...);
-ZEND_API int open_file_for_scanning(zend_file_handle *file_handle CLS_DC);
-ZEND_API void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_DC);
+ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC);
+ZEND_API zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC);
+ZEND_API zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC);
+ZEND_API int zend_execute_scripts(int type TSRMLS_DC, int file_count, ...);
+ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC);
+ZEND_API void init_op_array(zend_op_array *op_array, int type, int initial_ops_size TSRMLS_DC);
ZEND_API void destroy_op_array(zend_op_array *op_array);
-ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle CLS_DC);
+ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC);
ZEND_API void zend_file_handle_dtor(zend_file_handle *fh);
ZEND_API void destroy_zend_function(zend_function *function);
#define ZEND_FUNCTION_DTOR (void (*)(void *)) destroy_zend_function
#define ZEND_CLASS_DTOR (void (*)(void *)) destroy_zend_class
-zend_op *get_next_op(zend_op_array *op_array CLS_DC);
-void init_op(zend_op *op CLS_DC);
+zend_op *get_next_op(zend_op_array *op_array TSRMLS_DC);
+void init_op(zend_op *op TSRMLS_DC);
int get_next_op_number(zend_op_array *op_array);
int print_class(zend_class_entry *class_entry);
void print_op_array(zend_op_array *op_array, int optimizations);
ZEND_API zend_bool zend_is_compiling(void);
ZEND_API char *zend_make_compiled_string_description(char *name);
-int zendlex(znode *zendlval CLS_DC);
+int zendlex(znode *zendlval TSRMLS_DC);
#define ZEND_NOP 0
int return_value_used;
zval *inc_filename = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R);
zval tmp_inc_filename;
- CLS_FETCH();
+ TSRMLS_FETCH();
if (inc_filename->type!=IS_STRING) {
tmp_inc_filename = *inc_filename;
if (file_handle.handle.fp) {
if (!opened_path || zend_hash_add(&EG(included_files), opened_path, strlen(opened_path)+1, (void *)&dummy, sizeof(int), NULL)==SUCCESS) {
- new_op_array = zend_compile_file(&file_handle, (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) CLS_CC);
- zend_destroy_file_handle(&file_handle CLS_CC);
+ new_op_array = zend_compile_file(&file_handle, (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
+ zend_destroy_file_handle(&file_handle TSRMLS_CC);
opened_path = NULL; /* zend_destroy_file_handle() already frees it */
} else {
fclose(file_handle.handle.fp);
break;
case ZEND_INCLUDE:
case ZEND_REQUIRE:
- new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename CLS_CC TSRMLS_CC);
+ new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename TSRMLS_CC);
break;
case ZEND_EVAL: {
char *eval_desc = zend_make_compiled_string_description("eval()'d code");
- new_op_array = compile_string(inc_filename, eval_desc CLS_CC);
+ new_op_array = compile_string(inc_filename, eval_desc TSRMLS_CC);
efree(eval_desc);
}
break;
ZEND_API extern void (*zend_execute)(zend_op_array *op_array TSRMLS_DC);
-void init_executor(CLS_D TSRMLS_DC);
+void init_executor(TSRMLS_D);
void shutdown_executor(TSRMLS_D);
ZEND_API void execute(zend_op_array *op_array TSRMLS_DC);
ZEND_API int zend_is_true(zval *op);
}
}
-ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC TSRMLS_DC);
+ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
static inline int i_zend_is_true(zval *op)
{
int result;
return SUCCESS;
}
-void execute_new_code(CLS_D);
+void execute_new_code(TSRMLS_D);
/* services */
}
-void init_executor(CLS_D TSRMLS_DC)
+void init_executor(TSRMLS_D)
{
INIT_ZVAL(EG(uninitialized_zval));
INIT_ZVAL(EG(error_zval));
}
-ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC TSRMLS_DC)
+ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC)
{
zval pv;
zend_op_array *new_op_array;
original_handle_op_arrays = CG(handle_op_arrays);
CG(handle_op_arrays) = 0;
- new_op_array = compile_string(&pv, string_name CLS_CC);
+ new_op_array = compile_string(&pv, string_name TSRMLS_CC);
CG(handle_op_arrays) = original_handle_op_arrays;
if (new_op_array) {
}
-void execute_new_code(CLS_D)
+void execute_new_code(TSRMLS_D)
{
zend_op *opline, *end;
zend_op *ret_opline;
- TSRMLS_FETCH();
if (!CG(interactive)
|| CG(active_op_array)->backpatch_count>0
return;
}
- ret_opline = get_next_op(CG(active_op_array) CLS_CC);
+ ret_opline = get_next_op(CG(active_op_array) TSRMLS_CC);
ret_opline->opcode = ZEND_RETURN;
ret_opline->op1.op_type = IS_CONST;
INIT_ZVAL(ret_opline->op1.u.constant);
TSRMLS_FETCH();
/* is there any point in this? we're terminating the request anyway...
- PLS_FETCH();
-
PG(connection_status) |= PHP_CONNECTION_TIMEOUT;
*/
zend_error(E_ERROR, "Maximum execution time of %d second%s exceeded",
break;
case WM_TIMER: {
#ifdef ZTS
- zend_executor_globals *executor_globals;
+ void ***tsrm_ls;
- executor_globals = ts_resource_ex(executor_globals_id, &wParam);
- if (!executor_globals) {
+ tsrm_ls = ts_resource_ex(0, &wParam);
+ if (!tsrm_ls) {
/* Thread died before receiving its timeout? */
break;
}
#endif
KillTimer(timeout_window, wParam);
- executor_globals->timed_out = 1;
+ EG(timed_out) = 1;
}
break;
default:
#define ZEND_FAST_ALLOC(p, type, fc_type) \
{ \
- ALS_FETCH(); \
+ TSRMLS_FETCH(); \
\
if (((p) = (type *) AG(fast_cache_list_head)[fc_type])) { \
AG(fast_cache_list_head)[fc_type] = ((zend_fast_cache_list_entry *) AG(fast_cache_list_head)[fc_type])->next; \
#define ZEND_FAST_FREE(p, fc_type) \
{ \
- ALS_FETCH(); \
+ TSRMLS_FETCH(); \
\
((zend_fast_cache_list_entry *) (p))->next = (zend_fast_cache_list_entry *) AG(fast_cache_list_head)[fc_type]; \
AG(fast_cache_list_head)[fc_type] = (zend_fast_cache_list_entry *) (p); \
/* Compiler */
#ifdef ZTS
-# define CLS_D zend_compiler_globals *compiler_globals
-# define CLS_DC , CLS_D
-# define CLS_C compiler_globals
-# define CLS_CC , CLS_C
-# define CG(v) (((zend_compiler_globals *) compiler_globals)->v)
-# define CLS_FETCH() zend_compiler_globals *compiler_globals = (zend_compiler_globals *) ts_resource(compiler_globals_id)
+# define CG(v) TSRMG(compiler_globals_id, zend_compiler_globals *, v)
BEGIN_EXTERN_C()
int zendparse(void *compiler_globals);
END_EXTERN_C()
#else
-# define CLS_D void
-# define CLS_DC
-# define CLS_C
-# define CLS_CC
# define CG(v) (compiler_globals.v)
-# define CLS_FETCH()
extern ZEND_API struct _zend_compiler_globals compiler_globals;
int zendparse(void);
#endif
/* Memory Manager */
#ifdef ZTS
-# define ALS_D zend_alloc_globals *alloc_globals
-# define ALS_DC , ALS_D
-# define ALS_C alloc_globals
-# define ALS_CC , ALS_C
-# define AG(v) (((zend_alloc_globals *) alloc_globals)->v)
-# define ALS_FETCH() zend_alloc_globals *alloc_globals = (zend_alloc_globals *) ts_resource(alloc_globals_id)
+# define AG(v) TSRMG(alloc_globals_id, zend_alloc_globals *, v)
#else
-# define ALS_D void
-# define ALS_DC
-# define ALS_C
-# define ALS_CC
# define AG(v) (alloc_globals.v)
-# define ALS_FETCH()
extern ZEND_API zend_alloc_globals alloc_globals;
#endif
extern char *zendtext;
extern int zendleng;
#else
-#define zendtext ((char *) zend_get_zendtext(CLS_C))
-#define zendleng zend_get_zendleng(CLS_C)
+#define zendtext ((char *) zend_get_zendtext(TSRMLS_C))
+#define zendleng zend_get_zendleng(TSRMLS_C)
#endif
ZEND_API void zend_html_putc(char c)
char *last_color = syntax_highlighter_ini->highlight_html;
char *next_color;
int in_string=0;
- CLS_FETCH();
+ TSRMLS_FETCH();
zend_printf("<code>");
zend_printf("<font color=\"%s\">\n", last_color);
/* highlight stuff coming back from zendlex() */
token.type = 0;
- while ((token_type=lex_scan(&token CLS_CC))) {
+ while ((token_type=lex_scan(&token TSRMLS_CC))) {
switch (token_type) {
case T_INLINE_HTML:
next_color = syntax_highlighter_ini->highlight_html;
efree(token.value.str.val);
if (has_semicolon) {
/* the following semicolon was unput(), ignore it */
- lex_scan(&token CLS_CC);
+ lex_scan(&token TSRMLS_CC);
}
}
token.type = 0;
extern char *zendtext;
extern int zendleng;
#else
-#define zendtext ((char *) zend_get_zendtext(CLS_C))
-#define zendleng zend_get_zendleng(CLS_C)
+#define zendtext ((char *) zend_get_zendtext(TSRMLS_C))
+#define zendleng zend_get_zendleng(TSRMLS_C)
#endif
int nest_level=0;
int emit_whitespace[256];
int i;
- CLS_FETCH();
+ TSRMLS_FETCH();
memset(emit_whitespace, 0, sizeof(int)*256);
/* highlight stuff coming back from zendlex() */
token.type = 0;
- while ((token_type=lex_scan(&token CLS_CC))) {
+ while ((token_type=lex_scan(&token TSRMLS_CC))) {
switch (token_type) {
case T_INLINE_HTML:
zend_write(zendtext, zendleng);
char *error_buf;
int error_buf_len;
char *currently_parsed_filename = zend_ini_scanner_get_filename();
- CLS_FETCH();
+ TSRMLS_FETCH();
error_buf_len = 128+strlen(currently_parsed_filename); /* should be more than enough */
error_buf = (char *) emalloc(error_buf_len);
{
zend_ini_parser_param ini_parser_param;
int retval;
- CLS_FETCH();
+ TSRMLS_FETCH();
ini_parser_param.ini_parser_cb = ini_parser_cb;
ini_parser_param.arg = arg;
int zend_ini_scanner_get_lineno()
{
- CLS_FETCH();
+ TSRMLS_FETCH();
return CG(ini_scanner)->lineno();
}
char *zend_ini_scanner_get_filename()
{
- CLS_FETCH();
+ TSRMLS_FETCH();
return CG(ini_scanner)->filename;
}
int ini_lex(zval *ini_lval)
{
- CLS_FETCH();
+ TSRMLS_FETCH();
return CG(ini_scanner)->lex_scan(ini_lval);
}
int zend_ini_open_file_for_scanning(zend_file_handle *fh)
{
FILE *fp;
- CLS_FETCH();
+ TSRMLS_FETCH();
switch (fh->type) {
case ZEND_HANDLE_FP:
break;
#ifdef ZTS
case ZEND_HANDLE_STDIOSTREAM: {
- CLS_FETCH();
+ TSRMLS_FETCH();
delete CG(ini_scanner);
}
break;
#define YYERROR_VERBOSE
#define YYSTYPE znode
#ifdef ZTS
-# define YYPARSE_PARAM compiler_globals
-# define YYLEX_PARAM compiler_globals
+# define YYPARSE_PARAM tsrm_ls
+# define YYLEX_PARAM tsrm_ls
#endif
top_statement_list
;
-top_statement_list:
- top_statement_list { zend_do_extended_info(CLS_C); } top_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
+top_statement_list:
+ top_statement_list { zend_do_extended_info(TSRMLS_C); } top_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
| /* empty */
;
top_statement:
statement
- | declaration_statement { zend_do_early_binding(CLS_C); }
+ | declaration_statement { zend_do_early_binding(TSRMLS_C); }
;
inner_statement_list:
- inner_statement_list { zend_do_extended_info(CLS_C); } inner_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
+ inner_statement_list { zend_do_extended_info(TSRMLS_C); } inner_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
| /* empty */
;
statement:
- unticked_statement { zend_do_ticks(CLS_C); }
+ unticked_statement { zend_do_ticks(TSRMLS_C); }
;
unticked_statement:
'{' inner_statement_list '}'
- | T_IF '(' expr ')' { zend_do_if_cond(&$3, &$4 CLS_CC); } statement { zend_do_if_after_statement(&$4, 1 CLS_CC); } elseif_list else_single { zend_do_if_end(CLS_C); }
- | T_IF '(' expr ')' ':' { zend_do_if_cond(&$3, &$4 CLS_CC); } inner_statement_list { zend_do_if_after_statement(&$4, 1 CLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { zend_do_if_end(CLS_C); }
- | T_WHILE '(' { $1.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' { zend_do_while_cond(&$4, &$5 CLS_CC); } while_statement { zend_do_while_end(&$1, &$5 CLS_CC); }
- | T_DO { $1.u.opline_num = get_next_op_number(CG(active_op_array)); zend_do_do_while_begin(CLS_C); } statement T_WHILE '(' { $5.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' ';' { zend_do_do_while_end(&$1, &$5, &$7 CLS_CC); }
+ | T_IF '(' expr ')' { zend_do_if_cond(&$3, &$4 TSRMLS_CC); } statement { zend_do_if_after_statement(&$4, 1 TSRMLS_CC); } elseif_list else_single { zend_do_if_end(TSRMLS_C); }
+ | T_IF '(' expr ')' ':' { zend_do_if_cond(&$3, &$4 TSRMLS_CC); } inner_statement_list { zend_do_if_after_statement(&$4, 1 TSRMLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { zend_do_if_end(TSRMLS_C); }
+ | T_WHILE '(' { $1.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' { zend_do_while_cond(&$4, &$5 TSRMLS_CC); } while_statement { zend_do_while_end(&$1, &$5 TSRMLS_CC); }
+ | T_DO { $1.u.opline_num = get_next_op_number(CG(active_op_array)); zend_do_do_while_begin(TSRMLS_C); } statement T_WHILE '(' { $5.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' ';' { zend_do_do_while_end(&$1, &$5, &$7 TSRMLS_CC); }
| T_FOR
'('
for_expr
- ';' { zend_do_free(&$3 CLS_CC); $4.u.opline_num = get_next_op_number(CG(active_op_array)); }
+ ';' { zend_do_free(&$3 TSRMLS_CC); $4.u.opline_num = get_next_op_number(CG(active_op_array)); }
for_expr
- ';' { zend_do_extended_info(CLS_C); zend_do_for_cond(&$6, &$7 CLS_CC); }
+ ';' { zend_do_extended_info(TSRMLS_C); zend_do_for_cond(&$6, &$7 TSRMLS_CC); }
for_expr
- ')' { zend_do_free(&$9 CLS_CC); zend_do_for_before_statement(&$4, &$7 CLS_CC); }
- for_statement { zend_do_for_end(&$7 CLS_CC); }
- | T_SWITCH '(' expr ')' { zend_do_switch_cond(&$3 CLS_CC); } switch_case_list { zend_do_switch_end(&$6 CLS_CC); }
- | T_BREAK ';' { zend_do_brk_cont(ZEND_BRK, NULL CLS_CC); }
- | T_BREAK expr ';' { zend_do_brk_cont(ZEND_BRK, &$2 CLS_CC); }
- | T_CONTINUE ';' { zend_do_brk_cont(ZEND_CONT, NULL CLS_CC); }
- | T_CONTINUE expr ';' { zend_do_brk_cont(ZEND_CONT, &$2 CLS_CC); }
- | T_RETURN ';' { zend_do_return(NULL, 0 CLS_CC); }
- | T_RETURN expr_without_variable ';' { zend_do_return(&$2, 0 CLS_CC); }
- | T_RETURN cvar ';' { zend_do_return(&$2, 1 CLS_CC); }
+ ')' { zend_do_free(&$9 TSRMLS_CC); zend_do_for_before_statement(&$4, &$7 TSRMLS_CC); }
+ for_statement { zend_do_for_end(&$7 TSRMLS_CC); }
+ | T_SWITCH '(' expr ')' { zend_do_switch_cond(&$3 TSRMLS_CC); } switch_case_list { zend_do_switch_end(&$6 TSRMLS_CC); }
+ | T_BREAK ';' { zend_do_brk_cont(ZEND_BRK, NULL TSRMLS_CC); }
+ | T_BREAK expr ';' { zend_do_brk_cont(ZEND_BRK, &$2 TSRMLS_CC); }
+ | T_CONTINUE ';' { zend_do_brk_cont(ZEND_CONT, NULL TSRMLS_CC); }
+ | T_CONTINUE expr ';' { zend_do_brk_cont(ZEND_CONT, &$2 TSRMLS_CC); }
+ | T_RETURN ';' { zend_do_return(NULL, 0 TSRMLS_CC); }
+ | T_RETURN expr_without_variable ';' { zend_do_return(&$2, 0 TSRMLS_CC); }
+ | T_RETURN cvar ';' { zend_do_return(&$2, 1 TSRMLS_CC); }
| T_GLOBAL global_var_list ';'
| T_STATIC static_var_list ';'
| T_ECHO echo_expr_list ';'
- | T_INLINE_HTML { zend_do_echo(&$1 CLS_CC); }
- | expr ';' { zend_do_free(&$1 CLS_CC); }
+ | T_INLINE_HTML { zend_do_echo(&$1 TSRMLS_CC); }
+ | expr ';' { zend_do_free(&$1 TSRMLS_CC); }
| T_USE use_filename ';' { zend_error(E_COMPILE_ERROR,"use: Not yet supported. Please use include_once() or require_once()"); zval_dtor(&$2.u.constant); }
| T_UNSET '(' unset_variables ')' ';'
- | T_FOREACH '(' w_cvar T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 1 CLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 CLS_CC); }
- | T_FOREACH '(' expr_without_variable T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 0 CLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 CLS_CC); }
- | T_DECLARE { zend_do_declare_begin(CLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(CLS_C); }
+ | T_FOREACH '(' w_cvar T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 1 TSRMLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 TSRMLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 TSRMLS_CC); }
+ | T_FOREACH '(' expr_without_variable T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 0 TSRMLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 TSRMLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 TSRMLS_CC); }
+ | T_DECLARE { zend_do_declare_begin(TSRMLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(TSRMLS_C); }
| ';' /* empty statement */
;
;
unset_variable:
- cvar { zend_do_end_variable_parse(BP_VAR_UNSET, 0 CLS_CC); zend_do_unset(&$1 CLS_CC); }
+ cvar { zend_do_end_variable_parse(BP_VAR_UNSET, 0 TSRMLS_CC); zend_do_unset(&$1 TSRMLS_CC); }
;
use_filename:
declaration_statement:
- unticked_declaration_statement { zend_do_ticks(CLS_C); }
+ unticked_declaration_statement { zend_do_ticks(TSRMLS_C); }
;
unticked_declaration_statement:
- T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
- '(' parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 CLS_CC); }
- | T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
- parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 CLS_CC); }
- | T_CLASS T_STRING { zend_do_begin_class_declaration(&$2, NULL CLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(CLS_C); }
- | T_CLASS T_STRING T_EXTENDS T_STRING { zend_do_begin_class_declaration(&$2, &$4 CLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(CLS_C); }
+ T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type TSRMLS_CC); }
+ '(' parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
+ | T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type TSRMLS_CC); }
+ parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
+ | T_CLASS T_STRING { zend_do_begin_class_declaration(&$2, NULL TSRMLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(TSRMLS_C); }
+ | T_CLASS T_STRING T_EXTENDS T_STRING { zend_do_begin_class_declaration(&$2, &$4 TSRMLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(TSRMLS_C); }
;
declare_list:
- T_STRING '=' static_scalar { zend_do_declare_stmt(&$1, &$3 CLS_CC); }
- | declare_list ',' T_STRING '=' static_scalar { zend_do_declare_stmt(&$3, &$5 CLS_CC); }
+ T_STRING '=' static_scalar { zend_do_declare_stmt(&$1, &$3 TSRMLS_CC); }
+ | declare_list ',' T_STRING '=' static_scalar { zend_do_declare_stmt(&$3, &$5 TSRMLS_CC); }
;
case_list:
/* empty */ { $$.op_type = IS_UNUSED; }
- | case_list T_CASE expr case_separator { zend_do_extended_info(CLS_C); zend_do_case_before_statement(&$1, &$2, &$3 CLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST }
- | case_list T_DEFAULT case_separator { zend_do_extended_info(CLS_C); zend_do_default_before_statement(&$1, &$2 CLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST; }
+ | case_list T_CASE expr case_separator { zend_do_extended_info(TSRMLS_C); zend_do_case_before_statement(&$1, &$2, &$3 TSRMLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 TSRMLS_CC); $$.op_type = IS_CONST }
+ | case_list T_DEFAULT case_separator { zend_do_extended_info(TSRMLS_C); zend_do_default_before_statement(&$1, &$2 TSRMLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 TSRMLS_CC); $$.op_type = IS_CONST; }
;
elseif_list:
/* empty */
- | elseif_list T_ELSEIF '(' expr ')' { zend_do_if_cond(&$4, &$5 CLS_CC); } statement { zend_do_if_after_statement(&$5, 0 CLS_CC); }
+ | elseif_list T_ELSEIF '(' expr ')' { zend_do_if_cond(&$4, &$5 TSRMLS_CC); } statement { zend_do_if_after_statement(&$5, 0 TSRMLS_CC); }
;
new_elseif_list:
/* empty */
- | new_elseif_list T_ELSEIF '(' expr ')' ':' { zend_do_if_cond(&$4, &$5 CLS_CC); } inner_statement_list { zend_do_if_after_statement(&$5, 0 CLS_CC); }
+ | new_elseif_list T_ELSEIF '(' expr ')' ':' { zend_do_if_cond(&$4, &$5 TSRMLS_CC); } inner_statement_list { zend_do_if_after_statement(&$5, 0 TSRMLS_CC); }
;
non_empty_parameter_list:
- T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
- | '&' T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
- | T_CONST T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
- | T_VARIABLE '=' static_scalar { znode tmp; fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$3, BYREF_NONE CLS_CC); }
- | non_empty_parameter_list ',' T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
- | non_empty_parameter_list ',' '&' T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
- | non_empty_parameter_list ',' T_CONST T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
- | non_empty_parameter_list ',' T_VARIABLE '=' static_scalar { znode tmp; fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$5, BYREF_NONE CLS_CC); }
+ T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$1, 0 TSRMLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE TSRMLS_CC); }
+ | '&' T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$2, 0 TSRMLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE TSRMLS_CC); }
+ | T_CONST T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$2, 0 TSRMLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE TSRMLS_CC); }
+ | T_VARIABLE '=' static_scalar { znode tmp; fetch_simple_variable(&tmp, &$1, 0 TSRMLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$3, BYREF_NONE TSRMLS_CC); }
+ | non_empty_parameter_list ',' T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$3, 0 TSRMLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE TSRMLS_CC); }
+ | non_empty_parameter_list ',' '&' T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$4, 0 TSRMLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE TSRMLS_CC); }
+ | non_empty_parameter_list ',' T_CONST T_VARIABLE { znode tmp; fetch_simple_variable(&tmp, &$4, 0 TSRMLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE TSRMLS_CC); }
+ | non_empty_parameter_list ',' T_VARIABLE '=' static_scalar { znode tmp; fetch_simple_variable(&tmp, &$3, 0 TSRMLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$5, BYREF_NONE TSRMLS_CC); }
;
non_empty_function_call_parameter_list:
- expr_without_variable { $$.u.constant.value.lval = 1; zend_do_pass_param(&$1, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
- | cvar { $$.u.constant.value.lval = 1; zend_do_pass_param(&$1, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
- | '&' w_cvar { $$.u.constant.value.lval = 1; zend_do_pass_param(&$2, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
- | non_empty_function_call_parameter_list ',' expr_without_variable { $$.u.constant.value.lval=$1.u.constant.value.lval+1; zend_do_pass_param(&$3, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
- | non_empty_function_call_parameter_list ',' cvar { $$.u.constant.value.lval=$1.u.constant.value.lval+1; zend_do_pass_param(&$3, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
- | non_empty_function_call_parameter_list ',' '&' w_cvar { $$.u.constant.value.lval=$1.u.constant.value.lval+1; zend_do_pass_param(&$4, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
+ expr_without_variable { $$.u.constant.value.lval = 1; zend_do_pass_param(&$1, ZEND_SEND_VAL, $$.u.constant.value.lval TSRMLS_CC); }
+ | cvar { $$.u.constant.value.lval = 1; zend_do_pass_param(&$1, ZEND_SEND_VAR, $$.u.constant.value.lval TSRMLS_CC); }
+ | '&' w_cvar { $$.u.constant.value.lval = 1; zend_do_pass_param(&$2, ZEND_SEND_REF, $$.u.constant.value.lval TSRMLS_CC); }
+ | non_empty_function_call_parameter_list ',' expr_without_variable { $$.u.constant.value.lval=$1.u.constant.value.lval+1; zend_do_pass_param(&$3, ZEND_SEND_VAL, $$.u.constant.value.lval TSRMLS_CC); }
+ | non_empty_function_call_parameter_list ',' cvar { $$.u.constant.value.lval=$1.u.constant.value.lval+1; zend_do_pass_param(&$3, ZEND_SEND_VAR, $$.u.constant.value.lval TSRMLS_CC); }
+ | non_empty_function_call_parameter_list ',' '&' w_cvar { $$.u.constant.value.lval=$1.u.constant.value.lval+1; zend_do_pass_param(&$4, ZEND_SEND_REF, $$.u.constant.value.lval TSRMLS_CC); }
;
global_var_list:
- global_var_list ',' global_var { zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
- | global_var { zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
+ global_var_list ',' global_var { zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_GLOBAL TSRMLS_CC); }
+ | global_var { zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_GLOBAL TSRMLS_CC); }
;
static_var_list:
- static_var_list ',' T_VARIABLE { zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_STATIC CLS_CC); }
- | static_var_list ',' T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$3, &$5, ZEND_FETCH_STATIC CLS_CC); }
- | T_VARIABLE { zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_STATIC CLS_CC); }
- | T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$1, &$3, ZEND_FETCH_STATIC CLS_CC); }
+ static_var_list ',' T_VARIABLE { zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }
+ | static_var_list ',' T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$3, &$5, ZEND_FETCH_STATIC TSRMLS_CC); }
+ | T_VARIABLE { zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }
+ | T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$1, &$3, ZEND_FETCH_STATIC TSRMLS_CC); }
;
class_statement:
T_VAR class_variable_decleration ';'
- | T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); } '('
- parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 CLS_CC); }
- | T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); }
- parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 CLS_CC); }
+ | T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type TSRMLS_CC); } '('
+ parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
+ | T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type TSRMLS_CC); }
+ parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
;
| '&' { $$.op_type = ZEND_RETURN_REF; }
class_variable_decleration:
- class_variable_decleration ',' T_VARIABLE { zend_do_declare_property(&$3, NULL CLS_CC); }
- | class_variable_decleration ',' T_VARIABLE '=' static_scalar { zend_do_declare_property(&$3, &$5 CLS_CC); }
- | T_VARIABLE { zend_do_declare_property(&$1, NULL CLS_CC); }
- | T_VARIABLE '=' static_scalar { zend_do_declare_property(&$1, &$3 CLS_CC); }
+ class_variable_decleration ',' T_VARIABLE { zend_do_declare_property(&$3, NULL TSRMLS_CC); }
+ | class_variable_decleration ',' T_VARIABLE '=' static_scalar { zend_do_declare_property(&$3, &$5 TSRMLS_CC); }
+ | T_VARIABLE { zend_do_declare_property(&$1, NULL TSRMLS_CC); }
+ | T_VARIABLE '=' static_scalar { zend_do_declare_property(&$1, &$3 TSRMLS_CC); }
;
echo_expr_list:
- | echo_expr_list ',' expr { zend_do_echo(&$3 CLS_CC); }
- | expr { zend_do_echo(&$1 CLS_CC); }
+ | echo_expr_list ',' expr { zend_do_echo(&$3 TSRMLS_CC); }
+ | expr { zend_do_echo(&$1 TSRMLS_CC); }
;
;
non_empty_for_expr:
- non_empty_for_expr ',' { zend_do_free(&$1 CLS_CC); } expr { $$ = $4; }
+ non_empty_for_expr ',' { zend_do_free(&$1 TSRMLS_CC); } expr { $$ = $4; }
| expr { $$ = $1; }
;
expr_without_variable:
- T_LIST '(' { zend_do_list_init(CLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 CLS_CC); }
- | cvar '=' expr { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign(&$$, &$1, &$3 CLS_CC); }
- | cvar '=' '&' w_cvar { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$4 CLS_CC); }
- | cvar '=' '&' function_call { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$4 CLS_CC); }
- | cvar '=' '&' T_NEW static_or_variable_string { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_new_object(&$4, &$5 CLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$5, &$4, &$7 CLS_CC); zend_do_extended_fcall_end(CLS_C); zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$3 CLS_CC); }
- | T_NEW static_or_variable_string { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_new_object(&$1, &$2 CLS_CC); } ctor_arguments { zend_do_end_new_object(&$$, &$2, &$1, &$4 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
- | cvar T_PLUS_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 CLS_CC); }
- | cvar T_MINUS_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 CLS_CC); }
- | cvar T_MUL_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 CLS_CC); }
- | cvar T_DIV_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 CLS_CC); }
- | cvar T_CONCAT_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 CLS_CC); }
- | cvar T_MOD_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 CLS_CC); }
- | cvar T_AND_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 CLS_CC); }
- | cvar T_OR_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 CLS_CC); }
- | cvar T_XOR_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 CLS_CC); }
- | cvar T_SL_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 CLS_CC); }
- | cvar T_SR_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 CLS_CC); }
- | rw_cvar T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC CLS_CC); }
- | T_INC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC CLS_CC); }
- | rw_cvar T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC CLS_CC); }
- | T_DEC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC CLS_CC); }
- | expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
- | expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }
- | expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
- | expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }
- | expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 CLS_CC); }
- | expr '|' expr { zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 CLS_CC); }
- | expr '&' expr { zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 CLS_CC); }
- | expr '^' expr { zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 CLS_CC); }
- | expr '.' expr { zend_do_binary_op(ZEND_CONCAT,&$$,&$1,&$3 CLS_CC); }
- | expr '+' expr { zend_do_binary_op(ZEND_ADD,&$$,&$1,&$3 CLS_CC); }
- | expr '-' expr { zend_do_binary_op(ZEND_SUB,&$$,&$1,&$3 CLS_CC); }
- | expr '*' expr { zend_do_binary_op(ZEND_MUL,&$$,&$1,&$3 CLS_CC); }
- | expr '/' expr { zend_do_binary_op(ZEND_DIV,&$$,&$1,&$3 CLS_CC); }
- | expr '%' expr { zend_do_binary_op(ZEND_MOD,&$$,&$1,&$3 CLS_CC); }
- | expr T_SL expr { zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 CLS_CC); }
- | expr T_SR expr { zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 CLS_CC); }
- | '+' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 CLS_CC); }
- | '-' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 CLS_CC); }
- | '!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 CLS_CC); }
- | '~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 CLS_CC); }
- | expr T_IS_IDENTICAL expr { zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
- | expr T_IS_NOT_IDENTICAL expr { zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
- | expr T_IS_EQUAL expr { zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 CLS_CC); }
- | expr T_IS_NOT_EQUAL expr { zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 CLS_CC); }
- | expr '<' expr { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 CLS_CC); }
- | expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 CLS_CC); }
- | expr '>' expr { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 CLS_CC); }
- | expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 CLS_CC); }
+ T_LIST '(' { zend_do_list_init(TSRMLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 TSRMLS_CC); }
+ | cvar '=' expr { zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); }
+ | cvar '=' '&' w_cvar { zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$4 TSRMLS_CC); }
+ | cvar '=' '&' function_call { zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$4 TSRMLS_CC); }
+ | cvar '=' '&' T_NEW static_or_variable_string { zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$4, &$5 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$5, &$4, &$7 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$3 TSRMLS_CC); }
+ | T_NEW static_or_variable_string { zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$1, &$2 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$$, &$2, &$1, &$4 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
+ | cvar T_PLUS_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_MINUS_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_MUL_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_DIV_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_CONCAT_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_MOD_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_AND_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_OR_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_XOR_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_SL_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 TSRMLS_CC); }
+ | cvar T_SR_EQUAL expr { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 TSRMLS_CC); }
+ | rw_cvar T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC TSRMLS_CC); }
+ | T_INC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC TSRMLS_CC); }
+ | rw_cvar T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC TSRMLS_CC); }
+ | T_DEC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC TSRMLS_CC); }
+ | expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
+ | expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
+ | expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
+ | expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
+ | expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr '|' expr { zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr '&' expr { zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr '^' expr { zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr '.' expr { zend_do_binary_op(ZEND_CONCAT,&$$,&$1,&$3 TSRMLS_CC); }
+ | expr '+' expr { zend_do_binary_op(ZEND_ADD,&$$,&$1,&$3 TSRMLS_CC); }
+ | expr '-' expr { zend_do_binary_op(ZEND_SUB,&$$,&$1,&$3 TSRMLS_CC); }
+ | expr '*' expr { zend_do_binary_op(ZEND_MUL,&$$,&$1,&$3 TSRMLS_CC); }
+ | expr '/' expr { zend_do_binary_op(ZEND_DIV,&$$,&$1,&$3 TSRMLS_CC); }
+ | expr '%' expr { zend_do_binary_op(ZEND_MOD,&$$,&$1,&$3 TSRMLS_CC); }
+ | expr T_SL expr { zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr T_SR expr { zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 TSRMLS_CC); }
+ | '+' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); }
+ | '-' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); }
+ | '!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 TSRMLS_CC); }
+ | '~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 TSRMLS_CC); }
+ | expr T_IS_IDENTICAL expr { zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr T_IS_NOT_IDENTICAL expr { zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr T_IS_EQUAL expr { zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr T_IS_NOT_EQUAL expr { zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr '<' expr { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
+ | expr '>' expr { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 TSRMLS_CC); }
+ | expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 TSRMLS_CC); }
| '(' expr ')' { $$ = $2; }
- | expr '?' { zend_do_begin_qm_op(&$1, &$2 CLS_CC); }
- expr ':' { zend_do_qm_true(&$4, &$2, &$5 CLS_CC); }
- expr { zend_do_qm_false(&$$, &$7, &$2, &$5 CLS_CC); }
+ | expr '?' { zend_do_begin_qm_op(&$1, &$2 TSRMLS_CC); }
+ expr ':' { zend_do_qm_true(&$4, &$2, &$5 TSRMLS_CC); }
+ expr { zend_do_qm_false(&$$, &$7, &$2, &$5 TSRMLS_CC); }
| function_call { $$ = $1; }
| internal_functions_in_yacc { $$ = $1; }
- | T_INT_CAST expr { zend_do_cast(&$$, &$2, IS_LONG CLS_CC); }
- | T_DOUBLE_CAST expr { zend_do_cast(&$$, &$2, IS_DOUBLE CLS_CC); }
- | T_STRING_CAST expr { zend_do_cast(&$$, &$2, IS_STRING CLS_CC); }
- | T_ARRAY_CAST expr { zend_do_cast(&$$, &$2, IS_ARRAY CLS_CC); }
- | T_OBJECT_CAST expr { zend_do_cast(&$$, &$2, IS_OBJECT CLS_CC); }
- | T_BOOL_CAST expr { zend_do_cast(&$$, &$2, IS_BOOL CLS_CC); }
- | T_UNSET_CAST expr { zend_do_cast(&$$, &$2, IS_NULL CLS_CC); }
- | T_EXIT exit_expr { zend_do_exit(&$$, &$2 CLS_CC); }
- | '@' { zend_do_begin_silence(&$1 CLS_CC); } expr { zend_do_end_silence(&$1 CLS_CC); $$ = $3; }
+ | T_INT_CAST expr { zend_do_cast(&$$, &$2, IS_LONG TSRMLS_CC); }
+ | T_DOUBLE_CAST expr { zend_do_cast(&$$, &$2, IS_DOUBLE TSRMLS_CC); }
+ | T_STRING_CAST expr { zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); }
+ | T_ARRAY_CAST expr { zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); }
+ | T_OBJECT_CAST expr { zend_do_cast(&$$, &$2, IS_OBJECT TSRMLS_CC); }
+ | T_BOOL_CAST expr { zend_do_cast(&$$, &$2, IS_BOOL TSRMLS_CC); }
+ | T_UNSET_CAST expr { zend_do_cast(&$$, &$2, IS_NULL TSRMLS_CC); }
+ | T_EXIT exit_expr { zend_do_exit(&$$, &$2 TSRMLS_CC); }
+ | '@' { zend_do_begin_silence(&$1 TSRMLS_CC); } expr { zend_do_end_silence(&$1 TSRMLS_CC); $$ = $3; }
| scalar { $$ = $1; }
| T_ARRAY '(' array_pair_list ')' { $$ = $3; }
- | '`' encaps_list '`' { zend_do_shell_exec(&$$, &$2 CLS_CC); }
- | T_PRINT expr { zend_do_print(&$$, &$2 CLS_CC); }
+ | '`' encaps_list '`' { zend_do_shell_exec(&$$, &$2 TSRMLS_CC); }
+ | T_PRINT expr { zend_do_print(&$$, &$2 TSRMLS_CC); }
;
function_call:
- T_STRING '(' { $2.u.opline_num = zend_do_begin_function_call(&$1 CLS_CC); }
+ T_STRING '(' { $2.u.opline_num = zend_do_begin_function_call(&$1 TSRMLS_CC); }
function_call_parameter_list
- ')' { zend_do_end_function_call(&$1, &$$, &$4, 0, $2.u.opline_num CLS_CC); zend_do_extended_fcall_end(CLS_C); }
- | cvar '(' { zend_do_begin_dynamic_function_call(&$1 CLS_CC); }
+ ')' { zend_do_end_function_call(&$1, &$$, &$4, 0, $2.u.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); }
+ | cvar '(' { zend_do_begin_dynamic_function_call(&$1 TSRMLS_CC); }
function_call_parameter_list
- ')' { zend_do_end_function_call(&$1, &$$, &$4, 0, 1 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
- | T_STRING T_PAAMAYIM_NEKUDOTAYIM static_or_variable_string '(' { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_class_member_function_call(&$1, &$3 CLS_CC); }
+ ')' { zend_do_end_function_call(&$1, &$$, &$4, 0, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
+ | T_STRING T_PAAMAYIM_NEKUDOTAYIM static_or_variable_string '(' { zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); }
function_call_parameter_list
- ')' { zend_do_end_function_call(&$3, &$$, &$6, 1, 1 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
+ ')' { zend_do_end_function_call(&$3, &$$, &$6, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
;
static_scalar: /* compile-time evaluated scalars */
common_scalar { $$ = $1; }
- | T_STRING { zend_do_fetch_constant(&$$, &$1, ZEND_CT CLS_CC); }
+ | T_STRING { zend_do_fetch_constant(&$$, &$1, ZEND_CT TSRMLS_CC); }
| '+' static_scalar { $$ = $1; }
| '-' static_scalar { zval minus_one; minus_one.type = IS_LONG; minus_one.value.lval = -1; mul_function(&$2.u.constant, &$2.u.constant, &minus_one); $$ = $2; }
| T_ARRAY '(' static_array_pair_list ')' { $$ = $3; $$.u.constant.type = IS_CONSTANT_ARRAY; }
scalar:
- T_STRING { zend_do_fetch_constant(&$$, &$1, ZEND_RT CLS_CC); }
+ T_STRING { zend_do_fetch_constant(&$$, &$1, ZEND_RT TSRMLS_CC); }
| T_STRING_VARNAME { $$ = $1; }
| common_scalar { $$ = $1; }
| '"' encaps_list '"' { $$ = $2; }
| '\'' encaps_list '\'' { $$ = $2; }
- | T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; zend_do_end_heredoc(CLS_C); }
+ | T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; zend_do_end_heredoc(TSRMLS_C); }
;
r_cvar:
- cvar { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); $$ = $1; }
+ cvar { zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC); $$ = $1; }
;
w_cvar:
- cvar { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); $$ = $1; }
+ cvar { zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); $$ = $1; }
;
rw_cvar:
- cvar { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); $$ = $1; }
+ cvar { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); $$ = $1; }
;
cvar:
cvar_without_objects { $$ = $1; }
- | cvar_without_objects T_OBJECT_OPERATOR { zend_do_push_object(&$1 CLS_CC); } ref_list { $$ = $4; }
+ | cvar_without_objects T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); } ref_list { $$ = $4; }
;
cvar_without_objects:
reference_variable { $$ = $1; }
- | simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 CLS_CC); }
+ | simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 TSRMLS_CC); }
;
reference_variable:
- reference_variable '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 CLS_CC); }
- | reference_variable '{' expr '}' { fetch_string_offset(&$$, &$1, &$3 CLS_CC); }
- | compound_variable { zend_do_fetch_globals(&$1 CLS_CC); zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+ reference_variable '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
+ | reference_variable '{' expr '}' { fetch_string_offset(&$$, &$1, &$3 TSRMLS_CC); }
+ | compound_variable { zend_do_fetch_globals(&$1 TSRMLS_CC); zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
;
ref_list:
object_property { $$ = $1; }
- | ref_list T_OBJECT_OPERATOR { zend_do_push_object(&$1 CLS_CC); } object_property { $$ = $4; }
+ | ref_list T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); } object_property { $$ = $4; }
;
object_property:
object_dim_list { $$ = $1; }
- | cvar_without_objects { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); } { znode tmp_znode; zend_do_pop_object(&tmp_znode CLS_CC); zend_do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC);}
+ | cvar_without_objects { zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC); } { znode tmp_znode; zend_do_pop_object(&tmp_znode TSRMLS_CC); zend_do_fetch_property(&$$, &tmp_znode, &$1 TSRMLS_CC);}
;
object_dim_list:
- object_dim_list '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 CLS_CC); }
- | object_dim_list '{' expr '}' { fetch_string_offset(&$$, &$1, &$3 CLS_CC); }
- | variable_name { znode tmp_znode; zend_do_pop_object(&tmp_znode CLS_CC); zend_do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC);}
+ object_dim_list '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
+ | object_dim_list '{' expr '}' { fetch_string_offset(&$$, &$1, &$3 TSRMLS_CC); }
+ | variable_name { znode tmp_znode; zend_do_pop_object(&tmp_znode TSRMLS_CC); zend_do_fetch_property(&$$, &tmp_znode, &$1 TSRMLS_CC);}
;
variable_name:
assignment_list_element:
- cvar { zend_do_add_list_element(&$1 CLS_CC); }
- | T_LIST '(' { zend_do_new_list_begin(CLS_C); } assignment_list ')' { zend_do_new_list_end(CLS_C); }
- | /* empty */ { zend_do_add_list_element(NULL CLS_CC); }
+ cvar { zend_do_add_list_element(&$1 TSRMLS_CC); }
+ | T_LIST '(' { zend_do_new_list_begin(TSRMLS_C); } assignment_list ')' { zend_do_new_list_end(TSRMLS_C); }
+ | /* empty */ { zend_do_add_list_element(NULL TSRMLS_CC); }
;
array_pair_list:
- /* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 CLS_CC); }
+ /* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 TSRMLS_CC); }
| non_empty_array_pair_list possible_comma { $$ = $1; }
;
non_empty_array_pair_list:
- non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr { zend_do_add_array_element(&$$, &$5, &$3, 0 CLS_CC); }
- | non_empty_array_pair_list ',' expr { zend_do_add_array_element(&$$, &$3, NULL, 0 CLS_CC); }
- | expr T_DOUBLE_ARROW expr { zend_do_init_array(&$$, &$3, &$1, 0 CLS_CC); }
- | expr { zend_do_init_array(&$$, &$1, NULL, 0 CLS_CC); }
- | non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_cvar { zend_do_add_array_element(&$$, &$6, &$3, 1 CLS_CC); }
- | non_empty_array_pair_list ',' '&' w_cvar { zend_do_add_array_element(&$$, &$4, NULL, 1 CLS_CC); }
- | expr T_DOUBLE_ARROW '&' w_cvar { zend_do_init_array(&$$, &$4, &$1, 1 CLS_CC); }
- | '&' w_cvar { zend_do_init_array(&$$, &$2, NULL, 1 CLS_CC); }
+ non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr { zend_do_add_array_element(&$$, &$5, &$3, 0 TSRMLS_CC); }
+ | non_empty_array_pair_list ',' expr { zend_do_add_array_element(&$$, &$3, NULL, 0 TSRMLS_CC); }
+ | expr T_DOUBLE_ARROW expr { zend_do_init_array(&$$, &$3, &$1, 0 TSRMLS_CC); }
+ | expr { zend_do_init_array(&$$, &$1, NULL, 0 TSRMLS_CC); }
+ | non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_cvar { zend_do_add_array_element(&$$, &$6, &$3, 1 TSRMLS_CC); }
+ | non_empty_array_pair_list ',' '&' w_cvar { zend_do_add_array_element(&$$, &$4, NULL, 1 TSRMLS_CC); }
+ | expr T_DOUBLE_ARROW '&' w_cvar { zend_do_init_array(&$$, &$4, &$1, 1 TSRMLS_CC); }
+ | '&' w_cvar { zend_do_init_array(&$$, &$2, NULL, 1 TSRMLS_CC); }
;
encaps_list:
- encaps_list encaps_var { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); zend_do_add_variable(&$$, &$1, &$2 CLS_CC); }
- | encaps_list T_STRING { zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
- | encaps_list T_NUM_STRING { zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
- | encaps_list T_ENCAPSED_AND_WHITESPACE { zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
- | encaps_list T_CHARACTER { zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
- | encaps_list T_BAD_CHARACTER { zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
- | encaps_list '[' { $2.u.constant.value.lval = (long) '['; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
- | encaps_list ']' { $2.u.constant.value.lval = (long) ']'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
- | encaps_list '{' { $2.u.constant.value.lval = (long) '{'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
- | encaps_list '}' { $2.u.constant.value.lval = (long) '}'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
- | encaps_list T_OBJECT_OPERATOR { znode tmp; $2.u.constant.value.lval = (long) '-'; zend_do_add_char(&tmp, &$1, &$2 CLS_CC); $2.u.constant.value.lval = (long) '>'; zend_do_add_char(&$$, &tmp, &$2 CLS_CC); }
- | /* empty */ { zend_do_init_string(&$$ CLS_CC); }
+ encaps_list encaps_var { zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC); zend_do_add_variable(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list T_STRING { zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list T_NUM_STRING { zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list T_ENCAPSED_AND_WHITESPACE { zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list T_CHARACTER { zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list T_BAD_CHARACTER { zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list '[' { $2.u.constant.value.lval = (long) '['; zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list ']' { $2.u.constant.value.lval = (long) ']'; zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list '{' { $2.u.constant.value.lval = (long) '{'; zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list '}' { $2.u.constant.value.lval = (long) '}'; zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+ | encaps_list T_OBJECT_OPERATOR { znode tmp; $2.u.constant.value.lval = (long) '-'; zend_do_add_char(&tmp, &$1, &$2 TSRMLS_CC); $2.u.constant.value.lval = (long) '>'; zend_do_add_char(&$$, &tmp, &$2 TSRMLS_CC); }
+ | /* empty */ { zend_do_init_string(&$$ TSRMLS_CC); }
;
encaps_var:
- T_VARIABLE { zend_do_fetch_globals(&$1 CLS_CC); zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
- | T_VARIABLE '[' { zend_do_begin_variable_parse(CLS_C); } encaps_var_offset ']' { zend_do_fetch_globals(&$1 CLS_CC); fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
- | T_VARIABLE T_OBJECT_OPERATOR T_STRING { zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$2, &$1, 1 CLS_CC); zend_do_fetch_property(&$$, &$2, &$3 CLS_CC); }
- | T_DOLLAR_OPEN_CURLY_BRACES expr '}' { zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$2, 1 CLS_CC); }
- | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { zend_do_begin_variable_parse(CLS_C); fetch_array_begin(&$$, &$2, &$4 CLS_CC); }
+ T_VARIABLE { zend_do_fetch_globals(&$1 TSRMLS_CC); zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
+ | T_VARIABLE '[' { zend_do_begin_variable_parse(TSRMLS_C); } encaps_var_offset ']' { zend_do_fetch_globals(&$1 TSRMLS_CC); fetch_array_begin(&$$, &$1, &$4 TSRMLS_CC); }
+ | T_VARIABLE T_OBJECT_OPERATOR T_STRING { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$2, &$1, 1 TSRMLS_CC); zend_do_fetch_property(&$$, &$2, &$3 TSRMLS_CC); }
+ | T_DOLLAR_OPEN_CURLY_BRACES expr '}' { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$2, 1 TSRMLS_CC); }
+ | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_begin(&$$, &$2, &$4 TSRMLS_CC); }
| T_CURLY_OPEN cvar '}' { $$ = $2; }
;
encaps_var_offset:
T_STRING { $$ = $1; }
| T_NUM_STRING { $$ = $1; }
- | T_VARIABLE { fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+ | T_VARIABLE { fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
;
internal_functions_in_yacc:
T_ISSET '(' isset_variables ')' { $$ = $3; }
- | T_EMPTY '(' cvar ')' { zend_do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 CLS_CC); }
- | T_INCLUDE expr { zend_do_include_or_eval(ZEND_INCLUDE, &$$, &$2 CLS_CC); }
- | T_INCLUDE_ONCE expr { zend_do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 CLS_CC); }
- | T_EVAL '(' expr ')' { zend_do_include_or_eval(ZEND_EVAL, &$$, &$3 CLS_CC); }
- | T_REQUIRE expr { zend_do_include_or_eval(ZEND_REQUIRE, &$$, &$2 CLS_CC); }
- | T_REQUIRE_ONCE expr { zend_do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 CLS_CC); }
+ | T_EMPTY '(' cvar ')' { zend_do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 TSRMLS_CC); }
+ | T_INCLUDE expr { zend_do_include_or_eval(ZEND_INCLUDE, &$$, &$2 TSRMLS_CC); }
+ | T_INCLUDE_ONCE expr { zend_do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 TSRMLS_CC); }
+ | T_EVAL '(' expr ')' { zend_do_include_or_eval(ZEND_EVAL, &$$, &$3 TSRMLS_CC); }
+ | T_REQUIRE expr { zend_do_include_or_eval(ZEND_REQUIRE, &$$, &$2 TSRMLS_CC); }
+ | T_REQUIRE_ONCE expr { zend_do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 TSRMLS_CC); }
;
isset_variables:
- cvar { zend_do_isset_or_isempty(ZEND_ISSET, &$$, &$1 CLS_CC); }
- | isset_variables ',' { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } cvar { znode tmp; zend_do_isset_or_isempty(ZEND_ISSET, &tmp, &$4 CLS_CC); zend_do_boolean_and_end(&$$, &$1, &tmp, &$2 CLS_CC); }
+ cvar { zend_do_isset_or_isempty(ZEND_ISSET, &$$, &$1 TSRMLS_CC); }
+ | isset_variables ',' { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } cvar { znode tmp; zend_do_isset_or_isempty(ZEND_ISSET, &tmp, &$4 TSRMLS_CC); zend_do_boolean_and_end(&$$, &$1, &tmp, &$2 TSRMLS_CC); }
;
%%
{
public:
virtual ~ZendFlexLexer();
- int lex_scan(zval *zendlval CLS_DC);
+ int lex_scan(zval *zendlval TSRMLS_DC);
void BeginState(int state);
};
#endif
#ifdef ZTS
-#define YY_DECL int ZendFlexLexer::lex_scan(zval *zendlval CLS_DC)
+#define YY_DECL int ZendFlexLexer::lex_scan(zval *zendlval TSRMLS_DC)
#else
-#define YY_DECL int lex_scan(zval *zendlval CLS_DC)
+#define YY_DECL int lex_scan(zval *zendlval TSRMLS_DC)
#endif
#define YY_INTERACTIVE
}
BEGIN_EXTERN_C()
-void startup_scanner(CLS_D)
+void startup_scanner(TSRMLS_D)
{
CG(heredoc) = NULL;
CG(heredoc_len)=0;
}
-void shutdown_scanner(CLS_D)
+void shutdown_scanner(TSRMLS_D)
{
if (CG(heredoc)) {
efree(CG(heredoc));
END_EXTERN_C()
-static inline void save_lexical_state(zend_lex_state *lex_state CLS_DC)
+static inline void save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
{
#ifndef ZTS
memcpy(&lex_state->buffer_state,&YY_CURRENT_BUFFER,sizeof(YY_BUFFER_STATE));
#else
lex_state->ZFL = CG(ZFL);
#endif
- lex_state->filename = zend_get_compiled_filename(CLS_C);
+ lex_state->filename = zend_get_compiled_filename(TSRMLS_C);
lex_state->lineno = CG(zend_lineno);
}
-static inline void restore_lexical_state(zend_lex_state *lex_state CLS_DC)
+static inline void restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
{
#ifndef ZTS
YY_BUFFER_STATE original_buffer_state = YY_CURRENT_BUFFER;
}
-ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle CLS_DC)
+ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC)
{
zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
}
-ZEND_API int open_file_for_scanning(zend_file_handle *file_handle CLS_DC)
+ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
{
char *file_path=NULL;
END_EXTERN_C()
-ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS_DC)
+ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
{
zend_lex_state original_lex_state;
zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
retval_znode.u.constant.is_ref = 0;
retval_znode.u.constant.refcount = 1;
- save_lexical_state(&original_lex_state CLS_CC);
+ save_lexical_state(&original_lex_state TSRMLS_CC);
retval = op_array; /* success oriented */
- if (open_file_for_scanning(file_handle CLS_CC)==FAILURE) {
+ if (open_file_for_scanning(file_handle TSRMLS_CC)==FAILURE) {
if (type==ZEND_REQUIRE) {
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
zend_bailout();
}
compilation_successful=0;
} else {
- init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE CLS_CC);
+ init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
CG(in_compilation) = 1;
CG(active_op_array) = op_array;
- compiler_result = zendparse(CLS_C);
- zend_do_return(&retval_znode, 0 CLS_CC);
+ compiler_result = zendparse(TSRMLS_C);
+ zend_do_return(&retval_znode, 0 TSRMLS_CC);
CG(in_compilation) = original_in_compilation;
if (compiler_result==1) { /* parser error */
CG(unclean_shutdown) = 1;
}
}
if (compilation_successful) {
- restore_lexical_state(&original_lex_state CLS_CC);
+ restore_lexical_state(&original_lex_state TSRMLS_CC);
}
return retval;
}
-zend_op_array *compile_filename(int type, zval *filename CLS_DC TSRMLS_DC)
+zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
{
zend_file_handle file_handle;
zval tmp;
file_handle.opened_path = NULL;
- retval = zend_compile_file(&file_handle, type CLS_CC);
+ retval = zend_compile_file(&file_handle, type TSRMLS_CC);
if (retval && file_handle.opened_path) {
int dummy = 1;
zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);
}
- zend_destroy_file_handle(&file_handle CLS_CC);
+ zend_destroy_file_handle(&file_handle TSRMLS_CC);
if (filename==&tmp) {
zval_dtor(&tmp);
#ifndef ZTS
static inline int prepare_string_for_scanning(zval *str, char *filename)
#else
-static inline int prepare_string_for_scanning(zval *str, istrstream **input_stream, char *filename CLS_DC)
+static inline int prepare_string_for_scanning(zval *str, istrstream **input_stream, char *filename TSRMLS_DC)
#endif
{
#ifndef ZTS
}
-zend_op_array *compile_string(zval *source_string, char *filename CLS_DC)
+zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
{
zend_lex_state original_lex_state;
zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
convert_to_string(&tmp);
source_string = &tmp;
- save_lexical_state(&original_lex_state CLS_CC);
+ save_lexical_state(&original_lex_state TSRMLS_CC);
#ifndef ZTS
if (prepare_string_for_scanning(source_string, filename)==FAILURE) {
#else
- if (prepare_string_for_scanning(source_string, &input_stream, filename CLS_CC)==FAILURE) {
+ if (prepare_string_for_scanning(source_string, &input_stream, filename TSRMLS_CC)==FAILURE) {
#endif
efree(op_array);
retval = NULL;
} else {
- init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE CLS_CC);
+ init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
CG(active_op_array) = op_array;
#ifndef ZTS
BEGIN(ST_IN_SCRIPTING);
#else
CG(ZFL)->BeginState(ST_IN_SCRIPTING);
#endif
- compiler_result = zendparse(CLS_C);
+ compiler_result = zendparse(TSRMLS_C);
if (compiler_result==1) {
CG(active_op_array) = original_active_op_array;
CG(unclean_shutdown)=1;
retval = NULL;
} else {
- zend_do_return(NULL, 0 CLS_CC);
+ zend_do_return(NULL, 0 TSRMLS_CC);
CG(active_op_array) = original_active_op_array;
pass_two(op_array);
retval = op_array;
}
- restore_lexical_state(&original_lex_state CLS_CC);
+ restore_lexical_state(&original_lex_state TSRMLS_CC);
}
#ifdef ZTS
delete input_stream;
{
zend_lex_state original_lex_state;
zend_file_handle file_handle;
- CLS_FETCH();
+ TSRMLS_FETCH();
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.filename = filename;
file_handle.free_filename = 0;
file_handle.opened_path = NULL;
- save_lexical_state(&original_lex_state CLS_CC);
- if (open_file_for_scanning(&file_handle CLS_CC)==FAILURE) {
+ save_lexical_state(&original_lex_state TSRMLS_CC);
+ if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {
zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename);
return FAILURE;
}
zend_highlight(syntax_highlighter_ini);
- zend_destroy_file_handle(&file_handle CLS_CC);
- restore_lexical_state(&original_lex_state CLS_CC);
+ zend_destroy_file_handle(&file_handle TSRMLS_CC);
+ restore_lexical_state(&original_lex_state TSRMLS_CC);
return SUCCESS;
}
#ifdef ZTS
istrstream *input_stream;
#endif
- CLS_FETCH();
+ TSRMLS_FETCH();
str = &tmp;
zval_copy_ctor(str);
- save_lexical_state(&original_lex_state CLS_CC);
+ save_lexical_state(&original_lex_state TSRMLS_CC);
#ifndef ZTS
if (prepare_string_for_scanning(str, str_name)==FAILURE) {
#else
- if (prepare_string_for_scanning(str, &input_stream, str_name CLS_CC)==FAILURE) {
+ if (prepare_string_for_scanning(str, &input_stream, str_name TSRMLS_CC)==FAILURE) {
#endif
return FAILURE;
}
zend_highlight(syntax_highlighter_ini);
- restore_lexical_state(&original_lex_state CLS_CC);
+ restore_lexical_state(&original_lex_state TSRMLS_CC);
#ifdef ZTS
delete input_stream;
#endif
#ifdef ZTS
BEGIN_EXTERN_C()
-int lex_scan(zval *zendlval CLS_DC)
+int lex_scan(zval *zendlval TSRMLS_DC)
{
- return CG(ZFL)->lex_scan(zendlval CLS_CC);
+ return CG(ZFL)->lex_scan(zendlval TSRMLS_CC);
}
-const char *zend_get_zendtext(CLS_D)
+const char *zend_get_zendtext(TSRMLS_D)
{
return CG(ZFL)->YYText();
}
-int zend_get_zendleng(CLS_D)
+int zend_get_zendleng(TSRMLS_D)
{
return CG(ZFL)->YYLeng();
}
}
<ST_IN_SCRIPTING>"__FILE__" {
- char *filename = zend_get_compiled_filename(CLS_C);
+ char *filename = zend_get_compiled_filename(TSRMLS_C);
if (!filename) {
filename = "";
-void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_DC)
+void init_op_array(zend_op_array *op_array, int type, int initial_ops_size TSRMLS_DC)
{
op_array->type = type;
op_array->T = 0;
op_array->function_name = NULL;
- op_array->filename = zend_get_compiled_filename(CLS_C);
+ op_array->filename = zend_get_compiled_filename(TSRMLS_C);
op_array->arg_types = NULL;
}
-void init_op(zend_op *op CLS_DC)
+void init_op(zend_op *op TSRMLS_DC)
{
memset(&op->result, 0, sizeof(znode));
op->lineno = CG(zend_lineno);
memset(&op->op2, 0, sizeof(znode));
}
-zend_op *get_next_op(zend_op_array *op_array CLS_DC)
+zend_op *get_next_op(zend_op_array *op_array TSRMLS_DC)
{
zend_uint next_op_num = op_array->last++;
zend_op *next_op;
next_op = &(op_array->opcodes[next_op_num]);
- init_op(next_op CLS_CC);
+ init_op(next_op TSRMLS_CC);
return next_op;
}
}
-static void zend_update_extended_info(zend_op_array *op_array CLS_DC)
+static void zend_update_extended_info(zend_op_array *op_array TSRMLS_DC)
{
zend_op *opline = op_array->opcodes, *end=opline+op_array->last;
int pass_two(zend_op_array *op_array)
{
zend_op *opline, *end;
- CLS_FETCH();
+ TSRMLS_FETCH();
if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) {
return 0;
}
if (CG(extended_info)) {
- zend_update_extended_info(op_array CLS_CC);
+ zend_update_extended_info(op_array TSRMLS_CC);
}
if (CG(handle_op_arrays)) {
zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_handler, op_array);
projects / php / commitdiff