source: trunk/processor/processor.m4 @ 495

Last change on this file since 495 was 495, checked in by moo, 7 years ago

shallow copy for some compiler result infos

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