/*
 * Copyright (c) 2002-2004, 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
 *
 *  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/utilities/make_tdf/tdf.alg,v 1.2 2004/03/13 07:39:04 bp Exp $
 */

/*
 *    AUTOMATICALLY GENERATED FROM ALGEBRA tdf (VERSION 1.0)
 *    BY calculus (VERSION 1.3)
 */

#ifndef TDF_H_INCLUDED
#define	TDF_H_INCLUDED

#ifndef tdf_NAME
#define	tdf_NAME				"tdf"
#define	tdf_VERSION			"1.0"
#define	tdf_SPECIFICATION			0
#define	tdf_IMPLEMENTATION			1
#endif


/* Primitive types */

typedef char * string;


/* Basic types */

typedef union tdf_tag {
	unsigned ag_tag;
	union tdf_tag *ag_ptr;
	unsigned ag_enum;
	unsigned long ag_long_enum;
	int ag_prim_int;
	unsigned ag_prim_unsigned;
	string ag_prim_string;
} tdf;

typedef tdf *tdf_PTR;

#ifndef tdf_DESTR_DEFINED
#define	tdf_DESTR_DEFINED
typedef void (*DESTROYER) (tdf *, unsigned);
#endif

#define	PTR(A)	tdf_PTR
#define	LIST(A)	tdf_PTR
#define	STACK(A)	tdf_PTR
#define	SIZE(A)	int


/* Assertion macros */

#ifdef ASSERTS
extern tdf *check_null_tdf (tdf *, const char *, int);
extern tdf *check_tag_tdf (tdf *, unsigned, const char *, int);
extern tdf *check_tag_etc_tdf (tdf *, unsigned, unsigned, const char *, int);
#define	CHECK_NULL(P)\
	(check_null_tdf ((P), __FILE__, __LINE__))
#define	CHECK_TAG(P, N)\
	(check_tag_tdf ((P), (unsigned)(N), __FILE__, __LINE__))
