source: trunk/processor/processor.m4 @ 231

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

fix zval reference handling

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