source: trunk/processor/processor.m4 @ 78

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

catch up with PHP_5_2, zend_property_info.ce

File size: 16.1 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')
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            ')
[4]186            STRUCT_P_EX(zval, dst[0], src[0], `[0]', `', ` ')
[1]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)
[56]235#ifdef ZEND_ENGINE_2_1
[1]236    DISPATCH(int, doc_comment_len)
237    PROC_USTRING_L(, doc_comment, doc_comment_len)
[56]238#endif
[78]239    dnl isnt in php6 yet
240#if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE)
241    PROC_CLASS_ENTRY_P(ce)
242#endif
[1]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)
[4]292            DONE(`interfaces')
[1]293        }
294        else {
[4]295            COPYNULL(interfaces)
[1]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            */
[4]311            DONE(`interfaces')
[1]312        }
313        else {
[4]314            COPYNULL(interfaces)
[1]315        }
316    ')
[4]317    IFRESTORE(`', `
318        IFDASM(`', `
319            DONE(`interfaces')
320        ')
321    ')
[1]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 after SETNULL(constructor)
366    STRUCT(HashTable, function_table, HashTable_zend_function)
367    IFRESTORE(`dst->function_table.pDestructor = (dtor_func_t) destroy_zend_function;')
368')
369dnl }}}
370DEF_STRUCT_P_FUNC(`znode', , `dnl {{{
371    DISPATCH(int, op_type)
372
373#ifdef IS_CV
[11]374#   define XCACHE_IS_CV IS_CV
[1]375#else
[11]376/* compatible with zend optimizer */
377#   define XCACHE_IS_CV 16
[1]378#endif
[11]379    assert(src->op_type == IS_CONST ||
380        src->op_type == IS_VAR ||
381        src->op_type == XCACHE_IS_CV ||
[1]382        src->op_type == IS_TMP_VAR ||
383        src->op_type == IS_UNUSED);
[11]384#undef XCACHE_IS_CV
[1]385    dnl dirty dispatch
386    DISABLECHECK(`
387    switch (src->op_type) {
388        case IS_CONST:
389            STRUCT(zval, u.constant)
390            break;
391        IFCOPY(`
392            IFNOTMEMCPY(`
393                default:
394                    memcpy(&dst->u, &src->u, sizeof(src->u));
395            ')
396        ', `
397        case IS_VAR:
398        case IS_TMP_VAR:
399#ifdef IS_CV
400        case IS_CV:
401#else
402        case 16:
403#endif
404            DISPATCH(zend_uint, u.var)
405            DISPATCH(zend_uint, u.EA.type)
406            break;
407        case IS_UNUSED:
408            IFDASM(`DISPATCH(zend_uint, u.var)')
409            DISPATCH(zend_uint, u.opline_num)
410#ifndef ZEND_ENGINE_2
411            DISPATCH(zend_uint, u.fetch_type)
412#endif
413            DISPATCH(zend_uint, u.EA.type)
414            break;
415        ')
416    }
417    ')
418    DONE(u)
419')
420dnl }}}
421DEF_STRUCT_P_FUNC(`zend_op', , `dnl {{{
422    DISPATCH(zend_uchar, opcode)
423    STRUCT(znode, result)
424    STRUCT(znode, op1)
425    STRUCT(znode, op2)
426    DISPATCH(ulong, extended_value)
427    DISPATCH(uint, lineno)
428#ifdef ZEND_ENGINE_2_1
429    IFCOPY(`
430        switch (src->opcode) {
431            case ZEND_JMP:
432                dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src);
433                break;
434
435            case ZEND_JMPZ:
436            case ZEND_JMPNZ:
437            case ZEND_JMPZ_EX:
438            case ZEND_JMPNZ_EX:
439                dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src);
440                break;
441
442            default:
443                break;
444        }
445    ')
446    DISPATCH(opcode_handler_t, handler)
447#endif
448')
449dnl }}}
450DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{
451    IFRESTORE(`
452    if (!processor->readonly_protection) {
453        /* really fast shallow copy */
454        memcpy(dst, src, sizeof(src[0]));
455        dst->refcount[0] = 1000;
456        /* deep */
457        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
458        define(`SKIPASSERT_ONCE')
459
460    IFRESTORE(`
461#ifdef ZEND_ENGINE_2
462        if (dst->scope) {
463            dst->scope = xc_get_class(processor, (int) dst->scope);
464            xc_fix_method(processor, dst);
465        }
466#endif
467    ')
468
469    }
470    else
471    ')
472    do {
473    dnl RESTORE is done above!
[11]474    zend_uint ii;
[1]475    int i;
476
477    /* Common elements */
478    DISPATCH(zend_uchar, type)
479    PROC_USTRING(, function_name)
480#ifdef ZEND_ENGINE_2
481    IFRESTORE(`
482        if (dst->scope) {
483            dst->scope = xc_get_class(processor, (int) dst->scope);
484            xc_fix_method(processor, dst);
485        }
486        DONE(scope)
487    ', `
488        PROC_CLASS_ENTRY_P(scope)
489    ')
490    DISPATCH(zend_uint, fn_flags)
491    /* useless */
492    COPY(prototype)
[11]493    STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info)
[1]494    DISPATCH(zend_uint, num_args)
495    DISPATCH(zend_uint, required_num_args)
496    DISPATCH(zend_bool, pass_rest_by_reference)
497#else
498    if (src->arg_types) {
499        ALLOC(dst->arg_types, zend_uchar, src->arg_types[0] + 1)
500        IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));')
501        IFDASM(`do {
[11]502            zend_uint ii;
[1]503            int i;
504            zval *zv;
505            ALLOC_INIT_ZVAL(zv);
506            array_init(zv);
507            for (i = 0; i < src->arg_types[0]; i ++) {
508                add_next_index_long(zv, src->arg_types[i + 1]);
509            }
510            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
511        } while (0);')
512        DONE(arg_types)
513    }
514    else {
515        IFDASM(`do {
516            /* empty array */
517            zval *zv;
518            ALLOC_INIT_ZVAL(zv);
519            array_init(zv);
520            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
521        } while (0);
522        DONE(arg_types)
523        ', `
524        COPYNULL(arg_types)
525        ')
526    }
527#endif
528    DISPATCH(unsigned char, return_reference)
529    /* END of common elements */
530#ifdef IS_UNICODE
531    SETNULL(u_twin)
532#endif
533
534    STRUCT_P(zend_uint, refcount)
535    UNFIXPOINTER(zend_uint, refcount)
536
537    pushdef(`AFTER_ALLOC', `IFCOPY(`
538        processor->active_opcodes_dst = dst->opcodes;
539        processor->active_opcodes_src = src->opcodes;
540    ')')
[11]541    STRUCT_ARRAY_I(last, zend_op, opcodes)
[1]542    popdef(`AFTER_ALLOC')
543    DISPATCH(zend_uint, last)
544    IFCOPY(`dst->size = src->last;DONE(size)', `DISPATCH(zend_uint, size)')
545
546#ifdef IS_CV
547    STRUCT_ARRAY(last_var, zend_compiled_variable, vars)
548    DISPATCH(int, last_var)
549    IFCOPY(`dst->size_var = src->last_var;DONE(size_var)', `DISPATCH(zend_uint, size_var)')
550#else
551    dnl zend_cv.m4 is illegal to be made public, don not ask me for it
552    IFDASM(`
[4]553        sinclude(srcdir`/processor/zend_cv.m4')
[1]554        ')
555#endif
556
557    DISPATCH(zend_uint, T)
558
[11]559    STRUCT_ARRAY_I(last_brk_cont, zend_brk_cont_element, brk_cont_array)
[1]560    DISPATCH(zend_uint, last_brk_cont)
561    DISPATCH(zend_uint, current_brk_cont)
562#ifndef ZEND_ENGINE_2
563    DISPATCH(zend_bool, uses_globals)
564#endif
565
566#ifdef ZEND_ENGINE_2
567    STRUCT_ARRAY(last_try_catch, zend_try_catch_element, try_catch_array)
568    DISPATCH(int, last_try_catch)
569#endif
570
571    STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
572
573    IFCOPY(`dst->start_op = src->start_op;')
574    DONE(start_op)
575    DISPATCH(int, backpatch_count)
576
577    DISPATCH(zend_bool, done_pass_two)
578#ifdef ZEND_ENGINE_2
579    DISPATCH(zend_bool, uses_this)
580#endif
581
582    IFRESTORE(`COPY(filename)', `PROC_STRING(filename)')
583#ifdef IS_UNICODE
584    PROC_STRING(script_encoding)
585#endif
586#ifdef ZEND_ENGINE_2
587    DISPATCH(zend_uint, line_start)
588    DISPATCH(zend_uint, line_end)
589    DISPATCH(int, doc_comment_len)
590    PROC_USTRING_L(, doc_comment, doc_comment_len)
591#endif
592
593    /* reserved */
594    DONE(reserved)
595#if defined(HARDENING_PATCH) && HARDENING_PATCH
596    DISPATCH(zend_bool, created_by_eval)
597#endif
598    } while (0);
599')
600dnl }}}
601
602DEF_STRUCT_P_FUNC(`xc_funcinfo_t', , `dnl {{{
603    DISPATCH(zend_uint, key_size)
604#ifdef IS_UNICODE
605    DISPATCH(zend_uchar, type)
606#endif
607    IFRESTORE(`COPY(key)', `
608        PROC_USTRING_N(type, key, key_size)
609    ')
610    STRUCT(zend_function, func)
611')
612dnl }}}
613DEF_STRUCT_P_FUNC(`xc_classinfo_t', , `dnl {{{
614    DISPATCH(zend_uint, key_size)
615#ifdef IS_UNICODE
616    DISPATCH(zend_uchar, type)
617#endif
618    IFRESTORE(`COPY(key)', `
619        PROC_USTRING_N(type, key, key_size)
620    ')
621#ifdef ZEND_ENGINE_2
622    STRUCT_P(zend_class_entry, cest)
623#else
624    STRUCT(zend_class_entry, cest)
625#endif
626')
627dnl }}}
628DEF_STRUCT_P_FUNC(`xc_entry_data_php_t', , `dnl {{{
629    zend_uint i;
630
631#ifdef HAVE_INODE
632    DISPATCH(int, device)
633    DISPATCH(int, inode)
634#endif
635    DISPATCH(size_t, sourcesize)
636
637    DISPATCH(time_t, mtime)
638
639    STRUCT_P(zend_op_array, op_array)
640
641    DISPATCH(zend_uint, funcinfo_cnt)
642    STRUCT_ARRAY(funcinfo_cnt, xc_funcinfo_t, funcinfos)
643
644    DISPATCH(zend_uint, classinfo_cnt)
645    pushdef(`BEFORE_LOOP', `
646        IFCOPY(`
647            processor->active_class_num = i + 1;
648        ')
649    ')
650    STRUCT_ARRAY(classinfo_cnt, xc_classinfo_t, classinfos)
651    popdef(`BEFORE_LOOP')
652')
653dnl }}}
654DEF_STRUCT_P_FUNC(`xc_entry_data_var_t', , `dnl {{{
655    DISPATCH(time_t, etime)
656    IFSTORE(`
657        if (processor->reference) {
658            if (zend_hash_add(&processor->zvalptrs, (char *)&src->value, sizeof(&src->value), (void*)&src->value, sizeof(src->value), NULL) == SUCCESS) {
659                dnl fprintf(stderr, "mark[%p] = %p\n", &src->value, &dst->value);
660            }
661            else {
662                assert(0);
663            }
664        }
665    ')
[4]666    STRUCT_P_EX(zval_ptr, dst->value, src->value, `value', `', `&')
[1]667    DONE(value)
668')
669dnl }}}
670dnl {{{ xc_entry_t
671DEF_STRUCT_P_FUNC(`xc_entry_t', , `
672    IFCOPY(`
673        processor->xce_dst = dst;
674        processor->xce_src = src;
675    ')
676    DISPATCH(xc_entry_type_t, type)
677    DISPATCH(size_t, size)
678
679    DISPATCH(xc_hash_value_t, hvalue)
680    COPY(cache)
681    /* skip */
682    DONE(next)
683
684    IFSTORE(`dst->refcount = 0; DONE(refcount)', `DISPATCH(long, refcount)')
685
686    DISPATCH(time_t, ctime)
687    DISPATCH(time_t, atime)
688    DISPATCH(time_t, dtime)
689    DISPATCH(zend_ulong, hits)
690#ifdef IS_UNICODE
691    DISPATCH(zend_uchar, name_type)
692#endif
693    dnl {{{ name
694    DISABLECHECK(`
695#ifdef IS_UNICODE
696        if (src->name_type == IS_UNICODE) {
697            DISPATCH(int32_t, name.ustr.len)
698        }
699        else {
700            DISPATCH(int, name.str.len)
701        }
702#else
703        DISPATCH(int, name.str.len)
704#endif
705        IFRESTORE(`COPY(name.str.val)', `PROC_USTRING_L(name_type, name.str.val, name.str.len)')
706    ')
707    DONE(name)
708    dnl }}}
709
710    dnl {{{ data
711    DISABLECHECK(`
712        switch (src->type) {
713        case XC_TYPE_PHP:
714            STRUCT_P(xc_entry_data_php_t, data.php)
715            break;
716        case XC_TYPE_VAR:
717            STRUCT_P(xc_entry_data_var_t, data.var)
718            break;
719        default:
720            assert(0);
721        }
722    ')
723    DONE(data)
724    dnl }}}
725')
726dnl }}}
727dnl ====================================================
Note: See TracBrowser for help on using the repository browser.