cp/ps/modem/psbase/inc/sctpred.h

/* ANP: Assumption: host system defines 'XENV' and 'SDL_SIMULATION'. This is true in UMTS case. */
/* To find the 'else' and 'endif' clause search for: 'SDTENV && SDL_SIMULATION'                   */

/******************************************************************************
*
*                               (C) Danish Wireless Design
*
* $RCSfile: sctpred.h,v $
*
* $Author: pbo $
* $Revision: 1.4 $
* $Date: 2001/07/18 13:01:54 $
*
* Description:
*
*******************************************************************************/

#ifndef X_SCTPRED_H
#define X_SCTPRED_H


/* This file contains implementation of the predefined data types
   except PId. The functions defined here can be found in the file
   sctpred.c.
*/

/*
FILE INDEX
00   Some utility macros
01   Typedef, Default value, Literals
02   Prototypes and macros for the operators of the data types
03   Read and Write functions
04   Generator String
05   Generator Array  (array that cannot become array in C)
06   Generator Powerset  (limited and discrete component type)
07   Generator Powerset  (general component type)
*/

/****+***************************************************************
00   Some utility macros
********************************************************************/

/* Macros used in the generator implementations */

#ifndef XENUM_TYPE
#define XENUM_TYPE int
#endif

#ifndef XNOUSE_OPFUNCS
#define T_SDL_OPFUNCS(P) , P
#else
#define T_SDL_OPFUNCS(P)
#endif


#ifdef XECSOP
#define xReportStringError(S1,S2)   xSDLOpError(S1,S2);
#else
#define xReportStringError(S1,S2)
#endif


/****+***************************************************************
01   Typedef, Default value, Literals
********************************************************************/
/****+***************************************************************
     NEW FOR TAU 4.2
********************************************************************/
/*
FILE INDEX
01   Assignment macros
02   SDL predefined data types
03   Utility functions
04   Read and Write functions
*/

#ifndef xOffsetOf
#define xOffsetOf(type, field)  ((xptrint) &((type *) 0)->field)
#endif

/****+***************************************************************
     Type info nodes
********************************************************************/
/*---+---------------------------------------------------------------
     Boolean
-------------------------------------------------------------------*/
/*xlb20080717
#if !defined(X_COMPACT_BOOL)
typedef int     SDL_boolean;
#else
typedef unsigned char     SDL_boolean;
#endif
*/
#define xDef_SDL_Boolean(V)       (*(V) = (SDL_Boolean)0)
#define yDef_SDL_Boolean(V)       xDef_SDL_Boolean(V)
#define yAssF_SDL_Boolean(V,E,A)  (V = E)
#define yEqF_SDL_Boolean(E1,E2)   ((E1) == (E2))
#define yNEqF_SDL_Boolean(E1,E2)  ((E1) != (E2))
#define ySrtN_SDL_Boolean         xSrtN_SDL_Boolean

#define SDL_False 0
#define SDL_false 0
#define SDL_True  1
#define SDL_true  1


/*---+---------------------------------------------------------------
     Character
-------------------------------------------------------------------*/

typedef char    SDL_Character;
typedef char    SDL_character;

#define xDef_SDL_Character(V)       (*(V) = '\000')
#define yDef_SDL_Character(V)       xDef_SDL_Character(V)
#define yAssF_SDL_Character(V,E,A)  (V = E)
#define yEqF_SDL_Character(E1,E2)   ((E1) == (E2))
#define yNEqF_SDL_Character(E1,E2)  ((E1) != (E2))
#define ySrtN_SDL_Character         xSrtN_SDL_Character

/* predefined literals for non-printable characters,
   other literals as in C */
#define SDL_NUL '\000'
#define SDL_SOH '\001'
#define SDL_STX '\002'
#define SDL_ETX '\003'
#define SDL_EOT '\004'
#define SDL_ENQ '\005'
#define SDL_ACK '\006'
#define SDL_BEL '\007'
#define SDL_BS  '\010'
#define SDL_HT  '\011'
#define SDL_LF  '\012'
#define SDL_VT  '\013'
#define SDL_FF  '\014'
#define SDL_CR  '\015'
#define SDL_SO  '\016'
#define SDL_SI  '\017'
#define SDL_DLE '\020'
#define SDL_DC1 '\021'
#define SDL_DC2 '\022'
#define SDL_DC3 '\023'
#define SDL_DC4 '\024'
#define SDL_NAK '\025'
#define SDL_SYN '\026'
#define SDL_ETB '\027'
#define SDL_CAN '\030'
#define SDL_EM  '\031'
#define SDL_SUB '\032'
#define SDL_ESC '\033'
#define SDL_IS4 '\034'
#define SDL_IS3 '\035'
#define SDL_IS2 '\036'
#define SDL_IS1 '\037'
#define SDL_DEL '\177'
#define SDL_E_NUL '\200'
#define SDL_E_SOH '\201'
#define SDL_E_STX '\202'
#define SDL_E_ETX '\203'
#define SDL_E_EOT '\204'
#define SDL_E_ENQ '\205'
#define SDL_E_ACK '\206'
#define SDL_E_BEL '\207'
#define SDL_E_BS  '\210'
#define SDL_E_HT  '\211'
#define SDL_E_LF  '\212'
#define SDL_E_VT  '\213'
#define SDL_E_FF  '\214'
#define SDL_E_CR  '\215'
#define SDL_E_SO  '\216'
#define SDL_E_SI  '\217'
#define SDL_E_DLE '\220'
#define SDL_E_DC1 '\221'
#define SDL_E_DC2 '\222'
#define SDL_E_DC3 '\223'
#define SDL_E_DC4 '\224'
#define SDL_E_NAK '\225'
#define SDL_E_SYN '\226'
#define SDL_E_ETB '\227'
#define SDL_E_CAN '\230'
#define SDL_E_EM  '\231'
#define SDL_E_SUB '\232'
#define SDL_E_ESC '\233'
#define SDL_E_IS4 '\234'
#define SDL_E_IS3 '\235'
#define SDL_E_IS2 '\236'
#define SDL_E_IS1 '\237'


/*---+---------------------------------------------------------------
     Null
-------------------------------------------------------------------*/

typedef LONG     SDL_Null;

#define xDef_SDL_Null(V)       (*(V) = (SDL_Null)0)
#define yDef_SDL_Null(V)       xDef_SDL_Null(V)
#define yAssF_SDL_Null(V,E,A)  (V = E)
#define yEqF_SDL_Null(E1,E2)   ((E1) == (E2))
#define yNEqF_SDL_Null(E1,E2)  ((E1) != (E2))
#define ySrtN_SDL_Null         xSrtN_SDL_Null

#define SDL_NullValue  0

#ifndef ANY_SDL_Null
#define ANY_SDL_Null           (SDL_Null)0
#endif




/*---+---------------------------------------------------------------
     Charstring
-------------------------------------------------------------------*/

typedef CHAR   *SDL_Charstring;
typedef CHAR   *SDL_charstring;


#define xDef_SDL_Charstring(V)       (*(V) = (SDL_Charstring)0)
#define yDef_SDL_Charstring(V)       xDef_SDL_Charstring(V)
#define yAssF_SDL_Charstring(V,E,A) (V = E)
#define yEqF_SDL_Charstring(E1,E2)   xEq_SDL_Charstring(E1,E2)
#define yNEqF_SDL_Charstring(E1,E2)  (! xEq_SDL_Charstring(E1,E2))
#define ySrtN_SDL_Charstring         xSrtN_SDL_Charstring

#define SDL_CHARSTRING_LIT(P1, P2)   P1


/*---+---------------------------------------------------------------
     Duration
-------------------------------------------------------------------*/
#if 0
#ifndef _TIMESPEC_
#define _TIMESPEC_
typedef long      timespec;
#endif
#endif
//typedef SDL_Duration  SDL_duration;

/*Name:KangShuJie Date:2008.01.25 Reason:windows±àÒëÖÐWaringÌ«¶à*/
#ifdef _OS_WIN
extern SDL_Duration SDL_Duration_Lit(SINT32 s, SINT32 ns);
#endif
/*End KangShuJie*/
#define xDef_SDL_Duration(V)      ( *(V) = 0)
#define yDef_SDL_Duration(V)       xDef_SDL_Duration(V)
#define yAssF_SDL_Duration(V,E,A) (V = E)
#define yEqF_SDL_Duration(E1,E2)   xEq_SDL_Duration(E1,E2)
#define yNEqF_SDL_Duration(E1,E2)  (! xEq_SDL_Duration(E1,E2))
#define ySrtN_SDL_Duration         xSrtN_SDL_Duration

#define SDL_DURATION_LIT(R,I,D)    SDL_Duration_Lit(I,D)

/*Date:2008-2-19  Name: Dongzhi  Reason:½«GSMµÄTU¸ÄΪUMTSµÄTU*/
//xlb20080717#define CLOCK_TICK       10000000
//#define CLOCK_TICK       4615385      /* TDMA frame duration in ns */
#define TDMA_CLOCK_TICK  4615385      /* TDMA frame duration in ns */
#define SDT_TICKPERSEC   217          /* well, actually: 216,66664861111261574061535494872 */


/*---+---------------------------------------------------------------
     Integer
-------------------------------------------------------------------*/

#if !defined(X_LONG_INT)
typedef LONG  SDL_Integer;
typedef LONG  SDL_integer;
#else
typedef LONG  SDL_Integer;
typedef LONG  SDL_integer;
#endif

#define xDef_SDL_Integer(V)       (*(V) = (SDL_Integer)0)
#define yDef_SDL_Integer(V)       xDef_SDL_Integer(V)
#define yAssF_SDL_Integer(V,E,A)  (V = E)
#define yEqF_SDL_Integer(E1,E2)   ((E1) == (E2))
#define yNEqF_SDL_Integer(E1,E2)  ((E1) != (E2))
#define ySrtN_SDL_Integer         xSrtN_SDL_Integer

#define SDL_INTEGER_LIT(I)        I
/* Literals as in C */

#ifdef XVALIDATOR
#define xMax_SDL_Integer 2147483647
#endif


/*---+---------------------------------------------------------------
     Natural
-------------------------------------------------------------------*/

#if !defined(X_LONG_INT)
typedef LONG  SDL_Natural;
typedef LONG  SDL_natural;
#else
typedef LONG  SDL_Natural;
typedef LONG  SDL_natural;
#endif

#define xDef_SDL_Natural(V)       (*(V) = (SDL_Natural)0)
#define yDef_SDL_Natural(V)       xDef_SDL_Natural(V)
#define yAssF_SDL_Natural(V,E,A)  (V = E)
#define yEqF_SDL_Natural(E1,E2)   ((E1) == (E2))
#define yNEqF_SDL_Natural(E1,E2)  ((E1) != (E2))
#define ySrtN_SDL_Natural         xSrtN_SDL_Natural


/*---+---------------------------------------------------------------
     PId
-------------------------------------------------------------------*/

#define ySrtN_SDL_PId             xSrtN_SDL_PId
/* see sctsdl.c and scttypes.h for implementation of PId */


#ifndef XNOUSEOFREAL
/*---+---------------------------------------------------------------
     Real
-------------------------------------------------------------------*/

typedef double   SDL_Real;
typedef double   SDL_real;

#define xDef_SDL_Real(V)       (*(V) = 0.0)
#define yDef_SDL_Real(V)       xDef_SDL_Real(V)
#define yAssF_SDL_Real(V,E,A)  (V = E)
#define yEqF_SDL_Real(E1,E2)   ((E1) == (E2))
#define yNEqF_SDL_Real(E1,E2)  ((E1) != (E2))
#define ySrtN_SDL_Real         xSrtN_SDL_Real

#define SDL_REAL_LIT(R,I,D)    R
/* Literals as in C */
#endif


/*---+---------------------------------------------------------------
     Time
-------------------------------------------------------------------*/


//typedef SDL_Time  SDL_time;

#define xDef_SDL_Time(V)       (*(V) = SDL_Time_Lit(0, 0))
#define yDef_SDL_Time(V)       xDef_SDL_Time(V)
#define yAssF_SDL_Time(V,E,A)  (V = E)
#define yEqF_SDL_Time(E1,E2)   xEq_SDL_Time(E1,E2)
#define yNEqF_SDL_Time(E1,E2)  (! xEq_SDL_Time(E1,E2))
#define ySrtN_SDL_Time         xSrtN_SDL_Time

#define SDL_TIME_LIT(R,I,D)    SDL_Duration_Lit(I,D)
#define SDL_Time_Lit(I,D)      SDL_Duration_Lit(I,D)

#ifdef XVALIDATOR
extern SDL_Time xMaxTime;
#endif




/*---+---------------------------------------------------------------
     ASN1 coder and generic data model
-------------------------------------------------------------------*/

/* These types are used by the generic data model, but also by the SDL
   encoders/decoders in the old data model */

typedef enum
{
  /*SDL - standard types*/
  type_SDL_Integer=128,
  type_SDL_Real=129,
  type_SDL_Natural=130,
  type_SDL_Boolean=131,
  type_SDL_Character=132,
  type_SDL_Time=133,
  type_SDL_Duration=134,
  type_SDL_Pid=135,
  type_SDL_Charstring=136,
  type_SDL_Bit=137,
  type_SDL_Bit_string=138,
  type_SDL_Octet=139,
  type_SDL_Octet_string=140,
  type_SDL_IA5String=141,
  type_SDL_NumericString=142,
  type_SDL_PrintableString=143,
  type_SDL_VisibleString=144,
  type_SDL_NULL=145,
  type_SDL_Object_identifier=146,

  /* SDL - standard ctypes */
  type_SDL_ShortInt=150,
  type_SDL_LongInt=151,
  type_SDL_UnsignedShortInt=152,
  type_SDL_UnsignedInt=153,
  type_SDL_UnsignedLongInt=154,
  type_SDL_Float=155,
  type_SDL_Charstar=156,
  type_SDL_Voidstar=157,
  type_SDL_Voidstarstar=158,

  /* SDL - user defined types */
  type_SDL_Syntype=170,
  type_SDL_Inherits=171,
  type_SDL_Enum=172,
  type_SDL_Struct=173,
  type_SDL_Union=174,
  type_SDL_UnionC=175,
  type_SDL_Choice=176,
  type_SDL_ChoicePresent=177,
  type_SDL_Powerset=178,
  type_SDL_GPowerset=179,
  type_SDL_Bag=180,
  type_SDL_String=181,
  type_SDL_LString=182,
  type_SDL_Array=183,
  type_SDL_Carray=184,
  type_SDL_GArray=185,
  type_SDL_Own=186,
  type_SDL_Oref=187,
  type_SDL_Ref=188,
  type_SDL_Userdef=189,
  type_SDL_EmptyType=190,
  type_SDL_ComBuf=191,

  /* SDL - signals */
  type_SDL_Signal=200,
  type_SDL_SignalId=201

} tSDLTypeClass;




