source: branches/1.1/processor/processor.m4 @ 253

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

1.2->1.1: merged [231]: fix zval reference handling

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