source: trunk/processor/processor.m4 @ 218

Last change on this file since 218 was 218, checked in by moo, 8 years ago

processor: zend_constant.name uses malloc

File size: 18.8 KB
RevLine 
[1]1dnl ================
2/* {{{ Pre-declare */
3DECL_STRUCT_P_FUNC(`zval')
4DECL_STRUCT_P_FUNC(`zval_ptr')
5DECL_STRUCT_P_FUNC(`zend_op_array')
6DECL_STRUCT_P_FUNC(`zend_class_entry')
[95]7#ifdef HAVE_XCACHE_CONSTANT
8DECL_STRUCT_P_FUNC(`zend_constant')
9#endif
[1]10DECL_STRUCT_P_FUNC(`zend_function')
11DECL_STRUCT_P_FUNC(`xc_entry_t')
12#ifdef ZEND_ENGINE_2
13DECL_STRUCT_P_FUNC(`zend_property_info')
14#endif
15/* }}} */
16dnl ====================================================
17dnl {{{ zend_compiled_variable
18#ifdef IS_CV
19DEF_STRUCT_P_FUNC(`zend_compiled_variable', , `
20    DISPATCH(int, name_len)
[103]21    PROC_ZSTRING_L(, name, name_len)
[1]22    DISPATCH(ulong, hash_value)
23')
24#endif
25dnl }}}
26dnl {{{ zend_uint
27DEF_STRUCT_P_FUNC(`zend_uint', , `
28    IFCOPY(`dst[0] = src[0];')
29    IFDPRINT(`
30        INDENT()
31        fprintf(stderr, "%u\n", src[0]);
32    ')
33    DONE_SIZE(sizeof(src[0]))
34')
35dnl }}}
36dnl {{{ int
37#ifndef ZEND_ENGINE_2
38DEF_STRUCT_P_FUNC(`int', , `
39    IFCOPY(`*dst = *src;')
40    IFDPRINT(`
41        INDENT()
42        fprintf(stderr, "%d\n", src[0]);
43    ')
44    DONE_SIZE(sizeof(src[0]))
45')
46#endif
47dnl }}}
48dnl {{{ zend_try_catch_element
49#ifdef ZEND_ENGINE_2
50DEF_STRUCT_P_FUNC(`zend_try_catch_element', , `
51    DISPATCH(zend_uint, try_op)
52    DISPATCH(zend_uint, catch_op)
53')
54#endif /* ifdef ZEND_ENGINE_2 */
55dnl }}}
56dnl {{{ zend_brk_cont_element
57DEF_STRUCT_P_FUNC(`zend_brk_cont_element', , `
[194]58#ifdef ZEND_ENGINE_2_2
[200]59#ifndef IS_UNICODE
[194]60    DISPATCH(int, start)
61#endif
[200]62#endif
[1]63    DISPATCH(int, cont)
64    DISPATCH(int, brk)
65    DISPATCH(int, parent)
66')
67dnl }}}
68DEF_HASH_TABLE_FUNC(`HashTable_zval_ptr',           `zval_ptr')
[196]69DEF_HASH_TABLE_FUNC(`HashTable_zval_ptr_static_member_check',  `zval_ptr', , `xc_hash_static_member_check(processor, BUCKET TSRMLS_CC)')
[95]70#ifdef HAVE_XCACHE_CONSTANT
71DEF_HASH_TABLE_FUNC(`HashTable_zend_constant',      `zend_constant')
72#endif
[1]73DEF_HASH_TABLE_FUNC(`HashTable_zend_function',      `zend_function')
74#ifdef ZEND_ENGINE_2
75DEF_HASH_TABLE_FUNC(`HashTable_zend_property_info', `zend_property_info')
76#endif
77DEF_STRUCT_P_FUNC(`zval', , `dnl {{{
78    IFDASM(`do {
79        zval_dtor(dst);
80        *dst = *src;
81        zval_copy_ctor(dst);
82        ZVAL_REFCOUNT(dst) = 1;
83        DONE(value)
84        DONE(refcount)
85        DONE(type)
86        DONE(is_ref)
87    } while(0);
88    return;
89    ', `
90        dnl IFDASM else
91        /* Variable information */
92dnl {{{ zvalue_value
93        DISABLECHECK(`
94        switch (src->type & ~IS_CONSTANT_INDEX) {
95            case IS_LONG:
96            case IS_RESOURCE:
97            case IS_BOOL:
98                DISPATCH(long, value.lval)
99                break;
100            case IS_DOUBLE:
101                DISPATCH(double, value.dval)
102                break;
103            case IS_NULL:
104                IFDPRINT(`INDENT()`'fprintf(stderr, "\tNULL\n");')
105                break;
106
107            case IS_CONSTANT:
108#ifdef IS_UNICODE
109                if (UG(unicode)) {
110                    goto proc_unicode;
111                }
112#endif
113            case IS_STRING:
114#ifdef FLAG_IS_BC
115            case FLAG_IS_BC:
116#endif
117                DISPATCH(int, value.str.len)
118                PROC_STRING_L(value.str.val, value.str.len)
119                break;
120#ifdef IS_UNICODE
121            case IS_UNICODE:
122proc_unicode:
[103]123                DISPATCH(int32_t, value.uni.len)
124                PROC_ZSTRING_L(1, value.uni.val, value.uni.len)
[1]125                break;
126#endif
127
128            case IS_ARRAY:
129            case IS_CONSTANT_ARRAY:
130                STRUCT_P(HashTable, value.ht, HashTable_zval_ptr)
131                break;
132
133            case IS_OBJECT:
134                IFNOTMEMCPY(`IFCOPY(`memcpy(dst, src, sizeof(src[0]));')')
135                dnl STRUCT(value.obj)
136#ifndef ZEND_ENGINE_2
137                STRUCT_P(zend_class_entry, value.obj.ce)
138                STRUCT_P(HashTable, value.obj.properties, HashTable_zval_ptr)
139#endif
140                break;
141
142            default:
143                assert(0);
144        }
145        ')
146dnl }}}
147        DONE(value)
148        DISPATCH(zval_data_type, type)
149        DISPATCH(zend_uchar, is_ref)
150        DISPATCH(zend_ushort, refcount)
151    ')dnl IFDASM
152')
153dnl }}}
154DEF_STRUCT_P_FUNC(`zval_ptr', , `dnl {{{
155    IFDASM(`
156        pushdefFUNC_NAME(`zval')
157        FUNC_NAME (dst, src[0] TSRMLS_CC);
158        popdef(`FUNC_NAME')
159    ', `
160        do {
161            IFCALCCOPY(`
162                if (processor->reference) {
163                    zval_ptr *ppzv;
164                    if (zend_hash_find(&processor->zvalptrs, (char *)src[0], sizeof(src[0]), (void**)&ppzv) == SUCCESS) {
165                        IFCOPY(`
166                            dst[0] = *ppzv;
167                            /* *dst is updated */
168                            dnl fprintf(stderr, "*dst is set to %p\n", dst[0]);
169                        ')
170                        IFSTORE(`assert(xc_is_shm(dst[0]));')
171                        IFRESTORE(`assert(!xc_is_shm(dst[0]));')
172                        break;
173                    }
174                }
175            ')
176           
177            ALLOC(dst[0], zval)
178            IFCALCCOPY(`
179                if (processor->reference) {
180                    IFCALC(`
181                        /* make dummy */
182                        zval_ptr pzv = (zval_ptr)-1;
183                    ', `
184                        zval_ptr pzv = dst[0];
185                    ')
186                    if (zend_hash_add(&processor->zvalptrs, (char *)src[0], sizeof(src[0]), (void*)&pzv, sizeof(pzv), NULL) == SUCCESS) {
187                        /* first add, go on */
188                        dnl fprintf(stderr, "mark[%p] = %p\n", src[0], pzv);
189                    }
190                    else {
191                        assert(0);
192                    }
193                }
194            ')
195            IFCOPY(`
196                dnl fprintf(stderr, "copy from %p to %p\n", src[0], dst[0]);
197            ')
[4]198            STRUCT_P_EX(zval, dst[0], src[0], `[0]', `', ` ')
[1]199        } while (0);
200    ')
201    DONE_SIZE(sizeof(zval_ptr))
202')
203dnl }}}
204dnl {{{ zend_arg_info
205#ifdef ZEND_ENGINE_2
206DEF_STRUCT_P_FUNC(`zend_arg_info', , `
207    DISPATCH(zend_uint, name_len)
[103]208    PROC_ZSTRING_L(, name, name_len)
[1]209    DISPATCH(zend_uint, class_name_len)
[103]210    PROC_ZSTRING_L(, class_name, class_name_len)
[1]211    DISPATCH(zend_bool, array_type_hint)
212    DISPATCH(zend_bool, allow_null)
213    DISPATCH(zend_bool, pass_by_reference)
214    DISPATCH(zend_bool, return_reference)
215    DISPATCH(int, required_num_args)
216')
217#endif
218dnl }}}
[95]219#ifdef HAVE_XCACHE_CONSTANT
220DEF_STRUCT_P_FUNC(`zend_constant', , `dnl {{{
221    STRUCT(zval, value)
222    DISPATCH(int, flags)
223    DISPATCH(uint, name_len)
[218]224    pushdef(`emalloc', `malloc($1)')
225    pushdef(`ecalloc', `calloc($1, $2)')
[103]226    PROC_ZSTRING_L(, name, name_len)
[218]227    popdef(`ecalloc')
228    popdef(`emalloc')
[95]229    DISPATCH(int, module_number)
230')
231dnl }}}
232#endif
[1]233DEF_STRUCT_P_FUNC(`zend_function', , `dnl {{{
234    DISABLECHECK(`
235    switch (src->type) {
236    case ZEND_INTERNAL_FUNCTION:
237    case ZEND_OVERLOADED_FUNCTION:
238        IFNOTMEMCPY(`IFCOPY(`memcpy(dst, src, sizeof(src[0]));')')
239        break;
240
241    case ZEND_USER_FUNCTION:
242    case ZEND_EVAL_CODE:
243        DONE(type)
244        STRUCT(zend_op_array, op_array)
245        break;
246
247    default:
248        assert(0);
249    }
250    ')
251    DONE_SIZE(sizeof(src[0]))
252')
253dnl }}}
254dnl {{{ zend_property_info
255#ifdef ZEND_ENGINE_2
256DEF_STRUCT_P_FUNC(`zend_property_info', , `
257    DISPATCH(zend_uint, flags)
258    DISPATCH(int, name_length)
[103]259    PROC_ZSTRING_L(, name, name_length)
[1]260    DISPATCH(ulong, h)
[56]261#ifdef ZEND_ENGINE_2_1
[1]262    DISPATCH(int, doc_comment_len)
[103]263    PROC_STRING_L(doc_comment, doc_comment_len)
[56]264#endif
[78]265    dnl isnt in php6 yet
266#if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE)
267    PROC_CLASS_ENTRY_P(ce)
268#endif
[1]269')
270#endif
271dnl }}}
272DEF_STRUCT_P_FUNC(`zend_class_entry', , `dnl {{{
[199]273    IFCALCCOPY(`
[1]274        processor->active_class_entry_src = src;
[199]275        IFCOPY(`processor->active_class_entry_dst = dst;')
[1]276    ')
277    DISPATCH(char, type)
278    DISPATCH(zend_uint, name_length)
[103]279    PROC_ZSTRING_L(, name, name_length)
[1]280    IFRESTORE(`
281#ifndef ZEND_ENGINE_2
282        /* just copy parent and resolve on install_class */
283        COPY(parent)
284#else
285        PROC_CLASS_ENTRY_P(parent)
286#endif
287    ', `
288        PROC_CLASS_ENTRY_P(parent)
289    ')
290#ifdef ZEND_ENGINE_2
291    DISPATCH(int, refcount)
292#else
293    STRUCT_P(int, refcount)
294#endif
295    DISPATCH(zend_bool, constants_updated)
296#ifdef ZEND_ENGINE_2
297    DISPATCH(zend_uint, ce_flags)
298#endif
299
300    STRUCT(HashTable, default_properties, HashTable_zval_ptr)
[217]301    IFSTORE(`xc_hash_reset_zval_refcount(&dst->default_properties TSRMLS_CC);')
[1]302    IFCOPY(`dst->builtin_functions = src->builtin_functions;')
303    DONE(builtin_functions)
304#ifdef ZEND_ENGINE_2
305    STRUCT(HashTable, properties_info, HashTable_zend_property_info)
306#   ifdef ZEND_ENGINE_2_1
[199]307    STRUCT(HashTable, default_static_members, IFCALCSTORE(HashTable_zval_ptr_static_member_check, HashTable_zval_ptr))
[1]308    IFCOPY(`dst->static_members = &dst->default_static_members;')
[196]309    IFRESTORE(`if (dst->parent) xc_fix_static_members(processor, dst TSRMLS_CC);')
[1]310    DONE(static_members)
311#   else
[199]312    STRUCT_P(HashTable, static_members, IFCALCSTORE(HashTable_zval_ptr_static_member_check, HashTable_zval_ptr))
[1]313#   endif
314    STRUCT(HashTable, constants_table, HashTable_zval_ptr)
[217]315    IFSTORE(`xc_hash_reset_zval_refcount(&dst->constants_table TSRMLS_CC);')
[1]316
317    dnl runtime binding: ADD_INTERFACE will deal with it
318    IFRESTORE(`
319        if (src->num_interfaces) {
320            CALLOC(dst->interfaces, zend_class_entry*, src->num_interfaces)
[4]321            DONE(`interfaces')
[1]322        }
323        else {
[4]324            COPYNULL(interfaces)
[1]325        }
326    ')
327    IFDASM(`
328        if (src->num_interfaces) {
329            /*
330            zval *arr;
331            ALLOC_INIT_ZVAL(arr);
332            array_init(arr);
333            for (i = 0; i < src->num_interfaces; i ++) {
334                zval *zv;
335                ALLOC_INIT_ZVAL(zv);
336                ZVAL_STRING(src->num_interfaces);
337            }
338            add_assoc_zval_ex(dst, ZEND_STRS("interfaces"), arr);
339            */
[4]340            DONE(`interfaces')
[1]341        }
342        else {
[4]343            COPYNULL(interfaces)
[1]344        }
345    ')
[4]346    IFRESTORE(`', `
347        IFDASM(`', `
348            DONE(`interfaces')
349        ')
350    ')
[1]351    DISPATCH(zend_uint, num_interfaces)
352
353    IFRESTORE(`COPY(filename)', `PROC_STRING(filename)')
354    DISPATCH(zend_uint, line_start)
355    DISPATCH(zend_uint, line_end)
356#ifdef ZEND_ENGINE_2_1
357    DISPATCH(zend_uint, doc_comment_len)
[103]358    PROC_STRING_L(doc_comment, doc_comment_len)
[1]359#endif
360    /* # NOT DONE */
361    COPY(serialize_func)
362    COPY(unserialize_func)
363    COPY(iterator_funcs)
364    COPY(create_object)
365    COPY(get_iterator)
366    COPY(interface_gets_implemented)
367    COPY(serialize)
368    COPY(unserialize)
369    /* deal with it inside xc_fix_method */
370    SETNULL(constructor)
371    COPY(destructor)
372    COPY(clone)
373    COPY(__get)
374    COPY(__set)
375/* should be >5.1 */
376#ifdef ZEND_ENGINE_2_1
377    COPY(__unset)
378    COPY(__isset)
[94]379# if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6
[1]380    COPY(__tostring)
381# endif
382#endif
383    COPY(__call)
384    /* # NOT DONE */
385    COPY(module)
386#else
387    COPY(handle_function_call)
388    COPY(handle_property_get)
389    COPY(handle_property_set)
390#endif
[89]391    dnl must do after SETNULL(constructor) and dst->parent
[1]392    STRUCT(HashTable, function_table, HashTable_zend_function)
[99]393    IFRESTORE(`dst->function_table.pDestructor = ZEND_FUNCTION_DTOR;')
[199]394    IFCALCCOPY(`
[89]395        processor->active_class_entry_src = NULL;
[199]396        IFCOPY(`processor->active_class_entry_dst = NULL;')
[89]397    ')
[1]398')
399dnl }}}
400DEF_STRUCT_P_FUNC(`znode', , `dnl {{{
401    DISPATCH(int, op_type)
402
403#ifdef IS_CV
[11]404#   define XCACHE_IS_CV IS_CV
[1]405#else
[11]406/* compatible with zend optimizer */
407#   define XCACHE_IS_CV 16
[1]408#endif
[11]409    assert(src->op_type == IS_CONST ||
410        src->op_type == IS_VAR ||
411        src->op_type == XCACHE_IS_CV ||
[1]412        src->op_type == IS_TMP_VAR ||
413        src->op_type == IS_UNUSED);
[11]414#undef XCACHE_IS_CV
[1]415    dnl dirty dispatch
416    DISABLECHECK(`
417    switch (src->op_type) {
418        case IS_CONST:
419            STRUCT(zval, u.constant)
420            break;
421        IFCOPY(`
422            IFNOTMEMCPY(`
423                default:
424                    memcpy(&dst->u, &src->u, sizeof(src->u));
425            ')
426        ', `
427        case IS_VAR:
428        case IS_TMP_VAR:
429#ifdef IS_CV
430        case IS_CV:
431#else
432        case 16:
433#endif
434            DISPATCH(zend_uint, u.var)
435            DISPATCH(zend_uint, u.EA.type)
436            break;
437        case IS_UNUSED:
438            IFDASM(`DISPATCH(zend_uint, u.var)')
439            DISPATCH(zend_uint, u.opline_num)
440#ifndef ZEND_ENGINE_2
441            DISPATCH(zend_uint, u.fetch_type)
442#endif
443            DISPATCH(zend_uint, u.EA.type)
444            break;
445        ')
446    }
447    ')
448    DONE(u)
449')
450dnl }}}
451DEF_STRUCT_P_FUNC(`zend_op', , `dnl {{{
452    DISPATCH(zend_uchar, opcode)
453    STRUCT(znode, result)
454    STRUCT(znode, op1)
455    STRUCT(znode, op2)
456    DISPATCH(ulong, extended_value)
457    DISPATCH(uint, lineno)
458#ifdef ZEND_ENGINE_2_1
459    IFCOPY(`
460        switch (src->opcode) {
461            case ZEND_JMP:
462                dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src);
463                break;
464
465            case ZEND_JMPZ:
466            case ZEND_JMPNZ:
467            case ZEND_JMPZ_EX:
468            case ZEND_JMPNZ_EX:
469                dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src);
470                break;
471
472            default:
473                break;
474        }
475    ')
476    DISPATCH(opcode_handler_t, handler)
477#endif
478')
479dnl }}}
480DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{
481    IFRESTORE(`
[212]482    dnl shadow copy must NOT meet:
483    dnl readonly_protection=on
484    dnl main op_array && have early binding
485    if (!processor->readonly_protection && !(src == processor->xce_src->data.php->op_array && processor->xce_src->data.php->have_early_binding)) {
[1]486        /* really fast shallow copy */
487        memcpy(dst, src, sizeof(src[0]));
488        dst->refcount[0] = 1000;
489        /* deep */
490        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
491        define(`SKIPASSERT_ONCE')
492    }
493    else
494    ')
495    do {
496    dnl RESTORE is done above!
[11]497    zend_uint ii;
[1]498    int i;
499
500    /* Common elements */
501    DISPATCH(zend_uchar, type)
[103]502    PROC_ZSTRING(, function_name)
[1]503#ifdef ZEND_ENGINE_2
504    DISPATCH(zend_uint, fn_flags)
[89]505    dnl mark it as -1 on store, and lookup parent on restore
506    IFSTORE(`dst->prototype = (processor->active_class_entry_src && src->prototype) ? (zend_function *) -1 : NULL; DONE(prototype)', `
507            IFRESTORE(`do {
508                zend_function *parent;
509                if (src->prototype != NULL
510                 && zend_u_hash_find(&(processor->active_class_entry_dst->parent->function_table),
511                        UG(unicode) ? IS_UNICODE : IS_STRING,
[103]512                        src->function_name, xc_zstrlen(UG(unicode), src->function_name) + 1,
[89]513                        (void **) &parent) == SUCCESS) {
514                    /* see do_inherit_method_check() */
515                    if ((parent->common.fn_flags & ZEND_ACC_ABSTRACT)) {
516                      dst->prototype = parent;
517                    }
518                    else {
519                        dst->prototype = parent->common.prototype;
520                    }
521                }
522                else {
523                    dst->prototype = NULL;
524                }
525                DONE(prototype)
526            } while (0);
527            ', `
528                COPYNULL(prototype)
529            ')
530    ')
[11]531    STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info)
[1]532    DISPATCH(zend_uint, num_args)
533    DISPATCH(zend_uint, required_num_args)
534    DISPATCH(zend_bool, pass_rest_by_reference)
535#else
536    if (src->arg_types) {
537        ALLOC(dst->arg_types, zend_uchar, src->arg_types[0] + 1)
538        IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));')
539        IFDASM(`do {
[11]540            zend_uint ii;
[1]541            int i;
542            zval *zv;
543            ALLOC_INIT_ZVAL(zv);
544            array_init(zv);
545            for (i = 0; i < src->arg_types[0]; i ++) {
546                add_next_index_long(zv, src->arg_types[i + 1]);
547            }
548            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
549        } while (0);')
550        DONE(arg_types)
551    }
552    else {
553        IFDASM(`do {
554            /* empty array */
555            zval *zv;
556            ALLOC_INIT_ZVAL(zv);
557            array_init(zv);
558            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
559        } while (0);
560        DONE(arg_types)
561        ', `
562        COPYNULL(arg_types)
563        ')
564    }
565#endif
566    DISPATCH(unsigned char, return_reference)
567    /* END of common elements */
568#ifdef IS_UNICODE
[103]569    dnl SETNULL(u_twin)
[1]570#endif
571
572    STRUCT_P(zend_uint, refcount)
573    UNFIXPOINTER(zend_uint, refcount)
574
575    pushdef(`AFTER_ALLOC', `IFCOPY(`
576        processor->active_opcodes_dst = dst->opcodes;
577        processor->active_opcodes_src = src->opcodes;
578    ')')
[11]579    STRUCT_ARRAY_I(last, zend_op, opcodes)
[1]580    popdef(`AFTER_ALLOC')
581    DISPATCH(zend_uint, last)
582    IFCOPY(`dst->size = src->last;DONE(size)', `DISPATCH(zend_uint, size)')
583
584#ifdef IS_CV
585    STRUCT_ARRAY(last_var, zend_compiled_variable, vars)
586    DISPATCH(int, last_var)
587    IFCOPY(`dst->size_var = src->last_var;DONE(size_var)', `DISPATCH(zend_uint, size_var)')
588#else
589    dnl zend_cv.m4 is illegal to be made public, don not ask me for it
590    IFDASM(`
[4]591        sinclude(srcdir`/processor/zend_cv.m4')
[1]592        ')
593#endif
594
595    DISPATCH(zend_uint, T)
596
[11]597    STRUCT_ARRAY_I(last_brk_cont, zend_brk_cont_element, brk_cont_array)
[1]598    DISPATCH(zend_uint, last_brk_cont)
599    DISPATCH(zend_uint, current_brk_cont)
600#ifndef ZEND_ENGINE_2
601    DISPATCH(zend_bool, uses_globals)
602#endif
603
604#ifdef ZEND_ENGINE_2
605    STRUCT_ARRAY(last_try_catch, zend_try_catch_element, try_catch_array)
606    DISPATCH(int, last_try_catch)
607#endif
608
609    STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
610
[95]611    COPY(start_op)
[1]612    DISPATCH(int, backpatch_count)
613
614    DISPATCH(zend_bool, done_pass_two)
615#ifdef ZEND_ENGINE_2
616    DISPATCH(zend_bool, uses_this)
617#endif
618
619    IFRESTORE(`COPY(filename)', `PROC_STRING(filename)')
620#ifdef IS_UNICODE
621    PROC_STRING(script_encoding)
622#endif
623#ifdef ZEND_ENGINE_2
624    DISPATCH(zend_uint, line_start)
625    DISPATCH(zend_uint, line_end)
626    DISPATCH(int, doc_comment_len)
[103]627    PROC_STRING_L(doc_comment, doc_comment_len)
[1]628#endif
629
630    /* reserved */
631    DONE(reserved)
632#if defined(HARDENING_PATCH) && HARDENING_PATCH
633    DISPATCH(zend_bool, created_by_eval)
634#endif
635    } while (0);
[189]636
637    IFRESTORE(`
638#ifdef ZEND_ENGINE_2
639        if (dst->scope) {
640            dst->scope = xc_get_class(processor, (zend_ulong) dst->scope);
641            xc_fix_method(processor, dst);
642        }
643        DONE(scope)
644#endif
645    ', `
646#ifdef ZEND_ENGINE_2
647        PROC_CLASS_ENTRY_P(scope)
648#endif
649    ')
650
651    IFRESTORE(`
652        if (xc_have_op_array_ctor) {
653            zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) xc_zend_extension_op_array_ctor_handler, dst TSRMLS_CC);
654        }
655    ')
[1]656')
657dnl }}}
658
[95]659#ifdef HAVE_XCACHE_CONSTANT
660DEF_STRUCT_P_FUNC(`xc_constinfo_t', , `dnl {{{
661    DISPATCH(zend_uint, key_size)
662#ifdef IS_UNICODE
663    DISPATCH(zend_uchar, type)
664#endif
665    IFRESTORE(`COPY(key)', `
[103]666        PROC_ZSTRING_N(type, key, key_size)
[95]667    ')
668    STRUCT(zend_constant, constant)
669')
670dnl }}}
671#endif
[1]672DEF_STRUCT_P_FUNC(`xc_funcinfo_t', , `dnl {{{
673    DISPATCH(zend_uint, key_size)
674#ifdef IS_UNICODE
675    DISPATCH(zend_uchar, type)
676#endif
677    IFRESTORE(`COPY(key)', `
[103]678        PROC_ZSTRING_N(type, key, key_size)
[1]679    ')
680    STRUCT(zend_function, func)
681')
682dnl }}}
683DEF_STRUCT_P_FUNC(`xc_classinfo_t', , `dnl {{{
684    DISPATCH(zend_uint, key_size)
685#ifdef IS_UNICODE
686    DISPATCH(zend_uchar, type)
687#endif
688    IFRESTORE(`COPY(key)', `
[103]689        PROC_ZSTRING_N(type, key, key_size)
[1]690    ')
691#ifdef ZEND_ENGINE_2
692    STRUCT_P(zend_class_entry, cest)
693#else
694    STRUCT(zend_class_entry, cest)
695#endif
[212]696    DISPATCH(int, oplineno)
[1]697')
698dnl }}}
699DEF_STRUCT_P_FUNC(`xc_entry_data_php_t', , `dnl {{{
700    zend_uint i;
701
702#ifdef HAVE_INODE
703    DISPATCH(int, device)
704    DISPATCH(int, inode)
705#endif
706    DISPATCH(size_t, sourcesize)
707
708    DISPATCH(time_t, mtime)
709
710    STRUCT_P(zend_op_array, op_array)
711
[95]712#ifdef HAVE_XCACHE_CONSTANT
713    DISPATCH(zend_uint, constinfo_cnt)
714    STRUCT_ARRAY(constinfo_cnt, xc_constinfo_t, constinfos)
715#endif
716
[1]717    DISPATCH(zend_uint, funcinfo_cnt)
718    STRUCT_ARRAY(funcinfo_cnt, xc_funcinfo_t, funcinfos)
719
720    DISPATCH(zend_uint, classinfo_cnt)
721    pushdef(`BEFORE_LOOP', `
722        IFCOPY(`
723            processor->active_class_num = i + 1;
724        ')
725    ')
726    STRUCT_ARRAY(classinfo_cnt, xc_classinfo_t, classinfos)
[212]727    DISPATCH(zend_bool, have_early_binding)
[1]728    popdef(`BEFORE_LOOP')
729')
730dnl }}}
731DEF_STRUCT_P_FUNC(`xc_entry_data_var_t', , `dnl {{{
732    IFSTORE(`
733        if (processor->reference) {
734            if (zend_hash_add(&processor->zvalptrs, (char *)&src->value, sizeof(&src->value), (void*)&src->value, sizeof(src->value), NULL) == SUCCESS) {
735                dnl fprintf(stderr, "mark[%p] = %p\n", &src->value, &dst->value);
736            }
737            else {
738                assert(0);
739            }
740        }
741    ')
[4]742    STRUCT_P_EX(zval_ptr, dst->value, src->value, `value', `', `&')
[1]743    DONE(value)
744')
745dnl }}}
746dnl {{{ xc_entry_t
747DEF_STRUCT_P_FUNC(`xc_entry_t', , `
748    IFCOPY(`
749        processor->xce_dst = dst;
750        processor->xce_src = src;
751    ')
752    DISPATCH(xc_entry_type_t, type)
753    DISPATCH(size_t, size)
754
755    DISPATCH(xc_hash_value_t, hvalue)
756    COPY(cache)
757    /* skip */
758    DONE(next)
759
760    IFSTORE(`dst->refcount = 0; DONE(refcount)', `DISPATCH(long, refcount)')
761
762    DISPATCH(time_t, ctime)
763    DISPATCH(time_t, atime)
764    DISPATCH(time_t, dtime)
[114]765    DISPATCH(long, ttl)
[1]766    DISPATCH(zend_ulong, hits)
767#ifdef IS_UNICODE
768    DISPATCH(zend_uchar, name_type)
769#endif
770    dnl {{{ name
771    DISABLECHECK(`
772#ifdef IS_UNICODE
773        if (src->name_type == IS_UNICODE) {
774            DISPATCH(int32_t, name.ustr.len)
775        }
776        else {
777            DISPATCH(int, name.str.len)
778        }
779#else
780        DISPATCH(int, name.str.len)
781#endif
[103]782        IFRESTORE(`COPY(name.str.val)', `
783#ifdef IS_UNICODE
784            PROC_ZSTRING_L(name_type, name.uni.val, name.uni.len)
785#else
786            PROC_STRING_L(name.str.val, name.str.len)
787#endif
788        ')
[1]789    ')
790    DONE(name)
791    dnl }}}
792
793    dnl {{{ data
794    DISABLECHECK(`
795        switch (src->type) {
796        case XC_TYPE_PHP:
797            STRUCT_P(xc_entry_data_php_t, data.php)
798            break;
799        case XC_TYPE_VAR:
800            STRUCT_P(xc_entry_data_var_t, data.var)
801            break;
802        default:
803            assert(0);
804        }
805    ')
806    DONE(data)
807    dnl }}}
808')
809dnl }}}
810dnl ====================================================
Note: See TracBrowser for help on using the repository browser.