#ifndef T_CONST
#define T_CONST const
#endif

#ifndef T_SDL_EXTRA_COMP
#define T_SDL_EXTRA_COMP
#define T_SDL_EXTRA_VALUE
#endif

#ifndef T_SDL_USERDEF_COMP
#define T_SDL_USERDEF_COMP
#endif

#ifdef T_SDL_NAMES
#define T_SDL_Names(P) , P
#else
#define T_SDL_Names(P)
#endif

#ifdef T_SIGNAL_SDL_NAMES
#define T_Signal_SDL_Names(P) , P
#else
#define T_Signal_SDL_Names(P)
#endif

#ifdef T_SDL_INFO
#define T_SDL_Info(P) , P
#else
#define T_SDL_Info(P)
#endif

#define NEEDSFREE(P)    (((tSDLTypeInfo *)(P))->OpNeeds & (unsigned char)1)
#define NEEDSEQUAL(P)   (((tSDLTypeInfo *)(P))->OpNeeds & (unsigned char)2)
#define NEEDSASSIGN(P)  (((tSDLTypeInfo *)(P))->OpNeeds & (unsigned char)4)


/* Types used to represent a general String and GPowerset. */
typedef struct xString_ystruct  *xString_yptr;
typedef struct xString_ystruct {
  xString_yptr  Suc;
  int           Data;
} xString_yrec;
typedef struct {
  xString_yptr  First;
  xString_yptr  Last;
  int           Length;
  int           IsAssigned;
} xString_Type;

struct tSDLFuncInfo;

/* ------- General type information for SDL types ------- */
typedef T_CONST struct tSDLTypeInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
#ifndef XNOUSE_OPFUNCS
  struct tSDLFuncInfo *OpFuncs;
#endif
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
#ifdef XREADANDWRITEF
  xIdNode         FatherScope;
  xSortIdNode     SortIdNode;
#endif
} tSDLTypeInfo;


/* ------------------ Enumeration type ------------------ */

typedef T_CONST struct {
  int             LiteralValue;
  char           *LiteralName;
} tSDLEnumLiteralInfo;

typedef T_CONST struct tSDLEnumInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
#ifndef XNOUSE_OPFUNCS
  struct tSDLFuncInfo *OpFuncs;
#endif
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
#ifdef XREADANDWRITEF
  xIdNode         FatherScope;
  xSortIdNode     SortIdNode;
#endif
  tSDLTypeInfo   *CompOrFatherSort;
#ifdef XREADANDWRITEF
  int             NoOfLiterals;
  tSDLEnumLiteralInfo *LiteralList;
#endif
} tSDLEnumInfo;

/* ---------- Syntype, Inherits, Own, Oref, Ref --------- */
typedef T_CONST struct tSDLGenInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  tSDLTypeInfo   *CompOrFatherSort;
} tSDLGenInfo;


/* ---------------------- Powerset ---------------------- */
typedef T_CONST struct tSDLPowersetInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  tSDLTypeInfo   *CompSort;
  int             Length;
  int             LowestValue;
} tSDLPowersetInfo;


/* ----------------------- Struct ----------------------- */
typedef int (*tGetFunc) XPP((void *));
typedef void (*tAssFunc) XPP((void *, int));

typedef T_CONST struct {
  xptrint         OffsetPresent; /* 0 if not optional */
  void           *DefaultValue;
} tSDLFieldOptInfo;

typedef T_CONST struct {
  tGetFunc        GetTag;
  tAssFunc        AssTag;
} tSDLFieldBitFInfo;


typedef T_CONST struct {
  tSDLTypeInfo   *CompSort;
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  xptrint         Offset;        /* ~0 for bitfield */
  tSDLFieldOptInfo *ExtraInfo;
} tSDLFieldInfo;

typedef T_CONST struct tSDLStructInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  tSDLFieldInfo  *Components;
  int             NumOfComponents;
} tSDLStructInfo;


/* -------------------- Choice, Union ------------------- */
typedef T_CONST struct {
  tSDLTypeInfo        *CompSort;
#ifdef T_SDL_NAMES
  char                *Name;
#endif
} tSDLChoiceFieldInfo;

typedef T_CONST struct tSDLChoiceInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  tSDLChoiceFieldInfo *Components;
  int                  NumOfComponents;
  xptrint              OffsetToUnion;
  xptrint              TagSortSize;
} tSDLChoiceInfo;


/* ------------------- Array, CArray -------------------- */
typedef T_CONST struct tSDLArrayInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  tSDLTypeInfo   *CompSort;
  int             Length;
} tSDLArrayInfo;


/* ----------------------- GArray ----------------------- */
typedef T_CONST struct tSDLGArrayInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  tSDLTypeInfo   *IndexSort;
  tSDLTypeInfo   *CompSort;
  xptrint         yrecSize;
  xptrint         yrecIndexOffset;
  xptrint         yrecDataOffset;
  xptrint         arrayDataOffset;
} tSDLGArrayInfo;


/* ----- GPowerset, Bag, String, Object_Identifier ------ */
typedef T_CONST struct tSDLGenListInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  tSDLTypeInfo   *CompSort;
  xptrint         yrecSize;
  xptrint         yrecDataOffset;
} tSDLGenListInfo;


/* ---------------------- LString ----------------------- */
typedef T_CONST struct tSDLLStringInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  tSDLTypeInfo   *CompSort;
  int             MaxLength;
  xptrint         DataOffset;
} tSDLLStringInfo;


/* ---------------------- Userdef ----------------------- */
/* used for user defined types #ADT(T(h)) */
typedef T_CONST struct tSDLUserdefInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SDL_NAMES
  char           *Name;
#endif
  T_SDL_USERDEF_COMP
} tSDLUserdefInfo;


/* ----------------------- Signal ----------------------- */
typedef T_CONST struct {
  tSDLTypeInfo       *ParaSort;
  xptrint             Offset;
} tSDLSignalParaInfo;

typedef T_CONST struct tSDLSignalInfoS {
  tSDLTypeClass   TypeClass;
  unsigned char   OpNeeds;
  xptrint         SortSize;
  struct tSDLFuncInfo *OpFuncs;
  T_SDL_EXTRA_COMP
#ifdef T_SIGNAL_SDL_NAMES
  char           *Name;
#endif
  tSDLSignalParaInfo *Param;
  int             NoOfPara;
} tSDLSignalInfo;

typedef struct tSDLFuncInfo {
  void *(*AssFunc) XPP((void *, void *, int));
  SDL_Boolean (*EqFunc) XPP((void *, void *));
  void (*FreeFunc) XPP((void **));
} tSDLFuncInfo;


/* Types used to represent a general Bag. */
typedef struct xBag_ystruct  *xBag_yptr;
typedef struct xBag_ystruct {
  xBag_yptr     Suc;
  int           NoOfItems;
  int           Data;
} xBag_yrec;
typedef struct {
  xBag_yptr     First;
  xBag_yptr     Last;
  int           Length;
  int           IsAssigned;
} xBag_Type;


extern tSDLTypeInfo ySDL_SDL_Integer;
extern tSDLTypeInfo ySDL_SDL_Real;
extern tSDLTypeInfo ySDL_SDL_Natural;
extern tSDLTypeInfo ySDL_SDL_Boolean;
extern tSDLTypeInfo ySDL_SDL_Character;
extern tSDLTypeInfo ySDL_SDL_Time;
extern tSDLTypeInfo ySDL_SDL_Duration;
extern tSDLTypeInfo ySDL_SDL_PId;
extern tSDLTypeInfo ySDL_SDL_Charstring;
extern tSDLTypeInfo ySDL_SDL_Bit;
extern tSDLTypeInfo ySDL_SDL_Bit_String;
extern tSDLTypeInfo ySDL_SDL_Octet;
extern tSDLTypeInfo ySDL_SDL_Octet_String;
extern tSDLTypeInfo ySDL_SDL_IA5String;
extern tSDLTypeInfo ySDL_SDL_NumericString;
extern tSDLTypeInfo ySDL_SDL_PrintableString;
extern tSDLTypeInfo ySDL_SDL_VisibleString;
extern tSDLTypeInfo ySDL_SDL_Null;
extern tSDLGenListInfo ySDL_SDL_Object_Identifier;

/* End section with type info nodes */

extern LONG         GenericGetValue   XPP((DWORD, VOID *));
extern VOID        GenericSetValue   XPP((DWORD, VOID *, LONG));


/****+***************************************************************
01
********************************************************************/

/* Macros used in assign functions */

/* XASS_1_2_3 should be read:
1 = AC  : always copy
1 = MR  : may reuse (take pointer if temporary object)
1 = AR  : always reuse (take pointer)
2 = ASS : new object assigned to "variable"
2 = TMP : new object temporary
3 = FR  : call free for old value refered to by variable
3 = NF  : do not call free for old value
*/
#define XASS_AC_ASS_FR  (int)25  /* 1+8+16 */
#define XASS_MR_ASS_FR  (int)26  /* 2+8+16 */  /* = XASS */
#define XASS_AR_ASS_FR  (int)28  /* 4+8+16 */

#define XASS_AC_TMP_FR  (int)17  /* 1+0+16 */
#define XASS_MR_TMP_FR  (int)18  /* 2+0+16 */  /* = XASSMAKE */
#define XASS_AR_TMP_FR  (int)20  /* 4+0+16 */

#define XASS_AC_ASS_NF  (int)9   /* 1+8+0  */
#define XASS_MR_ASS_NF  (int)10  /* 2+8+0  */
#define XASS_AR_ASS_NF  (int)12  /* 4+8+0  */

#define XASS_AC_TMP_NF  (int)1   /* 1+0+0  */  /* = XASS2MAKE */
#define XASS_MR_TMP_NF  (int)2   /* 2+0+0  */  /* = XASSMAKE */
#define XASS_AR_TMP_NF  (int)4   /* 4+0+0  */

#define SHOULD_COPY(P)          (P & (int)1)
#define MAY_REUSE(P)            (P & (int)2)
#define SHOULD_REUSE(P)         (P & (int)4)
#define SHOULD_RESULT_BE_ASS(P) (P & (int)8)
#define SHOULD_FREE_OLD(P)      (P & (int)16)

#define SET_ASS_NF(P)           ((P & (int)15) | (int)8)
#define SET_NF(P)               (P & (int)15)



/*---+---------------------------------------------------------------
     Bit
-------------------------------------------------------------------*/

typedef BYTE SDL_Bit;

#define yAssF_SDL_Bit(V,E,A)  (V = E)
#define yEqF_SDL_Bit(E1,E2)   ((E1) == (E2))
#define yNEqF_SDL_Bit(E1,E2)  ((E1) != (E2))
#define ySrtN_SDL_Bit         xSrtN_SDL_Bit

#define SDL_BIT_LIT(I)        I

#define xNot_SDL_Bit(B)       (!(B))
#define xAnd_SDL_Bit(B1,B2)   ((B1)&(B2))
#define xOr_SDL_Bit(B1,B2)    ((B1)|(B2))
#define xXor_SDL_Bit(B1,B2)   ((B1)^(B2))
#define xImpl_SDL_Bit(B1,B2)  ((B1)<=(B2))

#ifndef ANY_SDL_Bit
#define ANY_SDL_Bit           (SDL_Bit)(GETINTRAND % 2)
#endif


/*---+---------------------------------------------------------------
     Octet
-------------------------------------------------------------------*/

typedef BYTE SDL_Octet;

#define xDef_SDL_Octet(V)       (*(V) = (SDL_Octet)0)
#define yAssF_SDL_Octet(V,E,A)  (V = E)
#define yEqF_SDL_Octet(E1,E2)   ((E1) == (E2))
#define yNEqF_SDL_Octet(E1,E2)  ((E1) != (E2))
#define ySrtN_SDL_Octet         xSrtN_SDL_Octet

extern SDL_Bit *yAddr_SDL_Octet XPP((SDL_Octet *, SDL_Integer));
extern SDL_Bit xExtr_SDL_Octet XPP((SDL_Octet, SDL_Integer));

#define xLT_SDL_Octet(B1,B2)  ((B1)<(B2))
#define xLE_SDL_Octet(B1,B2)  ((B1)<=(B2))
#define xGT_SDL_Octet(B1,B2)  ((B1)>(B2))
#define xGE_SDL_Octet(B1,B2)  ((B1)>=(B2))

#define xNot_SDL_Octet(B)       (SDL_Octet)(~(B))
#define xAnd_SDL_Octet(B1,B2)   ((B1)&(B2))
#define xOr_SDL_Octet(B1,B2)    ((B1)|(B2))
#define xXor_SDL_Octet(B1,B2)   ((B1)^(B2))
#define xImpl_SDL_Octet(B1,B2)  xNot_SDL_Octet(xAnd_SDL_Octet((B1),xNot_SDL_Octet(B2)))
#define xShiftL_SDL_Octet(B,I)  (SDL_Octet)(((B)<<(I)) & 0xFF)
#define xShiftR_SDL_Octet(B,I)  ((B)>>(I))
#define xPlus_SDL_Octet(B1,B2)  (SDL_Octet)(((B1)+(B2)) & 0xFF)
#define xMinus_SDL_Octet(B1,B2) (SDL_Octet)((B1)-(B2))
#define xMult_SDL_Octet(B1,B2)  (SDL_Octet)(((B1)*(B2)) & 0xFF)
#define xI2O_SDL_Octet(I)       (SDL_Octet)(I)
#define xO2I_SDL_Octet(B)       (SDL_Integer)(B)

#ifndef XEINTDIV
#define xDiv_SDL_Octet(B1,B2)   ((B1)/(B2))
#define xMod_SDL_Octet(B1,B2)   ((B1)%(B2))
#define xRem_SDL_Octet(B1,B2)   ((B1)%(B2))
#else
extern SDL_Octet xDiv_SDL_Octet XPP((SDL_Octet, SDL_Octet));
extern SDL_Octet xMod_SDL_Octet XPP((SDL_Octet, SDL_Octet));
extern SDL_Octet xRem_SDL_Octet XPP((SDL_Octet, SDL_Octet));
#endif

extern SDL_Octet xBitStr_SDL_Octet XPP((SDL_Charstring));
extern SDL_Octet xHexStr_SDL_Octet XPP((SDL_Charstring));

#ifndef ANY_SDL_Octet
#define ANY_SDL_Octet           (SDL_Octet)(GETINTRAND % 256)
#endif



#ifndef XNOUSEOFOCTETBITSTRING
/*---+---------------------------------------------------------------
     Bit_String
-------------------------------------------------------------------*/

typedef struct {
  int             Length;
  xbool           IsAssigned;
  unsigned char * Bits;
} SDL_Bit_String;

