source: svn/trunk/processor/processor.m4 @ 311

Last change on this file since 311 was 311, checked in by Xuefer, 10 years ago

restruct cached compile, add md5 table to recognize and merge file with same content

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