/* * Copyright (c) 2003, The Tendra Project * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice unmodified, this list of conditions, and the following * disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * * Crown Copyright (c) 1997, 1998 * * This TenDRA(r) Computer Program is subject to Copyright * owned by the United Kingdom Secretary of State for Defence * acting through the Defence Evaluation and Research Agency * (DERA). It is made available to Recipients with a * royalty-free licence for its use, reproduction, transfer * to other parties and amendment for any purpose not excluding * product development provided that any such use et cetera * shall be deemed to be acceptance of the following conditions:- * * (1) Its Recipients shall ensure that this Notice is * reproduced upon any copies or amended versions of it; * * (2) Any amended version of it shall be clearly marked to * show both the nature of and the organisation responsible * for the relevant amendment or amendments; * * (3) Its onward transfer from a recipient to another * party shall be deemed to be that party's acceptance of * these conditions; * * (4) DERA gives no warranty or assurance as to its * quality or suitability for any purpose and DERA accepts * no liability whatsoever in relation to any use to which * it may be put. * * $TenDRA: tendra/src/producers/common/c_class.alg,v 1.18 2005/11/07 18:42:37 stefanf Exp $ */ /* * AUTOMATICALLY GENERATED FROM ALGEBRA c_class (VERSION 1.1) * BY calculus (VERSION 1.3) */ #ifndef C_CLASS_H_INCLUDED #define C_CLASS_H_INCLUDED #ifndef c_class_NAME #define c_class_NAME "c_class" #define c_class_VERSION "1.1" #define c_class_SPECIFICATION 0 #define c_class_IMPLEMENTATION 1 #endif /* Primitive types */ typedef character * string; typedef unsigned long ulong_type; typedef struct tdf_stream * BITSTREAM_P; typedef struct pptok_tag * PPTOKEN_P; /* Basic types */ typedef union c_class_tag { unsigned ag_tag; union c_class_tag *ag_ptr; unsigned ag_enum; unsigned long ag_long_enum; int ag_prim_int; unsigned ag_prim_unsigned; string ag_prim_string; ulong_type ag_prim_ulong; BITSTREAM_P ag_prim_bits; PPTOKEN_P ag_prim_pptok; } c_class; typedef c_class *c_class_PTR; #ifndef c_class_DESTR_DEFINED #define c_class_DESTR_DEFINED typedef void (*DESTROYER) (c_class *, unsigned); #endif #define PTR(A) c_class_PTR #define LIST(A) c_class_PTR #define STACK(A) c_class_PTR #define SIZE(A) int /* Assertion macros */ #ifdef ASSERTS extern c_class *check_null_c_class (c_class *, const char *, int); extern c_class *check_tag_c_class (c_class *, unsigned, const char *, int); extern c_class *check_tag_etc_c_class (c_class *, unsigned, unsigned, const char *, int); #define CHECK_NULL(P)\ (check_null_c_class ((P), __FILE__, __LINE__)) #define CHECK_TAG(P, N)\ (check_tag_c_class ((P), (unsigned)(N), __FILE__, __LINE__)) #define CHECK_TAG_ETC(P, L, U)\ (check_tag_etc_c_class ((P), (unsigned)(L), (unsigned)(U), __FILE__, __LINE__)) #else #define CHECK_NULL(P) (P) #define CHECK_TAG(P, N) (P) #define CHECK_TAG_ETC(P, L, U) (P) #endif /* Enumeration definitions */ typedef unsigned CV_SPEC; typedef unsigned BUILTIN_TYPE; typedef unsigned long BASE_TYPE; typedef unsigned long CLASS_INFO; typedef unsigned CLASS_USAGE; typedef unsigned long DECL_SPEC; typedef unsigned QUALIFIER; typedef unsigned NTEST; typedef unsigned RMODE; /* Union type definitions */ typedef c_class *INT_TYPE; typedef c_class *FLOAT_TYPE; typedef c_class *CLASS_TYPE; typedef c_class *GRAPH; typedef c_class *VIRTUAL; typedef c_class *ENUM_TYPE; typedef c_class *TYPE; typedef c_class *HASHID; typedef c_class *IDENTIFIER; typedef c_class *MEMBER; typedef c_class *NAMESPACE; typedef c_class *NAT; typedef c_class *FLOAT; typedef c_class *STRING; typedef c_class *EXP; typedef c_class *OFFSET; typedef c_class *TOKEN; typedef c_class *INSTANCE; typedef c_class *ERROR; /* Structure declarations */ typedef struct var_tag VARIABLE; typedef struct loc_tag LOCATION; typedef struct posn_tag POSITION; /* Identity type definitions */ /* Structure definitions */ #ifndef c_class_STRUCT_DEFINED #define c_class_STRUCT_DEFINED struct var_tag { IDENTIFIER id; DECL_SPEC info; }; struct loc_tag { ulong_type line; ulong_type column; PTR (POSITION) posn; }; struct posn_tag { string file; int quote_file; string input; string base; string dir; ulong_type offset; PTR (LOCATION) from; ulong_type datestamp; ulong_type tok; }; #endif /* c_class_STRUCT_DEFINED */ /* Function declarations */ extern c_class *gen_c_class (unsigned); extern void destroy_c_class (c_class *, unsigned); extern void dummy_destroy_c_class (c_class *, unsigned); extern void destroy_c_class_list (c_class *, unsigned); extern c_class *append_c_class_list (c_class *,c_class *); extern c_class *end_c_class_list (c_class *); extern unsigned length_c_class_list (c_class *); extern c_class *reverse_c_class_list (c_class *); #ifdef c_class_IO_ROUTINES extern unsigned crt_c_class_alias; extern void set_c_class_alias (c_class *, unsigned); extern c_class *find_c_class_alias (unsigned); extern void clear_c_class_alias (void); #endif /* Run-time type information */ #ifndef GEN_c_class #define GEN_c_class(A, B) gen_c_class ((unsigned)(A)) #endif #define TYPEID_ptr 0u #define TYPEID_list 1u #define TYPEID_stack 2u #define TYPEID_itype 3u #define TYPEID_ftype 4u #define TYPEID_ctype 5u #define TYPEID_graph 6u #define TYPEID_virt 7u #define TYPEID_etype 8u #define TYPEID_type 9u #define TYPEID_hashid 10u #define TYPEID_id 11u #define TYPEID_member 12u #define TYPEID_nspace 13u #define TYPEID_nat 14u #define TYPEID_flt 15u #define TYPEID_str 16u #define TYPEID_exp 17u #define TYPEID_off 18u #define TYPEID_tok 19u #define TYPEID_inst 20u #define TYPEID_err 21u /* Definitions for pointers */ #define STEP_ptr(A, B) (CHECK_NULL (A) + B) #define SIZE_ptr(A) 1 #define NULL_ptr(A) ((c_class *)0) #define IS_NULL_ptr(A) ((A) == 0) #define EQ_ptr(A, B) ((A) == (B)) #define MAKE_ptr(A) GEN_c_class ((A), TYPEID_ptr) #define DESTROY_ptr(A, B) destroy_c_class ((A), (unsigned)(B)) #define UNIQ_ptr(A) GEN_c_class ( 1, TYPEID_ptr ) #define DESTROY_UNIQ_ptr(A) destroy_c_class ((A), 1u) #ifdef c_class_IO_ROUTINES #define VOIDSTAR_ptr(A) ((void *)(A)) #endif #define COPY_ptr(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_ptr(A) (CHECK_NULL (A)->ag_ptr) #define CONS_ptr(A, B, C)\ {\ c_class *x0_ = GEN_c_class ( 2, TYPEID_list );\ x0_[1].ag_ptr = (A);\ x0_->ag_ptr = (B);\ (C) = x0_;\ } #define UN_CONS_ptr(A, B, C)\ {\ c_class *x1_ = CHECK_NULL (C);\ (A) = x1_[1].ag_ptr;\ (B) = x1_->ag_ptr;\ } #define DESTROY_CONS_ptr(D, A, B, C)\ {\ c_class *x2_ = CHECK_NULL (C);\ (A) = x2_[1].ag_ptr;\ (B) = x2_->ag_ptr;\ (D) (x2_, 2u);\ } #define PUSH_ptr(A, B)\ {\ c_class **r3_ = &(B);\ c_class *x3_ = GEN_c_class ( 2, TYPEID_stack );\ x3_[1].ag_ptr = (A);\ x3_->ag_ptr = *r3_;\ *r3_ = x3_;\ } #define POP_ptr(A, B)\ {\ c_class **r4_ = &(B);\ c_class *x4_ = CHECK_NULL (*r4_);\ (A) = x4_[1].ag_ptr;\ *r4_ = x4_->ag_ptr;\ destroy_c_class (x4_, 2u);\ } /* Definitions for lists */ #define HEAD_list(A) (CHECK_NULL (A) + 1) #define PTR_TAIL_list(A) (CHECK_NULL (A)) #define TAIL_list(A) (CHECK_NULL (A)->ag_ptr) #define LENGTH_list(A) length_c_class_list ((A)) #define END_list(A) end_c_class_list ((A)) #define REVERSE_list(A) reverse_c_class_list ((A)) #define APPEND_list(A, B) append_c_class_list ((A), (B)) #define SIZE_list(A) 1 #define NULL_list(A) ((c_class *) 0) #define IS_NULL_list(A) ((A) == 0) #define EQ_list(A, B) ((A) == (B)) #define UNIQ_list(A) GEN_c_class ( 1, TYPEID_list ) #define DESTROY_UNIQ_list(A) destroy_c_class ((A), 1u) #ifdef c_class_IO_ROUTINES #define VOIDSTAR_list(A) ((void *) (A)) #endif #define DESTROY_list(A, B)\ {\ destroy_c_class_list ((A), (unsigned) (B));\ } #define COPY_list(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_list(A) (CHECK_NULL (A)->ag_ptr) #define CONS_list(A, B, C)\ {\ c_class *x5_ = GEN_c_class ( 2, TYPEID_list );\ x5_[1].ag_ptr = (A);\ x5_->ag_ptr = (B);\ (C) = x5_;\ } #define UN_CONS_list(A, B, C)\ {\ c_class *x6_ = CHECK_NULL (C);\ (A) = x6_[1].ag_ptr;\ (B) = x6_->ag_ptr;\ } #define DESTROY_CONS_list(D, A, B, C)\ {\ c_class *x7_ = CHECK_NULL (C);\ (A) = x7_[1].ag_ptr;\ (B) = x7_->ag_ptr;\ (D) (x7_, 2u);\ } #define PUSH_list(A, B)\ {\ c_class **r8_ = &(B);\ c_class *x8_ = GEN_c_class ( 2, TYPEID_stack );\ x8_[1].ag_ptr = (A);\ x8_->ag_ptr = *r8_;\ *r8_ = x8_;\ } #define POP_list(A, B)\ {\ c_class **r9_ = &(B);\ c_class *x9_ = CHECK_NULL (*r9_);\ (A) = x9_[1].ag_ptr;\ *r9_ = x9_->ag_ptr;\ destroy_c_class (x9_, 2u);\ } /* Definitions for stacks */ #define SIZE_stack(A) 1 #define NULL_stack(A) ((c_class *) 0) #define IS_NULL_stack(A) ((A) == 0) #define STACK_list(A) (A) #define LIST_stack(A) (A) #define COPY_stack(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_stack(A) (CHECK_NULL (A)->ag_ptr) #define CONS_stack(A, B, C)\ {\ c_class *x10_ = GEN_c_class ( 2, TYPEID_list );\ x10_[1].ag_ptr = (A);\ x10_->ag_ptr = (B);\ (C) = x10_;\ } #define UN_CONS_stack(A, B, C)\ {\ c_class *x11_ = CHECK_NULL (C);\ (A) = x11_[1].ag_ptr;\ (B) = x11_->ag_ptr;\ } #define DESTROY_CONS_stack(D, A, B, C)\ {\ c_class *x12_ = CHECK_NULL (C);\ (A) = x12_[1].ag_ptr;\ (B) = x12_->ag_ptr;\ (D) (x12_, 2u);\ } #define PUSH_stack(A, B)\ {\ c_class **r13_ = &(B);\ c_class *x13_ = GEN_c_class ( 2, TYPEID_stack );\ x13_[1].ag_ptr = (A);\ x13_->ag_ptr = *r13_;\ *r13_ = x13_;\ } #define POP_stack(A, B)\ {\ c_class **r14_ = &(B);\ c_class *x14_ = CHECK_NULL (*r14_);\ (A) = x14_[1].ag_ptr;\ *r14_ = x14_->ag_ptr;\ destroy_c_class (x14_, 2u);\ } /* Definitions for sizes */ #define SCALE(A, B) ((A) * (int) (B)) /* Definitions for primitive int */ #define SIZE_int 1 #define COPY_int(A, B) (CHECK_NULL (A)->ag_prim_int = (B)) #define DEREF_int(A) (CHECK_NULL (A)->ag_prim_int) #define CONS_int(A, B, C)\ {\ c_class *x15_ = GEN_c_class ( 2, TYPEID_list );\ COPY_int (x15_ + 1, (A));\ x15_->ag_ptr = (B);\ (C) = x15_;\ } #define UN_CONS_int(A, B, C)\ {\ c_class *x16_ = CHECK_NULL (C);\ (A) = DEREF_int (x16_ + 1);\ (B) = x16_->ag_ptr;\ } #define DESTROY_CONS_int(D, A, B, C)\ {\ c_class *x17_ = CHECK_NULL (C);\ (A) = DEREF_int (x17_ + 1);\ (B) = x17_->ag_ptr;\ (D) (x17_, 2u);\ } #define PUSH_int(A, B)\ {\ c_class **r18_ = &(B);\ c_class *x18_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_int (x18_ + 1, (A));\ x18_->ag_ptr = *r18_;\ *r18_ = x18_;\ } #define POP_int(A, B)\ {\ c_class **r19_ = &(B);\ c_class *x19_ = CHECK_NULL (*r19_);\ (A) = DEREF_int (x19_ + 1);\ *r19_ = x19_->ag_ptr;\ destroy_c_class (x19_, 2u);\ } /* Definitions for primitive unsigned */ #define SIZE_unsigned 1 #define COPY_unsigned(A, B) (CHECK_NULL (A)->ag_prim_unsigned = (B)) #define DEREF_unsigned(A) (CHECK_NULL (A)->ag_prim_unsigned) #define CONS_unsigned(A, B, C)\ {\ c_class *x20_ = GEN_c_class ( 2, TYPEID_list );\ COPY_unsigned (x20_ + 1, (A));\ x20_->ag_ptr = (B);\ (C) = x20_;\ } #define UN_CONS_unsigned(A, B, C)\ {\ c_class *x21_ = CHECK_NULL (C);\ (A) = DEREF_unsigned (x21_ + 1);\ (B) = x21_->ag_ptr;\ } #define DESTROY_CONS_unsigned(D, A, B, C)\ {\ c_class *x22_ = CHECK_NULL (C);\ (A) = DEREF_unsigned (x22_ + 1);\ (B) = x22_->ag_ptr;\ (D) (x22_, 2u);\ } #define PUSH_unsigned(A, B)\ {\ c_class **r23_ = &(B);\ c_class *x23_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_unsigned (x23_ + 1, (A));\ x23_->ag_ptr = *r23_;\ *r23_ = x23_;\ } #define POP_unsigned(A, B)\ {\ c_class **r24_ = &(B);\ c_class *x24_ = CHECK_NULL (*r24_);\ (A) = DEREF_unsigned (x24_ + 1);\ *r24_ = x24_->ag_ptr;\ destroy_c_class (x24_, 2u);\ } /* Definitions for primitive string */ #define SIZE_string 1 #define COPY_string(A, B) (CHECK_NULL (A)->ag_prim_string = (B)) #define DEREF_string(A) (CHECK_NULL (A)->ag_prim_string) #define CONS_string(A, B, C)\ {\ c_class *x25_ = GEN_c_class ( 2, TYPEID_list );\ COPY_string (x25_ + 1, (A));\ x25_->ag_ptr = (B);\ (C) = x25_;\ } #define UN_CONS_string(A, B, C)\ {\ c_class *x26_ = CHECK_NULL (C);\ (A) = DEREF_string (x26_ + 1);\ (B) = x26_->ag_ptr;\ } #define DESTROY_CONS_string(D, A, B, C)\ {\ c_class *x27_ = CHECK_NULL (C);\ (A) = DEREF_string (x27_ + 1);\ (B) = x27_->ag_ptr;\ (D) (x27_, 2u);\ } #define PUSH_string(A, B)\ {\ c_class **r28_ = &(B);\ c_class *x28_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_string (x28_ + 1, (A));\ x28_->ag_ptr = *r28_;\ *r28_ = x28_;\ } #define POP_string(A, B)\ {\ c_class **r29_ = &(B);\ c_class *x29_ = CHECK_NULL (*r29_);\ (A) = DEREF_string (x29_ + 1);\ *r29_ = x29_->ag_ptr;\ destroy_c_class (x29_, 2u);\ } /* Definitions for primitive ulong_type */ #define SIZE_ulong 1 #define COPY_ulong(A, B) (CHECK_NULL (A)->ag_prim_ulong = (B)) #define DEREF_ulong(A) (CHECK_NULL (A)->ag_prim_ulong) #define CONS_ulong(A, B, C)\ {\ c_class *x30_ = GEN_c_class ( 2, TYPEID_list );\ COPY_ulong (x30_ + 1, (A));\ x30_->ag_ptr = (B);\ (C) = x30_;\ } #define UN_CONS_ulong(A, B, C)\ {\ c_class *x31_ = CHECK_NULL (C);\ (A) = DEREF_ulong (x31_ + 1);\ (B) = x31_->ag_ptr;\ } #define DESTROY_CONS_ulong(D, A, B, C)\ {\ c_class *x32_ = CHECK_NULL (C);\ (A) = DEREF_ulong (x32_ + 1);\ (B) = x32_->ag_ptr;\ (D) (x32_, 2u);\ } #define PUSH_ulong(A, B)\ {\ c_class **r33_ = &(B);\ c_class *x33_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_ulong (x33_ + 1, (A));\ x33_->ag_ptr = *r33_;\ *r33_ = x33_;\ } #define POP_ulong(A, B)\ {\ c_class **r34_ = &(B);\ c_class *x34_ = CHECK_NULL (*r34_);\ (A) = DEREF_ulong (x34_ + 1);\ *r34_ = x34_->ag_ptr;\ destroy_c_class (x34_, 2u);\ } /* Definitions for primitive BITSTREAM_P */ #define SIZE_bits 1 #define COPY_bits(A, B) (CHECK_NULL (A)->ag_prim_bits = (B)) #define DEREF_bits(A) (CHECK_NULL (A)->ag_prim_bits) #define CONS_bits(A, B, C)\ {\ c_class *x35_ = GEN_c_class ( 2, TYPEID_list );\ COPY_bits (x35_ + 1, (A));\ x35_->ag_ptr = (B);\ (C) = x35_;\ } #define UN_CONS_bits(A, B, C)\ {\ c_class *x36_ = CHECK_NULL (C);\ (A) = DEREF_bits (x36_ + 1);\ (B) = x36_->ag_ptr;\ } #define DESTROY_CONS_bits(D, A, B, C)\ {\ c_class *x37_ = CHECK_NULL (C);\ (A) = DEREF_bits (x37_ + 1);\ (B) = x37_->ag_ptr;\ (D) (x37_, 2u);\ } #define PUSH_bits(A, B)\ {\ c_class **r38_ = &(B);\ c_class *x38_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_bits (x38_ + 1, (A));\ x38_->ag_ptr = *r38_;\ *r38_ = x38_;\ } #define POP_bits(A, B)\ {\ c_class **r39_ = &(B);\ c_class *x39_ = CHECK_NULL (*r39_);\ (A) = DEREF_bits (x39_ + 1);\ *r39_ = x39_->ag_ptr;\ destroy_c_class (x39_, 2u);\ } /* Definitions for primitive PPTOKEN_P */ #define SIZE_pptok 1 #define COPY_pptok(A, B) (CHECK_NULL (A)->ag_prim_pptok = (B)) #define DEREF_pptok(A) (CHECK_NULL (A)->ag_prim_pptok) #define CONS_pptok(A, B, C)\ {\ c_class *x40_ = GEN_c_class ( 2, TYPEID_list );\ COPY_pptok (x40_ + 1, (A));\ x40_->ag_ptr = (B);\ (C) = x40_;\ } #define UN_CONS_pptok(A, B, C)\ {\ c_class *x41_ = CHECK_NULL (C);\ (A) = DEREF_pptok (x41_ + 1);\ (B) = x41_->ag_ptr;\ } #define DESTROY_CONS_pptok(D, A, B, C)\ {\ c_class *x42_ = CHECK_NULL (C);\ (A) = DEREF_pptok (x42_ + 1);\ (B) = x42_->ag_ptr;\ (D) (x42_, 2u);\ } #define PUSH_pptok(A, B)\ {\ c_class **r43_ = &(B);\ c_class *x43_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_pptok (x43_ + 1, (A));\ x43_->ag_ptr = *r43_;\ *r43_ = x43_;\ } #define POP_pptok(A, B)\ {\ c_class **r44_ = &(B);\ c_class *x44_ = CHECK_NULL (*r44_);\ (A) = DEREF_pptok (x44_ + 1);\ *r44_ = x44_->ag_ptr;\ destroy_c_class (x44_, 2u);\ } /* Definitions for enumeration CV_SPEC */ #define cv_none ((CV_SPEC) 0u) #define cv_const ((CV_SPEC) 1u) #define cv_volatile ((CV_SPEC) 2u) #define cv_restrict ((CV_SPEC) 4u) #define cv_lvalue ((CV_SPEC) 8u) #define cv_c ((CV_SPEC) 16u) #define cv_cpp ((CV_SPEC) 32u) #define cv_qual ((CV_SPEC) 7u) #define cv_mask ((CV_SPEC) 15u) #define cv_language ((CV_SPEC) 48u) #define ORDER_cv ((unsigned long) 49) #define SIZE_cv 1 #define COPY_cv(A, B) (CHECK_NULL (A)->ag_enum = (B)) #define DEREF_cv(A) (CHECK_NULL (A)->ag_enum) /* Definitions for enumeration BUILTIN_TYPE */ #define ntype_none ((BUILTIN_TYPE) 0u) #define ntype_char ((BUILTIN_TYPE) 1u) #define ntype_schar ((BUILTIN_TYPE) 2u) #define ntype_uchar ((BUILTIN_TYPE) 3u) #define ntype_sshort ((BUILTIN_TYPE) 4u) #define ntype_ushort ((BUILTIN_TYPE) 5u) #define ntype_sint ((BUILTIN_TYPE) 6u) #define ntype_uint ((BUILTIN_TYPE) 7u) #define ntype_slong ((BUILTIN_TYPE) 8u) #define ntype_ulong ((BUILTIN_TYPE) 9u) #define ntype_sllong ((BUILTIN_TYPE) 10u) #define ntype_ullong ((BUILTIN_TYPE) 11u) #define ntype_float ((BUILTIN_TYPE) 12u) #define ntype_double ((BUILTIN_TYPE) 13u) #define ntype_ldouble ((BUILTIN_TYPE) 14u) #define ntype_void ((BUILTIN_TYPE) 15u) #define ntype_bottom ((BUILTIN_TYPE) 16u) #define ntype_bool ((BUILTIN_TYPE) 17u) #define ntype_ptrdiff_t ((BUILTIN_TYPE) 18u) #define ntype_size_t ((BUILTIN_TYPE) 19u) #define ntype_wchar_t ((BUILTIN_TYPE) 20u) #define ntype_ellipsis ((BUILTIN_TYPE) 21u) #define ORDER_ntype ((unsigned long) 22) #define SIZE_ntype 1 #define COPY_ntype(A, B) (CHECK_NULL (A)->ag_enum = (B)) #define DEREF_ntype(A) (CHECK_NULL (A)->ag_enum) /* Definitions for enumeration BASE_TYPE */ #define btype_none ((BASE_TYPE) 0u) #define btype_class ((BASE_TYPE) 1u) #define btype_struct_ ((BASE_TYPE) 2u) #define btype_union_ ((BASE_TYPE) 3u) #define btype_enum_ ((BASE_TYPE) 4u) #define btype_alias ((BASE_TYPE) 5u) #define btype_any ((BASE_TYPE) 6u) #define btype_named ((BASE_TYPE) 7u) #define btype_signed ((BASE_TYPE) 8u) #define btype_unsigned ((BASE_TYPE) 16u) #define btype_char ((BASE_TYPE) 32u) #define btype_short ((BASE_TYPE) 64u) #define btype_int ((BASE_TYPE) 128u) #define btype_long ((BASE_TYPE) 256u) #define btype_long2 ((BASE_TYPE) 512u) #define btype_float ((BASE_TYPE) 1024u) #define btype_double ((BASE_TYPE) 2048u) #define btype_void ((BASE_TYPE) 4096u) #define btype_bottom ((BASE_TYPE) 8192u) #define btype_bool ((BASE_TYPE) 16384u) #define btype_ptrdiff_t ((BASE_TYPE) 32768u) #define btype_size_t ((BASE_TYPE) 65536u) #define btype_wchar_t ((BASE_TYPE) 131072u) #define btype_schar ((BASE_TYPE) 40u) #define btype_uchar ((BASE_TYPE) 48u) #define btype_sshort ((BASE_TYPE) 200u) #define btype_ushort ((BASE_TYPE) 208u) #define btype_sint ((BASE_TYPE) 136u) #define btype_uint ((BASE_TYPE) 144u) #define btype_slong ((BASE_TYPE) 392u) #define btype_ulong ((BASE_TYPE) 400u) #define btype_llong ((BASE_TYPE) 768u) #define btype_sllong ((BASE_TYPE) 904u) #define btype_ullong ((BASE_TYPE) 912u) #define btype_ldouble ((BASE_TYPE) 2304u) #define btype_ellipsis ((BASE_TYPE) 262144u) #define btype_star ((BASE_TYPE) 524288u) #define btype_template ((BASE_TYPE) 1048576u) #define btype_typename ((BASE_TYPE) 2097152u) #define btype_args ((BASE_TYPE) 4194304u) #define btype_keyword ((BASE_TYPE) 154624u) #define btype_other ((BASE_TYPE) 261120u) #define btype_arith ((BASE_TYPE) 1152u) #define btype_scalar ((BASE_TYPE) 525440u) #define ORDER_btype ((unsigned long) 4194305) #define SIZE_btype 1 #define COPY_btype(A, B) (CHECK_NULL (A)->ag_long_enum = (B)) #define DEREF_btype(A) (CHECK_NULL (A)->ag_long_enum) /* Definitions for enumeration CLASS_INFO */ #define cinfo_none ((CLASS_INFO) 0u) #define cinfo_complete ((CLASS_INFO) 1u) #define cinfo_defined ((CLASS_INFO) 2u) #define cinfo_struct_ ((CLASS_INFO) 4u) #define cinfo_union_ ((CLASS_INFO) 8u) #define cinfo_template ((CLASS_INFO) 16u) #define cinfo_token ((CLASS_INFO) 32u) #define cinfo_pod ((CLASS_INFO) 64u) #define cinfo_nested ((CLASS_INFO) 128u) #define cinfo_rescan ((CLASS_INFO) 256u) #define cinfo_recursive ((CLASS_INFO) 512u) #define cinfo_incomplete ((CLASS_INFO) 1024u) #define cinfo_base ((CLASS_INFO) 2048u) #define cinfo_multiple_base ((CLASS_INFO) 4096u) #define cinfo_virtual_base ((CLASS_INFO) 8192u) #define cinfo_templ_base ((CLASS_INFO) 16384u) #define cinfo_ambiguous ((CLASS_INFO) 32768u) #define cinfo_empty ((CLASS_INFO) 65536u) #define cinfo_private ((CLASS_INFO) 131072u) #define cinfo_const ((CLASS_INFO) 262144u) #define cinfo_static ((CLASS_INFO) 524288u) #define cinfo_function ((CLASS_INFO) 1048576u) #define cinfo_params ((CLASS_INFO) 2097152u) #define cinfo_polymorphic ((CLASS_INFO) 4194304u) #define cinfo_poly_base ((CLASS_INFO) 8388608u) #define cinfo_abstract ((CLASS_INFO) 16777216u) #define cinfo_trivial_constr ((CLASS_INFO) 33554432u) #define cinfo_trivial_destr ((CLASS_INFO) 67108864u) #define cinfo_trivial_copy ((CLASS_INFO) 134217728u) #define cinfo_trivial_assign ((CLASS_INFO) 268435456u) #define cinfo_const_copy ((CLASS_INFO) 536870912u) #define cinfo_const_assign ((CLASS_INFO) 1073741824u) #define cinfo_usr_constr ((CLASS_INFO) 2147483648u) #define cinfo_key ((CLASS_INFO) 12u) #define cinfo_non_aggregate ((CLASS_INFO) 2151811104u) #define cinfo_force_copy ((CLASS_INFO) 3670016u) #define cinfo_trivial_make ((CLASS_INFO) 436207616u) #define cinfo_trivial ((CLASS_INFO) 503316480u) #define cinfo_implicit ((CLASS_INFO) 2113929216u) #define cinfo_default ((CLASS_INFO) 2113994816u) #define ORDER_cinfo ((unsigned long) 2151811105) #define SIZE_cinfo 1 #define COPY_cinfo(A, B) (CHECK_NULL (A)->ag_long_enum = (B)) #define DEREF_cinfo(A) (CHECK_NULL (A)->ag_long_enum) /* Definitions for enumeration CLASS_USAGE */ #define cusage_none ((CLASS_USAGE) 0u) #define cusage_address ((CLASS_USAGE) 1u) #define cusage_destr ((CLASS_USAGE) 2u) #define cusage_delete ((CLASS_USAGE) 4u) #define cusage_delete_array ((CLASS_USAGE) 8u) #define ORDER_cusage ((unsigned long) 9) #define SIZE_cusage 1 #define COPY_cusage(A, B) (CHECK_NULL (A)->ag_enum = (B)) #define DEREF_cusage(A) (CHECK_NULL (A)->ag_enum) /* Definitions for enumeration DECL_SPEC */ #define dspec_none ((DECL_SPEC) 0u) #define dspec_used ((DECL_SPEC) 1u) #define dspec_called ((DECL_SPEC) 2u) #define dspec_defn ((DECL_SPEC) 4u) #define dspec_inherit ((DECL_SPEC) 8u) #define dspec_alias ((DECL_SPEC) 16u) #define dspec_done ((DECL_SPEC) 32u) #define dspec_static ((DECL_SPEC) 64u) #define dspec_extern ((DECL_SPEC) 128u) #define dspec_auto ((DECL_SPEC) 256u) #define dspec_register ((DECL_SPEC) 512u) #define dspec_mutable ((DECL_SPEC) 1024u) #define dspec_inline ((DECL_SPEC) 2048u) #define dspec_virtual ((DECL_SPEC) 4096u) #define dspec_explicit ((DECL_SPEC) 8192u) #define dspec_friend ((DECL_SPEC) 16384u) #define dspec_typedef ((DECL_SPEC) 32768u) #define dspec_public ((DECL_SPEC) 65536u) #define dspec_protected ((DECL_SPEC) 131072u) #define dspec_private ((DECL_SPEC) 196608u) #define dspec_public2 ((DECL_SPEC) 262144u) #define dspec_protected2 ((DECL_SPEC) 524288u) #define dspec_private2 ((DECL_SPEC) 786432u) #define dspec_c ((DECL_SPEC) 1048576u) #define dspec_cpp ((DECL_SPEC) 2097152u) #define dspec_ignore ((DECL_SPEC) 4194304u) #define dspec_implicit ((DECL_SPEC) 8388608u) #define dspec_instance ((DECL_SPEC) 16777216u) #define dspec_main ((DECL_SPEC) 33554432u) #define dspec_pure ((DECL_SPEC) 67108864u) #define dspec_reserve ((DECL_SPEC) 134217728u) #define dspec_temp ((DECL_SPEC) 268435456u) #define dspec_template ((DECL_SPEC) 536870912u) #define dspec_token ((DECL_SPEC) 1073741824u) #define dspec_trivial ((DECL_SPEC) 2147483648u) #define dspec_linkage ((DECL_SPEC) 192u) #define dspec_storage ((DECL_SPEC) 1984u) #define dspec_function ((DECL_SPEC) 14336u) #define dspec_keyword ((DECL_SPEC) 65472u) #define dspec_duplicate ((DECL_SPEC) 65472u) #define dspec_access ((DECL_SPEC) 196608u) #define dspec_access2 ((DECL_SPEC) 786432u) #define dspec_language ((DECL_SPEC) 3145728u) #define dspec_other ((DECL_SPEC) 4290772992u) #define ORDER_dspec ((unsigned long) 4290772993) #define SIZE_dspec 1 #define COPY_dspec(A, B) (CHECK_NULL (A)->ag_long_enum = (B)) #define DEREF_dspec(A) (CHECK_NULL (A)->ag_long_enum) #define CONS_dspec(A, B, C)\ {\ c_class *x45_ = GEN_c_class ( 2, TYPEID_list );\ COPY_dspec (x45_ + 1, (A));\ x45_->ag_ptr = (B);\ (C) = x45_;\ } #define UN_CONS_dspec(A, B, C)\ {\ c_class *x46_ = CHECK_NULL (C);\ (A) = DEREF_dspec (x46_ + 1);\ (B) = x46_->ag_ptr;\ } #define DESTROY_CONS_dspec(D, A, B, C)\ {\ c_class *x47_ = CHECK_NULL (C);\ (A) = DEREF_dspec (x47_ + 1);\ (B) = x47_->ag_ptr;\ (D) (x47_, 2u);\ } #define PUSH_dspec(A, B)\ {\ c_class **r48_ = &(B);\ c_class *x48_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_dspec (x48_ + 1, (A));\ x48_->ag_ptr = *r48_;\ *r48_ = x48_;\ } #define POP_dspec(A, B)\ {\ c_class **r49_ = &(B);\ c_class *x49_ = CHECK_NULL (*r49_);\ (A) = DEREF_dspec (x49_ + 1);\ *r49_ = x49_->ag_ptr;\ destroy_c_class (x49_, 2u);\ } /* Definitions for enumeration QUALIFIER */ #define qual_none ((QUALIFIER) 0u) #define qual_nested ((QUALIFIER) 1u) #define qual_full ((QUALIFIER) 2u) #define qual_top ((QUALIFIER) 3u) #define qual_mark ((QUALIFIER) 4u) #define qual_explicit ((QUALIFIER) 3u) #define ORDER_qual ((unsigned long) 5) #define SIZE_qual 1 #define COPY_qual(A, B) (CHECK_NULL (A)->ag_enum = (B)) #define DEREF_qual(A) (CHECK_NULL (A)->ag_enum) /* Definitions for enumeration NTEST */ #define ntest_eq ((NTEST) 0u) #define ntest_greater ((NTEST) 1u) #define ntest_greater_eq ((NTEST) 2u) #define ntest_less ((NTEST) 3u) #define ntest_less_eq ((NTEST) 4u) #define ntest_not_eq ((NTEST) 5u) #define ntest_not_greater ((NTEST) 6u) #define ntest_not_greater_eq ((NTEST) 7u) #define ntest_not_less ((NTEST) 8u) #define ntest_not_less_eq ((NTEST) 9u) #define ntest_not_not_eq ((NTEST) 10u) #define ntest_none ((NTEST) 11u) #define ntest_negate ((NTEST) 5u) #define ntest_not ((NTEST) 5u) #define ntest_not_not ((NTEST) 10u) #define ORDER_ntest ((unsigned long) 12) #define SIZE_ntest 1 #define COPY_ntest(A, B) (CHECK_NULL (A)->ag_enum = (B)) #define DEREF_ntest(A) (CHECK_NULL (A)->ag_enum) /* Definitions for enumeration RMODE */ #define rmode_as_state ((RMODE) 0u) #define rmode_to_nearest ((RMODE) 1u) #define rmode_to_larger ((RMODE) 2u) #define rmode_to_smaller ((RMODE) 3u) #define rmode_to_zero ((RMODE) 4u) #define ORDER_rmode ((unsigned long) 5) #define SIZE_rmode 1 #define COPY_rmode(A, B) (CHECK_NULL (A)->ag_enum = (B)) #define DEREF_rmode(A) (CHECK_NULL (A)->ag_enum) /* Definitions for structure VARIABLE */ #define var_id(P) ((P) + 0) #define var_info(P) ((P) + 1) #define SIZE_var 2 #define COPY_var(A, B)\ {\ c_class *x50_ = CHECK_NULL (A);\ VARIABLE y50_;\ y50_ = (B);\ COPY_id (x50_ + 0, y50_.id);\ COPY_dspec (x50_ + 1, y50_.info);\ } #define DEREF_var(A, B)\ {\ c_class *x51_ = CHECK_NULL (A);\ VARIABLE *y51_ = &(B);\ y51_->id = DEREF_id (x51_ + 0);\ y51_->info = DEREF_dspec (x51_ + 1);\ } #define MAKE_var(id_, info_, var_)\ {\ c_class *x52_ = CHECK_NULL (var_);\ COPY_id (x52_ + 0, (id_));\ COPY_dspec (x52_ + 1, (info_));\ } #define CONS_var(A, B, C)\ {\ c_class *x53_ = GEN_c_class ( 3, TYPEID_list );\ COPY_var (x53_ + 1, (A));\ x53_->ag_ptr = (B);\ (C) = x53_;\ } #define UN_CONS_var(A, B, C)\ {\ c_class *x54_ = CHECK_NULL (C);\ DEREF_var (x54_ + 1, (A));\ (B) = x54_->ag_ptr;\ } #define DESTROY_CONS_var(D, A, B, C)\ {\ c_class *x55_ = CHECK_NULL (C);\ DEREF_var (x55_ + 1, (A));\ (B) = x55_->ag_ptr;\ (D) (x55_, 3u);\ } #define PUSH_var(A, B)\ {\ c_class **r56_ = &(B);\ c_class *x56_ = GEN_c_class ( 3, TYPEID_stack );\ COPY_var (x56_ + 1, (A));\ x56_->ag_ptr = *r56_;\ *r56_ = x56_;\ } #define POP_var(A, B)\ {\ c_class **r57_ = &(B);\ c_class *x57_ = CHECK_NULL (*r57_);\ DEREF_var (x57_ + 1, (A));\ *r57_ = x57_->ag_ptr;\ destroy_c_class (x57_, 3u);\ } /* Definitions for structure LOCATION */ #define loc_line(P) ((P) + 0) #define loc_column(P) ((P) + 1) #define loc_posn(P) ((P) + 2) #define SIZE_loc 3 #define COPY_loc(A, B)\ {\ c_class *x58_ = CHECK_NULL (A);\ LOCATION y58_;\ y58_ = (B);\ COPY_ulong (x58_ + 0, y58_.line);\ COPY_ulong (x58_ + 1, y58_.column);\ COPY_ptr (x58_ + 2, y58_.posn);\ } #define DEREF_loc(A, B)\ {\ c_class *x59_ = CHECK_NULL (A);\ LOCATION *y59_ = &(B);\ y59_->line = DEREF_ulong (x59_ + 0);\ y59_->column = DEREF_ulong (x59_ + 1);\ y59_->posn = DEREF_ptr (x59_ + 2);\ } #define MAKE_loc(line_, column_, posn_, loc_)\ {\ c_class *x60_ = CHECK_NULL (loc_);\ COPY_ulong (x60_ + 0, (line_));\ COPY_ulong (x60_ + 1, (column_));\ COPY_ptr (x60_ + 2, (posn_));\ } #define CONS_loc(A, B, C)\ {\ c_class *x61_ = GEN_c_class ( 4, TYPEID_list );\ COPY_loc (x61_ + 1, (A));\ x61_->ag_ptr = (B);\ (C) = x61_;\ } #define UN_CONS_loc(A, B, C)\ {\ c_class *x62_ = CHECK_NULL (C);\ DEREF_loc (x62_ + 1, (A));\ (B) = x62_->ag_ptr;\ } #define DESTROY_CONS_loc(D, A, B, C)\ {\ c_class *x63_ = CHECK_NULL (C);\ DEREF_loc (x63_ + 1, (A));\ (B) = x63_->ag_ptr;\ (D) (x63_, 4u);\ } #define PUSH_loc(A, B)\ {\ c_class **r64_ = &(B);\ c_class *x64_ = GEN_c_class ( 4, TYPEID_stack );\ COPY_loc (x64_ + 1, (A));\ x64_->ag_ptr = *r64_;\ *r64_ = x64_;\ } #define POP_loc(A, B)\ {\ c_class **r65_ = &(B);\ c_class *x65_ = CHECK_NULL (*r65_);\ DEREF_loc (x65_ + 1, (A));\ *r65_ = x65_->ag_ptr;\ destroy_c_class (x65_, 4u);\ } /* Definitions for structure POSITION */ #define posn_file(P) ((P) + 0) #define posn_quote_file(P) ((P) + 1) #define posn_input(P) ((P) + 2) #define posn_base(P) ((P) + 3) #define posn_dir(P) ((P) + 4) #define posn_offset(P) ((P) + 5) #define posn_from(P) ((P) + 6) #define posn_datestamp(P) ((P) + 7) #define posn_tok(P) ((P) + 8) #define SIZE_posn 9 #define COPY_posn(A, B)\ {\ c_class *x66_ = CHECK_NULL (A);\ POSITION y66_;\ y66_ = (B);\ COPY_string (x66_ + 0, y66_.file);\ COPY_int (x66_ + 1, y66_.quote_file);\ COPY_string (x66_ + 2, y66_.input);\ COPY_string (x66_ + 3, y66_.base);\ COPY_string (x66_ + 4, y66_.dir);\ COPY_ulong (x66_ + 5, y66_.offset);\ COPY_ptr (x66_ + 6, y66_.from);\ COPY_ulong (x66_ + 7, y66_.datestamp);\ COPY_ulong (x66_ + 8, y66_.tok);\ } #define DEREF_posn(A, B)\ {\ c_class *x67_ = CHECK_NULL (A);\ POSITION *y67_ = &(B);\ y67_->file = DEREF_string (x67_ + 0);\ y67_->quote_file = DEREF_int (x67_ + 1);\ y67_->input = DEREF_string (x67_ + 2);\ y67_->base = DEREF_string (x67_ + 3);\ y67_->dir = DEREF_string (x67_ + 4);\ y67_->offset = DEREF_ulong (x67_ + 5);\ y67_->from = DEREF_ptr (x67_ + 6);\ y67_->datestamp = DEREF_ulong (x67_ + 7);\ y67_->tok = DEREF_ulong (x67_ + 8);\ } #define MAKE_posn(file_, quote_file_, input_, base_, dir_, offset_, from_, datestamp_, posn_)\ {\ c_class *x68_ = CHECK_NULL (posn_);\ COPY_string (x68_ + 0, (file_));\ COPY_int (x68_ + 1, (quote_file_));\ COPY_string (x68_ + 2, (input_));\ COPY_string (x68_ + 3, (base_));\ COPY_string (x68_ + 4, (dir_));\ COPY_ulong (x68_ + 5, (offset_));\ COPY_ptr (x68_ + 6, (from_));\ COPY_ulong (x68_ + 7, (datestamp_));\ COPY_ulong (x68_ + 8, LINK_NONE);\ } #define CONS_posn(A, B, C)\ {\ c_class *x69_ = GEN_c_class ( 10, TYPEID_list );\ COPY_posn (x69_ + 1, (A));\ x69_->ag_ptr = (B);\ (C) = x69_;\ } #define UN_CONS_posn(A, B, C)\ {\ c_class *x70_ = CHECK_NULL (C);\ DEREF_posn (x70_ + 1, (A));\ (B) = x70_->ag_ptr;\ } #define DESTROY_CONS_posn(D, A, B, C)\ {\ c_class *x71_ = CHECK_NULL (C);\ DEREF_posn (x71_ + 1, (A));\ (B) = x71_->ag_ptr;\ (D) (x71_, 10u);\ } #define PUSH_posn(A, B)\ {\ c_class **r72_ = &(B);\ c_class *x72_ = GEN_c_class ( 10, TYPEID_stack );\ COPY_posn (x72_ + 1, (A));\ x72_->ag_ptr = *r72_;\ *r72_ = x72_;\ } #define POP_posn(A, B)\ {\ c_class **r73_ = &(B);\ c_class *x73_ = CHECK_NULL (*r73_);\ DEREF_posn (x73_ + 1, (A));\ *r73_ = x73_->ag_ptr;\ destroy_c_class (x73_, 10u);\ } /* Definitions for union INT_TYPE */ #define ORDER_itype 6u #define SIZE_itype 1 #define NULL_itype ((INT_TYPE) 0) #define IS_NULL_itype(A) ((A) == 0) #define EQ_itype(A, B) ((A) == (B)) #define COPY_itype(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_itype(A) (CHECK_NULL (A)->ag_ptr) #define CONS_itype(A, B, C)\ {\ c_class *x74_ = GEN_c_class ( 2, TYPEID_list );\ COPY_itype (x74_ + 1, (A));\ x74_->ag_ptr = (B);\ (C) = x74_;\ } #define UN_CONS_itype(A, B, C)\ {\ c_class *x75_ = CHECK_NULL (C);\ (A) = DEREF_itype (x75_ + 1);\ (B) = x75_->ag_ptr;\ } #define DESTROY_CONS_itype(D, A, B, C)\ {\ c_class *x76_ = CHECK_NULL (C);\ (A) = DEREF_itype (x76_ + 1);\ (B) = x76_->ag_ptr;\ (D) (x76_, 2u);\ } #define PUSH_itype(A, B)\ {\ c_class **r77_ = &(B);\ c_class *x77_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_itype (x77_ + 1, (A));\ x77_->ag_ptr = *r77_;\ *r77_ = x77_;\ } #define POP_itype(A, B)\ {\ c_class **r78_ = &(B);\ c_class *x78_ = CHECK_NULL (*r78_);\ (A) = DEREF_itype (x78_ + 1);\ *r78_ = x78_->ag_ptr;\ destroy_c_class (x78_, 2u);\ } /* Definitions for union FLOAT_TYPE */ #define ORDER_ftype 4u #define SIZE_ftype 1 #define NULL_ftype ((FLOAT_TYPE) 0) #define IS_NULL_ftype(A) ((A) == 0) #define EQ_ftype(A, B) ((A) == (B)) #define COPY_ftype(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_ftype(A) (CHECK_NULL (A)->ag_ptr) #define CONS_ftype(A, B, C)\ {\ c_class *x79_ = GEN_c_class ( 2, TYPEID_list );\ COPY_ftype (x79_ + 1, (A));\ x79_->ag_ptr = (B);\ (C) = x79_;\ } #define UN_CONS_ftype(A, B, C)\ {\ c_class *x80_ = CHECK_NULL (C);\ (A) = DEREF_ftype (x80_ + 1);\ (B) = x80_->ag_ptr;\ } #define DESTROY_CONS_ftype(D, A, B, C)\ {\ c_class *x81_ = CHECK_NULL (C);\ (A) = DEREF_ftype (x81_ + 1);\ (B) = x81_->ag_ptr;\ (D) (x81_, 2u);\ } #define PUSH_ftype(A, B)\ {\ c_class **r82_ = &(B);\ c_class *x82_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_ftype (x82_ + 1, (A));\ x82_->ag_ptr = *r82_;\ *r82_ = x82_;\ } #define POP_ftype(A, B)\ {\ c_class **r83_ = &(B);\ c_class *x83_ = CHECK_NULL (*r83_);\ (A) = DEREF_ftype (x83_ + 1);\ *r83_ = x83_->ag_ptr;\ destroy_c_class (x83_, 2u);\ } /* Definitions for union CLASS_TYPE */ #define ORDER_ctype 1u #define SIZE_ctype 1 #define NULL_ctype ((CLASS_TYPE) 0) #define IS_NULL_ctype(A) ((A) == 0) #define EQ_ctype(A, B) ((A) == (B)) #define COPY_ctype(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_ctype(A) (CHECK_NULL (A)->ag_ptr) #define CONS_ctype(A, B, C)\ {\ c_class *x84_ = GEN_c_class ( 2, TYPEID_list );\ COPY_ctype (x84_ + 1, (A));\ x84_->ag_ptr = (B);\ (C) = x84_;\ } #define UN_CONS_ctype(A, B, C)\ {\ c_class *x85_ = CHECK_NULL (C);\ (A) = DEREF_ctype (x85_ + 1);\ (B) = x85_->ag_ptr;\ } #define DESTROY_CONS_ctype(D, A, B, C)\ {\ c_class *x86_ = CHECK_NULL (C);\ (A) = DEREF_ctype (x86_ + 1);\ (B) = x86_->ag_ptr;\ (D) (x86_, 2u);\ } #define PUSH_ctype(A, B)\ {\ c_class **r87_ = &(B);\ c_class *x87_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_ctype (x87_ + 1, (A));\ x87_->ag_ptr = *r87_;\ *r87_ = x87_;\ } #define POP_ctype(A, B)\ {\ c_class **r88_ = &(B);\ c_class *x88_ = CHECK_NULL (*r88_);\ (A) = DEREF_ctype (x88_ + 1);\ *r88_ = x88_->ag_ptr;\ destroy_c_class (x88_, 2u);\ } /* Definitions for union GRAPH */ #define ORDER_graph 1u #define SIZE_graph 1 #define NULL_graph ((GRAPH) 0) #define IS_NULL_graph(A) ((A) == 0) #define EQ_graph(A, B) ((A) == (B)) #define COPY_graph(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_graph(A) (CHECK_NULL (A)->ag_ptr) #define CONS_graph(A, B, C)\ {\ c_class *x89_ = GEN_c_class ( 2, TYPEID_list );\ COPY_graph (x89_ + 1, (A));\ x89_->ag_ptr = (B);\ (C) = x89_;\ } #define UN_CONS_graph(A, B, C)\ {\ c_class *x90_ = CHECK_NULL (C);\ (A) = DEREF_graph (x90_ + 1);\ (B) = x90_->ag_ptr;\ } #define DESTROY_CONS_graph(D, A, B, C)\ {\ c_class *x91_ = CHECK_NULL (C);\ (A) = DEREF_graph (x91_ + 1);\ (B) = x91_->ag_ptr;\ (D) (x91_, 2u);\ } #define PUSH_graph(A, B)\ {\ c_class **r92_ = &(B);\ c_class *x92_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_graph (x92_ + 1, (A));\ x92_->ag_ptr = *r92_;\ *r92_ = x92_;\ } #define POP_graph(A, B)\ {\ c_class **r93_ = &(B);\ c_class *x93_ = CHECK_NULL (*r93_);\ (A) = DEREF_graph (x93_ + 1);\ *r93_ = x93_->ag_ptr;\ destroy_c_class (x93_, 2u);\ } /* Definitions for union VIRTUAL */ #define ORDER_virt 6u #define SIZE_virt 1 #define NULL_virt ((VIRTUAL) 0) #define IS_NULL_virt(A) ((A) == 0) #define EQ_virt(A, B) ((A) == (B)) #define COPY_virt(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_virt(A) (CHECK_NULL (A)->ag_ptr) #define CONS_virt(A, B, C)\ {\ c_class *x94_ = GEN_c_class ( 2, TYPEID_list );\ COPY_virt (x94_ + 1, (A));\ x94_->ag_ptr = (B);\ (C) = x94_;\ } #define UN_CONS_virt(A, B, C)\ {\ c_class *x95_ = CHECK_NULL (C);\ (A) = DEREF_virt (x95_ + 1);\ (B) = x95_->ag_ptr;\ } #define DESTROY_CONS_virt(D, A, B, C)\ {\ c_class *x96_ = CHECK_NULL (C);\ (A) = DEREF_virt (x96_ + 1);\ (B) = x96_->ag_ptr;\ (D) (x96_, 2u);\ } #define PUSH_virt(A, B)\ {\ c_class **r97_ = &(B);\ c_class *x97_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_virt (x97_ + 1, (A));\ x97_->ag_ptr = *r97_;\ *r97_ = x97_;\ } #define POP_virt(A, B)\ {\ c_class **r98_ = &(B);\ c_class *x98_ = CHECK_NULL (*r98_);\ (A) = DEREF_virt (x98_ + 1);\ *r98_ = x98_->ag_ptr;\ destroy_c_class (x98_, 2u);\ } /* Definitions for union ENUM_TYPE */ #define ORDER_etype 1u #define SIZE_etype 1 #define NULL_etype ((ENUM_TYPE) 0) #define IS_NULL_etype(A) ((A) == 0) #define EQ_etype(A, B) ((A) == (B)) #define COPY_etype(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_etype(A) (CHECK_NULL (A)->ag_ptr) #define CONS_etype(A, B, C)\ {\ c_class *x99_ = GEN_c_class ( 2, TYPEID_list );\ COPY_etype (x99_ + 1, (A));\ x99_->ag_ptr = (B);\ (C) = x99_;\ } #define UN_CONS_etype(A, B, C)\ {\ c_class *x100_ = CHECK_NULL (C);\ (A) = DEREF_etype (x100_ + 1);\ (B) = x100_->ag_ptr;\ } #define DESTROY_CONS_etype(D, A, B, C)\ {\ c_class *x101_ = CHECK_NULL (C);\ (A) = DEREF_etype (x101_ + 1);\ (B) = x101_->ag_ptr;\ (D) (x101_, 2u);\ } #define PUSH_etype(A, B)\ {\ c_class **r102_ = &(B);\ c_class *x102_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_etype (x102_ + 1, (A));\ x102_->ag_ptr = *r102_;\ *r102_ = x102_;\ } #define POP_etype(A, B)\ {\ c_class **r103_ = &(B);\ c_class *x103_ = CHECK_NULL (*r103_);\ (A) = DEREF_etype (x103_ + 1);\ *r103_ = x103_->ag_ptr;\ destroy_c_class (x103_, 2u);\ } /* Definitions for union TYPE */ #define ORDER_type 18u #define SIZE_type 1 #define NULL_type ((TYPE) 0) #define IS_NULL_type(A) ((A) == 0) #define EQ_type(A, B) ((A) == (B)) #define COPY_type(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_type(A) (CHECK_NULL (A)->ag_ptr) #define CONS_type(A, B, C)\ {\ c_class *x104_ = GEN_c_class ( 2, TYPEID_list );\ COPY_type (x104_ + 1, (A));\ x104_->ag_ptr = (B);\ (C) = x104_;\ } #define UN_CONS_type(A, B, C)\ {\ c_class *x105_ = CHECK_NULL (C);\ (A) = DEREF_type (x105_ + 1);\ (B) = x105_->ag_ptr;\ } #define DESTROY_CONS_type(D, A, B, C)\ {\ c_class *x106_ = CHECK_NULL (C);\ (A) = DEREF_type (x106_ + 1);\ (B) = x106_->ag_ptr;\ (D) (x106_, 2u);\ } #define PUSH_type(A, B)\ {\ c_class **r107_ = &(B);\ c_class *x107_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_type (x107_ + 1, (A));\ x107_->ag_ptr = *r107_;\ *r107_ = x107_;\ } #define POP_type(A, B)\ {\ c_class **r108_ = &(B);\ c_class *x108_ = CHECK_NULL (*r108_);\ (A) = DEREF_type (x108_ + 1);\ *r108_ = x108_->ag_ptr;\ destroy_c_class (x108_, 2u);\ } /* Definitions for union HASHID */ #define ORDER_hashid 7u #define SIZE_hashid 1 #define NULL_hashid ((HASHID) 0) #define IS_NULL_hashid(A) ((A) == 0) #define EQ_hashid(A, B) ((A) == (B)) #define COPY_hashid(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_hashid(A) (CHECK_NULL (A)->ag_ptr) #define CONS_hashid(A, B, C)\ {\ c_class *x109_ = GEN_c_class ( 2, TYPEID_list );\ COPY_hashid (x109_ + 1, (A));\ x109_->ag_ptr = (B);\ (C) = x109_;\ } #define UN_CONS_hashid(A, B, C)\ {\ c_class *x110_ = CHECK_NULL (C);\ (A) = DEREF_hashid (x110_ + 1);\ (B) = x110_->ag_ptr;\ } #define DESTROY_CONS_hashid(D, A, B, C)\ {\ c_class *x111_ = CHECK_NULL (C);\ (A) = DEREF_hashid (x111_ + 1);\ (B) = x111_->ag_ptr;\ (D) (x111_, 2u);\ } #define PUSH_hashid(A, B)\ {\ c_class **r112_ = &(B);\ c_class *x112_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_hashid (x112_ + 1, (A));\ x112_->ag_ptr = *r112_;\ *r112_ = x112_;\ } #define POP_hashid(A, B)\ {\ c_class **r113_ = &(B);\ c_class *x113_ = CHECK_NULL (*r113_);\ (A) = DEREF_hashid (x113_ + 1);\ *r113_ = x113_->ag_ptr;\ destroy_c_class (x113_, 2u);\ } /* Definitions for union IDENTIFIER */ #define ORDER_id 30u #define SIZE_id 1 #define NULL_id ((IDENTIFIER) 0) #define IS_NULL_id(A) ((A) == 0) #define EQ_id(A, B) ((A) == (B)) #define COPY_id(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_id(A) (CHECK_NULL (A)->ag_ptr) #define CONS_id(A, B, C)\ {\ c_class *x114_ = GEN_c_class ( 2, TYPEID_list );\ COPY_id (x114_ + 1, (A));\ x114_->ag_ptr = (B);\ (C) = x114_;\ } #define UN_CONS_id(A, B, C)\ {\ c_class *x115_ = CHECK_NULL (C);\ (A) = DEREF_id (x115_ + 1);\ (B) = x115_->ag_ptr;\ } #define DESTROY_CONS_id(D, A, B, C)\ {\ c_class *x116_ = CHECK_NULL (C);\ (A) = DEREF_id (x116_ + 1);\ (B) = x116_->ag_ptr;\ (D) (x116_, 2u);\ } #define PUSH_id(A, B)\ {\ c_class **r117_ = &(B);\ c_class *x117_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_id (x117_ + 1, (A));\ x117_->ag_ptr = *r117_;\ *r117_ = x117_;\ } #define POP_id(A, B)\ {\ c_class **r118_ = &(B);\ c_class *x118_ = CHECK_NULL (*r118_);\ (A) = DEREF_id (x118_ + 1);\ *r118_ = x118_->ag_ptr;\ destroy_c_class (x118_, 2u);\ } /* Definitions for union MEMBER */ #define ORDER_member 2u #define SIZE_member 1 #define NULL_member ((MEMBER) 0) #define IS_NULL_member(A) ((A) == 0) #define EQ_member(A, B) ((A) == (B)) #define COPY_member(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_member(A) (CHECK_NULL (A)->ag_ptr) #define CONS_member(A, B, C)\ {\ c_class *x119_ = GEN_c_class ( 2, TYPEID_list );\ COPY_member (x119_ + 1, (A));\ x119_->ag_ptr = (B);\ (C) = x119_;\ } #define UN_CONS_member(A, B, C)\ {\ c_class *x120_ = CHECK_NULL (C);\ (A) = DEREF_member (x120_ + 1);\ (B) = x120_->ag_ptr;\ } #define DESTROY_CONS_member(D, A, B, C)\ {\ c_class *x121_ = CHECK_NULL (C);\ (A) = DEREF_member (x121_ + 1);\ (B) = x121_->ag_ptr;\ (D) (x121_, 2u);\ } #define PUSH_member(A, B)\ {\ c_class **r122_ = &(B);\ c_class *x122_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_member (x122_ + 1, (A));\ x122_->ag_ptr = *r122_;\ *r122_ = x122_;\ } #define POP_member(A, B)\ {\ c_class **r123_ = &(B);\ c_class *x123_ = CHECK_NULL (*r123_);\ (A) = DEREF_member (x123_ + 1);\ *r123_ = x123_->ag_ptr;\ destroy_c_class (x123_, 2u);\ } /* Definitions for union NAMESPACE */ #define ORDER_nspace 9u #define SIZE_nspace 1 #define NULL_nspace ((NAMESPACE) 0) #define IS_NULL_nspace(A) ((A) == 0) #define EQ_nspace(A, B) ((A) == (B)) #define COPY_nspace(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_nspace(A) (CHECK_NULL (A)->ag_ptr) #define CONS_nspace(A, B, C)\ {\ c_class *x124_ = GEN_c_class ( 2, TYPEID_list );\ COPY_nspace (x124_ + 1, (A));\ x124_->ag_ptr = (B);\ (C) = x124_;\ } #define UN_CONS_nspace(A, B, C)\ {\ c_class *x125_ = CHECK_NULL (C);\ (A) = DEREF_nspace (x125_ + 1);\ (B) = x125_->ag_ptr;\ } #define DESTROY_CONS_nspace(D, A, B, C)\ {\ c_class *x126_ = CHECK_NULL (C);\ (A) = DEREF_nspace (x126_ + 1);\ (B) = x126_->ag_ptr;\ (D) (x126_, 2u);\ } #define PUSH_nspace(A, B)\ {\ c_class **r127_ = &(B);\ c_class *x127_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_nspace (x127_ + 1, (A));\ x127_->ag_ptr = *r127_;\ *r127_ = x127_;\ } #define POP_nspace(A, B)\ {\ c_class **r128_ = &(B);\ c_class *x128_ = CHECK_NULL (*r128_);\ (A) = DEREF_nspace (x128_ + 1);\ *r128_ = x128_->ag_ptr;\ destroy_c_class (x128_, 2u);\ } /* Definitions for union NAT */ #define ORDER_nat 5u #define SIZE_nat 1 #define NULL_nat ((NAT) 0) #define IS_NULL_nat(A) ((A) == 0) #define EQ_nat(A, B) ((A) == (B)) #define COPY_nat(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_nat(A) (CHECK_NULL (A)->ag_ptr) #define CONS_nat(A, B, C)\ {\ c_class *x129_ = GEN_c_class ( 2, TYPEID_list );\ COPY_nat (x129_ + 1, (A));\ x129_->ag_ptr = (B);\ (C) = x129_;\ } #define UN_CONS_nat(A, B, C)\ {\ c_class *x130_ = CHECK_NULL (C);\ (A) = DEREF_nat (x130_ + 1);\ (B) = x130_->ag_ptr;\ } #define DESTROY_CONS_nat(D, A, B, C)\ {\ c_class *x131_ = CHECK_NULL (C);\ (A) = DEREF_nat (x131_ + 1);\ (B) = x131_->ag_ptr;\ (D) (x131_, 2u);\ } #define PUSH_nat(A, B)\ {\ c_class **r132_ = &(B);\ c_class *x132_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_nat (x132_ + 1, (A));\ x132_->ag_ptr = *r132_;\ *r132_ = x132_;\ } #define POP_nat(A, B)\ {\ c_class **r133_ = &(B);\ c_class *x133_ = CHECK_NULL (*r133_);\ (A) = DEREF_nat (x133_ + 1);\ *r133_ = x133_->ag_ptr;\ destroy_c_class (x133_, 2u);\ } /* Definitions for union FLOAT */ #define ORDER_flt 1u #define SIZE_flt 1 #define NULL_flt ((FLOAT) 0) #define IS_NULL_flt(A) ((A) == 0) #define EQ_flt(A, B) ((A) == (B)) #define COPY_flt(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_flt(A) (CHECK_NULL (A)->ag_ptr) #define CONS_flt(A, B, C)\ {\ c_class *x134_ = GEN_c_class ( 2, TYPEID_list );\ COPY_flt (x134_ + 1, (A));\ x134_->ag_ptr = (B);\ (C) = x134_;\ } #define UN_CONS_flt(A, B, C)\ {\ c_class *x135_ = CHECK_NULL (C);\ (A) = DEREF_flt (x135_ + 1);\ (B) = x135_->ag_ptr;\ } #define DESTROY_CONS_flt(D, A, B, C)\ {\ c_class *x136_ = CHECK_NULL (C);\ (A) = DEREF_flt (x136_ + 1);\ (B) = x136_->ag_ptr;\ (D) (x136_, 2u);\ } #define PUSH_flt(A, B)\ {\ c_class **r137_ = &(B);\ c_class *x137_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_flt (x137_ + 1, (A));\ x137_->ag_ptr = *r137_;\ *r137_ = x137_;\ } #define POP_flt(A, B)\ {\ c_class **r138_ = &(B);\ c_class *x138_ = CHECK_NULL (*r138_);\ (A) = DEREF_flt (x138_ + 1);\ *r138_ = x138_->ag_ptr;\ destroy_c_class (x138_, 2u);\ } /* Definitions for union STRING */ #define ORDER_str 1u #define SIZE_str 1 #define NULL_str ((STRING) 0) #define IS_NULL_str(A) ((A) == 0) #define EQ_str(A, B) ((A) == (B)) #define COPY_str(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_str(A) (CHECK_NULL (A)->ag_ptr) #define CONS_str(A, B, C)\ {\ c_class *x139_ = GEN_c_class ( 2, TYPEID_list );\ COPY_str (x139_ + 1, (A));\ x139_->ag_ptr = (B);\ (C) = x139_;\ } #define UN_CONS_str(A, B, C)\ {\ c_class *x140_ = CHECK_NULL (C);\ (A) = DEREF_str (x140_ + 1);\ (B) = x140_->ag_ptr;\ } #define DESTROY_CONS_str(D, A, B, C)\ {\ c_class *x141_ = CHECK_NULL (C);\ (A) = DEREF_str (x141_ + 1);\ (B) = x141_->ag_ptr;\ (D) (x141_, 2u);\ } #define PUSH_str(A, B)\ {\ c_class **r142_ = &(B);\ c_class *x142_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_str (x142_ + 1, (A));\ x142_->ag_ptr = *r142_;\ *r142_ = x142_;\ } #define POP_str(A, B)\ {\ c_class **r143_ = &(B);\ c_class *x143_ = CHECK_NULL (*r143_);\ (A) = DEREF_str (x143_ + 1);\ *r143_ = x143_->ag_ptr;\ destroy_c_class (x143_, 2u);\ } /* Definitions for union EXP */ #define ORDER_exp 88u #define SIZE_exp 1 #define NULL_exp ((EXP) 0) #define IS_NULL_exp(A) ((A) == 0) #define EQ_exp(A, B) ((A) == (B)) #define COPY_exp(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_exp(A) (CHECK_NULL (A)->ag_ptr) #define CONS_exp(A, B, C)\ {\ c_class *x144_ = GEN_c_class ( 2, TYPEID_list );\ COPY_exp (x144_ + 1, (A));\ x144_->ag_ptr = (B);\ (C) = x144_;\ } #define UN_CONS_exp(A, B, C)\ {\ c_class *x145_ = CHECK_NULL (C);\ (A) = DEREF_exp (x145_ + 1);\ (B) = x145_->ag_ptr;\ } #define DESTROY_CONS_exp(D, A, B, C)\ {\ c_class *x146_ = CHECK_NULL (C);\ (A) = DEREF_exp (x146_ + 1);\ (B) = x146_->ag_ptr;\ (D) (x146_, 2u);\ } #define PUSH_exp(A, B)\ {\ c_class **r147_ = &(B);\ c_class *x147_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_exp (x147_ + 1, (A));\ x147_->ag_ptr = *r147_;\ *r147_ = x147_;\ } #define POP_exp(A, B)\ {\ c_class **r148_ = &(B);\ c_class *x148_ = CHECK_NULL (*r148_);\ (A) = DEREF_exp (x148_ + 1);\ *r148_ = x148_->ag_ptr;\ destroy_c_class (x148_, 2u);\ } /* Definitions for union OFFSET */ #define ORDER_off 13u #define SIZE_off 1 #define NULL_off ((OFFSET) 0) #define IS_NULL_off(A) ((A) == 0) #define EQ_off(A, B) ((A) == (B)) #define COPY_off(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_off(A) (CHECK_NULL (A)->ag_ptr) #define CONS_off(A, B, C)\ {\ c_class *x149_ = GEN_c_class ( 2, TYPEID_list );\ COPY_off (x149_ + 1, (A));\ x149_->ag_ptr = (B);\ (C) = x149_;\ } #define UN_CONS_off(A, B, C)\ {\ c_class *x150_ = CHECK_NULL (C);\ (A) = DEREF_off (x150_ + 1);\ (B) = x150_->ag_ptr;\ } #define DESTROY_CONS_off(D, A, B, C)\ {\ c_class *x151_ = CHECK_NULL (C);\ (A) = DEREF_off (x151_ + 1);\ (B) = x151_->ag_ptr;\ (D) (x151_, 2u);\ } #define PUSH_off(A, B)\ {\ c_class **r152_ = &(B);\ c_class *x152_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_off (x152_ + 1, (A));\ x152_->ag_ptr = *r152_;\ *r152_ = x152_;\ } #define POP_off(A, B)\ {\ c_class **r153_ = &(B);\ c_class *x153_ = CHECK_NULL (*r153_);\ (A) = DEREF_off (x153_ + 1);\ *r153_ = x153_->ag_ptr;\ destroy_c_class (x153_, 2u);\ } /* Definitions for union TOKEN */ #define ORDER_tok 10u #define SIZE_tok 1 #define NULL_tok ((TOKEN) 0) #define IS_NULL_tok(A) ((A) == 0) #define EQ_tok(A, B) ((A) == (B)) #define COPY_tok(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_tok(A) (CHECK_NULL (A)->ag_ptr) #define CONS_tok(A, B, C)\ {\ c_class *x154_ = GEN_c_class ( 2, TYPEID_list );\ COPY_tok (x154_ + 1, (A));\ x154_->ag_ptr = (B);\ (C) = x154_;\ } #define UN_CONS_tok(A, B, C)\ {\ c_class *x155_ = CHECK_NULL (C);\ (A) = DEREF_tok (x155_ + 1);\ (B) = x155_->ag_ptr;\ } #define DESTROY_CONS_tok(D, A, B, C)\ {\ c_class *x156_ = CHECK_NULL (C);\ (A) = DEREF_tok (x156_ + 1);\ (B) = x156_->ag_ptr;\ (D) (x156_, 2u);\ } #define PUSH_tok(A, B)\ {\ c_class **r157_ = &(B);\ c_class *x157_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_tok (x157_ + 1, (A));\ x157_->ag_ptr = *r157_;\ *r157_ = x157_;\ } #define POP_tok(A, B)\ {\ c_class **r158_ = &(B);\ c_class *x158_ = CHECK_NULL (*r158_);\ (A) = DEREF_tok (x158_ + 1);\ *r158_ = x158_->ag_ptr;\ destroy_c_class (x158_, 2u);\ } /* Definitions for union INSTANCE */ #define ORDER_inst 2u #define SIZE_inst 1 #define NULL_inst ((INSTANCE) 0) #define IS_NULL_inst(A) ((A) == 0) #define EQ_inst(A, B) ((A) == (B)) #define COPY_inst(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_inst(A) (CHECK_NULL (A)->ag_ptr) #define CONS_inst(A, B, C)\ {\ c_class *x159_ = GEN_c_class ( 2, TYPEID_list );\ COPY_inst (x159_ + 1, (A));\ x159_->ag_ptr = (B);\ (C) = x159_;\ } #define UN_CONS_inst(A, B, C)\ {\ c_class *x160_ = CHECK_NULL (C);\ (A) = DEREF_inst (x160_ + 1);\ (B) = x160_->ag_ptr;\ } #define DESTROY_CONS_inst(D, A, B, C)\ {\ c_class *x161_ = CHECK_NULL (C);\ (A) = DEREF_inst (x161_ + 1);\ (B) = x161_->ag_ptr;\ (D) (x161_, 2u);\ } #define PUSH_inst(A, B)\ {\ c_class **r162_ = &(B);\ c_class *x162_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_inst (x162_ + 1, (A));\ x162_->ag_ptr = *r162_;\ *r162_ = x162_;\ } #define POP_inst(A, B)\ {\ c_class **r163_ = &(B);\ c_class *x163_ = CHECK_NULL (*r163_);\ (A) = DEREF_inst (x163_ + 1);\ *r163_ = x163_->ag_ptr;\ destroy_c_class (x163_, 2u);\ } /* Definitions for union ERROR */ #define ORDER_err 2u #define SIZE_err 1 #define NULL_err ((ERROR) 0) #define IS_NULL_err(A) ((A) == 0) #define EQ_err(A, B) ((A) == (B)) #define COPY_err(A, B) (CHECK_NULL (A)->ag_ptr = (B)) #define DEREF_err(A) (CHECK_NULL (A)->ag_ptr) #define CONS_err(A, B, C)\ {\ c_class *x164_ = GEN_c_class ( 2, TYPEID_list );\ COPY_err (x164_ + 1, (A));\ x164_->ag_ptr = (B);\ (C) = x164_;\ } #define UN_CONS_err(A, B, C)\ {\ c_class *x165_ = CHECK_NULL (C);\ (A) = DEREF_err (x165_ + 1);\ (B) = x165_->ag_ptr;\ } #define DESTROY_CONS_err(D, A, B, C)\ {\ c_class *x166_ = CHECK_NULL (C);\ (A) = DEREF_err (x166_ + 1);\ (B) = x166_->ag_ptr;\ (D) (x166_, 2u);\ } #define PUSH_err(A, B)\ {\ c_class **r167_ = &(B);\ c_class *x167_ = GEN_c_class ( 2, TYPEID_stack );\ COPY_err (x167_ + 1, (A));\ x167_->ag_ptr = *r167_;\ *r167_ = x167_;\ } #define POP_err(A, B)\ {\ c_class **r168_ = &(B);\ c_class *x168_ = CHECK_NULL (*r168_);\ (A) = DEREF_err (x168_ + 1);\ *r168_ = x168_->ag_ptr;\ destroy_c_class (x168_, 2u);\ } /* Maximum allocation size */ #define c_class_GEN_MAX 20 #endif