#define xDef_SDL_Bit_String(V) \
  {(*V).Length = 0; (*V).IsAssigned = (xbool)1; (*V).Bits = 0;}
#define yDef_SDL_Bit_String(V)       xDef_SDL_Bit_String(V)
#define yAssF_SDL_Bit_String(V,E,A)  xAss_SDL_Bit_String(&(V),E,A)
#define yEqF_SDL_Bit_String(E1,E2)   xEq_SDL_Bit_String(E1,E2)
#define yNEqF_SDL_Bit_String(E1,E2)  (! xEq_SDL_Bit_String(E1,E2))
#define ySrtN_SDL_Bit_String         xSrtN_SDL_Bit_String

#define yFree_SDL_Bit_String(P)  xFree_SDL_Bit_String(P)
extern void xAss_SDL_Bit_String XPP((SDL_Bit_String *, SDL_Bit_String, int));
extern SDL_Boolean xEq_SDL_Bit_String XPP((SDL_Bit_String, SDL_Bit_String));
extern void xFree_SDL_Bit_String XPP((void **));
extern SDL_Bit * yAddr_SDL_Bit_String XPP((SDL_Bit_String *, SDL_Integer));
extern SDL_Bit xExtr_SDL_Bit_String XPP((SDL_Bit_String, SDL_Integer));
extern SDL_Bit_String xNot_SDL_Bit_String XPP((SDL_Bit_String));
extern SDL_Bit_String xAnd_SDL_Bit_String XPP((SDL_Bit_String, SDL_Bit_String));
extern SDL_Bit_String xOr_SDL_Bit_String XPP((SDL_Bit_String, SDL_Bit_String));
extern SDL_Bit_String xXor_SDL_Bit_String XPP((SDL_Bit_String, SDL_Bit_String));
extern SDL_Bit_String xImpl_SDL_Bit_String XPP((SDL_Bit_String, SDL_Bit_String));
extern SDL_Bit_String xMkString_SDL_Bit_String XPP((SDL_Bit));
extern SDL_Integer xLength_SDL_Bit_String XPP((SDL_Bit_String));
extern SDL_Bit xFirst_SDL_Bit_String XPP((SDL_Bit_String));
extern SDL_Bit xLast_SDL_Bit_String XPP((SDL_Bit_String));
extern SDL_Bit_String xConcat_SDL_Bit_String XPP((SDL_Bit_String, SDL_Bit_String));
extern SDL_Bit_String xSubString_SDL_Bit_String XPP((SDL_Bit_String, SDL_Integer, SDL_Integer));
extern SDL_Bit_String xBitStr_SDL_Bit_String XPP((SDL_Charstring));

SDL_Bit_String xHexStr_SDL_Bit_String XPP((SDL_Charstring));



#ifndef ANY_SDL_Bit_String
#define ANY_SDL_Bit_String \
   xConcat_SDL_Bit_String \
     (xMkString_SDL_Bit_String(((unsigned char)(GETINTRAND%2))), \
      xMkString_SDL_Bit_String(((unsigned char)(GETINTRAND%2))) \
     )
#endif

#endif  /* XNOUSEOFOCTETBITSTRING */


#ifndef XNOUSEOFOCTETBITSTRING
/*---+---------------------------------------------------------------
     Octet_String
-------------------------------------------------------------------*/

/* An error in the implementation of Octet_String was introduced
   in SDT 3.2, when Octet_String was first supported.
   Octet_Strings should be indexed from 1, not from 0 as the
   SDL Suite implementation assumes. Note that Bit_Strings are indexed
   from 0. The inconsistancy between Octet_Strings and Bit_Strings
   in SDL is inherited from ASN.1.
   In SDT 3.6 this indexing error for Octet_Strings is corrected.
   To obtain the Octet_String behaviour from SDT3.2 - SDT3.5,
   OCTET_STRING_START_INDEX_0 should be defined, for example by
   uncommenting the #define below. It is not necessary to recompile
   the kernel for this to take effect.
   This change will effect the behaviour of indexing of
   Octet_Strings and the start parameter in operator SubString.
*/
/* #define OCTET_STRING_START_INDEX_0 */

typedef SDL_Bit_String SDL_Octet_String;

#define xDef_SDL_Octet_String(V) \
  {(*V).Length = 0; (*V).IsAssigned = (xbool)1; (*V).Bits = 0;}
#define yDef_SDL_Octet_String(V)       xDef_SDL_Octet_String(V)
#define yAssF_SDL_Octet_String(V,E,A)  xAss_SDL_Bit_String(&(V),E,A)
#define yEqF_SDL_Octet_String(E1,E2)   xEq_SDL_Bit_String(E1,E2)
#define yNEqF_SDL_Octet_String(E1,E2)  (! xEq_SDL_Bit_String(E1,E2))
#define ySrtN_SDL_Octet_String         xSrtN_SDL_Octet_String

#define yFree_SDL_Octet_String(P)  xFree_SDL_Bit_String(P)
#define xFree_SDL_Octet_String(P)  xFree_SDL_Bit_String(P)
#define xAss_SDL_Octet_String(V,E,A)  xAss_SDL_Bit_String(V,E,A)
#define xEq_SDL_Octet_String(V,E,A)  xEq_SDL_Bit_String(V,E,A)
#ifdef OCTET_STRING_START_INDEX_0
#define yAddr_SDL_Octet_String(B1,B2) yAddr_SDL_Bit_String(B1,B2)
#define xExtr_SDL_Octet_String(B1,B2) xExtr_SDL_Bit_String(B1,B2)
#else
#define yAddr_SDL_Octet_String(B1,B2) yAddr_SDL_Bit_String(B1,B2-1)
#define xExtr_SDL_Octet_String(B1,B2) xExtr_SDL_Bit_String(B1,B2-1)
#endif
#define xMkString_SDL_Octet_String(B)  xMkString_SDL_Bit_String(B)
#define xLength_SDL_Octet_String(B)  xLength_SDL_Bit_String(B)
#define xFirst_SDL_Octet_String(B)  xFirst_SDL_Bit_String(B)
#define xLast_SDL_Octet_String(B)  xLast_SDL_Bit_String(B)
#define xConcat_SDL_Octet_String(B1,B2)  xConcat_SDL_Bit_String(B1,B2)
#ifdef OCTET_STRING_START_INDEX_0
#define xSubString_SDL_Octet_String(B1,B2,B3)  xSubString_SDL_Bit_String(B1,B2,B3)
#else
#define xSubString_SDL_Octet_String(B1,B2,B3)  xSubString_SDL_Bit_String(B1,B2-1,B3)
#endif
extern SDL_Octet_String xBitStr_SDL_Octet_String XPP((SDL_Charstring));
extern SDL_Octet_String xHexStr_SDL_Octet_String XPP((SDL_Charstring));
extern SDL_Bit_String xBit_String_SDL_Octet_String XPP((SDL_Octet_String));
extern SDL_Octet_String xOctet_String_SDL_Octet_String XPP((SDL_Bit_String));

#ifndef ANY_SDL_Octet_String
#define ANY_SDL_Octet_String \
   xConcat_SDL_Octet_String \
     (xMkString_SDL_Octet_String(((unsigned char)(GETINTRAND%256))), \
      xMkString_SDL_Octet_String(((unsigned char)(GETINTRAND%256))) \
     )
#endif

#endif  /* XNOUSEOFOCTETBITSTRING */



/*---+---------------------------------------------------------------
     Object_Identifier
-------------------------------------------------------------------*/

typedef struct SDL_Object_Identifier_ystruct *SDL_Object_Identifier_yptr;
typedef struct SDL_Object_Identifier_ystruct {
  SDL_Object_Identifier_yptr Suc;
  SDL_Natural Data;
} SDL_Object_Identifier_yrec;
typedef struct {
  SDL_Object_Identifier_yptr First;
  SDL_Object_Identifier_yptr Last;
  int Length;
  int IsAssigned;
} SDL_Object_Identifier;

#define xDef_SDL_Object_Identifier(V) \
  {(*V).First = 0; (*V).Last = 0; (*V).Length = 0; (*V).IsAssigned = (xbool)1;}
#define yDef_SDL_Object_Identifier(V)       xDef_SDL_Object_Identifier(V)
#define yAssF_SDL_Object_Identifier(V,E,A)  yAss_SDL_Object_Identifier(&(V),E,A)
#define yEqF_SDL_Object_Identifier(E1,E2)   yEq_SDL_Object_Identifier(E1,E2)
#define yNEqF_SDL_Object_Identifier(E1,E2)  (! yEq_SDL_Object_Identifier(E1,E2))
#define ySrtN_SDL_Object_Identifier         xSrtN_SDL_Object_Identifier

extern SDL_Object_Identifier yEmptystring_SDL_Object_Identifier XPP((void));
extern SDL_Object_Identifier yMkString_SDL_Object_Identifier XPP((SDL_Natural));
extern SDL_Integer yLength_SDL_Object_Identifier XPP((SDL_Object_Identifier));
extern SDL_Natural yFirst_SDL_Object_Identifier XPP((SDL_Object_Identifier));
extern SDL_Natural yLast_SDL_Object_Identifier XPP((SDL_Object_Identifier));
extern SDL_Object_Identifier yConcat_SDL_Object_Identifier
    XPP((SDL_Object_Identifier, SDL_Object_Identifier));
extern SDL_Object_Identifier ySubString_SDL_Object_Identifier
    XPP((SDL_Object_Identifier, SDL_Integer, SDL_Integer));
extern SDL_Natural yExtr_SDL_Object_Identifier
    XPP((SDL_Object_Identifier, SDL_Integer));
extern SDL_Natural *yAddr_SDL_Object_Identifier
    XPP((SDL_Object_Identifier *, SDL_Integer));

extern void yAss_SDL_Object_Identifier
    XPP((SDL_Object_Identifier *, SDL_Object_Identifier, int));
extern SDL_Boolean yEq_SDL_Object_Identifier
    XPP((SDL_Object_Identifier, SDL_Object_Identifier));
extern void yFree_SDL_Object_Identifier XPP((void **));

#ifndef ANY_SDL_Object_Identifier
#define ANY_SDL_Object_Identifier  \
   yConcat_SDL_Object_Identifier(yMkString_SDL_Object_Identifier(ANY_SDL_Natural), \
     yMkString_SDL_Object_Identifier(ANY_SDL_Natural))
#endif


/*---+---------------------------------------------------------------
     GenericAssignSort
-------------------------------------------------------------------*/

extern void        GenericFreeSort   XPP((void **, tSDLTypeInfo *));
extern SDL_Boolean GenericEqualSort  XPP((void *, void *, tSDLTypeInfo *));
extern VOID *      GenericAssignSort XPP((VOID *, VOID *, LONG, tSDLTypeInfo *));
// #define GenericAssignSort(Addr,Expr,AssName,dummy)  *(Addr) = *(Expr)








/****+***************************************************************
02   Prototypes and macros for the operators of the data types
********************************************************************/

/*---+---------------------------------------------------------------
     yInit_Predefined
-------------------------------------------------------------------*/

#ifndef XOPTSORT
extern void yInit_Predefined XPP((void));
#endif


/*---+---------------------------------------------------------------
     Boolean
-------------------------------------------------------------------*/

#define xNot_SDL_Boolean(B)       (!(B))
#define xAnd_SDL_Boolean(B1,B2)   ((B1)&&(B2))
#define xOr_SDL_Boolean(B1,B2)    ((B1)||(B2))
#define xXor_SDL_Boolean(B1,B2)   ((B1)!=(B2))
#define xImpl_SDL_Boolean(B1,B2)  ((B1)<=(B2))
#define ANY_SDL_Boolean           (SDL_Boolean)(GETINTRAND % 2)

/*---+---------------------------------------------------------------
     Character
-------------------------------------------------------------------*/

#define xLT_SDL_Character(C1,C2)  ((C1)<(C2))
#define xLE_SDL_Character(C1,C2)  ((C1)<=(C2))
#define xGT_SDL_Character(C1,C2)  ((C1)>(C2))
#define xGE_SDL_Character(C1,C2)  ((C1)>=(C2))
#define xChr_SDL_Character(I)  ((SDL_Character)xMod_SDL_Integer(I,128))
#define xNum_SDL_Character(C)  ((SDL_Integer)C)
#define ANY_SDL_Character         xChr_SDL_Character(GETINTRAND)


/*---+---------------------------------------------------------------
     Charstring
-------------------------------------------------------------------*/

/*-- yFree_SDL_Charstring -----------------------------------------*/
#define yFree_SDL_Charstring(P)  xFree_SDL_Charstring(P)
extern void xFree_SDL_Charstring XPP((void **));
/* function in sctos.c */

/*-- xAss_SDL_Charstring ------------------------------------------*/
extern void xAss_SDL_Charstring  XPP((
  SDL_Charstring *CVar,
  SDL_Charstring  CExpr,
  int             AssType ));

/*-- xEq_SDL_Charstring -------------------------------------------*/
extern SDL_Boolean xEq_SDL_Charstring  XPP((
  SDL_Charstring C1,
  SDL_Charstring C2 ));

/*-- xMod_SDL_Charstring ------------------------------------------*/
/* No longer used by generated code */
extern SDL_Charstring xMod_SDL_Charstring XPP((
  SDL_Charstring  C,
  SDL_Integer     Index,
  SDL_Character   Value ));

/*-- yAddr_SDL_Charstring ------------------------------------------*/
extern SDL_Character * yAddr_SDL_Charstring XPP((
  SDL_Charstring *C,
  SDL_Integer     Index ));

/*-- xExtr_SDL_Charstring -----------------------------------------*/
extern SDL_Character xExtr_SDL_Charstring XPP((
  SDL_Charstring  C,
  SDL_Integer     Index ));

/*-- xMkString_SDL_Charstring -------------------------------------*/
extern SDL_Charstring xMkString_SDL_Charstring XPP((
  SDL_Character C ));

/*-- xLength_SDL_Charstring ---------------------------------------*/
extern SDL_Integer xLength_SDL_Charstring XPP((
  SDL_Charstring  C ));

/*-- xFirst_SDL_Charstring ----------------------------------------*/
extern SDL_Character xFirst_SDL_Charstring XPP((
  SDL_Charstring  C ));

/*-- xLast_SDL_Charstring -----------------------------------------*/
extern SDL_Character xLast_SDL_Charstring XPP((
  SDL_Charstring  C ));

/*-- xConcat_SDL_Charstring ---------------------------------------*/
extern SDL_Charstring xConcat_SDL_Charstring XPP((
  SDL_Charstring  C1,
  SDL_Charstring  C2 ));

/*-- xSubString_SDL_Charstring ------------------------------------*/
extern SDL_Charstring xSubString_SDL_Charstring XPP((
  SDL_Charstring  C,
  SDL_Integer     Start,
  SDL_Integer     SubLength ));

