source: branches/1.3/processor/processor.m4 @ 886

Last change on this file since 886 was 886, checked in by moo, 2 years ago

merge some changes from trunk

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