source: trunk/processor/processor.m4 @ 122

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

remove typo

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