#define ANY_SDL_Charstring \
   xConcat_SDL_Charstring \
     (xMkString_SDL_Charstring( ((SDL_Character)(1+GETINTRAND%127)) ), \
      xMkString_SDL_Charstring( ((SDL_Character)(1+GETINTRAND%127)) ) \
     )


/*---+---------------------------------------------------------------
     Duration
-------------------------------------------------------------------*/

/*-- xPlus_SDL_Duration -------------------------------------------*/

#define xPlus_SDL_Duration(D1,D2) ((D1) + (D2))

/*-- xMinus_SDL_Duration ------------------------------------------*/

#define xMinus_SDL_Duration(D1,D2) ((D1) - (D2))

/*-- xMonMinus_SDL_Duration ---------------------------------------*/

#define xMonMinus_SDL_Duration(D) (-(D))

/*-- xMult_SDL_Duration -------------------------------------------*/
#ifndef XNOUSEOFREAL
extern SDL_Duration xMult_SDL_Duration  XPP((
  SDL_Duration D,
  SDL_Real     R ));
#endif

/*-- xMultRD_SDL_Duration -----------------------------------------*/
#define xMultRD_SDL_Duration(R,D) xMult_SDL_Duration(D, R)

/*-- xDiv_SDL_Duration --------------------------------------------*/
#ifndef XNOUSEOFREAL
extern SDL_Duration xDiv_SDL_Duration  XPP((
  SDL_Duration D,
  SDL_Real     R ));
#endif

#define xGT_SDL_Duration(P1, P2)  xLT_SDL_Time(P2, P1)
#define xGE_SDL_Duration(P1, P2)  xLE_SDL_Time(P2, P1)
#define xLT_SDL_Duration(P1, P2)  xLT_SDL_Time(P1, P2)
#define xLE_SDL_Duration(P1, P2)  xLE_SDL_Time(P1, P2)

/*-- xEq_SDL_Duration ---------------------------------------------*/

#define xEq_SDL_Duration(D1,D2) ((D1) == (D2))

#define ANY_SDL_Duration \
   SDL_Duration_Lit(GETINTRAND, GETINTRAND % 1000000000)


/*---+---------------------------------------------------------------
     Integer
-------------------------------------------------------------------*/

#define xMonMinus_SDL_Integer(I)   (-(I))
#define xPlus_SDL_Integer(I1,I2)   ((I1)+(I2))
#define xMinus_SDL_Integer(I1,I2)  ((I1)-(I2))
#define xMult_SDL_Integer(I1,I2)   ((I1)*(I2))

/*-- xDiv_SDL_Integer ---------------------------------------------*/
#ifdef XEINTDIV
extern SDL_Integer xDiv_SDL_Integer XPP((
  SDL_Integer  i,
  SDL_Integer  k ));
#else
#define xDiv_SDL_Integer(i,k) ((i)/(k))
#endif

/*-- xMod_SDL_Integer ---------------------------------------------*/
#define xMod_SDL_Integer(i_, k_) ((i_) % (k_))


/*-- xRem_SDL_Integer ---------------------------------------------*/
#ifdef XEINTDIV
extern SDL_Integer xRem_SDL_Integer XPP((
  SDL_Integer  i,
  SDL_Integer  k ));
#else
#define xRem_SDL_Integer(i,k) ((i)%(k))
#endif

#define xLT_SDL_Integer(I1,I2)  ((I1)<(I2))
#define xLE_SDL_Integer(I1,I2)  ((I1)<=(I2))
#define xGT_SDL_Integer(I1,I2)  ((I1)>(I2))
#define xGE_SDL_Integer(I1,I2)  ((I1)>=(I2))

/*-- xFix_SDL_Integer ---------------------------------------------*/
#ifdef XEFIXOF
extern SDL_Integer xFix_SDL_Integer XPP((
  SDL_Real     Re ));
#else
#define xFix_SDL_Integer(Re)   ((SDL_Integer)Re)
#endif

/* -- xFloat_SDL_Integer ------------------------------------------*/
#ifndef XNOUSEOFREAL
#define xFloat_SDL_Integer(I)   ((SDL_Real)I)
#endif

#define ANY_SDL_Integer         (SDL_Integer)(GETINTRAND - GETINTRAND_MAX/2)


/*---+---------------------------------------------------------------
     Natural
-------------------------------------------------------------------*/

/*-- xTest_SDL_Natural --------------------------------------------*/
#ifdef XTESTF
extern xbool xTest_SDL_Natural  XPP((
  void * N ));
#endif

/*-- xTstA_SDL_Natural --------------------------------------------*/
#ifdef XERANGE
extern SDL_Natural xTstA_SDL_Natural XPP(( SDL_Natural  N ));
#define yTstA_SDL_Natural(N)  xTstA_SDL_Natural(N)
#else
#define xTstA_SDL_Natural(N)  N
#define yTstA_SDL_Natural(N)  N
#endif

/*-- xTstI_SDL_Natural --------------------------------------------*/
#ifdef XEINDEX
extern SDL_Natural xTstI_SDL_Natural XPP(( SDL_Natural  N ));
#define yTstI_SDL_Natural(N)  xTstI_SDL_Natural(N)
#else
#define xTstI_SDL_Natural(N)  N
#define yTstI_SDL_Natural(N)  N
#endif

#define ANY_SDL_Natural         (SDL_Natural)(GETINTRAND)


/*---+---------------------------------------------------------------
     PId
-------------------------------------------------------------------*/

#define ANY_SDL_PId             SDL_NULL


/*---+---------------------------------------------------------------
     Real
-------------------------------------------------------------------*/

#define xMonMinus_SDL_Real(R)   (-(R))
#define xPlus_SDL_Real(R1,R2)   ((R1)+(R2))
#define xMinus_SDL_Real(R1,R2)  ((R1)-(R2))
#define xMult_SDL_Real(R1,R2)   ((R1)*(R2))

/*-- xDiv_SDL_Real ------------------------------------------------*/
#ifndef XNOUSEOFREAL
#ifdef XEREALDIV
extern SDL_Real xDiv_SDL_Real XPP((
  SDL_Real     i,
  SDL_Real     k ));
#else
#define xDiv_SDL_Real(i,k) ((i)/(k))
#endif
#endif

#define xLT_SDL_Real(R1,R2)  ((R1)<(R2))
#define xLE_SDL_Real(R1,R2)  ((R1)<=(R2))
#define xGT_SDL_Real(R1,R2)  ((R1)>(R2))
#define xGE_SDL_Real(R1,R2)  ((R1)>=(R2))

#define ANY_SDL_Real         (SDL_Real)(GETINTRAND - GETINTRAND_MAX/2)


/*---+---------------------------------------------------------------
     Time
-------------------------------------------------------------------*/

/*-- xPlus_SDL_Time -----------------------------------------------*/
#define xPlus_SDL_Time(P1, P2)  ((P1) + (P2))

/*-- xPlusDT_SDL_Time ---------------------------------------------*/
#define xPlusDT_SDL_Time(P1, P2)  ((P1) + (P2))

/*-- xMinusD_SDL_Time ---------------------------------------------*/
#define xMinusD_SDL_Time(P1, P2) ((P1) - (P2))

/*-- xMinusT_SDL_Time ---------------------------------------------*/
#define xMinusT_SDL_Time(P1, P2) ((P1) - (P2))

/*-- xEq_SDL_Time -------------------------------------------------*/
#define xEq_SDL_Time(P1, P2) ((P1) == (P2))

/*-- xLT_SDL_Time -------------------------------------------------*/
#define xLT_SDL_Time(T1, T2) ((T1) < (T2))

/*-- xLE_SDL_Time -------------------------------------------------*/
#define xLE_SDL_Time(T1, T2) ((T1) <= (T2))

/*-- xGT_SDL_Time -------------------------------------------------*/
#define xGT_SDL_Time(P1, P2) ((P1) > (P2))

/*-- xGE_SDL_Time -------------------------------------------------*/
#define xGE_SDL_Time(P1, P2) ((P1) >= (P2))

#define ANY_SDL_Time \
   SDL_Time_Lit(GETINTRAND, GETINTRAND % 1000000000)


/****+***************************************************************
03   Read and Write functions
********************************************************************/
#ifdef XREADANDWRITEF

/*-- xRead_SDL_Boolean --------------------------------------------*/
#define xRead_SDL_Boolean(Addr)  xReadSort(Addr, xSrtN_SDL_Boolean)

/*-- xWri_SDL_Boolean ---------------------------------------------*/
#define xWri_SDL_Boolean(Value)  xWriteSort(Value, xSrtN_SDL_Boolean)

/*-- xRead_SDL_Character ------------------------------------------*/
extern int xRead_SDL_Character XPP((void *));

/*-- xWri_SDL_Character -------------------------------------------*/
extern char * xWri_SDL_Character XPP((void *));

/*-- xRead_SDL_Charstring -----------------------------------------*/
extern int xRead_SDL_Charstring XPP((void *));

/*-- xWri_SDL_Charstring ------------------------------------------*/
extern char * xWri_SDL_Charstring XPP((void *));

/*-- xRead_SDL_Duration -------------------------------------------*/
extern int xRead_SDL_Duration XPP((void *));

/*-- xWri_SDL_Duration --------------------------------------------*/
extern char * xWri_SDL_Duration XPP((void *));

/*-- xRead_SDL_Integer --------------------------------------------*/
extern int xRead_SDL_Integer XPP((void *));

/*-- xWri_SDL_Integer ---------------------------------------------*/
extern char * xWri_SDL_Integer XPP((void *));

/*-- xRead_SDL_Real -----------------------------------------------*/
extern int xRead_SDL_Real XPP((void *));

/*-- xWri_SDL_Real ------------------------------------------------*/
extern char * xWri_SDL_Real XPP((void *));

/*-- xRead_SDL_Time -----------------------------------------------*/
extern int xRead_SDL_Time XPP((void *));

/*-- xWri_SDL_Time ------------------------------------------------*/
extern char * xWri_SDL_Time XPP((void *));



/* Help functions, also used by sctutil.c and sctmon.c */
/*-- xReadSDL_Time ------------------------------------------------*/
extern int xReadSDL_Time XPP((SDL_Time *));

/*-- xWriteSDL_Time -----------------------------------------------*/
extern char * xWriteSDL_Time XPP((SDL_Time, int));


#endif
   /* XREADANDWRITEF */



#ifndef XNO_LONG_MACROS

/****+***************************************************************
04   Generator String
********************************************************************/

/* typedef for String type ----------------------------------------*/

#define String_Type(SORT, COMPONENTSORT) \
   typedef struct XCAT(SORT,_ystruct)  * XCAT(SORT,_yptr); \
   typedef struct XCAT(SORT,_ystruct) { \
     XCAT(SORT,_yptr)   Suc; \
     COMPONENTSORT      Data; \
   } XCAT(SORT,_yrec); \
   typedef struct { \
     XCAT(SORT,_yptr) First; \
     XCAT(SORT,_yptr) Last; \
     int              Length; \
     xbool            IsAssigned; \
   } SORT;


/* String operator prototypes -------------------------------------*/

#define String_prototypes(SORT, COMPONENTSORT) \
  extern SORT XCAT(yEmptystring_,SORT) XPP((void)); \
  extern SORT XCAT(yMkString_,SORT) XPP((COMPONENTSORT)); \
  extern SDL_Integer XCAT(yLength_,SORT) XPP((SORT)); \
  extern COMPONENTSORT XCAT(yFirst_,SORT) XPP((SORT)); \
  extern COMPONENTSORT XCAT(yLast_,SORT) XPP((SORT)); \
  extern SORT XCAT(yConcat_,SORT) XPP((SORT, SORT)); \
  extern SORT XCAT(ySubString_,SORT) \
     XPP((SORT, SDL_Integer, SDL_Integer)); \
  extern COMPONENTSORT XCAT(yExtr_,SORT) XPP((SORT, SDL_Integer)); \
  extern COMPONENTSORT *XCAT(yAddr_,SORT) XPP((SORT *, SDL_Integer)); \
  \
  extern XCAT(SORT,_yptr)  XCAT(yGetAvail_,SORT) XPP((void)); \
  extern void XCAT(yAppend_,SORT) XPP((SORT *result, SORT S)); \
  \
  extern char * XCAT(yWri_,SORT) XPP((void * S)); \
  extern int XCAT(yRead_,SORT) XPP((void * Result));



/* String operator implementations --------------------------------*/

/*-- yEmptystring_SORT (String)------------------------------------*/
#define String_Emptystring(SORT, COMPONENTSORT) \
  extern SORT XCAT(yEmptystring_,SORT) XPP((void)) \
  { \
    SORT Result; \
    Result.First = (XCAT(SORT,_yptr))0; \
    Result.Last = (XCAT(SORT,_yptr))0; \
    Result.Length = 0; \
    Result.IsAssigned = (xbool)0; \
    return Result; \
  }


/*-- yMkString_SORT (String)---------------------------------------*/
#define String_MkString(SORT, COMPONENTSORT) \
  extern XCAT(SORT,_yptr) XCAT(yGetAvail_,SORT) XPP((void)) \
  { \
    XCAT(SORT,_yptr) Item; \
    if (XCAT(yAvail_,SORT) != (XCAT(SORT,_yptr))0) { \
      Item = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = XCAT(yAvail_,SORT)->Suc; \
    } else { \
      Item = (XCAT(SORT,_yptr))xAlloc((unsigned)sizeof(XCAT(SORT,_yrec))); \
    } \
    Item->Suc = (XCAT(SORT,_yptr))0; \
    XCAT(yDef_,COMPONENTSORT)(&Item->Data); \
    return Item; \
  } \
  \
  extern SORT XCAT(yMkString_,SORT) \
    XPP_PROTO( (COMPONENTSORT Component) ) \
    XPP_NOPROTO( (Component) COMPONENTSORT Component; ) \
  { \
    SORT Result; \
    Result.First = XCAT(yGetAvail_,SORT)(); \
    Result.Last = Result.First; \
    Result.Length = 1; \
    Result.IsAssigned = (xbool)0; \
    XCAT(yAssF_,COMPONENTSORT)(Result.First->Data, Component, XASS); \
    return Result; \
  }


/*-- yLength_SORT (String)-----------------------------------------*/
#define String_Length(SORT, COMPONENTSORT) \
  extern SDL_Integer XCAT(yLength_,SORT) \
    XPP_PROTO( (SORT S) ) \
    XPP_NOPROTO( (S) SORT S; ) \
  { \
    if (! S.IsAssigned && S.First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)&S); \
    } \
    return S.Length; \
  }

