source: trunk/processor/processor.m4 @ 91

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

kill compiler warnings

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