source: trunk/processor/processor.m4 @ 199

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

processor: remove commented code, fix corruption detected by --eanble-xcache-test for [196]

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