source: trunk/processor/processor.m4 @ 217

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

processor: reset refcount to 0 to kill leak warning

File size: 18.7 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)
[103]224    PROC_ZSTRING_L(, name, name_len)
[95]225    DISPATCH(int, module_number)
226')
227dnl }}}
228#endif
[1]229DEF_STRUCT_P_FUNC(`zend_function', , `dnl {{{
230    DISABLECHECK(`
231    switch (src->type) {
232    case ZEND_INTERNAL_FUNCTION:
233    case ZEND_OVERLOADED_FUNCTION:
234        IFNOTMEMCPY(`IFCOPY(`memcpy(dst, src, sizeof(src[0]));')')
235        break;
236
237    case ZEND_USER_FUNCTION:
238    case ZEND_EVAL_CODE:
239        DONE(type)
240        STRUCT(zend_op_array, op_array)
241        break;
242
243    default:
244        assert(0);
245    }
246    ')
247    DONE_SIZE(sizeof(src[0]))
248')
249dnl }}}
250dnl {{{ zend_property_info
251#ifdef ZEND_ENGINE_2
252DEF_STRUCT_P_FUNC(`zend_property_info', , `
253    DISPATCH(zend_uint, flags)
254    DISPATCH(int, name_length)
[103]255    PROC_ZSTRING_L(, name, name_length)
[1]256    DISPATCH(ulong, h)
[56]257#ifdef ZEND_ENGINE_2_1
[1]258    DISPATCH(int, doc_comment_len)
[103]259    PROC_STRING_L(doc_comment, doc_comment_len)
[56]260#endif
[78]261    dnl isnt in php6 yet
262#if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE)
263    PROC_CLASS_ENTRY_P(ce)
264#endif
[1]265')
266#endif
267dnl }}}
268DEF_STRUCT_P_FUNC(`zend_class_entry', , `dnl {{{
[199]269    IFCALCCOPY(`
[1]270        processor->active_class_entry_src = src;
[199]271        IFCOPY(`processor->active_class_entry_dst = dst;')
[1]272    ')
273    DISPATCH(char, type)
274    DISPATCH(zend_uint, name_length)
[103]275    PROC_ZSTRING_L(, name, name_length)
[1]276    IFRESTORE(`
277#ifndef ZEND_ENGINE_2
278        /* just copy parent and resolve on install_class */
279        COPY(parent)
280#else
281        PROC_CLASS_ENTRY_P(parent)
282#endif
283    ', `
284        PROC_CLASS_ENTRY_P(parent)
285    ')
286#ifdef ZEND_ENGINE_2
287    DISPATCH(int, refcount)
288#else
289    STRUCT_P(int, refcount)
290#endif
291    DISPATCH(zend_bool, constants_updated)
292#ifdef ZEND_ENGINE_2
293    DISPATCH(zend_uint, ce_flags)
294#endif
295
296    STRUCT(HashTable, default_properties, HashTable_zval_ptr)
[217]297    IFSTORE(`xc_hash_reset_zval_refcount(&dst->default_properties TSRMLS_CC);')
[1]298    IFCOPY(`dst->builtin_functions = src->builtin_functions;')
299    DONE(builtin_functions)
300#ifdef ZEND_ENGINE_2
301    STRUCT(HashTable, properties_info, HashTable_zend_property_info)
302#   ifdef ZEND_ENGINE_2_1
[199]303    STRUCT(HashTable, default_static_members, IFCALCSTORE(HashTable_zval_ptr_static_member_check, HashTable_zval_ptr))
[1]304    IFCOPY(`dst->static_members = &dst->default_static_members;')
[196]305    IFRESTORE(`if (dst->parent) xc_fix_static_members(processor, dst TSRMLS_CC);')
[1]306    DONE(static_members)
307#   else
[199]308    STRUCT_P(HashTable, static_members, IFCALCSTORE(HashTable_zval_ptr_static_member_check, HashTable_zval_ptr))
[1]309#   endif
310    STRUCT(HashTable, constants_table, HashTable_zval_ptr)
[217]311    IFSTORE(`xc_hash_reset_zval_refcount(&dst->constants_table TSRMLS_CC);')
[1]312
313    dnl runtime binding: ADD_INTERFACE will deal with it
314    IFRESTORE(`
315        if (src->num_interfaces) {
316            CALLOC(dst->interfaces, zend_class_entry*, src->num_interfaces)
[4]317            DONE(`interfaces')
[1]318        }
319        else {
[4]320            COPYNULL(interfaces)
[1]321        }
322    ')
323    IFDASM(`
324        if (src->num_interfaces) {
325            /*
326            zval *arr;
327            ALLOC_INIT_ZVAL(arr);
328            array_init(arr);
329            for (i = 0; i < src->num_interfaces; i ++) {
330                zval *zv;
331                ALLOC_INIT_ZVAL(zv);
332                ZVAL_STRING(src->num_interfaces);
333            }
334            add_assoc_zval_ex(dst, ZEND_STRS("interfaces"), arr);
335            */
[4]336            DONE(`interfaces')
[1]337        }
338        else {
[4]339            COPYNULL(interfaces)
[1]340        }
341    ')
[4]342    IFRESTORE(`', `
343        IFDASM(`', `
344            DONE(`interfaces')
345        ')
346    ')
[1]347    DISPATCH(zend_uint, num_interfaces)
348
349    IFRESTORE(`COPY(filename)', `PROC_STRING(filename)')
350    DISPATCH(zend_uint, line_start)
351    DISPATCH(zend_uint, line_end)
352#ifdef ZEND_ENGINE_2_1
353    DISPATCH(zend_uint, doc_comment_len)
[103]354    PROC_STRING_L(doc_comment, doc_comment_len)
[1]355#endif
356    /* # NOT DONE */
357    COPY(serialize_func)
358    COPY(unserialize_func)
359    COPY(iterator_funcs)
360    COPY(create_object)
361    COPY(get_iterator)
362    COPY(interface_gets_implemented)
363    COPY(serialize)
364    COPY(unserialize)
365    /* deal with it inside xc_fix_method */
366    SETNULL(constructor)
367    COPY(destructor)
368    COPY(clone)
369    COPY(__get)
370    COPY(__set)
371/* should be >5.1 */
372#ifdef ZEND_ENGINE_2_1
373    COPY(__unset)
374    COPY(__isset)
[94]375# if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6
[1]376    COPY(__tostring)
377# endif
378#endif
379    COPY(__call)
380    /* # NOT DONE */
381    COPY(module)
382#else
383    COPY(handle_function_call)
384    COPY(handle_property_get)
385    COPY(handle_property_set)
386#endif
[89]387    dnl must do after SETNULL(constructor) and dst->parent
[1]388    STRUCT(HashTable, function_table, HashTable_zend_function)
[99]389    IFRESTORE(`dst->function_table.pDestructor = ZEND_FUNCTION_DTOR;')
[199]390    IFCALCCOPY(`
[89]391        processor->active_class_entry_src = NULL;
[199]392        IFCOPY(`processor->active_class_entry_dst = NULL;')
[89]393    ')
[1]394')
395dnl }}}
396DEF_STRUCT_P_FUNC(`znode', , `dnl {{{
397    DISPATCH(int, op_type)
398
399#ifdef IS_CV
[11]400#   define XCACHE_IS_CV IS_CV
[1]401#else
[11]402/* compatible with zend optimizer */
403#   define XCACHE_IS_CV 16
[1]404#endif
[11]405    assert(src->op_type == IS_CONST ||
406        src->op_type == IS_VAR ||
407        src->op_type == XCACHE_IS_CV ||
[1]408        src->op_type == IS_TMP_VAR ||
409        src->op_type == IS_UNUSED);
[11]410#undef XCACHE_IS_CV
[1]411    dnl dirty dispatch
412    DISABLECHECK(`
413    switch (src->op_type) {
414        case IS_CONST:
415            STRUCT(zval, u.constant)
416            break;
417        IFCOPY(`
418            IFNOTMEMCPY(`
419                default:
420                    memcpy(&dst->u, &src->u, sizeof(src->u));
421            ')
422        ', `
423        case IS_VAR:
424        case IS_TMP_VAR:
425#ifdef IS_CV
426        case IS_CV:
427#else
428        case 16:
429#endif
430            DISPATCH(zend_uint, u.var)
431            DISPATCH(zend_uint, u.EA.type)
432            break;
433        case IS_UNUSED:
434            IFDASM(`DISPATCH(zend_uint, u.var)')
435            DISPATCH(zend_uint, u.opline_num)
436#ifndef ZEND_ENGINE_2
437            DISPATCH(zend_uint, u.fetch_type)
438#endif
439            DISPATCH(zend_uint, u.EA.type)
440            break;
441        ')
442    }
443    ')
444    DONE(u)
445')
446dnl }}}
447DEF_STRUCT_P_FUNC(`zend_op', , `dnl {{{
448    DISPATCH(zend_uchar, opcode)
449    STRUCT(znode, result)
450    STRUCT(znode, op1)
451    STRUCT(znode, op2)
452    DISPATCH(ulong, extended_value)
453    DISPATCH(uint, lineno)
454#ifdef ZEND_ENGINE_2_1
455    IFCOPY(`
456        switch (src->opcode) {
457            case ZEND_JMP:
458                dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src);
459                break;
460
461            case ZEND_JMPZ:
462            case ZEND_JMPNZ:
463            case ZEND_JMPZ_EX:
464            case ZEND_JMPNZ_EX:
465                dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src);
466                break;
467
468            default:
469                break;
470        }
471    ')
472    DISPATCH(opcode_handler_t, handler)
473#endif
474')
475dnl }}}
476DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{
477    IFRESTORE(`
[212]478    dnl shadow copy must NOT meet:
479    dnl readonly_protection=on
480    dnl main op_array && have early binding
481    if (!processor->readonly_protection && !(src == processor->xce_src->data.php->op_array && processor->xce_src->data.php->have_early_binding)) {
[1]482        /* really fast shallow copy */
483        memcpy(dst, src, sizeof(src[0]));
484        dst->refcount[0] = 1000;
485        /* deep */
486        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
487        define(`SKIPASSERT_ONCE')
488    }
489    else
490    ')
491    do {
492    dnl RESTORE is done above!
[11]493    zend_uint ii;
[1]494    int i;
495
496    /* Common elements */
497    DISPATCH(zend_uchar, type)
[103]498    PROC_ZSTRING(, function_name)
[1]499#ifdef ZEND_ENGINE_2
500    DISPATCH(zend_uint, fn_flags)
[89]501    dnl mark it as -1 on store, and lookup parent on restore
502    IFSTORE(`dst->prototype = (processor->active_class_entry_src && src->prototype) ? (zend_function *) -1 : NULL; DONE(prototype)', `
503            IFRESTORE(`do {
504                zend_function *parent;
505                if (src->prototype != NULL
506                 && zend_u_hash_find(&(processor->active_class_entry_dst->parent->function_table),
507                        UG(unicode) ? IS_UNICODE : IS_STRING,
[103]508                        src->function_name, xc_zstrlen(UG(unicode), src->function_name) + 1,
[89]509                        (void **) &parent) == SUCCESS) {
510                    /* see do_inherit_method_check() */
511                    if ((parent->common.fn_flags & ZEND_ACC_ABSTRACT)) {
512                      dst->prototype = parent;
513                    }
514                    else {
515                        dst->prototype = parent->common.prototype;
516                    }
517                }
518                else {
519                    dst->prototype = NULL;
520                }
521                DONE(prototype)
522            } while (0);
523            ', `
524                COPYNULL(prototype)
525            ')
526    ')
[11]527    STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info)
[1]528    DISPATCH(zend_uint, num_args)
529    DISPATCH(zend_uint, required_num_args)
530    DISPATCH(zend_bool, pass_rest_by_reference)
531#else
532    if (src->arg_types) {
533        ALLOC(dst->arg_types, zend_uchar, src->arg_types[0] + 1)
534        IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));')
535        IFDASM(`do {
[11]536            zend_uint ii;
[1]537            int i;
538            zval *zv;
539            ALLOC_INIT_ZVAL(zv);
540            array_init(zv);
541            for (i = 0; i < src->arg_types[0]; i ++) {
542                add_next_index_long(zv, src->arg_types[i + 1]);
543            }
544            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
545        } while (0);')
546        DONE(arg_types)
547    }
548    else {
549        IFDASM(`do {
550            /* empty array */
551            zval *zv;
552            ALLOC_INIT_ZVAL(zv);
553            array_init(zv);
554            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
555        } while (0);
556        DONE(arg_types)
557        ', `
558        COPYNULL(arg_types)
559        ')
560    }
561#endif
562    DISPATCH(unsigned char, return_reference)
563    /* END of common elements */
564#ifdef IS_UNICODE
[103]565    dnl SETNULL(u_twin)
[1]566#endif
567
568    STRUCT_P(zend_uint, refcount)
569    UNFIXPOINTER(zend_uint, refcount)
570
571    pushdef(`AFTER_ALLOC', `IFCOPY(`
572        processor->active_opcodes_dst = dst->opcodes;
573        processor->active_opcodes_src = src->opcodes;
574    ')')
[11]575    STRUCT_ARRAY_I(last, zend_op, opcodes)
[1]576    popdef(`AFTER_ALLOC')
577    DISPATCH(zend_uint, last)
578    IFCOPY(`dst->size = src->last;DONE(size)', `DISPATCH(zend_uint, size)')
579
580#ifdef IS_CV
581    STRUCT_ARRAY(last_var, zend_compiled_variable, vars)
582    DISPATCH(int, last_var)
583    IFCOPY(`dst->size_var = src->last_var;DONE(size_var)', `DISPATCH(zend_uint, size_var)')
584#else
585    dnl zend_cv.m4 is illegal to be made public, don not ask me for it
586    IFDASM(`
[4]587        sinclude(srcdir`/processor/zend_cv.m4')
[1]588        ')
589#endif
590
591    DISPATCH(zend_uint, T)
592
[11]593    STRUCT_ARRAY_I(last_brk_cont, zend_brk_cont_element, brk_cont_array)
[1]594    DISPATCH(zend_uint, last_brk_cont)
595    DISPATCH(zend_uint, current_brk_cont)
596#ifndef ZEND_ENGINE_2
597    DISPATCH(zend_bool, uses_globals)
598#endif
599
600#ifdef ZEND_ENGINE_2
601    STRUCT_ARRAY(last_try_catch, zend_try_catch_element, try_catch_array)
602    DISPATCH(int, last_try_catch)
603#endif
604
605    STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
606
[95]607    COPY(start_op)
[1]608    DISPATCH(int, backpatch_count)
609
610    DISPATCH(zend_bool, done_pass_two)
611#ifdef ZEND_ENGINE_2
612    DISPATCH(zend_bool, uses_this)
613#endif
614
615    IFRESTORE(`COPY(filename)', `PROC_STRING(filename)')
616#ifdef IS_UNICODE
617    PROC_STRING(script_encoding)
618#endif
619#ifdef ZEND_ENGINE_2
620    DISPATCH(zend_uint, line_start)
621    DISPATCH(zend_uint, line_end)
622    DISPATCH(int, doc_comment_len)
[103]623    PROC_STRING_L(doc_comment, doc_comment_len)
[1]624#endif
625
626    /* reserved */
627    DONE(reserved)
628#if defined(HARDENING_PATCH) && HARDENING_PATCH
629    DISPATCH(zend_bool, created_by_eval)
630#endif
631    } while (0);
[189]632
633    IFRESTORE(`
634#ifdef ZEND_ENGINE_2
635        if (dst->scope) {
636            dst->scope = xc_get_class(processor, (zend_ulong) dst->scope);
637            xc_fix_method(processor, dst);
638        }
639        DONE(scope)
640#endif
641    ', `
642#ifdef ZEND_ENGINE_2
643        PROC_CLASS_ENTRY_P(scope)
644#endif
645    ')
646
647    IFRESTORE(`
648        if (xc_have_op_array_ctor) {
649            zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) xc_zend_extension_op_array_ctor_handler, dst TSRMLS_CC);
650        }
651    ')
[1]652')
653dnl }}}
654
[95]655#ifdef HAVE_XCACHE_CONSTANT
656DEF_STRUCT_P_FUNC(`xc_constinfo_t', , `dnl {{{
657    DISPATCH(zend_uint, key_size)
658#ifdef IS_UNICODE
659    DISPATCH(zend_uchar, type)
660#endif
661    IFRESTORE(`COPY(key)', `
[103]662        PROC_ZSTRING_N(type, key, key_size)
[95]663    ')
664    STRUCT(zend_constant, constant)
665')
666dnl }}}
667#endif
[1]668DEF_STRUCT_P_FUNC(`xc_funcinfo_t', , `dnl {{{
669    DISPATCH(zend_uint, key_size)
670#ifdef IS_UNICODE
671    DISPATCH(zend_uchar, type)
672#endif
673    IFRESTORE(`COPY(key)', `
[103]674        PROC_ZSTRING_N(type, key, key_size)
[1]675    ')
676    STRUCT(zend_function, func)
677')
678dnl }}}
679DEF_STRUCT_P_FUNC(`xc_classinfo_t', , `dnl {{{
680    DISPATCH(zend_uint, key_size)
681#ifdef IS_UNICODE
682    DISPATCH(zend_uchar, type)
683#endif
684    IFRESTORE(`COPY(key)', `
[103]685        PROC_ZSTRING_N(type, key, key_size)
[1]686    ')
687#ifdef ZEND_ENGINE_2
688    STRUCT_P(zend_class_entry, cest)
689#else
690    STRUCT(zend_class_entry, cest)
691#endif
[212]692    DISPATCH(int, oplineno)
[1]693')
694dnl }}}
695DEF_STRUCT_P_FUNC(`xc_entry_data_php_t', , `dnl {{{
696    zend_uint i;
697
698#ifdef HAVE_INODE
699    DISPATCH(int, device)
700    DISPATCH(int, inode)
701#endif
702    DISPATCH(size_t, sourcesize)
703
704    DISPATCH(time_t, mtime)
705
706    STRUCT_P(zend_op_array, op_array)
707
[95]708#ifdef HAVE_XCACHE_CONSTANT
709    DISPATCH(zend_uint, constinfo_cnt)
710    STRUCT_ARRAY(constinfo_cnt, xc_constinfo_t, constinfos)
711#endif
712
[1]713    DISPATCH(zend_uint, funcinfo_cnt)
714    STRUCT_ARRAY(funcinfo_cnt, xc_funcinfo_t, funcinfos)
715
716    DISPATCH(zend_uint, classinfo_cnt)
717    pushdef(`BEFORE_LOOP', `
718        IFCOPY(`
719            processor->active_class_num = i + 1;
720        ')
721    ')
722    STRUCT_ARRAY(classinfo_cnt, xc_classinfo_t, classinfos)
[212]723    DISPATCH(zend_bool, have_early_binding)
[1]724    popdef(`BEFORE_LOOP')
725')
726dnl }}}
727DEF_STRUCT_P_FUNC(`xc_entry_data_var_t', , `dnl {{{
728    IFSTORE(`
729        if (processor->reference) {
730            if (zend_hash_add(&processor->zvalptrs, (char *)&src->value, sizeof(&src->value), (void*)&src->value, sizeof(src->value), NULL) == SUCCESS) {
731                dnl fprintf(stderr, "mark[%p] = %p\n", &src->value, &dst->value);
732            }
733            else {
734                assert(0);
735            }
736        }
737    ')
[4]738    STRUCT_P_EX(zval_ptr, dst->value, src->value, `value', `', `&')
[1]739    DONE(value)
740')
741dnl }}}
742dnl {{{ xc_entry_t
743DEF_STRUCT_P_FUNC(`xc_entry_t', , `
744    IFCOPY(`
745        processor->xce_dst = dst;
746        processor->xce_src = src;
747    ')
748    DISPATCH(xc_entry_type_t, type)
749    DISPATCH(size_t, size)
750
751    DISPATCH(xc_hash_value_t, hvalue)
752    COPY(cache)
753    /* skip */
754    DONE(next)
755
756    IFSTORE(`dst->refcount = 0; DONE(refcount)', `DISPATCH(long, refcount)')
757
758    DISPATCH(time_t, ctime)
759    DISPATCH(time_t, atime)
760    DISPATCH(time_t, dtime)
[114]761    DISPATCH(long, ttl)
[1]762    DISPATCH(zend_ulong, hits)
763#ifdef IS_UNICODE
764    DISPATCH(zend_uchar, name_type)
765#endif
766    dnl {{{ name
767    DISABLECHECK(`
768#ifdef IS_UNICODE
769        if (src->name_type == IS_UNICODE) {
770            DISPATCH(int32_t, name.ustr.len)
771        }
772        else {
773            DISPATCH(int, name.str.len)
774        }
775#else
776        DISPATCH(int, name.str.len)
777#endif
[103]778        IFRESTORE(`COPY(name.str.val)', `
779#ifdef IS_UNICODE
780            PROC_ZSTRING_L(name_type, name.uni.val, name.uni.len)
781#else
782            PROC_STRING_L(name.str.val, name.str.len)
783#endif
784        ')
[1]785    ')
786    DONE(name)
787    dnl }}}
788
789    dnl {{{ data
790    DISABLECHECK(`
791        switch (src->type) {
792        case XC_TYPE_PHP:
793            STRUCT_P(xc_entry_data_php_t, data.php)
794            break;
795        case XC_TYPE_VAR:
796            STRUCT_P(xc_entry_data_var_t, data.var)
797            break;
798        default:
799            assert(0);
800        }
801    ')
802    DONE(data)
803    dnl }}}
804')
805dnl }}}
806dnl ====================================================
Note: See TracBrowser for help on using the repository browser.