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

Last change on this file since 618 was 618, checked in by moo, 5 years ago

merged r487,r491,r492,r495 from trunk

  • Property svn:eol-style set to native
File size: 19.6 KB
RevLine 
[1]1dnl ================
2/* {{{ Pre-declare */
3DECL_STRUCT_P_FUNC(`zval')
4DECL_STRUCT_P_FUNC(`zval_ptr')
5DECL_STRUCT_P_FUNC(`zend_op_array')
6DECL_STRUCT_P_FUNC(`zend_class_entry')
[95]7#ifdef HAVE_XCACHE_CONSTANT
8DECL_STRUCT_P_FUNC(`zend_constant')
9#endif
[1]10DECL_STRUCT_P_FUNC(`zend_function')
11DECL_STRUCT_P_FUNC(`xc_entry_t')
12#ifdef ZEND_ENGINE_2
13DECL_STRUCT_P_FUNC(`zend_property_info')
14#endif
15/* }}} */
16dnl ====================================================
17dnl {{{ zend_compiled_variable
18#ifdef IS_CV
19DEF_STRUCT_P_FUNC(`zend_compiled_variable', , `
20    DISPATCH(int, name_len)
[103]21    PROC_ZSTRING_L(, name, name_len)
[1]22    DISPATCH(ulong, hash_value)
23')
24#endif
25dnl }}}
26dnl {{{ zend_uint
27DEF_STRUCT_P_FUNC(`zend_uint', , `
28    IFCOPY(`dst[0] = src[0];')
29    IFDPRINT(`
30        INDENT()
31        fprintf(stderr, "%u\n", src[0]);
32    ')
33    DONE_SIZE(sizeof(src[0]))
34')
35dnl }}}
36dnl {{{ int
37#ifndef ZEND_ENGINE_2
38DEF_STRUCT_P_FUNC(`int', , `
39    IFCOPY(`*dst = *src;')
40    IFDPRINT(`
41        INDENT()
42        fprintf(stderr, "%d\n", src[0]);
43    ')
44    DONE_SIZE(sizeof(src[0]))
45')
46#endif
47dnl }}}
48dnl {{{ zend_try_catch_element
49#ifdef ZEND_ENGINE_2
50DEF_STRUCT_P_FUNC(`zend_try_catch_element', , `
51    DISPATCH(zend_uint, try_op)
52    DISPATCH(zend_uint, catch_op)
53')
54#endif /* ifdef ZEND_ENGINE_2 */
55dnl }}}
56dnl {{{ zend_brk_cont_element
57DEF_STRUCT_P_FUNC(`zend_brk_cont_element', , `
[194]58#ifdef ZEND_ENGINE_2_2
[200]59#ifndef IS_UNICODE
[194]60    DISPATCH(int, start)
61#endif
[200]62#endif
[1]63    DISPATCH(int, cont)
64    DISPATCH(int, brk)
65    DISPATCH(int, parent)
66')
67dnl }}}
68DEF_HASH_TABLE_FUNC(`HashTable_zval_ptr',           `zval_ptr')
[95]69#ifdef HAVE_XCACHE_CONSTANT
70DEF_HASH_TABLE_FUNC(`HashTable_zend_constant',      `zend_constant')
71#endif
[1]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);
[618]81        Z_SET_REFCOUNT(*dst, 1);
[1]82        DONE(value)
83        DONE(type)
[617]84#ifdef ZEND_ENGINE_2_3
85        DONE(is_ref__gc)
86        DONE(refcount__gc)
87#else
[1]88        DONE(is_ref)
[617]89        DONE(refcount)
[483]90#endif
[1]91    } while(0);
92    return;
93    ', `
94        dnl IFDASM else
95        /* Variable information */
96dnl {{{ zvalue_value
97        DISABLECHECK(`
[618]98        switch ((Z_TYPE_P(src) & IS_CONSTANT_TYPE_MASK)) {
[1]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:
[103]127                DISPATCH(int32_t, value.uni.len)
128                PROC_ZSTRING_L(1, value.uni.val, value.uni.len)
[1]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)
[617]153#ifdef ZEND_ENGINE_2_3
154        DISPATCH(zend_uchar, is_ref__gc)
155#else
[1]156        DISPATCH(zend_uchar, is_ref)
[617]157#endif
158
159#ifdef ZEND_ENGINE_2_3
160        DISPATCH(zend_uint, refcount__gc)
161#elif defined(ZEND_ENGINE_2)
[616]162        DISPATCH(zend_uint, refcount)
163#else
[1]164        DISPATCH(zend_ushort, refcount)
[616]165#endif
[1]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;
[231]179                    if (zend_hash_find(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void **) &ppzv) == SUCCESS) {
[1]180                        IFCOPY(`
181                            dst[0] = *ppzv;
182                            /* *dst is updated */
[248]183                            dnl fprintf(stderr, "*dst is set to %p, KIND is_shm %d\n", dst[0], xc_is_shm(dst[0]));
[1]184                        ')
[233]185                        IFCALCSTORE(`processor->have_references = 1;')
[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];
[248]201                        FIXPOINTER_EX(zval, pzv)
[1]202                    ')
[231]203                    if (zend_hash_add(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void *) &pzv, sizeof(pzv), NULL) == SUCCESS) {
[1]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            ')
[230]215            IFDPRINT(`INDENT()`'fprintf(stderr, "[%p]", src[0]);')
[4]216            STRUCT_P_EX(zval, dst[0], src[0], `[0]', `', ` ')
[248]217            FIXPOINTER_EX(zval, dst[0])
[1]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)
[103]227    PROC_ZSTRING_L(, name, name_len)
[1]228    DISPATCH(zend_uint, class_name_len)
[103]229    PROC_ZSTRING_L(, class_name, class_name_len)
[1]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 }}}
[95]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)
[218]243    pushdef(`emalloc', `malloc($1)')
244    pushdef(`ecalloc', `calloc($1, $2)')
[103]245    PROC_ZSTRING_L(, name, name_len)
[218]246    popdef(`ecalloc')
247    popdef(`emalloc')
[95]248    DISPATCH(int, module_number)
249')
250dnl }}}
251#endif
[1]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)
[103]278    PROC_ZSTRING_L(, name, name_length)
[1]279    DISPATCH(ulong, h)
[56]280#ifdef ZEND_ENGINE_2_1
[1]281    DISPATCH(int, doc_comment_len)
[272]282    PROC_ZSTRING_L(, doc_comment, doc_comment_len)
[56]283#endif
[78]284    dnl isnt in php6 yet
285#if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE)
286    PROC_CLASS_ENTRY_P(ce)
287#endif
[1]288')
289#endif
290dnl }}}
291DEF_STRUCT_P_FUNC(`zend_class_entry', , `dnl {{{
[199]292    IFCALCCOPY(`
[1]293        processor->active_class_entry_src = src;
[199]294        IFCOPY(`processor->active_class_entry_dst = dst;')
[1]295    ')
296    DISPATCH(char, type)
297    DISPATCH(zend_uint, name_length)
[103]298    PROC_ZSTRING_L(, name, name_length)
[1]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
[233]325    STRUCT(HashTable, default_static_members, HashTable_zval_ptr)
[1]326    IFCOPY(`dst->static_members = &dst->default_static_members;')
327    DONE(static_members)
328#   else
[233]329    STRUCT_P(HashTable, static_members, HashTable_zval_ptr)
[1]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)
[4]337            DONE(`interfaces')
[1]338        }
339        else {
[4]340            COPYNULL(interfaces)
[1]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            */
[4]356            DONE(`interfaces')
[1]357        }
358        else {
[4]359            COPYNULL(interfaces)
[1]360        }
361    ')
[4]362    IFRESTORE(`', `
363        IFDASM(`', `
364            DONE(`interfaces')
365        ')
366    ')
[1]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)
[272]374    PROC_ZSTRING_L(, doc_comment, doc_comment_len)
[1]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)
[481]383#ifdef ZEND_ENGINE_2_3
384    COPY(get_static_method)
385#endif
[1]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)
[94]398# if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6
[1]399    COPY(__tostring)
400# endif
401#endif
402    COPY(__call)
[481]403#ifdef ZEND_CALLSTATIC_FUNC_NAME
404    COPY(__callstatic)
405#endif
[1]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
[89]413    dnl must do after SETNULL(constructor) and dst->parent
[1]414    STRUCT(HashTable, function_table, HashTable_zend_function)
[99]415    IFRESTORE(`dst->function_table.pDestructor = ZEND_FUNCTION_DTOR;')
[199]416    IFCALCCOPY(`
[89]417        processor->active_class_entry_src = NULL;
[199]418        IFCOPY(`processor->active_class_entry_dst = NULL;')
[89]419    ')
[1]420')
421dnl }}}
422DEF_STRUCT_P_FUNC(`znode', , `dnl {{{
423    DISPATCH(int, op_type)
424
425#ifdef IS_CV
[11]426#   define XCACHE_IS_CV IS_CV
[1]427#else
[11]428/* compatible with zend optimizer */
429#   define XCACHE_IS_CV 16
[1]430#endif
[11]431    assert(src->op_type == IS_CONST ||
432        src->op_type == IS_VAR ||
433        src->op_type == XCACHE_IS_CV ||
[1]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:
[594]450        case XCACHE_IS_CV:
[1]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)
[594]466#undef XCACHE_IS_CV
[1]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:
[617]487#ifdef ZEND_JMP_SET
488            case ZEND_JMP_SET:
489#endif
[1]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(`
[212]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->xce_src->data.php->op_array && processor->xce_src->data.php->have_early_binding)) {
[1]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!
[11]518    zend_uint ii;
[1]519    int i;
520
521    /* Common elements */
522    DISPATCH(zend_uchar, type)
[103]523    PROC_ZSTRING(, function_name)
[1]524#ifdef ZEND_ENGINE_2
525    DISPATCH(zend_uint, fn_flags)
[11]526    STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info)
[1]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 {
[11]535            zend_uint ii;
[1]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
[103]564    dnl SETNULL(u_twin)
[1]565#endif
566
567    STRUCT_P(zend_uint, refcount)
568    UNFIXPOINTER(zend_uint, refcount)
[221]569    IFSTORE(`dst->refcount[0] = 1;')
[1]570
571    pushdef(`AFTER_ALLOC', `IFCOPY(`
572        processor->active_opcodes_dst = dst->opcodes;
573        processor->active_opcodes_src = src->opcodes;
574    ')')
[11]575    STRUCT_ARRAY_I(last, zend_op, opcodes)
[1]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(`
[4]587        sinclude(srcdir`/processor/zend_cv.m4')
[1]588        ')
589#endif
590
591    DISPATCH(zend_uint, T)
592
[11]593    STRUCT_ARRAY_I(last_brk_cont, zend_brk_cont_element, brk_cont_array)
[1]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
[95]607    COPY(start_op)
[1]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
[267]617    IFRESTORE(`
618        COPY(script_encoding)
619    ', `
620        PROC_STRING(script_encoding)
621    ')
[1]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)
[272]627    PROC_ZSTRING_L(, doc_comment, doc_comment_len)
[1]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);
[189]636
[219]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
[189]669    IFRESTORE(`
670#ifdef ZEND_ENGINE_2
[219]671        if (src->scope) {
672            dst->scope = xc_get_class(processor, (zend_ulong) src->scope);
[189]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    ')
[1]688')
689dnl }}}
690
[95]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)', `
[103]698        PROC_ZSTRING_N(type, key, key_size)
[95]699    ')
700    STRUCT(zend_constant, constant)
701')
702dnl }}}
703#endif
[1]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)', `
[103]710        PROC_ZSTRING_N(type, key, key_size)
[1]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)', `
[103]721        PROC_ZSTRING_N(type, key, key_size)
[1]722    ')
723#ifdef ZEND_ENGINE_2
724    STRUCT_P(zend_class_entry, cest)
725#else
726    STRUCT(zend_class_entry, cest)
727#endif
[212]728    DISPATCH(int, oplineno)
[1]729')
730dnl }}}
[268]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
[1]743DEF_STRUCT_P_FUNC(`xc_entry_data_php_t', , `dnl {{{
744    zend_uint i;
745
746#ifdef HAVE_INODE
747    DISPATCH(int, device)
748    DISPATCH(int, inode)
749#endif
750    DISPATCH(size_t, sourcesize)
751
752    DISPATCH(time_t, mtime)
753
754    STRUCT_P(zend_op_array, op_array)
755
[95]756#ifdef HAVE_XCACHE_CONSTANT
757    DISPATCH(zend_uint, constinfo_cnt)
[618]758    IFRESTORE(`
759        COPY(constinfos)
760    ', `
761        STRUCT_ARRAY(constinfo_cnt, xc_constinfo_t, constinfos)
762    ')
[95]763#endif
764
[1]765    DISPATCH(zend_uint, funcinfo_cnt)
766    STRUCT_ARRAY(funcinfo_cnt, xc_funcinfo_t, funcinfos)
767
768    DISPATCH(zend_uint, classinfo_cnt)
769    pushdef(`BEFORE_LOOP', `
770        IFCOPY(`
771            processor->active_class_num = i + 1;
772        ')
773    ')
774    STRUCT_ARRAY(classinfo_cnt, xc_classinfo_t, classinfos)
[618]775    popdef(`BEFORE_LOOP')
[268]776#ifdef ZEND_ENGINE_2_1
777    DISPATCH(zend_uint, autoglobal_cnt)
[618]778    IFRESTORE(`
779        COPY(autoglobals)
780    ', `
781        STRUCT_ARRAY(autoglobal_cnt, xc_autoglobal_t, autoglobals)
782    ')
[268]783#endif
[212]784    DISPATCH(zend_bool, have_early_binding)
[1]785')
786dnl }}}
787DEF_STRUCT_P_FUNC(`xc_entry_data_var_t', , `dnl {{{
[230]788    IFDPRINT(`INDENT()`'fprintf(stderr, "zval:value");')
[4]789    STRUCT_P_EX(zval_ptr, dst->value, src->value, `value', `', `&')
[1]790    DONE(value)
791')
792dnl }}}
793dnl {{{ xc_entry_t
794DEF_STRUCT_P_FUNC(`xc_entry_t', , `
795    IFCOPY(`
796        processor->xce_dst = dst;
797        processor->xce_src = src;
798    ')
799    DISPATCH(xc_entry_type_t, type)
800    DISPATCH(size_t, size)
801
802    DISPATCH(xc_hash_value_t, hvalue)
803    COPY(cache)
804    /* skip */
805    DONE(next)
806
807    IFSTORE(`dst->refcount = 0; DONE(refcount)', `DISPATCH(long, refcount)')
808
809    DISPATCH(time_t, ctime)
810    DISPATCH(time_t, atime)
811    DISPATCH(time_t, dtime)
[114]812    DISPATCH(long, ttl)
[1]813    DISPATCH(zend_ulong, hits)
814#ifdef IS_UNICODE
815    DISPATCH(zend_uchar, name_type)
816#endif
817    dnl {{{ name
818    DISABLECHECK(`
819#ifdef IS_UNICODE
820        if (src->name_type == IS_UNICODE) {
821            DISPATCH(int32_t, name.ustr.len)
822        }
823        else {
824            DISPATCH(int, name.str.len)
825        }
826#else
827        DISPATCH(int, name.str.len)
828#endif
[103]829        IFRESTORE(`COPY(name.str.val)', `
830#ifdef IS_UNICODE
831            PROC_ZSTRING_L(name_type, name.uni.val, name.uni.len)
832#else
833            PROC_STRING_L(name.str.val, name.str.len)
834#endif
835        ')
[1]836    ')
837    DONE(name)
838    dnl }}}
839
840    dnl {{{ data
841    DISABLECHECK(`
842        switch (src->type) {
843        case XC_TYPE_PHP:
844            STRUCT_P(xc_entry_data_php_t, data.php)
845            break;
846        case XC_TYPE_VAR:
847            STRUCT_P(xc_entry_data_var_t, data.var)
848            break;
849        default:
850            assert(0);
851        }
852    ')
853    DONE(data)
854    dnl }}}
[233]855    DISPATCH(zend_bool, have_references)
[1]856')
857dnl }}}
858dnl ====================================================
Note: See TracBrowser for help on using the repository browser.