source: trunk/processor/processor.m4 @ 114

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

gc expired items, new ini: xcache.ttl xcache.gc_interval xcache.var_ttl xcache.var_maxttl xcache.var_gc_interval

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