source: trunk/processor/processor.m4 @ 11

Last change on this file since 11 was 11, checked in by moo, 9 years ago

make it build on windows vc compiler

File size: 15.9 KB
Line 
1dnl ================
2/* {{{ Pre-declare */
3DECL_STRUCT_P_FUNC(`zval')
4DECL_STRUCT_P_FUNC(`zval_ptr')
5DECL_STRUCT_P_FUNC(`zend_op_array')
6DECL_STRUCT_P_FUNC(`zend_class_entry')
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    DISPATCH(int, doc_comment_len)
236    PROC_USTRING_L(, doc_comment, doc_comment_len)
237')
238#endif
239dnl }}}
240DEF_STRUCT_P_FUNC(`zend_class_entry', , `dnl {{{
241    IFCOPY(`
242        processor->active_class_entry_src = src;
243        processor->active_class_entry_dst = dst;
244    ')
245    DISPATCH(char, type)
246    DISPATCH(zend_uint, name_length)
247    PROC_USTRING_L(, name, name_length)
248    IFRESTORE(`
249#ifndef ZEND_ENGINE_2
250        /* just copy parent and resolve on install_class */
251        COPY(parent)
252#else
253        PROC_CLASS_ENTRY_P(parent)
254#endif
255    ', `
256        PROC_CLASS_ENTRY_P(parent)
257    ')
258#ifdef ZEND_ENGINE_2
259    DISPATCH(int, refcount)
260#else
261    STRUCT_P(int, refcount)
262#endif
263    DISPATCH(zend_bool, constants_updated)
264#ifdef ZEND_ENGINE_2
265    DISPATCH(zend_uint, ce_flags)
266#endif
267
268    STRUCT(HashTable, default_properties, HashTable_zval_ptr)
269    IFCOPY(`dst->builtin_functions = src->builtin_functions;')
270    DONE(builtin_functions)
271#ifdef ZEND_ENGINE_2
272    STRUCT(HashTable, properties_info, HashTable_zend_property_info)
273#   ifdef ZEND_ENGINE_2_1
274    STRUCT(HashTable, default_static_members, HashTable_zval_ptr)
275    IFCOPY(`dst->static_members = &dst->default_static_members;')
276    DONE(static_members)
277#   else
278    STRUCT_P(HashTable, static_members, HashTable_zval_ptr)
279#   endif
280    STRUCT(HashTable, constants_table, HashTable_zval_ptr)
281
282    dnl runtime binding: ADD_INTERFACE will deal with it
283    IFRESTORE(`
284        if (src->num_interfaces) {
285            CALLOC(dst->interfaces, zend_class_entry*, src->num_interfaces)
286            DONE(`interfaces')
287        }
288        else {
289            COPYNULL(interfaces)
290        }
291    ')
292    IFDASM(`
293        if (src->num_interfaces) {
294            /*
295            zval *arr;
296            ALLOC_INIT_ZVAL(arr);
297            array_init(arr);
298            for (i = 0; i < src->num_interfaces; i ++) {
299                zval *zv;
300                ALLOC_INIT_ZVAL(zv);
301                ZVAL_STRING(src->num_interfaces);
302            }
303            add_assoc_zval_ex(dst, ZEND_STRS("interfaces"), arr);
304            */
305            DONE(`interfaces')
306        }
307        else {
308            COPYNULL(interfaces)
309        }
310    ')
311    IFRESTORE(`', `
312        IFDASM(`', `
313            DONE(`interfaces')
314        ')
315    ')
316    DISPATCH(zend_uint, num_interfaces)
317
318    IFRESTORE(`COPY(filename)', `PROC_STRING(filename)')
319    DISPATCH(zend_uint, line_start)
320    DISPATCH(zend_uint, line_end)
321#ifdef ZEND_ENGINE_2_1
322    DISPATCH(zend_uint, doc_comment_len)
323    PROC_USTRING_L(, doc_comment, doc_comment_len)
324#endif
325    /* # NOT DONE */
326    COPY(serialize_func)
327    COPY(unserialize_func)
328    COPY(iterator_funcs)
329    COPY(create_object)
330    COPY(get_iterator)
331    COPY(interface_gets_implemented)
332    COPY(serialize)
333    COPY(unserialize)
334    /* deal with it inside xc_fix_method */
335    SETNULL(constructor)
336    COPY(destructor)
337    COPY(clone)
338    COPY(__get)
339    COPY(__set)
340/* should be >5.1 */
341#ifdef ZEND_ENGINE_2_1
342    COPY(__unset)
343    COPY(__isset)
344# if PHP_MAJOR_VERSION >= 6
345    COPY(__tostring)
346# endif
347#endif
348    COPY(__call)
349#ifdef IS_UNICODE
350    SETNULL(u_twin)
351#endif
352    /* # NOT DONE */
353    COPY(module)
354#else
355    COPY(handle_function_call)
356    COPY(handle_property_get)
357    COPY(handle_property_set)
358#endif
359    dnl must after SETNULL(constructor)
360    STRUCT(HashTable, function_table, HashTable_zend_function)
361    IFRESTORE(`dst->function_table.pDestructor = (dtor_func_t) destroy_zend_function;')
362')
363dnl }}}
364DEF_STRUCT_P_FUNC(`znode', , `dnl {{{
365    DISPATCH(int, op_type)
366
367#ifdef IS_CV
368#   define XCACHE_IS_CV IS_CV
369#else
370/* compatible with zend optimizer */
371#   define XCACHE_IS_CV 16
372#endif
373    assert(src->op_type == IS_CONST ||
374        src->op_type == IS_VAR ||
375        src->op_type == XCACHE_IS_CV ||
376        src->op_type == IS_TMP_VAR ||
377        src->op_type == IS_UNUSED);
378#undef XCACHE_IS_CV
379    dnl dirty dispatch
380    DISABLECHECK(`
381    switch (src->op_type) {
382        case IS_CONST:
383            STRUCT(zval, u.constant)
384            break;
385        IFCOPY(`
386            IFNOTMEMCPY(`
387                default:
388                    memcpy(&dst->u, &src->u, sizeof(src->u));
389            ')
390        ', `
391        case IS_VAR:
392        case IS_TMP_VAR:
393#ifdef IS_CV
394        case IS_CV:
395#else
396        case 16:
397#endif
398            DISPATCH(zend_uint, u.var)
399            DISPATCH(zend_uint, u.EA.type)
400            break;
401        case IS_UNUSED:
402            IFDASM(`DISPATCH(zend_uint, u.var)')
403            DISPATCH(zend_uint, u.opline_num)
404#ifndef ZEND_ENGINE_2
405            DISPATCH(zend_uint, u.fetch_type)
406#endif
407            DISPATCH(zend_uint, u.EA.type)
408            break;
409        ')
410    }
411    ')
412    DONE(u)
413')
414dnl }}}
415DEF_STRUCT_P_FUNC(`zend_op', , `dnl {{{
416    DISPATCH(zend_uchar, opcode)
417    STRUCT(znode, result)
418    STRUCT(znode, op1)
419    STRUCT(znode, op2)
420    DISPATCH(ulong, extended_value)
421    DISPATCH(uint, lineno)
422#ifdef ZEND_ENGINE_2_1
423    IFCOPY(`
424        switch (src->opcode) {
425            case ZEND_JMP:
426                dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src);
427                break;
428
429            case ZEND_JMPZ:
430            case ZEND_JMPNZ:
431            case ZEND_JMPZ_EX:
432            case ZEND_JMPNZ_EX:
433                dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src);
434                break;
435
436            default:
437                break;
438        }
439    ')
440    DISPATCH(opcode_handler_t, handler)
441#endif
442')
443dnl }}}
444DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{
445    IFRESTORE(`
446    if (!processor->readonly_protection) {
447        /* really fast shallow copy */
448        memcpy(dst, src, sizeof(src[0]));
449        dst->refcount[0] = 1000;
450        /* deep */
451        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
452        define(`SKIPASSERT_ONCE')
453
454    IFRESTORE(`
455#ifdef ZEND_ENGINE_2
456        if (dst->scope) {
457            dst->scope = xc_get_class(processor, (int) dst->scope);
458            xc_fix_method(processor, dst);
459        }
460#endif
461    ')
462
463    }
464    else
465    ')
466    do {
467    dnl RESTORE is done above!
468    zend_uint ii;
469    int i;
470
471    /* Common elements */
472    DISPATCH(zend_uchar, type)
473    PROC_USTRING(, function_name)
474#ifdef ZEND_ENGINE_2
475    IFRESTORE(`
476        if (dst->scope) {
477            dst->scope = xc_get_class(processor, (int) dst->scope);
478            xc_fix_method(processor, dst);
479        }
480        DONE(scope)
481    ', `
482        PROC_CLASS_ENTRY_P(scope)
483    ')
484    DISPATCH(zend_uint, fn_flags)
485    /* useless */
486    COPY(prototype)
487    STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info)
488    DISPATCH(zend_uint, num_args)
489    DISPATCH(zend_uint, required_num_args)
490    DISPATCH(zend_bool, pass_rest_by_reference)
491#else
492    if (src->arg_types) {
493        ALLOC(dst->arg_types, zend_uchar, src->arg_types[0] + 1)
494        IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));')
495        IFDASM(`do {
496            zend_uint ii;
497            int i;
498            zval *zv;
499            ALLOC_INIT_ZVAL(zv);
500            array_init(zv);
501            for (i = 0; i < src->arg_types[0]; i ++) {
502                add_next_index_long(zv, src->arg_types[i + 1]);
503            }
504            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
505        } while (0);')
506        DONE(arg_types)
507    }
508    else {
509        IFDASM(`do {
510            /* empty array */
511            zval *zv;
512            ALLOC_INIT_ZVAL(zv);
513            array_init(zv);
514            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
515        } while (0);
516        DONE(arg_types)
517        ', `
518        COPYNULL(arg_types)
519        ')
520    }
521#endif
522    DISPATCH(unsigned char, return_reference)
523    /* END of common elements */
524#ifdef IS_UNICODE
525    SETNULL(u_twin)
526#endif
527
528    STRUCT_P(zend_uint, refcount)
529    UNFIXPOINTER(zend_uint, refcount)
530
531    pushdef(`AFTER_ALLOC', `IFCOPY(`
532        processor->active_opcodes_dst = dst->opcodes;
533        processor->active_opcodes_src = src->opcodes;
534    ')')
535    STRUCT_ARRAY_I(last, zend_op, opcodes)
536    popdef(`AFTER_ALLOC')
537    DISPATCH(zend_uint, last)
538    IFCOPY(`dst->size = src->last;DONE(size)', `DISPATCH(zend_uint, size)')
539
540#ifdef IS_CV
541    STRUCT_ARRAY(last_var, zend_compiled_variable, vars)
542    DISPATCH(int, last_var)
543    IFCOPY(`dst->size_var = src->last_var;DONE(size_var)', `DISPATCH(zend_uint, size_var)')
544#else
545    dnl zend_cv.m4 is illegal to be made public, don not ask me for it
546    IFDASM(`
547        sinclude(srcdir`/processor/zend_cv.m4')
548        ')
549#endif
550
551    DISPATCH(zend_uint, T)
552
553    STRUCT_ARRAY_I(last_brk_cont, zend_brk_cont_element, brk_cont_array)
554    DISPATCH(zend_uint, last_brk_cont)
555    DISPATCH(zend_uint, current_brk_cont)
556#ifndef ZEND_ENGINE_2
557    DISPATCH(zend_bool, uses_globals)
558#endif
559
560#ifdef ZEND_ENGINE_2
561    STRUCT_ARRAY(last_try_catch, zend_try_catch_element, try_catch_array)
562    DISPATCH(int, last_try_catch)
563#endif
564
565    STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
566
567    IFCOPY(`dst->start_op = src->start_op;')
568    DONE(start_op)
569    DISPATCH(int, backpatch_count)
570
571    DISPATCH(zend_bool, done_pass_two)
572#ifdef ZEND_ENGINE_2
573    DISPATCH(zend_bool, uses_this)
574#endif
575
576    IFRESTORE(`COPY(filename)', `PROC_STRING(filename)')
577#ifdef IS_UNICODE
578    PROC_STRING(script_encoding)
579#endif
580#ifdef ZEND_ENGINE_2
581    DISPATCH(zend_uint, line_start)
582    DISPATCH(zend_uint, line_end)
583    DISPATCH(int, doc_comment_len)
584    PROC_USTRING_L(, doc_comment, doc_comment_len)
585#endif
586
587    /* reserved */
588    DONE(reserved)
589#if defined(HARDENING_PATCH) && HARDENING_PATCH
590    DISPATCH(zend_bool, created_by_eval)
591#endif
592    } while (0);
593')
594dnl }}}
595
596DEF_STRUCT_P_FUNC(`xc_funcinfo_t', , `dnl {{{
597    DISPATCH(zend_uint, key_size)
598#ifdef IS_UNICODE
599    DISPATCH(zend_uchar, type)
600#endif
601    IFRESTORE(`COPY(key)', `
602        PROC_USTRING_N(type, key, key_size)
603    ')
604    STRUCT(zend_function, func)
605')
606dnl }}}
607DEF_STRUCT_P_FUNC(`xc_classinfo_t', , `dnl {{{
608    DISPATCH(zend_uint, key_size)
609#ifdef IS_UNICODE
610    DISPATCH(zend_uchar, type)
611#endif
612    IFRESTORE(`COPY(key)', `
613        PROC_USTRING_N(type, key, key_size)
614    ')
615#ifdef ZEND_ENGINE_2
616    STRUCT_P(zend_class_entry, cest)
617#else
618    STRUCT(zend_class_entry, cest)
619#endif
620')
621dnl }}}
622DEF_STRUCT_P_FUNC(`xc_entry_data_php_t', , `dnl {{{
623    zend_uint i;
624
625#ifdef HAVE_INODE
626    DISPATCH(int, device)
627    DISPATCH(int, inode)
628#endif
629    DISPATCH(size_t, sourcesize)
630
631    DISPATCH(time_t, mtime)
632
633    STRUCT_P(zend_op_array, op_array)
634
635    DISPATCH(zend_uint, funcinfo_cnt)
636    STRUCT_ARRAY(funcinfo_cnt, xc_funcinfo_t, funcinfos)
637
638    DISPATCH(zend_uint, classinfo_cnt)
639    pushdef(`BEFORE_LOOP', `
640        IFCOPY(`
641            processor->active_class_num = i + 1;
642        ')
643    ')
644    STRUCT_ARRAY(classinfo_cnt, xc_classinfo_t, classinfos)
645    popdef(`BEFORE_LOOP')
646')
647dnl }}}
648DEF_STRUCT_P_FUNC(`xc_entry_data_var_t', , `dnl {{{
649    DISPATCH(time_t, etime)
650    IFSTORE(`
651        if (processor->reference) {
652            if (zend_hash_add(&processor->zvalptrs, (char *)&src->value, sizeof(&src->value), (void*)&src->value, sizeof(src->value), NULL) == SUCCESS) {
653                dnl fprintf(stderr, "mark[%p] = %p\n", &src->value, &dst->value);
654            }
655            else {
656                assert(0);
657            }
658        }
659    ')
660    STRUCT_P_EX(zval_ptr, dst->value, src->value, `value', `', `&')
661    DONE(value)
662')
663dnl }}}
664dnl {{{ xc_entry_t
665DEF_STRUCT_P_FUNC(`xc_entry_t', , `
666    IFCOPY(`
667        processor->xce_dst = dst;
668        processor->xce_src = src;
669    ')
670    DISPATCH(xc_entry_type_t, type)
671    DISPATCH(size_t, size)
672
673    DISPATCH(xc_hash_value_t, hvalue)
674    COPY(cache)
675    /* skip */
676    DONE(next)
677
678    IFSTORE(`dst->refcount = 0; DONE(refcount)', `DISPATCH(long, refcount)')
679
680    DISPATCH(time_t, ctime)
681    DISPATCH(time_t, atime)
682    DISPATCH(time_t, dtime)
683    DISPATCH(zend_ulong, hits)
684#ifdef IS_UNICODE
685    DISPATCH(zend_uchar, name_type)
686#endif
687    dnl {{{ name
688    DISABLECHECK(`
689#ifdef IS_UNICODE
690        if (src->name_type == IS_UNICODE) {
691            DISPATCH(int32_t, name.ustr.len)
692        }
693        else {
694            DISPATCH(int, name.str.len)
695        }
696#else
697        DISPATCH(int, name.str.len)
698#endif
699        IFRESTORE(`COPY(name.str.val)', `PROC_USTRING_L(name_type, name.str.val, name.str.len)')
700    ')
701    DONE(name)
702    dnl }}}
703
704    dnl {{{ data
705    DISABLECHECK(`
706        switch (src->type) {
707        case XC_TYPE_PHP:
708            STRUCT_P(xc_entry_data_php_t, data.php)
709            break;
710        case XC_TYPE_VAR:
711            STRUCT_P(xc_entry_data_var_t, data.var)
712            break;
713        default:
714            assert(0);
715        }
716    ')
717    DONE(data)
718    dnl }}}
719')
720dnl }}}
721dnl ====================================================
Note: See TracBrowser for help on using the repository browser.