source: trunk/processor/processor.m4 @ 480

Last change on this file since 480 was 480, checked in by moo, 7 years ago

compile against PHP_5_3

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