source: trunk/processor/processor.m4 @ 194

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

PHP_5_2: new element in zend_brk_cont_element

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