source: trunk/processor/processor.m4 @ 233

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

processor: apply reference handling on opcode caching. reverted [196] [199] [220] and refix for #36

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