#define	CHECK_TAG_ETC(P, L, U)\
	(check_tag_etc_tdf ((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 tdf *PARAMETER;
typedef tdf *CONSTRUCT;
typedef tdf *SORT_INFO;
typedef tdf *SORT;
typedef tdf *LINKAGE;
typedef tdf *SPECIFICATION;
typedef tdf *COMMAND;


/* Structure declarations */



/* Identity type definitions */



/* Structure definitions */

#ifndef tdf_STRUCT_DEFINED
#define	tdf_STRUCT_DEFINED

#endif /* tdf_STRUCT_DEFINED */


/* Function declarations */

extern tdf *gen_tdf (unsigned);
extern void destroy_tdf (tdf *, unsigned);
extern void dummy_destroy_tdf (tdf *, unsigned);
extern void destroy_tdf_list (tdf *, unsigned);
extern tdf *append_tdf_list (tdf *,tdf *);
extern tdf *end_tdf_list (tdf *);
extern unsigned length_tdf_list (tdf *);
extern tdf *reverse_tdf_list (tdf *);
#ifdef tdf_IO_ROUTINES
extern unsigned crt_tdf_alias;
extern void set_tdf_alias (tdf *, unsigned);
extern tdf *find_tdf_alias (unsigned);
extern void clear_tdf_alias (void);
#endif


/* Run-time type information */

#ifndef GEN_tdf
#define	GEN_tdf(A, B)			gen_tdf ((unsigned)(A))
#endif
#define	TYPEID_ptr			0u
#define	TYPEID_list			1u
#define	TYPEID_stack			2u
#define	TYPEID_par				3u
#define	TYPEID_cons				4u
#define	TYPEID_info				5u
#define	TYPEID_sort				6u
#define	TYPEID_link				7u
#define	TYPEID_spec				8u
#define	TYPEID_cmd				9u


/* Definitions for pointers */

#define	STEP_ptr(A, B)			(CHECK_NULL (A) + B)
#define	SIZE_ptr(A)			1
#define	NULL_ptr(A)			((tdf *)0)
#define	IS_NULL_ptr(A)			((A) == 0)
#define	EQ_ptr(A, B)			((A) == (B))
#define	MAKE_ptr(A)			GEN_tdf ((A), TYPEID_ptr)
#define	DESTROY_ptr(A, B)		destroy_tdf ((A), (unsigned)(B))
#define	UNIQ_ptr(A)			GEN_tdf ( 1, TYPEID_ptr )
#define	DESTROY_UNIQ_ptr(A)		destroy_tdf ((A), 1u)
#ifdef tdf_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)\
	{\
		tdf *x0_ = GEN_tdf ( 2, TYPEID_list );\
		x0_[1].ag_ptr = (A);\
		x0_->ag_ptr = (B);\
		(C) = x0_;\
	}

#define	UN_CONS_ptr(A, B, C)\
	{\
		tdf *x1_ = CHECK_NULL (C);\
		(A) = x1_[1].ag_ptr;\
		(B) = x1_->ag_ptr;\
	}

#define	DESTROY_CONS_ptr(D, A, B, C)\
	{\
		tdf *x2_ = CHECK_NULL (C);\
		(A) = x2_[1].ag_ptr;\
		(B) = x2_->ag_ptr;\
		(D) (x2_, 2u);\
	}

#define	PUSH_ptr(A, B)\
	{\
		tdf **r3_ = &(B);\
		tdf *x3_ = GEN_tdf ( 2, TYPEID_stack );\
		x3_[1].ag_ptr = (A);\
		x3_->ag_ptr = *r3_;\
		*r3_ = x3_;\
	}

#define	POP_ptr(A, B)\
	{\
		tdf **r4_ = &(B);\
		tdf *x4_ = CHECK_NULL (*r4_);\
		(A) = x4_[1].ag_ptr;\
		*r4_ = x4_->ag_ptr;\
		destroy_tdf (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_tdf_list ((A))
#define	END_list(A)			end_tdf_list ((A))
#define	REVERSE_list(A)			reverse_tdf_list ((A))
#define	APPEND_list(A, B)		append_tdf_list ((A), (B))

#define	SIZE_list(A)			1
#define	NULL_list(A)			((tdf *) 0)
#define	IS_NULL_list(A)			((A) == 0)
#define	EQ_list(A, B)			((A) == (B))
#define	UNIQ_list(A)			GEN_tdf ( 1, TYPEID_list )
#define	DESTROY_UNIQ_list(A)		destroy_tdf ((A), 1u)
#ifdef tdf_IO_ROUTINES
#define	VOIDSTAR_list(A)		((void *) (A))
#endif

#define	DESTROY_list(A, B)\
	{\
		destroy_tdf_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)\
	{\
		tdf *x5_ = GEN_tdf ( 2, TYPEID_list );\
		x5_[1].ag_ptr = (A);\
		x5_->ag_ptr = (B);\
		(C) = x5_;\
	}

#define	UN_CONS_list(A, B, C)\
	{\
		tdf *x6_ = CHECK_NULL (C);\
		(A) = x6_[1].ag_ptr;\
		(B) = x6_->ag_ptr;\
	}

#define	DESTROY_CONS_list(D, A, B, C)\
	{\
		tdf *x7_ = CHECK_NULL (C);\
		(A) = x7_[1].ag_ptr;\
		(B) = x7_->ag_ptr;\
		(D) (x7_, 2u);\
	}

#define	PUSH_list(A, B)\
	{\
	tdf **r8_ = &(B);\
		tdf *x8_ = GEN_tdf ( 2, TYPEID_stack );\
		x8_[1].ag_ptr = (A);\
		x8_->ag_ptr = *r8_;\
		*r8_ = x8_;\
	}

#define	POP_list(A, B)\
	{\
		tdf **r9_ = &(B);\
		tdf *x9_ = CHECK_NULL (*r9_);\
		(A) = x9_[1].ag_ptr;\
		*r9_ = x9_->ag_ptr;\
		destroy_tdf (x9_, 2u);\
	}


/* Definitions for stacks */

#define	SIZE_stack(A)			1
#define	NULL_stack(A)			((tdf *) 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)\
	{\
		tdf *x10_ = GEN_tdf ( 2, TYPEID_list );\
		x10_[1].ag_ptr = (A);\
		x10_->ag_ptr = (B);\
		(C) = x10_;\
	}

#define	UN_CONS_stack(A, B, C)\
	{\
		tdf *x11_ = CHECK_NULL (C);\
		(A) = x11_[1].ag_ptr;\
		(B) = x11_->ag_ptr;\
	}

#define	DESTROY_CONS_stack(D, A, B, C)\
	{\
		tdf *x12_ = CHECK_NULL (C);\
		(A) = x12_[1].ag_ptr;\
		(B) = x12_->ag_ptr;\
		(D) (x12_, 2u);\
	}

#define	PUSH_stack(A, B)\
	{\
	tdf **r13_ = &(B);\
		tdf *x13_ = GEN_tdf ( 2, TYPEID_stack );\
		x13_[1].ag_ptr = (A);\
		x13_->ag_ptr = *r13_;\
		*r13_ = x13_;\
	}

#define	POP_stack(A, B)\
	{\
		tdf **r14_ = &(B);\
		tdf *x14_ = CHECK_NULL (*r14_);\
		(A) = x14_[1].ag_ptr;\
		*r14_ = x14_->ag_ptr;\
		destroy_tdf (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)\
	{\
		tdf *x15_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_int (x15_ + 1, (A));\
		x15_->ag_ptr = (B);\
		(C) = x15_;\
	}

#define	UN_CONS_int(A, B, C)\
	{\
		tdf *x16_ = CHECK_NULL (C);\
		(A) = DEREF_int (x16_ + 1);\
		(B) = x16_->ag_ptr;\
	}

#define	DESTROY_CONS_int(D, A, B, C)\
	{\
		tdf *x17_ = CHECK_NULL (C);\
		(A) = DEREF_int (x17_ + 1);\
		(B) = x17_->ag_ptr;\
		(D) (x17_, 2u);\
	}

#define	PUSH_int(A, B)\
	{\
		tdf **r18_ = &(B);\
		tdf *x18_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_int (x18_ + 1, (A));\
		x18_->ag_ptr = *r18_;\
		*r18_ = x18_;\
	}

#define	POP_int(A, B)\
	{\
		tdf **r19_ = &(B);\
		tdf *x19_ = CHECK_NULL (*r19_);\
		(A) = DEREF_int (x19_ + 1);\
		*r19_ = x19_->ag_ptr;\
		destroy_tdf (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)\
	{\
		tdf *x20_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_unsigned (x20_ + 1, (A));\
		x20_->ag_ptr = (B);\
		(C) = x20_;\
	}

#define	UN_CONS_unsigned(A, B, C)\
	{\
		tdf *x21_ = CHECK_NULL (C);\
		(A) = DEREF_unsigned (x21_ + 1);\
		(B) = x21_->ag_ptr;\
	}

#define	DESTROY_CONS_unsigned(D, A, B, C)\
	{\
		tdf *x22_ = CHECK_NULL (C);\
		(A) = DEREF_unsigned (x22_ + 1);\
		(B) = x22_->ag_ptr;\
		(D) (x22_, 2u);\
	}

#define	PUSH_unsigned(A, B)\
	{\
		tdf **r23_ = &(B);\
		tdf *x23_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_unsigned (x23_ + 1, (A));\
		x23_->ag_ptr = *r23_;\
		*r23_ = x23_;\
	}

#define	POP_unsigned(A, B)\
	{\
		tdf **r24_ = &(B);\
		tdf *x24_ = CHECK_NULL (*r24_);\
		(A) = DEREF_unsigned (x24_ + 1);\
		*r24_ = x24_->ag_ptr;\
		destroy_tdf (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)\
	{\
		tdf *x25_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_string (x25_ + 1, (A));\
		x25_->ag_ptr = (B);\
		(C) = x25_;\
	}

#define	UN_CONS_string(A, B, C)\
	{\
		tdf *x26_ = CHECK_NULL (C);\
		(A) = DEREF_string (x26_ + 1);\
		(B) = x26_->ag_ptr;\
	}

#define	DESTROY_CONS_string(D, A, B, C)\
	{\
		tdf *x27_ = CHECK_NULL (C);\
		(A) = DEREF_string (x27_ + 1);\
		(B) = x27_->ag_ptr;\
		(D) (x27_, 2u);\
	}

#define	PUSH_string(A, B)\
	{\
		tdf **r28_ = &(B);\
		tdf *x28_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_string (x28_ + 1, (A));\
		x28_->ag_ptr = *r28_;\
		*r28_ = x28_;\
	}

#define	POP_string(A, B)\
	{\
		tdf **r29_ = &(B);\
		tdf *x29_ = CHECK_NULL (*r29_);\
		(A) = DEREF_string (x29_ + 1);\
		*r29_ = x29_->ag_ptr;\
		destroy_tdf (x29_, 2u);\
	}


/* Definitions for union PARAMETER */

#define	ORDER_par				1u
#define	SIZE_par				1
#define	NULL_par				((PARAMETER) 0)
#define	IS_NULL_par(A)			((A) == 0)
#define	EQ_par(A, B)			((A) == (B))

#define	COPY_par(A, B)			(CHECK_NULL (A)->ag_ptr = (B))
#define	DEREF_par(A)			(CHECK_NULL (A)->ag_ptr)

#define	CONS_par(A, B, C)\
	{\
		tdf *x30_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_par (x30_ + 1, (A));\
		x30_->ag_ptr = (B);\
		(C) = x30_;\
	}

#define	UN_CONS_par(A, B, C)\
	{\
		tdf *x31_ = CHECK_NULL (C);\
		(A) = DEREF_par (x31_ + 1);\
		(B) = x31_->ag_ptr;\
	}

#define	DESTROY_CONS_par(D, A, B, C)\
	{\
		tdf *x32_ = CHECK_NULL (C);\
		(A) = DEREF_par (x32_ + 1);\
		(B) = x32_->ag_ptr;\
		(D) (x32_, 2u);\
	}

#define	PUSH_par(A, B)\
	{\
		tdf **r33_ = &(B);\
		tdf *x33_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_par (x33_ + 1, (A));\
		x33_->ag_ptr = *r33_;\
		*r33_ = x33_;\
	}

#define	POP_par(A, B)\
	{\
		tdf **r34_ = &(B);\
		tdf *x34_ = CHECK_NULL (*r34_);\
		(A) = DEREF_par (x34_ + 1);\
		*r34_ = x34_->ag_ptr;\
		destroy_tdf (x34_, 2u);\
	}


/* Definitions for union CONSTRUCT */

#define	ORDER_cons				1u
#define	SIZE_cons				1
#define	NULL_cons				((CONSTRUCT) 0)
#define	IS_NULL_cons(A)			((A) == 0)
#define	EQ_cons(A, B)			((A) == (B))

#define	COPY_cons(A, B)			(CHECK_NULL (A)->ag_ptr = (B))
#define	DEREF_cons(A)			(CHECK_NULL (A)->ag_ptr)

#define	CONS_cons(A, B, C)\
	{\
		tdf *x35_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_cons (x35_ + 1, (A));\
		x35_->ag_ptr = (B);\
		(C) = x35_;\
	}

#define	UN_CONS_cons(A, B, C)\
	{\
		tdf *x36_ = CHECK_NULL (C);\
		(A) = DEREF_cons (x36_ + 1);\
		(B) = x36_->ag_ptr;\
	}

#define	DESTROY_CONS_cons(D, A, B, C)\
	{\
		tdf *x37_ = CHECK_NULL (C);\
		(A) = DEREF_cons (x37_ + 1);\
		(B) = x37_->ag_ptr;\
		(D) (x37_, 2u);\
	}

#define	PUSH_cons(A, B)\
	{\
		tdf **r38_ = &(B);\
		tdf *x38_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_cons (x38_ + 1, (A));\
		x38_->ag_ptr = *r38_;\
		*r38_ = x38_;\
	}

#define	POP_cons(A, B)\
	{\
		tdf **r39_ = &(B);\
		tdf *x39_ = CHECK_NULL (*r39_);\
		(A) = DEREF_cons (x39_ + 1);\
		*r39_ = x39_->ag_ptr;\
		destroy_tdf (x39_, 2u);\
	}


/* Definitions for union SORT_INFO */

#define	ORDER_info				6u
#define	SIZE_info				1
#define	NULL_info				((SORT_INFO) 0)
#define	IS_NULL_info(A)			((A) == 0)
#define	EQ_info(A, B)			((A) == (B))

#define	COPY_info(A, B)			(CHECK_NULL (A)->ag_ptr = (B))
#define	DEREF_info(A)			(CHECK_NULL (A)->ag_ptr)

#define	CONS_info(A, B, C)\
	{\
		tdf *x40_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_info (x40_ + 1, (A));\
		x40_->ag_ptr = (B);\
		(C) = x40_;\
	}

#define	UN_CONS_info(A, B, C)\
	{\
		tdf *x41_ = CHECK_NULL (C);\
		(A) = DEREF_info (x41_ + 1);\
		(B) = x41_->ag_ptr;\
	}

#define	DESTROY_CONS_info(D, A, B, C)\
	{\
		tdf *x42_ = CHECK_NULL (C);\
		(A) = DEREF_info (x42_ + 1);\
		(B) = x42_->ag_ptr;\
		(D) (x42_, 2u);\
	}

#define	PUSH_info(A, B)\
	{\
		tdf **r43_ = &(B);\
		tdf *x43_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_info (x43_ + 1, (A));\
		x43_->ag_ptr = *r43_;\
		*r43_ = x43_;\
	}

#define	POP_info(A, B)\
	{\
		tdf **r44_ = &(B);\
		tdf *x44_ = CHECK_NULL (*r44_);\
		(A) = DEREF_info (x44_ + 1);\
		*r44_ = x44_->ag_ptr;\
		destroy_tdf (x44_, 2u);\
	}


/* Definitions for union SORT */

#define	ORDER_sort				1u
#define	SIZE_sort				1
#define	NULL_sort				((SORT) 0)
#define	IS_NULL_sort(A)			((A) == 0)
#define	EQ_sort(A, B)			((A) == (B))

#define	COPY_sort(A, B)			(CHECK_NULL (A)->ag_ptr = (B))
#define	DEREF_sort(A)			(CHECK_NULL (A)->ag_ptr)

#define	CONS_sort(A, B, C)\
	{\
		tdf *x45_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_sort (x45_ + 1, (A));\
		x45_->ag_ptr = (B);\
		(C) = x45_;\
	}

#define	UN_CONS_sort(A, B, C)\
	{\
		tdf *x46_ = CHECK_NULL (C);\
		(A) = DEREF_sort (x46_ + 1);\
		(B) = x46_->ag_ptr;\
	}

#define	DESTROY_CONS_sort(D, A, B, C)\
	{\
		tdf *x47_ = CHECK_NULL (C);\
		(A) = DEREF_sort (x47_ + 1);\
		(B) = x47_->ag_ptr;\
		(D) (x47_, 2u);\
	}

#define	PUSH_sort(A, B)\
	{\
		tdf **r48_ = &(B);\
		tdf *x48_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_sort (x48_ + 1, (A));\
		x48_->ag_ptr = *r48_;\
		*r48_ = x48_;\
	}

#define	POP_sort(A, B)\
	{\
		tdf **r49_ = &(B);\
		tdf *x49_ = CHECK_NULL (*r49_);\
		(A) = DEREF_sort (x49_ + 1);\
		*r49_ = x49_->ag_ptr;\
		destroy_tdf (x49_, 2u);\
	}


/* Definitions for union LINKAGE */

#define	ORDER_link				1u
#define	SIZE_link				1
#define	NULL_link				((LINKAGE) 0)
#define	IS_NULL_link(A)			((A) == 0)
#define	EQ_link(A, B)			((A) == (B))

#define	COPY_link(A, B)			(CHECK_NULL (A)->ag_ptr = (B))
#define	DEREF_link(A)			(CHECK_NULL (A)->ag_ptr)

#define	CONS_link(A, B, C)\
	{\
		tdf *x50_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_link (x50_ + 1, (A));\
		x50_->ag_ptr = (B);\
		(C) = x50_;\
	}

#define	UN_CONS_link(A, B, C)\
	{\
		tdf *x51_ = CHECK_NULL (C);\
		(A) = DEREF_link (x51_ + 1);\
		(B) = x51_->ag_ptr;\
	}

#define	DESTROY_CONS_link(D, A, B, C)\
	{\
		tdf *x52_ = CHECK_NULL (C);\
		(A) = DEREF_link (x52_ + 1);\
		(B) = x52_->ag_ptr;\
		(D) (x52_, 2u);\
	}

#define	PUSH_link(A, B)\
	{\
		tdf **r53_ = &(B);\
		tdf *x53_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_link (x53_ + 1, (A));\
		x53_->ag_ptr = *r53_;\
		*r53_ = x53_;\
	}

#define	POP_link(A, B)\
	{\
		tdf **r54_ = &(B);\
		tdf *x54_ = CHECK_NULL (*r54_);\
		(A) = DEREF_link (x54_ + 1);\
		*r54_ = x54_->ag_ptr;\
		destroy_tdf (x54_, 2u);\
	}


/* Definitions for union SPECIFICATION */

#define	ORDER_spec				1u
#define	SIZE_spec				1
#define	NULL_spec				((SPECIFICATION) 0)
#define	IS_NULL_spec(A)			((A) == 0)
#define	EQ_spec(A, B)			((A) == (B))

#define	COPY_spec(A, B)			(CHECK_NULL (A)->ag_ptr = (B))
#define	DEREF_spec(A)			(CHECK_NULL (A)->ag_ptr)

#define	CONS_spec(A, B, C)\
	{\
		tdf *x55_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_spec (x55_ + 1, (A));\
		x55_->ag_ptr = (B);\
		(C) = x55_;\
	}

#define	UN_CONS_spec(A, B, C)\
	{\
		tdf *x56_ = CHECK_NULL (C);\
		(A) = DEREF_spec (x56_ + 1);\
		(B) = x56_->ag_ptr;\
	}

#define	DESTROY_CONS_spec(D, A, B, C)\
	{\
		tdf *x57_ = CHECK_NULL (C);\
		(A) = DEREF_spec (x57_ + 1);\
		(B) = x57_->ag_ptr;\
		(D) (x57_, 2u);\
	}

#define	PUSH_spec(A, B)\
	{\
		tdf **r58_ = &(B);\
		tdf *x58_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_spec (x58_ + 1, (A));\
		x58_->ag_ptr = *r58_;\
		*r58_ = x58_;\
	}

#define	POP_spec(A, B)\
	{\
		tdf **r59_ = &(B);\
		tdf *x59_ = CHECK_NULL (*r59_);\
		(A) = DEREF_spec (x59_ + 1);\
		*r59_ = x59_->ag_ptr;\
		destroy_tdf (x59_, 2u);\
	}


/* Definitions for union COMMAND */

#define	ORDER_cmd				6u
#define	SIZE_cmd				1
#define	NULL_cmd				((COMMAND) 0)
#define	IS_NULL_cmd(A)			((A) == 0)
#define	EQ_cmd(A, B)			((A) == (B))

#define	COPY_cmd(A, B)			(CHECK_NULL (A)->ag_ptr = (B))
#define	DEREF_cmd(A)			(CHECK_NULL (A)->ag_ptr)

#define	CONS_cmd(A, B, C)\
	{\
		tdf *x60_ = GEN_tdf ( 2, TYPEID_list );\
		COPY_cmd (x60_ + 1, (A));\
		x60_->ag_ptr = (B);\
		(C) = x60_;\
	}

#define	UN_CONS_cmd(A, B, C)\
	{\
		tdf *x61_ = CHECK_NULL (C);\
		(A) = DEREF_cmd (x61_ + 1);\
		(B) = x61_->ag_ptr;\
	}

#define	DESTROY_CONS_cmd(D, A, B, C)\
	{\
		tdf *x62_ = CHECK_NULL (C);\
		(A) = DEREF_cmd (x62_ + 1);\
		(B) = x62_->ag_ptr;\
		(D) (x62_, 2u);\
	}

#define	PUSH_cmd(A, B)\
	{\
		tdf **r63_ = &(B);\
		tdf *x63_ = GEN_tdf ( 2, TYPEID_stack );\
		COPY_cmd (x63_ + 1, (A));\
		x63_->ag_ptr = *r63_;\
		*r63_ = x63_;\
	}

#define	POP_cmd(A, B)\
	{\
		tdf **r64_ = &(B);\
		tdf *x64_ = CHECK_NULL (*r64_);\
		(A) = DEREF_cmd (x64_ + 1);\
		*r64_ = x64_->ag_ptr;\
		destroy_tdf (x64_, 2u);\
	}


/* Maximum allocation size */

#define	tdf_GEN_MAX			10

#endif