/*-- yFirst_SORT (String)------------------------------------------*/
#define String_First(SORT, COMPONENTSORT) \
  extern COMPONENTSORT XCAT(yFirst_,SORT) \
    XPP_PROTO( (SORT S) ) \
    XPP_NOPROTO( (S) SORT S; ) \
  { \
    COMPONENTSORT Result; \
    if (S.Length > 0) { \
      Result = S.First->Data; \
      if (! S.IsAssigned) { \
        XCAT(yFree_,SORT)((void **)&S); \
      } \
    } else { \
      xReportStringError("First in String sort", "Length is zero") \
      (void)memset((void *)(&Result), 0, sizeof(COMPONENTSORT)); \
      XCAT(yDef_,COMPONENTSORT)(&Result); \
    } \
    return Result; \
  }


/*-- yLast_SORT (String)-------------------------------------------*/
#define String_Last(SORT, COMPONENTSORT) \
  extern COMPONENTSORT XCAT(yLast_,SORT) \
    XPP_PROTO( (SORT S) ) \
    XPP_NOPROTO( (S) SORT S; ) \
  { \
    COMPONENTSORT Result; \
    if (S.Length > 0) { \
      Result = S.Last->Data; \
      if (! S.IsAssigned) { \
        XCAT(yFree_,SORT)((void **)&S); \
      } \
    } else { \
      xReportStringError("Last in String sort", "Length is zero") \
      (void)memset((void *)(&Result), 0, sizeof(COMPONENTSORT)); \
      XCAT(yDef_,COMPONENTSORT)(&Result); \
    } \
    return Result; \
  }


/*-- yConcat_SORT (String)-----------------------------------------*/
#define String_Concat(SORT, COMPONENTSORT) \
  extern void XCAT(yAppend_,SORT) \
    XPP_PROTO( (SORT *result, SORT S) ) \
    XPP_NOPROTO( (result, S) SORT *result; SORT S; ) \
  { \
    XCAT(SORT,_yptr)  TempSVar, TempExpr; \
    \
    (*result).Length = (*result).Length + S.Length; \
    if (S.IsAssigned) { \
      TempExpr = S.First; \
      TempSVar = XCAT(yGetAvail_,SORT)(); \
      if ((*result).First == (XCAT(SORT,_yptr))0) \
        (*result).First = TempSVar; \
      else \
        (*result).Last->Suc = TempSVar; \
      XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
      \
      while (TempExpr->Suc != (XCAT(SORT,_yptr))0) { \
        TempExpr = TempExpr->Suc; \
        TempSVar->Suc = XCAT(yGetAvail_,SORT)(); \
        TempSVar = TempSVar->Suc; \
        XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
      } \
      (*result).Last = TempSVar; \
    } else { \
      if ((*result).First == (XCAT(SORT,_yptr))0) \
        (*result).First = S.First; \
      else \
        (*result).Last->Suc = S.First; \
      (*result).Last = S.Last; \
    } \
  } \
  \
  \
  extern SORT XCAT(yConcat_,SORT) \
    XPP_PROTO( (SORT S1, SORT S2) ) \
    XPP_NOPROTO( (S1, S2) SORT S1; SORT S2; ) \
  { \
    SORT result; \
    \
    result.First = (XCAT(SORT,_yptr))0; \
    result.Last = (XCAT(SORT,_yptr))0; \
    result.Length = 0; \
    result.IsAssigned = (xbool)0; \
    if (S1.Length == 0) { \
      if (S2.Length == 0) \
        return result; \
      else if (! S2.IsAssigned) \
        return S2; \
      else { \
        XCAT(yAppend_,SORT)(&result, S2); \
      } \
    } else if (S2.Length == 0) { \
      if (! S1.IsAssigned) \
        return S1; \
      else { \
        XCAT(yAppend_,SORT)(&result, S1);  \
      } \
    } else { \
      XCAT(yAppend_,SORT)(&result, S1); \
      XCAT(yAppend_,SORT)(&result, S2); \
    } \
    \
    return result; \
  }


/*-- ySubstring_SORT (String)--------------------------------------*/
#define String_Substring(SORT, COMPONENTSORT) \
  extern SORT XCAT(ySubString_,SORT) \
    XPP_PROTO( (SORT S, SDL_Integer Start, SDL_Integer SubLength) ) \
    XPP_NOPROTO( (S, Start, SubLength) SORT S; SDL_Integer Start; SDL_Integer SubLength; ) \
  { \
    SORT result; \
    XCAT(SORT,_yptr)  TempSVar, TempExpr; \
    int I; \
    \
    result.First = (XCAT(SORT,_yptr))0; \
    result.Last = (XCAT(SORT,_yptr))0; \
    result.Length = 0; \
    result.IsAssigned = (xbool)0; \
    if ( S.Length <= 0 ) { \
      xReportStringError("SubString in string sort", "Length is zero" ) \
    } else if ( Start <= 0 ) { \
      xReportStringError("SubString in string sort", \
                         "Start is less than or equal to zero" ) \
    } else if ( SubLength <= 0 ) { \
      xReportStringError("SubString in string sort", \
                         "SubLength is less than or equal to zero" ) \
    } else if ( Start+SubLength-1 > S.Length ) { \
      xReportStringError("SubString in string sort", \
        "Start+Substring-1 length is greater than string length" ) \
    } else { \
      TempExpr = S.First; \
      for (I=1; I<Start; I++) TempExpr = TempExpr->Suc; \
      TempSVar = XCAT(yGetAvail_,SORT)(); \
      result.First = TempSVar; \
      XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
      \
      for (I=2; I<=SubLength; I++) { \
        TempExpr = TempExpr->Suc; \
        TempSVar->Suc = XCAT(yGetAvail_,SORT)(); \
        TempSVar = TempSVar->Suc; \
        XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
      } \
      result.Last = TempSVar; \
      result.Length = SubLength; \
    } \
    if (! S.IsAssigned && S.First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)&S); \
    } \
    return result; \
  }



/*-- yModify_SORT (String)-----------------------------------------*/
#define String_Modify(SORT, COMPONENTSORT) \
  extern COMPONENTSORT *XCAT(yAddr_,SORT) \
    XPP_PROTO( (SORT *S, SDL_Integer Index) ) \
    XPP_NOPROTO( (S, Index) SORT *S; SDL_Integer Index; ) \
  { \
    COMPONENTSORT *result; \
    XCAT(SORT,_yptr) Temp; \
    if ((*S).Length == 0) { \
      xReportStringError("Modify of component of string sort", \
                         "String is empty. Returns default value" ) \
      result = (COMPONENTSORT *)xAlloc((xptrint)sizeof(COMPONENTSORT)); \
      XCAT(yDef_,COMPONENTSORT)(result); \
      return result; \
    } else { \
      if (Index > (*S).Length) { \
        xReportStringError("Modify of component of string sort", \
                           "Index > string length. Index set to 1" ) \
        Index = 1; \
      } \
      if (Index <= (SDL_Integer)0) { \
        xReportStringError("Modify of component of string sort", \
                           "Index <= 0. Index set to 1" ) \
        Index = 1; \
      } \
      Temp = (*S).First; \
      for (; Index>1; Index--) Temp = Temp->Suc; \
      if (! (*S).IsAssigned && (*S).First != (XCAT(SORT,_yptr))0) { \
        XCAT(yFree_,SORT)((void **)S); \
      } \
      return &Temp->Data; \
    } \
  }


/*-- yExtr_SORT (String)--------------------------------------------*/
#define String_Extract(SORT, COMPONENTSORT) \
  extern COMPONENTSORT XCAT(yExtr_,SORT) \
    XPP_PROTO( (SORT S, SDL_Integer Index) ) \
    XPP_NOPROTO( (S, Index) SORT S; SDL_Integer Index; ) \
  { \
    COMPONENTSORT result; \
    XCAT(SORT,_yptr) Temp; \
    if (S.Length == 0) { \
      xReportStringError("Extract in string sort", \
                         "String is empty. Returns default value" ) \
      (void)memset((void *)(&result), 0, sizeof(COMPONENTSORT)); \
      XCAT(yDef_,COMPONENTSORT)(&result); \
      return result; \
    } else { \
      if (Index > S.Length) { \
        xReportStringError("Extract in string sort", \
                           "Index > string length. Index set to 1" ) \
        Index = 1; \
      } \
      if (Index <= (SDL_Integer)0) { \
        xReportStringError("Extract in string sort", \
                           "Index <= 0. Index set to 1" ) \
        Index = 1; \
      } \
      Temp = S.First; \
      for (; Index>1; Index--) Temp = Temp->Suc; \
      if (! S.IsAssigned && S.First != (XCAT(SORT,_yptr))0) { \
        XCAT(yFree_,SORT)((void **)&S); \
      } \
      return Temp->Data; \
    } \
  }


/*-- yAss_SORT (String)--------------------------------------------*/
#define String_Assign(SORT, COMPONENTSORT) \
  static XCAT(SORT,_yptr)  XCAT(yAvail_,SORT) = (XCAT(SORT,_yptr))0; \
  extern void XCAT(yAss_,SORT) \
    XPP_PROTO( (SORT * SVar, SORT SExpr, int AssType) ) \
    XPP_NOPROTO( (SVar, SExpr, AssType)  SORT * SVar; SORT SExpr; int AssType; ) \
  { \
    XCAT(SORT,_yptr)  TempSVar, TempExpr; \
    \
    if ((*SVar).First == SExpr.First) \
      return; \
    if (AssType == XASS && (*SVar).First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)SVar); \
    } \
    if ( (SExpr.IsAssigned || AssType == XASS2MAKE) && \
         SExpr.First != (XCAT(SORT,_yptr))0) { \
      TempExpr = SExpr.First; \
      TempSVar = XCAT(yGetAvail_,SORT)(); \
      (*SVar).First = TempSVar; \
      XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
      \
      TempExpr = TempExpr->Suc; \
      while (TempExpr != (XCAT(SORT,_yptr))0) { \
        TempSVar->Suc = XCAT(yGetAvail_,SORT)(); \
        TempSVar = TempSVar->Suc; \
        XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
        TempExpr = TempExpr->Suc; \
      } \
      (*SVar).Last = TempSVar; \
    } else { \
      (*SVar).First = SExpr.First; \
      (*SVar).Last = SExpr.Last; \
    } \
    (*SVar).Length = SExpr.Length; \
    (*SVar).IsAssigned = (xbool)1; \
  }


/*-- yEq_SORT (String)---------------------------------------------*/
#define String_Equal(SORT, COMPONENTSORT) \
  extern SDL_Boolean XCAT(yEq_,SORT) \
    XPP_PROTO( (SORT Expr1, SORT Expr2) ) \
    XPP_NOPROTO( (Expr1, Expr2) SORT Expr1; SORT Expr2; ) \
  { \
    XCAT(SORT,_yptr)  Temp1, Temp2; \
    SDL_Boolean  Result; \
    \
    Result = SDL_True; \
    if (Expr1.Length != Expr2.Length) \
      Result = SDL_False; \
    Temp1 = Expr1.First; \
    Temp2 = Expr2.First; \
    while (Result && Temp1 != (XCAT(SORT,_yptr))0) { \
      if (XCAT(yNEqF_,COMPONENTSORT)(Temp1->Data, Temp2->Data) ) \
        Result = SDL_False; \
      Temp1 = Temp1->Suc; \
      Temp2 = Temp2->Suc; \
    } \
    if (! Expr1.IsAssigned && Expr1.First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)&Expr1); \
    } \
    if (! Expr2.IsAssigned && Expr2.First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)&Expr2); \
    } \
    return Result; \
  }

/*-- yDef_SORT (String)--------------------------------------------*/
#define String_Default(SORT, COMPONENTSORT) \
  extern void XCAT(yDef_,SORT) \
    XPP_PROTO( (SORT *S) ) \
    XPP_NOPROTO( (S) SORT *S; ) \
  { \
    (*S).First = (XCAT(SORT,_yptr))0; \
    (*S).Last = (XCAT(SORT,_yptr))0; \
    (*S).Length = 0; \
    (*S).IsAssigned = (xbool)1; \
  }


/*-- yFree_SORT (String)-------------------------------------------*/
#ifdef XFREEFUNCS
#define String_Free(SORT, COMPONENTSORT, HASCOMPFREE) \
  extern void XCAT(yFree_,SORT) \
    XPP_PROTO( (void ** C) ) \
    XPP_NOPROTO( (C) void ** C; ) \
  { \
    XCAT(SORT,_yptr)  Temp; \
    if (HASCOMPFREE) { \
      for (Temp =  (*(SORT *)C).First; \
           Temp != (XCAT(SORT,_yptr))0; \
           Temp =  Temp->Suc) { \
        XCAT(yFree_,COMPONENTSORT)((void **)&Temp->Data); \
      } \
    } \
    if ((*(SORT *)C).First != (XCAT(SORT,_yptr))0) { \
      (*(SORT *)C).Last->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = (*(SORT *)C).First; \
    } \
  }
#else
#define String_Free(SORT, COMPONENTSORT, HASCOMPFREE) \
  extern void XCAT(yFree_,SORT) \
    XPP_PROTO( (void ** C) ) \
    XPP_NOPROTO( (C) void ** C; ) \
  { \
    if ((*(SORT *)C).First != (XCAT(SORT,_yptr))0) { \
      (*(SORT *)C).Last->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = (*(SORT *)C).First; \
    } \
  }
#endif


/*-- yWri_SORT (String)-------------------------------------------*/
#define String_Write(SORT, COMPONENTSORT) \
  extern char * XCAT(yWri_,SORT) \
    XPP_PROTO( (void * S) ) \
    XPP_NOPROTO( (S) void * S; ) \
  { \
    XCAT(SORT,_yptr) Temp, TempLast; \
  static  char       CTemp[MAX_WRI_LENGTH]; \
    \
    strcpy(CTemp, "(. "); \
    TempLast = (*(SORT *)S).Last; \
    for (Temp = (*(SORT *)S).First; \
         Temp != (XCAT(SORT,_yptr))0; \
         Temp = Temp->Suc) { \
      xSafeStrcat(CTemp, \
             xWriteSort((void *)(&Temp->Data), XCAT(ySrtN_,COMPONENTSORT))); \
      if (strlen(CTemp) == MAX_WRI_LENGTH - 1) \
        return CTemp; \
      if (Temp != TempLast) \
        xSafeStrcat(CTemp, ", "); \
    } \
    xSafeStrcat(CTemp, " .)"); \
    return CTemp; \
  }


