source: trunk/processor/processor.m4 @ 200

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

BUCKET_KEY readability and PHP_6 build fix

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