Subversion Repositories tendra.SVN

/*

    		 Crown Copyright (c) 1997

    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.

*/

/*

    AUTOMATICALLY GENERATED FROM ALGEBRA calculus (VERSION 1.2)

    BY calculus (VERSION 1.2)

*/

#ifndef CALCULUS_H_INCLUDED

#define CALCULUS_H_INCLUDED

#ifndef calculus_NAME

#define calculus_NAME			"calculus"

#define calculus_VERSION		"1.2"

#define calculus_SPECIFICATION		0

#define calculus_IMPLEMENTATION		1

#endif

/* Prototype macros */

#ifndef CONST_S

#define CONST_S

#endif

/* Primitive types */

typedef unsigned long number;

typedef char * string;

/* Basic types */

typedef union calculus_tag {

    unsigned ag_tag;

    union calculus_tag *ag_ptr;

    unsigned ag_enum;

    unsigned long ag_long_enum;

    int ag_prim_int;

    number ag_prim_number;

    string ag_prim_string;

} calculus;

typedef calculus *calculus_PTR;

#ifndef calculus_DESTR_DEFINED

#define calculus_DESTR_DEFINED

typedef void (*DESTROYER)(calculus *, unsigned);

#endif

#define PTR(A)	calculus_PTR

#define LIST(A)	calculus_PTR

#define STACK(A)	calculus_PTR

#define SIZE(A)	int

/* Assertion macros */

#ifdef ASSERTS

extern calculus *check_null_calculus(calculus *, char *, int);

extern calculus *check_tag_calculus(calculus *, unsigned, char *, int);

extern calculus *check_tag_etc_calculus(calculus *, unsigned, unsigned, char *, int);

#define CHECK_NULL(P)\

    (check_null_calculus((P), __FILE__, __LINE__))

#define CHECK_TAG(P, N)\

    (check_tag_calculus((P), (unsigned)(N), __FILE__, __LINE__))