/*-- yRead_SORT (String)------------------------------------------*/
#define String_Read(SORT, COMPONENTSORT) \
  extern int XCAT(yRead_,SORT) \
    XPP_PROTO( (void * Result) ) \
    XPP_NOPROTO( (Result) void * Result; ) \
  { \
    COMPONENTSORT Item; \
    xxToken       Token; \
    char          strVar[256]; \
    int           Res; \
    \
    (*(SORT *)Result).First = (XCAT(SORT,_yptr))0; \
    (*(SORT *)Result).Last = (XCAT(SORT,_yptr))0; \
    (*(SORT *)Result).Length = 0; \
    (*(SORT *)Result).IsAssigned = (int)0; \
    Token = xScanToken(strVar); \
    if (Token != xxLParDot && Token != xxQuestionMark && Token != xxEoln) { \
      xPrintString("String value should start with (.\n"); \
      return 0; \
    } \
    if (Token != xxLParDot) xUngetToken(Token, strVar); \
    \
    while (Token != xxRParDot) { \
      sprintf(strVar, " (%s) : ", XCAT(ySrtN_,COMPONENTSORT)->Name); \
      (void)memset((void *)(&Item), 0, sizeof(COMPONENTSORT)); \
      Res = xReadOneParameter(XCAT(ySrtN_,COMPONENTSORT), strVar, (void *)&Item); \
      if (Res == 0) return 0; \
      if (Res == 2) { \
        Token = xScanToken(strVar); \
        if (Token == xxRParDot) break; \
        return 0; \
      } \
      XCAT(yAppend_,SORT)((SORT *)Result, XCAT(yMkString_,SORT)(Item)); \
      Token = xScanToken(strVar); \
      if (Token != xxRParDot) xUngetToken(Token, strVar); \
    } \
    (*(SORT *)Result).IsAssigned = (int)1; \
    return 1; \
  }

/****+***************************************************************
05   Generator Array  (array that cannot become array in C)
********************************************************************/

/* typedef for Array type -----------------------------------------*/

#define Array_Type(SORT, INDEXSORT, COMPONENTSORT) \
   typedef struct XCAT(SORT,_ystruct)  * XCAT(SORT,_yptr); \
   typedef struct XCAT(SORT,_ystruct) { \
     XCAT(SORT,_yptr)   Suc; \
     INDEXSORT          Index; \
     COMPONENTSORT      Data; \
   } XCAT(SORT,_yrec); \
   typedef struct { \
     XCAT(SORT,_yptr) First; \
     XCAT(SORT,_yptr) Last; \
     xbool            IsAssigned; \
     COMPONENTSORT    Data; \
   } SORT;


/* Array operator prototypes --------------------------------------*/

#define Array_prototypes(SORT, INDEXSORT, COMPONENTSORT) \
  extern SORT XCAT(yMake_,SORT) XPP((COMPONENTSORT)); \
  extern COMPONENTSORT XCAT(yExtr_,SORT) XPP((SORT, INDEXSORT)); \
  extern COMPONENTSORT *XCAT(yAddr_,SORT) XPP((SORT *, INDEXSORT)); \
  \
  extern XCAT(SORT,_yptr) XCAT(yGetAvail_,SORT) XPP((void)); \
  extern COMPONENTSORT XCAT(yExtrInner_,SORT) \
         XPP((SORT S, INDEXSORT Index)); \
  \
  extern char * XCAT(yWri_,SORT) XPP((void * S)); \
  extern int XCAT(yRead_,SORT) XPP((void * Result));


/* Array operator implementations ---------------------------------*/

/*-- yMake_SORT (Array)--------------------------------------------*/
#define Array_Make(SORT, INDEXSORT, COMPONENTSORT) \
  extern SORT XCAT(yMake_,SORT) \
    XPP_PROTO( (COMPONENTSORT Component) ) \
    XPP_NOPROTO( (Component) COMPONENTSORT Component; ) \
  { \
    SORT Result; \
    Result.First = (XCAT(SORT,_yptr))0; \
    Result.Last = (XCAT(SORT,_yptr))0; \
    Result.IsAssigned = (xbool)0; \
    XCAT(yAssF_,COMPONENTSORT)(Result.Data, Component, XASSMAKE); \
    return Result; \
  }


/*-- yModify_SORT (Array)------------------------------------------*/
#define Array_Modify(SORT, INDEXSORT, COMPONENTSORT) \
  extern XCAT(SORT,_yptr) XCAT(yGetAvail_,SORT) XPP((void)) \
  { \
    XCAT(SORT,_yptr) Item; \
    if (XCAT(yAvail_,SORT) != (XCAT(SORT,_yptr))0) { \
      Item = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = XCAT(yAvail_,SORT)->Suc; \
    } else { \
      Item = (XCAT(SORT,_yptr))xAlloc((unsigned)sizeof(XCAT(SORT,_yrec))); \
    } \
    Item->Suc = (XCAT(SORT,_yptr))0; \
    return Item; \
  } \
  \
  extern COMPONENTSORT *XCAT(yAddr_,SORT) \
    XPP_PROTO( (SORT *S, INDEXSORT Index) ) \
    XPP_NOPROTO( (S, Index) SORT *S; INDEXSORT Index; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    Temp = (*S).First; \
    while ( Temp != (XCAT(SORT,_yptr))0  && \
            XCAT(yNEqF_,INDEXSORT)(Temp->Index, Index) ) \
      Temp = Temp->Suc; \
    if (Temp != (XCAT(SORT,_yptr))0) \
      return &Temp->Data; \
    if ((*S).First == (XCAT(SORT,_yptr))0) { \
      (*S).First = XCAT(yGetAvail_,SORT)(); \
      (*S).Last = (*S).First; \
    } else { \
      (*S).Last->Suc = XCAT(yGetAvail_,SORT)(); \
      (*S).Last = (*S).Last->Suc; \
    } \
    XCAT(yAssF_,INDEXSORT)((*S).Last->Index, Index, XASS); \
    XCAT(yAssF_,COMPONENTSORT)((*S).Last->Data, (*S).Data, XASS); \
    return &(*S).Last->Data; \
  }


/*-- yExtr_SORT (Array)---------------------------------------------*/
#define Array_Extract(SORT, INDEXSORT, COMPONENTSORT) \
  \
  extern COMPONENTSORT XCAT(yExtrInner_,SORT) \
    XPP_PROTO( (SORT S, INDEXSORT Index) ) \
    XPP_NOPROTO( (S, Index) SORT S; INDEXSORT Index; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    Temp = S.First; \
    while ( Temp != (XCAT(SORT,_yptr))0  && \
            XCAT(yNEqF_,INDEXSORT)(Temp->Index, Index) ) \
      Temp = Temp->Suc; \
    if (Temp != (XCAT(SORT,_yptr))0) \
      return Temp->Data; \
    else \
      return S.Data; \
  } \
  \
  extern COMPONENTSORT XCAT(yExtr_,SORT) \
    XPP_PROTO( (SORT S, INDEXSORT Index) ) \
    XPP_NOPROTO( (S, Index) SORT S; INDEXSORT Index; ) \
  { \
    COMPONENTSORT result; \
    result = XCAT(yExtrInner_,SORT)(S, Index); \
    if (! S.IsAssigned && S.First != (XCAT(SORT,_yptr))0) \
      XCAT(yFree_,SORT)((void **)&S); \
    return result; \
  }


/*-- yAss_SORT (Array)---------------------------------------------*/
#define Array_Assign(SORT, INDEXSORT, COMPONENTSORT) \
  static XCAT(SORT,_yptr)  XCAT(yAvail_,SORT) = (XCAT(SORT,_yptr))0; \
  extern void XCAT(yAss_,SORT) \
    XPP_PROTO( (SORT * SVar, SORT SExpr, int AssType) ) \
    XPP_NOPROTO( (SVar, SExpr, AssType)  SORT * SVar; SORT SExpr; int AssType; ) \
  { \
    XCAT(SORT,_yptr)  TempSVar, TempExpr, PrevExpr; \
    \
    if ((*SVar).First != SExpr.First) {\
      if (AssType == XASS && (*SVar).First != (XCAT(SORT,_yptr))0) \
        XCAT(yFree_,SORT)((void **)SVar); \
      if ( (SExpr.IsAssigned || AssType == XASS2MAKE) && \
           SExpr.First != (XCAT(SORT,_yptr))0) { \
        TempExpr = SExpr.First; \
        TempSVar = XCAT(yGetAvail_,SORT)(); \
        (*SVar).First = TempSVar; \
        XCAT(yAssF_,INDEXSORT)(TempSVar->Index, TempExpr->Index, XASS); \
        XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
        \
        TempExpr = TempExpr->Suc; \
        while (TempExpr != (XCAT(SORT,_yptr))0) { \
          TempSVar->Suc = XCAT(yGetAvail_,SORT)(); \
          TempSVar = TempSVar->Suc; \
          XCAT(yAssF_,INDEXSORT)(TempSVar->Index, TempExpr->Index, XASS); \
          XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
          TempExpr = TempExpr->Suc; \
        } \
        (*SVar).Last = TempSVar; \
      } else { \
        (*SVar).First = SExpr.First; \
        (*SVar).Last = SExpr.Last; \
      } \
    } \
    XCAT(yAssF_,COMPONENTSORT)((*SVar).Data, SExpr.Data, XASS); \
    (*SVar).IsAssigned = (xbool)1; \
    \
    PrevExpr = (*SVar).First; \
    while ( PrevExpr != (XCAT(SORT,_yptr))0 && \
            XCAT(yEqF_,COMPONENTSORT)(PrevExpr->Data, (*SVar).Data) ) { \
      (*SVar).First = PrevExpr->Suc; \
      PrevExpr->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = PrevExpr; \
      PrevExpr = (*SVar).First; \
    } \
    if ( PrevExpr != (XCAT(SORT,_yptr))0 ) { \
      while ( PrevExpr->Suc != (XCAT(SORT,_yptr))0 ) { \
        TempExpr = PrevExpr->Suc; \
        if ( XCAT(yEqF_,COMPONENTSORT)(TempExpr->Data, (*SVar).Data) ) { \
          PrevExpr->Suc = TempExpr->Suc; \
          TempExpr->Suc = XCAT(yAvail_,SORT); \
          XCAT(yAvail_,SORT) = TempExpr; \
        } else { \
          PrevExpr = TempExpr; \
        } \
      } \
    } \
    (*SVar).Last = PrevExpr; \
  }


/*-- yEq_SORT (Array)----------------------------------------------*/
#define Array_Equal(SORT, INDEXSORT, COMPONENTSORT) \
  extern SDL_Boolean XCAT(yEq_,SORT) \
    XPP_PROTO( (SORT Expr1, SORT Expr2) ) \
    XPP_NOPROTO( (Expr1, Expr2) SORT Expr1; SORT Expr2; ) \
  { \
    XCAT(SORT,_yptr)  Temp; \
    SDL_Boolean  Result; \
    \
    Result = XCAT(yEqF_,COMPONENTSORT)(Expr1.Data, Expr2.Data); \
    if (Result) { \
      Temp = Expr1.First; \
      while (Result && Temp != (XCAT(SORT,_yptr))0) { \
        if (XCAT(yNEqF_,COMPONENTSORT) \
             (Temp->Data, XCAT(yExtrInner_,SORT)(Expr2, Temp->Index)) ) \
          Result = SDL_False; \
        Temp = Temp->Suc; \
      } \
      Temp = Expr2.First; \
      while (Result && Temp != (XCAT(SORT,_yptr))0) { \
        if (XCAT(yNEqF_,COMPONENTSORT) \
             (Temp->Data, XCAT(yExtrInner_,SORT)(Expr1, Temp->Index)) ) \
          Result = SDL_False; \
        Temp = Temp->Suc; \
      } \
    } \
    \
    if (! Expr1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&Expr1); \
    if (! Expr2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&Expr2); \
    return Result; \
  }

/*-- yDef_SORT (Array)---------------------------------------------*/
#define Array_Default(SORT, INDEXSORT, COMPONENTSORT) \
  extern void XCAT(yDef_,SORT) \
    XPP_PROTO( (SORT *S) ) \
    XPP_NOPROTO( (S) SORT *S; ) \
  { \
    (*S).First = (XCAT(SORT,_yptr))0; \
    (*S).Last = (XCAT(SORT,_yptr))0; \
    XCAT(yDef_,COMPONENTSORT)(&(*S).Data); \
    (*S).IsAssigned = (xbool)1; \
  }


/*-- yFree_SORT (Array)--------------------------------------------*/
#ifdef XFREEFUNCS
#define Array_Free(SORT, INDEXSORT, HASINDEXFREE, COMPONENTSORT, HASCOMPFREE) \
  extern void XCAT(yFree_,SORT) \
    XPP_PROTO( (void ** C) ) \
    XPP_NOPROTO( (C) void ** C; ) \
  { \
    XCAT(SORT,_yptr)  Temp; \
    if (HASCOMPFREE || HASINDEXFREE) { \
      for (Temp =  (*(SORT *)C).First; \
           Temp != (XCAT(SORT,_yptr))0; \
           Temp =  Temp->Suc) { \
        if (HASCOMPFREE) \
          XCAT(yFree_,COMPONENTSORT)((void **)&Temp->Data); \
        if (HASINDEXFREE) \
          XCAT(yFree_,INDEXSORT)((void **)&Temp->Index); \
      } \
      if (HASCOMPFREE) \
        XCAT(yFree_,COMPONENTSORT)((void **)&(*(SORT *)C).Data); \
    } \
    if ((*(SORT *)C).First != (XCAT(SORT,_yptr))0) { \
      (*(SORT *)C).Last->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = (*(SORT *)C).First; \
    } \
  }
#else
#define Array_Free(SORT, INDEXSORT, HASINDEXFREE, COMPONENTSORT, HASCOMPFREE) \
  extern void XCAT(yFree_,SORT) \
    XPP_PROTO( (void ** C) ) \
    XPP_NOPROTO( (C) void ** C; ) \
  { \
    if ((*(SORT *)C).First != (XCAT(SORT,_yptr))0) { \
      (*(SORT *)C).Last->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = (*(SORT *)C).First; \
    } \
  }
#endif


/*-- yWri_SORT (Array)---------------------------------------------*/
#define Array_Write(SORT, INDEXSORT, COMPONENTSORT) \
  extern char * XCAT(yWri_,SORT) \
    XPP_PROTO( (void * S) ) \
    XPP_NOPROTO( (S) void * S; ) \
  { \
    XCAT(SORT,_yptr) ArrPtr; \
  static  char       CTemp[MAX_WRI_LENGTH]; \
    \
    strcpy(CTemp, "(: (others:"); \
    xSafeStrcat(CTemp, \
       xWriteSort((void *)(&(*(SORT *)S).Data), XCAT(ySrtN_,COMPONENTSORT))); \
    xSafeStrcat(CTemp, ")"); \
    for (ArrPtr =  (*(SORT *)S).First; \
         ArrPtr != (XCAT(SORT,_yptr))0; \
         ArrPtr =  ArrPtr->Suc) { \
      xSafeStrcat(CTemp, ", ("); \
      xSafeStrcat(CTemp, \
               xWriteSort((void *)(&ArrPtr->Index), XCAT(ySrtN_,INDEXSORT))); \
      xSafeStrcat(CTemp, ":"); \
      xSafeStrcat(CTemp, \
            xWriteSort((void *)(&ArrPtr->Data), XCAT(ySrtN_,COMPONENTSORT))); \
      xSafeStrcat(CTemp, ")"); \
    } \
    xSafeStrcat(CTemp, " :)"); \
    return CTemp; \
  }


