/*
* Copyright (c) 2003, The Tendra Project <http://www.ten15.org/>
* 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
syntax highlighted by Code2HTML, v. 0.9.1