#define CHECK_TAG_ETC(P, L, U)\

    (check_tag_etc_calculus((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 */

/* Union type definitions */

typedef calculus *TYPE;

typedef calculus *COMMAND;

/* Structure declarations */

typedef struct alg_tag ALGEBRA_DEFN;

typedef struct cid_tag CLASS_ID;

typedef struct prim_tag PRIMITIVE;

typedef struct ec_tag ECONST;

typedef struct en_tag ENUM;

typedef struct ident_tag IDENTITY;

typedef struct cmp_tag COMPONENT;

typedef struct str_tag STRUCTURE;

typedef struct fld_tag FIELD;

typedef struct arg_tag ARGUMENT;

typedef struct map_tag MAP;

typedef struct un_tag UNION;

/* Identity type definitions */

typedef string name_string;

typedef int zero_int;

typedef PTR(int) int_P;

typedef PTR(number) number_P;

typedef PTR(string) string_P;

typedef PTR(ARGUMENT) ARGUMENT_P;

typedef PTR(CLASS_ID) CLASS_ID_P;

typedef PTR(CLASS_ID_P) CLASS_ID_P_P;

typedef PTR(COMPONENT) COMPONENT_P;

typedef PTR(ECONST) ECONST_P;

typedef PTR(ENUM) ENUM_P;

typedef PTR(FIELD) FIELD_P;

typedef PTR(IDENTITY) IDENTITY_P;

typedef PTR(MAP) MAP_P;

typedef PTR(PRIMITIVE) PRIMITIVE_P;

typedef PTR(STRUCTURE) STRUCTURE_P;

typedef PTR(TYPE) TYPE_P;

typedef PTR(TYPE_P) TYPE_P_P;

typedef PTR(UNION) UNION_P;

/* Structure definitions */

#ifndef calculus_STRUCT_DEFINED

#define calculus_STRUCT_DEFINED

struct alg_tag {

    string name;

    int major_no;

    int minor_no;

    LIST(PRIMITIVE_P) primitives;

    LIST(IDENTITY_P) identities;

    LIST(ENUM_P) enumerations;

    LIST(STRUCTURE_P) structures;

    LIST(UNION_P) unions;

    LIST(TYPE_P) types;

};

struct cid_tag {

    string name;

    string name_aux;

    int flag;

    name_string file;

    int line;

};

struct prim_tag {

    CLASS_ID_P id;

    string defn;

};

struct ec_tag {

    string name;

    number value;

};

struct en_tag {

    CLASS_ID_P id;

    LIST(ECONST_P) consts;

    number order;

    int lists;

};

struct ident_tag {

    CLASS_ID_P id;

    TYPE_P defn;

};

struct cmp_tag {

    string name;

    TYPE_P type;

    string value;

};

struct str_tag {

    CLASS_ID_P id;

    STRUCTURE_P base;

    LIST(COMPONENT_P) defn;

    zero_int output;

};

struct fld_tag {

    string name;

    int tag;

    int flag;

    int set;

    FIELD_P base;

    LIST(COMPONENT_P) defn;

};

struct arg_tag {

    string name;

    TYPE_P type;

};

struct map_tag {

    string name;

    int flag;

    TYPE_P ret_type;

    LIST(ARGUMENT_P) args;

};

struct un_tag {

    CLASS_ID_P id;

    UNION_P base;

    LIST(COMPONENT_P) s_defn;

    LIST(FIELD_P) u_defn;

    LIST(MAP_P) map;

    int no_fields;

};

#endif /* calculus_STRUCT_DEFINED */

/* Function declarations */

extern calculus *gen_calculus(unsigned);

extern void destroy_calculus(calculus *, unsigned);

extern void dummy_destroy_calculus (calculus *, unsigned);

extern void destroy_calculus_list (calculus *, unsigned);

extern calculus *append_calculus_list(calculus *, calculus *);

extern calculus *end_calculus_list(calculus *);

extern unsigned length_calculus_list(calculus *);

extern calculus *reverse_calculus_list(calculus *);

#ifdef calculus_IO_ROUTINES

extern unsigned crt_calculus_alias;

extern void set_calculus_alias(calculus *, unsigned);

extern calculus *find_calculus_alias(unsigned);

extern void clear_calculus_alias(void);

#endif

/* Run-time type information */

#ifndef GEN_calculus

#define GEN_calculus(A, B)		gen_calculus((unsigned)(A))

#endif

#define TYPEID_ptr			((unsigned)0)

#define TYPEID_list			((unsigned)1)

#define TYPEID_stack			((unsigned)2)

#define TYPEID_type			((unsigned)3)

#define TYPEID_cmd			((unsigned)4)

/* Definitions for pointers */

#define STEP_ptr(A, B)			(CHECK_NULL(A) + B)

#define SIZE_ptr(A)			1

#define NULL_ptr(A)			((calculus *)0)

#define IS_NULL_ptr(A)			((A) == 0)

#define EQ_ptr(A, B)			((A) == (B))

#define MAKE_ptr(A)			GEN_calculus((A), TYPEID_ptr)

#define DESTROY_ptr(A, B)		destroy_calculus((A), (unsigned)(B))

#define UNIQ_ptr(A)			GEN_calculus(1, TYPEID_ptr)

#define DESTROY_UNIQ_ptr(A)		destroy_calculus((A), (unsigned)1)

#ifdef calculus_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)\

    {\

	calculus *x0_ = GEN_calculus(2, TYPEID_list);\

	x0_[1].ag_ptr = (A);\

	x0_->ag_ptr = (B);\

	(C) = x0_;\

    }

#define UN_CONS_ptr(A, B, C)\

    {\

	calculus *x1_ = CHECK_NULL(C);\

	(A) = x1_[1].ag_ptr;\

	(B) = x1_->ag_ptr;\

    }

#define DESTROY_CONS_ptr(D, A, B, C)\

    {\

	calculus *x2_ = CHECK_NULL(C);\

	(A) = x2_[1].ag_ptr;\

	(B) = x2_->ag_ptr;\

	(D)(x2_, (unsigned)2);\

    }

#define PUSH_ptr(A, B)\

    {\

	calculus **r3_ = &(B);\

	calculus *x3_ = GEN_calculus(2, TYPEID_stack);\

	x3_[1].ag_ptr = (A);\

	x3_->ag_ptr = *r3_;\

	*r3_ = x3_;\

    }

#define POP_ptr(A, B)\

    {\

	calculus **r4_ = &(B);\

	calculus *x4_ = CHECK_NULL(*r4_);\

	(A) = x4_[1].ag_ptr;\

	*r4_ = x4_->ag_ptr;\

	destroy_calculus(x4_, (unsigned)2);\

    }

/* 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_calculus_list((A))

#define END_list(A)			end_calculus_list((A))

#define REVERSE_list(A)			reverse_calculus_list((A))

#define APPEND_list(A, B)		append_calculus_list((A), (B))

#define SIZE_list(A)			1

#define NULL_list(A)			((calculus *) 0)

#define IS_NULL_list(A)			((A) == 0)

#define EQ_list(A, B)			((A) == (B))

#define UNIQ_list(A)			GEN_calculus(1, TYPEID_list)

#define DESTROY_UNIQ_list(A)		destroy_calculus((A), (unsigned)1)

#ifdef calculus_IO_ROUTINES

#define VOIDSTAR_list(A)		((void *)(A))

#endif

#define DESTROY_list(A, B)\

    {\

	destroy_calculus_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)\

    {\

	calculus *x5_ = GEN_calculus(2, TYPEID_list);\

	x5_[1].ag_ptr = (A);\

	x5_->ag_ptr = (B);\

	(C) = x5_;\

    }

#define UN_CONS_list(A, B, C)\

    {\

	calculus *x6_ = CHECK_NULL(C);\

	(A) = x6_[1].ag_ptr;\

	(B) = x6_->ag_ptr;\

    }

#define DESTROY_CONS_list(D, A, B, C)\

    {\

	calculus *x7_ = CHECK_NULL(C);\

	(A) = x7_[1].ag_ptr;\

	(B) = x7_->ag_ptr;\

	(D)(x7_, (unsigned)2);\

    }

#define PUSH_list(A, B)\

    {\

	calculus **r8_ = &(B);\

	calculus *x8_ = GEN_calculus(2, TYPEID_stack);\

	x8_[1].ag_ptr = (A);\

	x8_->ag_ptr = *r8_;\

	*r8_ = x8_;\

    }

#define POP_list(A, B)\

    {\

	calculus **r9_ = &(B);\

	calculus *x9_ = CHECK_NULL(*r9_);\

	(A) = x9_[1].ag_ptr;\

	*r9_ = x9_->ag_ptr;\

	destroy_calculus(x9_, (unsigned)2);\

    }

/* Definitions for stacks */

#define SIZE_stack(A)			1

#define NULL_stack(A)			((calculus *) 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)\

    {\

	calculus *x10_ = GEN_calculus(2, TYPEID_list);\

	x10_[1].ag_ptr = (A);\

	x10_->ag_ptr = (B);\

	(C) = x10_;\

    }

#define UN_CONS_stack(A, B, C)\

    {\

	calculus *x11_ = CHECK_NULL(C);\

	(A) = x11_[1].ag_ptr;\

	(B) = x11_->ag_ptr;\

    }

#define DESTROY_CONS_stack(D, A, B, C)\

    {\

	calculus *x12_ = CHECK_NULL(C);\

	(A) = x12_[1].ag_ptr;\

	(B) = x12_->ag_ptr;\

	(D)(x12_, (unsigned)2);\

    }

#define PUSH_stack(A, B)\

    {\

	calculus **r13_ = &(B);\

	calculus *x13_ = GEN_calculus(2, TYPEID_stack);\

	x13_[1].ag_ptr = (A);\

	x13_->ag_ptr = *r13_;\

	*r13_ = x13_;\

    }

#define POP_stack(A, B)\

    {\

	calculus **r14_ = &(B);\

	calculus *x14_ = CHECK_NULL(*r14_);\

	(A) = x14_[1].ag_ptr;\

	*r14_ = x14_->ag_ptr;\

	destroy_calculus(x14_, (unsigned)2);\

    }

/* 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)\

    {\

	calculus *x15_ = GEN_calculus(2, TYPEID_list);\

	COPY_int(x15_ + 1, (A));\

	x15_->ag_ptr = (B);\

	(C) = x15_;\

    }

#define UN_CONS_int(A, B, C)\

    {\

	calculus *x16_ = CHECK_NULL(C);\

	(A) = DEREF_int(x16_ + 1);\

	(B) = x16_->ag_ptr;\

    }

#define DESTROY_CONS_int(D, A, B, C)\

    {\

	calculus *x17_ = CHECK_NULL(C);\

	(A) = DEREF_int(x17_ + 1);\

	(B) = x17_->ag_ptr;\

	(D)(x17_, (unsigned)2);\

    }

#define PUSH_int(A, B)\

    {\

	calculus **r18_ = &(B);\

	calculus *x18_ = GEN_calculus(2, TYPEID_stack);\

	COPY_int(x18_ + 1, (A));\

	x18_->ag_ptr = *r18_;\

	*r18_ = x18_;\

    }

#define POP_int(A, B)\

    {\

	calculus **r19_ = &(B);\

	calculus *x19_ = CHECK_NULL(*r19_);\

	(A) = DEREF_int(x19_ + 1);\

	*r19_ = x19_->ag_ptr;\

	destroy_calculus(x19_, (unsigned)2);\

    }

/* Definitions for primitive number */

#define SIZE_number			1

#define COPY_number(A, B)		(CHECK_NULL(A)->ag_prim_number = (B))

#define DEREF_number(A)			(CHECK_NULL(A)->ag_prim_number)

#define CONS_number(A, B, C)\

    {\

	calculus *x20_ = GEN_calculus(2, TYPEID_list);\

	COPY_number(x20_ + 1, (A));\

	x20_->ag_ptr = (B);\

	(C) = x20_;\

    }

#define UN_CONS_number(A, B, C)\

    {\

	calculus *x21_ = CHECK_NULL(C);\

	(A) = DEREF_number(x21_ + 1);\

	(B) = x21_->ag_ptr;\

    }

#define DESTROY_CONS_number(D, A, B, C)\

    {\

	calculus *x22_ = CHECK_NULL(C);\

	(A) = DEREF_number(x22_ + 1);\

	(B) = x22_->ag_ptr;\

	(D)(x22_, (unsigned)2);\

    }

#define PUSH_number(A, B)\

    {\

	calculus **r23_ = &(B);\

	calculus *x23_ = GEN_calculus(2, TYPEID_stack);\

	COPY_number(x23_ + 1, (A));\

	x23_->ag_ptr = *r23_;\

	*r23_ = x23_;\

    }

#define POP_number(A, B)\

    {\

	calculus **r24_ = &(B);\

	calculus *x24_ = CHECK_NULL(*r24_);\

	(A) = DEREF_number(x24_ + 1);\

	*r24_ = x24_->ag_ptr;\

	destroy_calculus(x24_, (unsigned)2);\

    }

/* 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)\

    {\

	calculus *x25_ = GEN_calculus(2, TYPEID_list);\

	COPY_string(x25_ + 1, (A));\

	x25_->ag_ptr = (B);\

	(C) = x25_;\

    }

#define UN_CONS_string(A, B, C)\

    {\

	calculus *x26_ = CHECK_NULL(C);\

	(A) = DEREF_string(x26_ + 1);\

	(B) = x26_->ag_ptr;\

    }

#define DESTROY_CONS_string(D, A, B, C)\

    {\

	calculus *x27_ = CHECK_NULL(C);\

	(A) = DEREF_string(x27_ + 1);\

	(B) = x27_->ag_ptr;\

	(D)(x27_, (unsigned)2);\

    }

#define PUSH_string(A, B)\

    {\

	calculus **r28_ = &(B);\

	calculus *x28_ = GEN_calculus(2, TYPEID_stack);\

	COPY_string(x28_ + 1, (A));\

	x28_->ag_ptr = *r28_;\

	*r28_ = x28_;\

    }

#define POP_string(A, B)\

    {\

	calculus **r29_ = &(B);\

	calculus *x29_ = CHECK_NULL(*r29_);\

	(A) = DEREF_string(x29_ + 1);\

	*r29_ = x29_->ag_ptr;\

	destroy_calculus(x29_, (unsigned)2);\

    }

/* Definitions for structure ALGEBRA_DEFN */

#define alg_name(P)			((P) + 0)

#define alg_major_no(P)			((P) + 1)

#define alg_minor_no(P)			((P) + 2)

#define alg_primitives(P)		((P) + 3)

#define alg_identities(P)		((P) + 4)

#define alg_enumerations(P)		((P) + 5)

#define alg_structures(P)		((P) + 6)

#define alg_unions(P)			((P) + 7)

#define alg_types(P)			((P) + 8)

#define SIZE_alg			9

#define COPY_alg(A, B)\

    {\

	calculus *x30_ = CHECK_NULL(A);\

	ALGEBRA_DEFN y30_;\

	y30_ = (B);\

	COPY_string(x30_ + 0, y30_.name);\

	COPY_int(x30_ + 1, y30_.major_no);\

	COPY_int(x30_ + 2, y30_.minor_no);\

	COPY_list(x30_ + 3, y30_.primitives);\

	COPY_list(x30_ + 4, y30_.identities);\

	COPY_list(x30_ + 5, y30_.enumerations);\

	COPY_list(x30_ + 6, y30_.structures);\

	COPY_list(x30_ + 7, y30_.unions);\

	COPY_list(x30_ + 8, y30_.types);\

    }

#define DEREF_alg(A, B)\

    {\

	calculus *x31_ = CHECK_NULL(A);\

	ALGEBRA_DEFN *y31_ = &(B);\

	y31_->name = DEREF_string(x31_ + 0);\

	y31_->major_no = DEREF_int(x31_ + 1);\

	y31_->minor_no = DEREF_int(x31_ + 2);\

	y31_->primitives = DEREF_list(x31_ + 3);\

	y31_->identities = DEREF_list(x31_ + 4);\

	y31_->enumerations = DEREF_list(x31_ + 5);\

	y31_->structures = DEREF_list(x31_ + 6);\

	y31_->unions = DEREF_list(x31_ + 7);\

	y31_->types = DEREF_list(x31_ + 8);\

    }

#define MAKE_alg(name_, major_no_, minor_no_, primitives_, identities_, enumerations_, structures_, unions_, types_, alg_)\

    {\

	calculus *x32_ = CHECK_NULL(alg_);\

	COPY_string(x32_ + 0, (name_));\

	COPY_int(x32_ + 1, (major_no_));\

	COPY_int(x32_ + 2, (minor_no_));\

	COPY_list(x32_ + 3, (primitives_));\

	COPY_list(x32_ + 4, (identities_));\

	COPY_list(x32_ + 5, (enumerations_));\

	COPY_list(x32_ + 6, (structures_));\

	COPY_list(x32_ + 7, (unions_));\

	COPY_list(x32_ + 8, (types_));\

    }

#define CONS_alg(A, B, C)\

    {\

	calculus *x33_ = GEN_calculus(10, TYPEID_list);\

	COPY_alg(x33_ + 1, (A));\

	x33_->ag_ptr = (B);\

	(C) = x33_;\

    }

#define UN_CONS_alg(A, B, C)\

    {\

	calculus *x34_ = CHECK_NULL(C);\

	DEREF_alg(x34_ + 1, (A));\

	(B) = x34_->ag_ptr;\

    }

#define DESTROY_CONS_alg(D, A, B, C)\

    {\

	calculus *x35_ = CHECK_NULL(C);\

	DEREF_alg(x35_ + 1, (A));\

	(B) = x35_->ag_ptr;\

	(D)(x35_, (unsigned)10);\

    }

#define PUSH_alg(A, B)\

    {\

	calculus **r36_ = &(B);\

	calculus *x36_ = GEN_calculus(10, TYPEID_stack);\

	COPY_alg(x36_ + 1, (A));\

	x36_->ag_ptr = *r36_;\

	*r36_ = x36_;\

    }

#define POP_alg(A, B)\

    {\

	calculus **r37_ = &(B);\

	calculus *x37_ = CHECK_NULL(*r37_);\

	DEREF_alg(x37_ + 1, (A));\

	*r37_ = x37_->ag_ptr;\

	destroy_calculus(x37_, (unsigned)10);\

    }

/* Definitions for structure CLASS_ID */

#define cid_name(P)			((P) + 0)

#define cid_name_aux(P)			((P) + 1)

#define cid_flag(P)			((P) + 2)

#define cid_file(P)			((P) + 3)

#define cid_line(P)			((P) + 4)

#define SIZE_cid			5

#define COPY_cid(A, B)\

    {\

	calculus *x38_ = CHECK_NULL(A);\

	CLASS_ID y38_;\

	y38_ = (B);\

	COPY_string(x38_ + 0, y38_.name);\

	COPY_string(x38_ + 1, y38_.name_aux);\

	COPY_int(x38_ + 2, y38_.flag);\

	COPY_string(x38_ + 3, y38_.file);\

	COPY_int(x38_ + 4, y38_.line);\

    }

#define DEREF_cid(A, B)\

    {\

	calculus *x39_ = CHECK_NULL(A);\

	CLASS_ID *y39_ = &(B);\

	y39_->name = DEREF_string(x39_ + 0);\

	y39_->name_aux = DEREF_string(x39_ + 1);\

	y39_->flag = DEREF_int(x39_ + 2);\

	y39_->file = DEREF_string(x39_ + 3);\

	y39_->line = DEREF_int(x39_ + 4);\

    }

#define MAKE_cid(name_, name_aux_, flag_, file_, line_, cid_)\

    {\

	calculus *x40_ = CHECK_NULL(cid_);\

	COPY_string(x40_ + 0, (name_));\

	COPY_string(x40_ + 1, (name_aux_));\

	COPY_int(x40_ + 2, (flag_));\

	COPY_string(x40_ + 3, (file_));\

	COPY_int(x40_ + 4, (line_));\

    }

#define CONS_cid(A, B, C)\

    {\

	calculus *x41_ = GEN_calculus(6, TYPEID_list);\

	COPY_cid(x41_ + 1, (A));\

	x41_->ag_ptr = (B);\

	(C) = x41_;\

    }

#define UN_CONS_cid(A, B, C)\

    {\

	calculus *x42_ = CHECK_NULL(C);\

	DEREF_cid(x42_ + 1, (A));\

	(B) = x42_->ag_ptr;\

    }

#define DESTROY_CONS_cid(D, A, B, C)\

    {\

	calculus *x43_ = CHECK_NULL(C);\

	DEREF_cid(x43_ + 1, (A));\

	(B) = x43_->ag_ptr;\

	(D)(x43_, (unsigned)6);\

    }

#define PUSH_cid(A, B)\

    {\

	calculus **r44_ = &(B);\

	calculus *x44_ = GEN_calculus(6, TYPEID_stack);\

	COPY_cid(x44_ + 1, (A));\

	x44_->ag_ptr = *r44_;\

	*r44_ = x44_;\

    }

#define POP_cid(A, B)\

    {\

	calculus **r45_ = &(B);\

	calculus *x45_ = CHECK_NULL(*r45_);\

	DEREF_cid(x45_ + 1, (A));\

	*r45_ = x45_->ag_ptr;\

	destroy_calculus(x45_, (unsigned)6);\

    }

/* Definitions for structure PRIMITIVE */

#define prim_id(P)			((P) + 0)

#define prim_defn(P)			((P) + 1)

#define SIZE_prim			2

#define COPY_prim(A, B)\

    {\

	calculus *x46_ = CHECK_NULL(A);\

	PRIMITIVE y46_;\

	y46_ = (B);\

	COPY_ptr(x46_ + 0, y46_.id);\

	COPY_string(x46_ + 1, y46_.defn);\

    }

#define DEREF_prim(A, B)\

    {\

	calculus *x47_ = CHECK_NULL(A);\

	PRIMITIVE *y47_ = &(B);\

	y47_->id = DEREF_ptr(x47_ + 0);\

	y47_->defn = DEREF_string(x47_ + 1);\

    }

#define MAKE_prim(id_, defn_, prim_)\

    {\

	calculus *x48_ = CHECK_NULL(prim_);\

	COPY_ptr(x48_ + 0, (id_));\

	COPY_string(x48_ + 1, (defn_));\

    }

#define CONS_prim(A, B, C)\

    {\

	calculus *x49_ = GEN_calculus(3, TYPEID_list);\

	COPY_prim(x49_ + 1, (A));\

	x49_->ag_ptr = (B);\

	(C) = x49_;\

    }

#define UN_CONS_prim(A, B, C)\

    {\

	calculus *x50_ = CHECK_NULL(C);\

	DEREF_prim(x50_ + 1, (A));\

	(B) = x50_->ag_ptr;\

    }

#define DESTROY_CONS_prim(D, A, B, C)\

    {\

	calculus *x51_ = CHECK_NULL(C);\

	DEREF_prim(x51_ + 1, (A));\

	(B) = x51_->ag_ptr;\

	(D)(x51_, (unsigned)3);\

    }

#define PUSH_prim(A, B)\

    {\

	calculus **r52_ = &(B);\