/*-- yRead_SORT (Array)--------------------------------------------*/
#define Array_Read(SORT, INDEXSORT, COMPONENTSORT) \
  extern int XCAT(yRead_,SORT) \
    XPP_PROTO( (void * Result) ) \
    XPP_NOPROTO( (Result) void * Result; ) \
  { \
    INDEXSORT     Index; \
    COMPONENTSORT Item; \
    xxToken       Token; \
    char          strVar[256]; \
    xbool         IsOthers; \
    int           Res; \
    \
    XCAT(yDef_,SORT)((SORT *)Result); \
    Token = xScanToken(strVar); \
    if (Token != xxLParColon && Token != xxQuestionMark && Token != xxEoln) { \
      xPrintString("Array value should start with (:\n"); \
      return 0; \
    } \
    if (Token != xxLParColon) xUngetToken(Token, strVar); \
    \
    IsOthers = (xbool)1; \
    while (Token != xxRParColon) { \
      Token = xScanToken(strVar); \
      if (Token == xxLPar) Token = xScanToken(strVar); \
      if (! IsOthers) { \
        if (Token == xxEoln || Token == xxQuestionMark) { \
          sprintf(strVar, " Index (%s) : ", XCAT(ySrtN_,INDEXSORT)->Name); \
          xPrintString(strVar); \
          Token = xScanToken(strVar); \
        } \
        if (Token == xxRParColon) break; \
        xUngetToken(Token, strVar); \
        (void)memset((void *)(&Index), 0, sizeof(INDEXSORT)); \
        if ( ! xReadSort((void *)&Index, XCAT(ySrtN_,INDEXSORT))) { \
          xPrintString("Illegal index value\n"); \
          return 0; \
        } \
        Token = xScanToken(strVar); \
      } else { \
        if (Token == xxEoln || Token == xxQuestionMark) { \
          xPrintString(" others"); \
        } else if (Token == xxId) { \
          if (xfEqualIdString(strVar, "others") != 2) { \
            xPrintString("others expected\n"); \
            return 0; \
          } \
          Token = xScanToken(strVar); \
        } else { \
          xPrintString("others expected\n"); \
          return 0; \
        } \
      } \
      if (Token != xxColon) xUngetToken(Token, strVar); \
      if (IsOthers) \
        sprintf(strVar, " Others component (%s) : ", XCAT(ySrtN_,COMPONENTSORT)->Name); \
      else \
        sprintf(strVar, " Component (%s) : ", XCAT(ySrtN_,COMPONENTSORT)->Name); \
      (void)memset((void *)(&Item), 0, sizeof(COMPONENTSORT)); \
      Res = xReadOneParameter(XCAT(ySrtN_,COMPONENTSORT), strVar, (void *)&Item); \
      if (Res == 0) { \
        xPrintString("Illegal component value\n"); \
        return 0; \
      } \
      if (IsOthers) \
        XCAT(yAss_,SORT)((SORT *)Result, XCAT(yMake_,SORT)(Item), XASS); \
      else \
        XCAT(yAssF_,COMPONENTSORT)( \
            (* XCAT(yAddr_,SORT)((SORT *)Result, Index)) , Item, XASS); \
      \
      Token = xScanToken(strVar); \
      if (Token == xxRPar) Token = xScanToken(strVar); \
      if (Token == xxComma) Token = xScanToken(strVar); \
      if (Token != xxRParColon) xUngetToken(Token, strVar); \
      IsOthers = (xbool)0; \
    } \
    (*(SORT *)Result).IsAssigned = (int)1; \
    return 1; \
  }


/****+***************************************************************
06   Generator Powerset  (limited and discrete component type)
********************************************************************/

/* typedef for Powerset type --------------------------------------*/

#define Powerset_Type(SORT, COMPONENTSORT, LOW, HIGH) \
  typedef struct { \
    unsigned long A[(HIGH-LOW)/32+1]; \
  } SORT;

  /* unsigned long is assumed to be 32 bits */


#define Powerset_prototypes(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SORT XCAT(yEmpty_,SORT) XPP((void)); \
  extern SDL_Boolean XCAT(yIn_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SORT XCAT(yIncl_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SORT XCAT(yDel_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SDL_Boolean XCAT(yLT_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yGT_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yLE_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yGE_,SORT) XPP((SORT, SORT)); \
  extern SORT XCAT(yAnd_,SORT) XPP((SORT, SORT)); \
  extern SORT XCAT(yOr_,SORT) XPP((SORT, SORT)); \
  \
  extern SDL_Integer XCAT(yCard_,SORT) XPP((SORT)); \
  extern COMPONENTSORT XCAT(yElement_,SORT) XPP((SORT, SDL_Integer));


/*-- yEmpty_SORT (Powerset)----------------------------------------*/
#define Powerset_Empty(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SORT XCAT(yEmpty_,SORT) XPP((void)) \
  { \
    SORT PS; \
    int Item; \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) \
      PS.A[Item] = 0; \
    return PS; \
  }


/*-- yIn_SORT (Powerset)-------------------------------------------*/
#define Powerset_In(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SDL_Boolean XCAT(yIn_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
    if (Item < LOW || Item > HIGH) return SDL_False; \
    Item = Item - LOW; \
    if ( ((unsigned long)1 << Item%32) & PS.A[Item/32] ) \
      return SDL_True; \
    return SDL_False; \
  }


/*-- yIncl_SORT (Powerset)-----------------------------------------*/
#define Powerset_Incl(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SORT XCAT(yIncl_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
    if (Item < LOW || Item > HIGH) return PS; \
    Item = Item - LOW; \
    PS.A[Item/32] = ((unsigned long)1 << Item%32) | PS.A[Item/32]; \
    return PS; \
  }


/*-- yDel_SORT (Powerset)------------------------------------------*/
#define Powerset_Del(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SORT XCAT(yDel_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
    if (Item < LOW || Item > HIGH) return PS; \
    Item = Item - LOW; \
    PS.A[Item/32] = ~((unsigned long)1 << Item%32) & PS.A[Item/32]; \
    return PS; \
  }


/*-- yAnd_SORT (Powerset)------------------------------------------*/
#define Powerset_And(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SORT XCAT(yAnd_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    SORT PS; \
    int Item; \
    \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) \
      PS.A[Item] = PS1.A[Item] & PS2.A[Item]; \
    return PS; \
  }


/*-- yOr_SORT (Powerset)-------------------------------------------*/
#define Powerset_Or(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SORT XCAT(yOr_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    SORT PS; \
    int Item; \
    \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) \
      PS.A[Item] = PS1.A[Item] | PS2.A[Item]; \
    return PS; \
  }


/*-- yLE_SORT (Powerset)-------------------------------------------*/
#define Powerset_LE(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SDL_Boolean XCAT(yLE_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    int Item; \
    \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) { \
      if ( (PS2.A[Item] | PS1.A[Item]) ^ PS2.A[Item] ) \
        return SDL_False; \
    } \
    return SDL_True; \
  }


/*-- yLT_SORT (Powerset)-------------------------------------------*/
#define Powerset_LT(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SDL_Boolean XCAT(yLT_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    int Item; \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) { \
      if ( (PS2.A[Item] | PS1.A[Item]) ^ PS2.A[Item] ) \
        return SDL_False; \
    } \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) { \
      if ( PS2.A[Item] ^ PS1.A[Item] ) \
        return SDL_True; \
    } \
    return SDL_False; \
  }


/*-- yGE_SORT (Powerset)-------------------------------------------*/
#define Powerset_GE(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SDL_Boolean XCAT(yGE_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    int Item; \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) { \
      if ( (PS1.A[Item] | PS2.A[Item]) ^ PS1.A[Item] ) \
        return SDL_False; \
    } \
    return SDL_True; \
  }


/*-- yGT_SORT (Powerset)-------------------------------------------*/
#define Powerset_GT(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SDL_Boolean XCAT(yGT_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    int Item; \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) { \
      if ( (PS1.A[Item] | PS2.A[Item]) ^ PS1.A[Item] ) \
        return SDL_False; \
    } \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) { \
      if ( PS1.A[Item] ^ PS2.A[Item] ) \
        return SDL_True; \
    } \
    return SDL_False; \
  }


/*-- yEq_SORT (Powerset)-------------------------------------------*/
#define Powerset_Equal(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SDL_Boolean XCAT(yEq_,SORT) \
    XPP_PROTO( (SORT Expr1, SORT Expr2) ) \
    XPP_NOPROTO( (Expr1, Expr2) SORT Expr1; SORT Expr2; ) \
  { \
    int Item; \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) { \
      if ( Expr1.A[Item] ^ Expr2.A[Item] ) \
        return SDL_False; \
    } \
    return SDL_True; \
  }


/*-- yDef_SORT (Powerset)------------------------------------------*/
#define Powerset_Default(SORT, COMPONENTSORT, LOW, HIGH) \
  extern void XCAT(yDef_,SORT) \
    XPP_PROTO( (SORT *S) ) \
    XPP_NOPROTO( (S) SORT *S; ) \
  { \
    int Item; \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) \
      (*S).A[Item] = (unsigned long)0; \
  }



/****+***************************************************************
07   Generator Powerset  (general component type)
********************************************************************/

/* typedef for GPowerset type -------------------------------------*/

#define GPowerset_Type(SORT, COMPONENTSORT) \
   typedef struct XCAT(SORT,_ystruct)  * XCAT(SORT,_yptr); \
   typedef struct XCAT(SORT,_ystruct) { \
     XCAT(SORT,_yptr)   Suc; \
     COMPONENTSORT      Data; \
   } XCAT(SORT,_yrec); \
   typedef struct { \
     XCAT(SORT,_yptr) First; \
     XCAT(SORT,_yptr) Last; \
     int              Length; \
     xbool            IsAssigned; \
   } SORT;


