source: trunk/processor/processor.m4 @ 4

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

compatibility fix: remove the using of gnu m4 extension

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