#define GPowerset_prototypes(SORT, COMPONENTSORT) \
  extern SORT XCAT(yEmpty_,SORT) XPP((void)); \
  extern SDL_Boolean XCAT(yIn_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SORT XCAT(yIncl_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SORT XCAT(yDel_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SDL_Boolean XCAT(yLT_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yGT_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yLE_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yGE_,SORT) XPP((SORT, SORT)); \
  extern SORT XCAT(yAnd_,SORT) XPP((SORT, SORT)); \
  extern SORT XCAT(yOr_,SORT) XPP((SORT, SORT)); \
  extern SDL_Integer XCAT(yCard_,SORT) XPP((SORT)); \
  extern COMPONENTSORT XCAT(yElement_,SORT) XPP((SORT, SDL_Integer)); \
  \
  extern SORT XCAT(yCopyList_,SORT) XPP((SORT PS)); \
  extern SDL_Boolean XCAT(yInInner_,SORT) \
            XPP((COMPONENTSORT Item, SORT PS)); \
  extern XCAT(SORT,_yptr) XCAT(yGetAvail_,SORT) XPP((void)); \
  \
  extern char * XCAT(yWri_,SORT) XPP((void * PS)); \
  extern int XCAT(yRead_,SORT) XPP((void * Result));


/*-- yEmpty_SORT (GPowerset)---------------------------------------*/
#define GPowerset_Empty(SORT, COMPONENTSORT) \
  extern XCAT(SORT,_yptr) XCAT(yGetAvail_,SORT) XPP((void)) \
  { \
    XCAT(SORT,_yptr) Item; \
    if (XCAT(yAvail_,SORT) != (XCAT(SORT,_yptr))0) { \
      Item = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = XCAT(yAvail_,SORT)->Suc; \
    } else { \
      Item = (XCAT(SORT,_yptr))xAlloc((unsigned)sizeof(XCAT(SORT,_yrec))); \
    } \
    Item->Suc = (XCAT(SORT,_yptr))0; \
    return Item; \
  } \
  \
  extern SORT XCAT(yEmpty_,SORT) XPP((void)) \
  { \
    SORT Result; \
    Result.First = (XCAT(SORT,_yptr))0; \
    Result.Last = (XCAT(SORT,_yptr))0; \
    Result.Length = 0; \
    Result.IsAssigned = (xbool)0; \
    return Result; \
  }


/*-- yIn_SORT (GPowerset)------------------------------------------*/
#define GPowerset_In(SORT, COMPONENTSORT) \
  extern SDL_Boolean XCAT(yInInner_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    SDL_Boolean Result; \
    Result = SDL_False; \
    for (Temp=PS.First; \
         Temp!=(XCAT(SORT,_yptr))0 && !Result; \
         Temp=Temp->Suc) \
      if ( XCAT(yEqF_,COMPONENTSORT)(Temp->Data, Item) ) \
        Result = SDL_True; \
    return Result; \
  } \
  \
  extern SDL_Boolean XCAT(yIn_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
    SDL_Boolean Result; \
    Result = XCAT(yInInner_,SORT)(Item, PS); \
    if (! PS.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS); \
    return Result; \
  }


/*-- yIncl_SORT (GPowerset)----------------------------------------*/
#define GPowerset_Incl(SORT, COMPONENTSORT) \
  extern SORT XCAT(yCopyList_,SORT) \
    XPP_PROTO( (SORT PS) ) \
    XPP_NOPROTO( (PS)  SORT PS; ) \
  { \
    XCAT(SORT,_yptr) TempPS, TempRes; \
    SORT Result; \
    Result = PS; \
    Result.IsAssigned = (xbool)0; \
    if (PS.First != (XCAT(SORT,_yptr))0 ) { \
      TempPS = PS.First; \
      TempRes = XCAT(yGetAvail_,SORT)(); \
      XCAT(yAssF_,COMPONENTSORT)(TempRes->Data, TempPS->Data, XASS); \
      Result.First = TempRes; \
      while (TempPS->Suc != (XCAT(SORT,_yptr))0) { \
        TempPS = TempPS->Suc; \
        TempRes->Suc = XCAT(yGetAvail_,SORT)(); \
        TempRes = TempRes->Suc; \
        XCAT(yAssF_,COMPONENTSORT)(TempRes->Data, TempPS->Data, XASS); \
      } \
      Result.Last = TempRes; \
    } \
    return Result; \
  } \
  \
  extern SORT XCAT(yIncl_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
    SORT Result; \
    if (PS.IsAssigned) \
      Result = XCAT(yCopyList_,SORT)(PS); \
    else \
      Result = PS; \
    if (! XCAT(yInInner_,SORT)(Item, Result) ) { \
      if (Result.Last == (XCAT(SORT,_yptr))0) { \
        Result.Last = XCAT(yGetAvail_,SORT)(); \
        Result.First = Result.Last; \
      } else { \
        Result.Last->Suc = XCAT(yGetAvail_,SORT)(); \
        Result.Last = Result.Last->Suc; \
      } \
      XCAT(yAssF_,COMPONENTSORT)(Result.Last->Data, Item, XASS); \
      Result.Length++; \
    } \
    return Result; \
  }


/*-- yDel_SORT (GPowerset)-----------------------------------------*/
#define GPowerset_Del(SORT, COMPONENTSORT) \
  extern SORT XCAT(yDel_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
    SORT Result; \
    XCAT(SORT,_yptr) Temp, Prev; \
    if (PS.IsAssigned) \
      Result = XCAT(yCopyList_,SORT)(PS); \
    else \
      Result = PS; \
    if ( Result.First != (XCAT(SORT,_yptr))0 ) { \
      Prev = Result.First; \
      if ( XCAT(yEqF_,COMPONENTSORT)(Prev->Data, Item) ) { \
        Result.First = Prev->Suc; \
        if (Result.Last == Prev) Result.Last = (XCAT(SORT,_yptr))0; \
        Prev->Suc = XCAT(yAvail_,SORT); \
        XCAT(yAvail_,SORT) = Prev; \
        Result.Length--; \
        return Result; \
      } \
      for (Temp=Prev->Suc; \
           Temp!=(XCAT(SORT,_yptr))0; \
           Temp=Temp->Suc) { \
        if ( XCAT(yEqF_,COMPONENTSORT)(Temp->Data, Item) ) {\
          Prev->Suc = Temp->Suc; \
          if (Result.Last == Temp) Result.Last = Prev; \
          Temp->Suc = XCAT(yAvail_,SORT); \
          XCAT(yAvail_,SORT) = Temp; \
          Result.Length--; \
          return Result; \
        } \
        Prev = Temp; \
      } \
    } \
    return Result; \
  }


/*-- yAnd_SORT (GPowerset)-----------------------------------------*/
#define GPowerset_And(SORT, COMPONENTSORT) \
  extern SORT XCAT(yAnd_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    SORT Result; \
    XCAT(SORT,_yptr) Temp; \
    Result = XCAT(yEmpty_,SORT)(); \
    for (Temp=PS1.First; Temp!=(XCAT(SORT,_yptr))0; Temp=Temp->Suc) \
      if ( XCAT(yInInner_,SORT)(Temp->Data, PS2) ) { \
        if (Result.First == (XCAT(SORT,_yptr))0) { \
          Result.First = XCAT(yGetAvail_,SORT)(); \
          Result.Last = Result.First; \
        } else { \
          Result.Last->Suc = XCAT(yGetAvail_,SORT)(); \
          Result.Last = Result.Last->Suc; \
        } \
        XCAT(yAssF_,COMPONENTSORT)(Result.Last->Data, Temp->Data, XASS); \
        Result.Length++; \
      } \
    if (! PS1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS1); \
    if (! PS2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS2); \
    return Result; \
  }


/*-- yOr_SORT (GPowerset)------------------------------------------*/
#define GPowerset_Or(SORT, COMPONENTSORT) \
  extern SORT XCAT(yOr_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    SORT Result; \
    XCAT(SORT,_yptr) Temp; \
    if (PS2.IsAssigned) \
      Result = XCAT(yCopyList_,SORT)(PS2); \
    else \
      Result = PS2; \
    for (Temp=PS1.First; Temp!=(XCAT(SORT,_yptr))0; Temp=Temp->Suc) \
      if ( ! XCAT(yInInner_,SORT)(Temp->Data, Result) ) { \
        if (Result.First == (XCAT(SORT,_yptr))0) { \
          Result.First = XCAT(yGetAvail_,SORT)(); \
          Result.Last = Result.First; \
        } else { \
          Result.Last->Suc = XCAT(yGetAvail_,SORT)(); \
          Result.Last = Result.Last->Suc; \
        } \
        XCAT(yAssF_,COMPONENTSORT)(Result.Last->Data, Temp->Data, XASS); \
        Result.Length++; \
      } \
    if (! PS1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS1); \
    return Result; \
  }


/*-- yLE_SORT (GPowerset)------------------------------------------*/
#define GPowerset_LE(SORT, COMPONENTSORT) \
  extern SDL_Boolean XCAT(yLE_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    SDL_Boolean Result; \
    Result = PS1.Length <= PS2.Length; \
    for (Temp=PS1.First; \
         Temp!=(XCAT(SORT,_yptr))0 && Result; \
         Temp=Temp->Suc) \
      if ( ! XCAT(yInInner_,SORT)(Temp->Data, PS2) ) \
        Result = SDL_False; \
    if (! PS1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS1); \
    if (! PS2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS2); \
    return Result; \
  }


/*-- yLT_SORT (GPowerset)------------------------------------------*/
#define GPowerset_LT(SORT, COMPONENTSORT) \
  extern SDL_Boolean XCAT(yLT_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    SDL_Boolean Result; \
    Result = PS1.Length < PS2.Length; \
    for (Temp=PS1.First; \
         Temp!=(XCAT(SORT,_yptr))0 && Result; \
         Temp=Temp->Suc) \
      if ( ! XCAT(yInInner_,SORT)(Temp->Data, PS2) ) \
        Result = SDL_False; \
    if (! PS1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS1); \
    if (! PS2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS2); \
    return Result; \
  }


/*-- yGE_SORT (GPowerset)------------------------------------------*/
#define GPowerset_GE(SORT, COMPONENTSORT) \
  extern SDL_Boolean XCAT(yGE_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    return XCAT(yLE_,SORT)(PS2, PS1); \
  }


/*-- yGT_SORT (GPowerset)------------------------------------------*/
#define GPowerset_GT(SORT, COMPONENTSORT) \
  extern SDL_Boolean XCAT(yGT_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    return XCAT(yLT_,SORT)(PS2, PS1); \
  }


/*-- yAss_SORT (GPowerset)-----------------------------------------*/
#define GPowerset_Assign(SORT, COMPONENTSORT) \
  static XCAT(SORT,_yptr)  XCAT(yAvail_,SORT) = (XCAT(SORT,_yptr))0; \
  extern void XCAT(yAss_,SORT) \
    XPP_PROTO( (SORT * SVar, SORT SExpr, int AssType) ) \
    XPP_NOPROTO( (SVar, SExpr, AssType)  SORT * SVar; SORT SExpr; int AssType; ) \
  { \
    if ((*SVar).First == SExpr.First) { \
      (*SVar).IsAssigned = (xbool)1; \
      return; \
    } \
    if (AssType == XASS && (*SVar).First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)SVar); \
    } \
    if ( (SExpr.IsAssigned || AssType == XASS2MAKE) && \
         SExpr.First != (XCAT(SORT,_yptr))0) { \
      *SVar = XCAT(yCopyList_,SORT)(SExpr); \
    } else { \
      (*SVar).First = SExpr.First; \
      (*SVar).Last = SExpr.Last; \
      (*SVar).Length = SExpr.Length; \
    } \
    (*SVar).IsAssigned = (xbool)1; \
  }


/*-- yEq_SORT (GPowerset)------------------------------------------*/
#define GPowerset_Equal(SORT, COMPONENTSORT) \
  extern SDL_Boolean XCAT(yEq_,SORT) \
    XPP_PROTO( (SORT Expr1, SORT Expr2) ) \
    XPP_NOPROTO( (Expr1, Expr2) SORT Expr1; SORT Expr2; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    SDL_Boolean Result; \
    Result = Expr1.Length == Expr2.Length; \
    for (Temp=Expr1.First; \
         Temp!=(XCAT(SORT,_yptr))0 && Result; \
         Temp=Temp->Suc) \
      if ( ! XCAT(yInInner_,SORT)(Temp->Data, Expr2) ) \
        Result = SDL_False; \
    if (! Expr1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&Expr1); \
    if (! Expr2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&Expr2); \
    return Result; \
  }


/*-- yDef_SORT (GPowerset)-----------------------------------------*/
#define GPowerset_Default(SORT, COMPONENTSORT) \
  extern void XCAT(yDef_,SORT) \
    XPP_PROTO( (SORT *S) ) \
    XPP_NOPROTO( (S) SORT *S; ) \
  { \
    (*S).First = (XCAT(SORT,_yptr))0; \
    (*S).Last = (XCAT(SORT,_yptr))0; \
    (*S).Length = 0; \
    (*S).IsAssigned = (xbool)1; \
  }


/*-- yFree_SORT (GPowerset)---------------------------------------*/
#ifdef XFREEFUNCS
#define GPowerset_Free(SORT, COMPONENTSORT, HASCOMPFREE) \
  extern void XCAT(yFree_,SORT) \
    XPP_PROTO( (void ** C) ) \
    XPP_NOPROTO( (C) void ** C; ) \
  { \
    XCAT(SORT,_yptr)  Temp; \
    if (HASCOMPFREE) { \
      for (Temp =  (*(SORT *)C).First; \
           Temp != (XCAT(SORT,_yptr))0; \
           Temp =  Temp->Suc) { \
        XCAT(yFree_,COMPONENTSORT)((void **)&Temp->Data); \
      } \
    } \
    if ((*(SORT *)C).First != (XCAT(SORT,_yptr))0) { \
      (*(SORT *)C).Last->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = (*(SORT *)C).First; \
    } \
  }
#else
#define GPowerset_Free(SORT, COMPONENTSORT, HASCOMPFREE) \
  extern void XCAT(yFree_,SORT) \
    XPP_PROTO( (void ** C) ) \
    XPP_NOPROTO( (C) void ** C; ) \
  { \
    if ((*(SORT *)C).First != (XCAT(SORT,_yptr))0) { \
      (*(SORT *)C).Last->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = (*(SORT *)C).First; \
    } \
  }
#endif


/*-- yCard_SORT (GPowerset)---------------------------------------*/
#define GPowerset_Card(SORT, COMPONENTSORT) \
  extern SDL_Integer XCAT(yCard_,SORT) \
    XPP_PROTO( (SORT PS) ) \
    XPP_NOPROTO( (PS)  SORT PS; ) \
  { \
    return PS.Length; \
  }


/*-- yElement_SORT (GPowerset)------------------------------------*/
#define GPowerset_Element(SORT, COMPONENTSORT) \
  extern COMPONENTSORT XCAT(yElement_,SORT) \
    XPP_PROTO( (SORT PS, SDL_Integer Index) ) \
    XPP_NOPROTO( (PS, Index)  SORT PS; SDL_Integer Index; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    int Number = 0; \
    COMPONENTSORT Result; \
    for (Temp=PS.First; \
         Temp!=(XCAT(SORT,_yptr))0 && ++Number<Index; \
         Temp=Temp->Suc) ; \
    if (Number == Index && Temp != (XCAT(SORT,_yptr))0) \
      return Temp->Data; \
    xReportStringError("Element in Powerset sort", "Index out of range") \
    (void)memset((void *)(&Result), 0, sizeof(COMPONENTSORT)); \
    XCAT(yDef_,COMPONENTSORT)(&Result); \
    return Result; \
  }


/*-- yWri_SORT (GPowerset)----------------------------------------*/
#define GPowerset_Write(SORT, COMPONENTSORT) \
  extern char * XCAT(yWri_,SORT) \
    XPP_PROTO( (void * PS) ) \
    XPP_NOPROTO( (PS) void * PS; ) \
  { \
    XCAT(SORT,_yptr) Temp, TempLast; \
  static  char       CTemp[MAX_WRI_LENGTH]; \
    \
    strcpy(CTemp, "[ "); \
    TempLast = (*(SORT *)PS).Last; \
    for (Temp = (*(SORT *)PS).First; \
         Temp != (XCAT(SORT,_yptr))0; \
         Temp = Temp->Suc) { \
      xSafeStrcat(CTemp, \
             xWriteSort((void *)(&Temp->Data), XCAT(ySrtN_,COMPONENTSORT))); \
      if (strlen(CTemp) == MAX_WRI_LENGTH - 1) \
        return CTemp; \
      if (Temp != TempLast) \
        xSafeStrcat(CTemp, ", "); \
    } \
    xSafeStrcat(CTemp, " ]"); \
    return CTemp; \
  }


/*-- yRead_SORT (GPowerset)---------------------------------------*/
#define GPowerset_Read(SORT, COMPONENTSORT) \
  extern int XCAT(yRead_,SORT) \
    XPP_PROTO( (void * Result) ) \
    XPP_NOPROTO( (Result) void * Result; ) \
  { \
    COMPONENTSORT Item; \
    xxToken       Token; \
    char          strVar[256]; \
    int           Res; \
    \
    (*(SORT *)Result).First = (XCAT(SORT,_yptr))0; \
    (*(SORT *)Result).Last = (XCAT(SORT,_yptr))0; \
    (*(SORT *)Result).Length = 0; \
    (*(SORT *)Result).IsAssigned = (int)0; \
    Token = xScanToken(strVar); \
    if (Token != xxLBracket && Token != xxQuestionMark && Token != xxEoln) { \
      xPrintString("Powerset value should start with [\n"); \
      return 0; \
    } \
    if (Token != xxLBracket) xUngetToken(Token, strVar); \
    \
    while (Token != xxRBracket) { \
      sprintf(strVar, " (%s) : ", XCAT(ySrtN_,COMPONENTSORT)->Name); \
      (void)memset((void *)(&Item), 0, sizeof(COMPONENTSORT)); \
      Res = xReadOneParameter(XCAT(ySrtN_,COMPONENTSORT), strVar, (void *)&Item); \
      if (Res == 0) return 0; \
      if (Res == 2) { \
        Token = xScanToken(strVar); \
        if (Token == xxRBracket) break; \
        return 0; \
      } \
      *(SORT *)Result = XCAT(yIncl_,SORT)(Item, *(SORT *)Result); \
      Token = xScanToken(strVar); \
      if (Token != xxRBracket) xUngetToken(Token, strVar); \
    } \
    (*(SORT *)Result).IsAssigned = (int)1; \
    return 1; \
  }
#endif
   /* XNO_LONG_MACROS */




#endif
   /* X_SCTPRED_H */

/*******************************************************************************
* History log:
*===============================================================================
* $Log: sctpred.h,v $
* Revision 1.4  2001/07/18 13:01:54  pbo
* New Release UGLOBE_2
*
* Revision 3.0  2001/07/18 11:29:36  pbo
* DUM_2
*
* Revision 2.0  2001/06/12 11:52:25  pbo
* DUM_1
*
* Revision 1.1.1.1  2001/03/28 13:37:25  pbo
* Initial version
*
*******************************************************************************/