Google
 

Trailing-Edge - PDP-10 Archives - SRI_NIC_PERM_FS_1_19910112 - kcc-5/kcc/ccsym.h
There are 8 other files named ccsym.h in the archive. Click here to see a list.
/*	CCSYM.H - Declarations for KCC type and symbol table structures
**
**	All changes after version 8 (8/8/85), unless otherwise specified, are
**	Copyright 1985, 1986 by Ken Harrenstien, SRI International.
**
**	Split from cc.h / David Eppstein / 23 May 85
*/

#ifndef EXT
#define EXT extern
#endif

/* Must define these together here since they need each other */
#define SYMBOL struct _symbol
#define TYPE struct _type

/* SYMBOL - Symbol table entry
**	All symbols have a name (Sname) and a "symbol class" (Sclass) which
**	determines the meaning of the rest of the structure.
*/
SYMBOL {
  struct {
    int s_class;		/* Symbol class - a SC_ value */
    int s_flags;		/* Symbol flags (SF_) */
    char s_name[_IDSIZE];	/* Symbol identifier string */
    union {		/* Use depends on Sclass */
	int s_int;		/* symbol value, misc uses */
	SYMBOL *s_sym;		/* symbol for label,static */
    } s_val;
    union {		/* Use depends on Sclass */
	TYPE *s_type;		/* C type pointer */
	int s_rwkey;		/* reserved word key */
	char *s_macptr;		/* macro pointer */
    } s_var;
  } Scontents;		/* Copyable contents (for struct assigns) */

			/* Only used for SC_TAG and SC_MEMBER */
    SYMBOL *Ssmnext;		/* next structure member */
    SYMBOL *Ssmtag;		/* tag of structure that member belongs to */

    SYMBOL *Sprev;		/* ptr to prev symbol on glob/local list */
    SYMBOL *Snext;		/* ptr to next symbol on ditto */
    int Srefs;			/* # times referenced since created */
    SYMBOL *Snhash;		/* ptr to next sym on this hash chain */
};

/* Defs providing external access to structure fields, depending on
 * the kind of symbol.  No "s_" member should ever be referenced directly.
 *
 * Need to finish documenting how each SC_ type uses Svalue and other fields,
 * and clean up some bad refs.
 */

/* Every symbol class uses these fields */
#define Sclass Scontents.s_class	/* Symbol class */
#define Sflags Scontents.s_flags	/* Symbol flags */
#define Sname Scontents.s_name		/* Symbol name string */

/* Many (but not all) symbol classes use these fields */
#define Stype Scontents.s_var.s_type	/* C type of symbol */
#define Svalue Scontents.s_val.s_int	/* Misc uses */

/* Sclass == SC_UNDEF
**	When the lexer returns an identifier, it also points "csymbol" 
** to an entry in the symtab.  If the symbol did not already exist, it is
** created with class SC_UNDEF.
**	Only Sname and Sclass will be set.
**	Stype will be NULL and Svalue zero.
** Normally the parser changes this quickly to something else, or gets
** rid of the symbol.  The only known usages which keep SC_UNDEF symbols
** around are:
**	- A pair of dummy symbols at the start of the global & local sym lists.
**	- References to structures/unions that have not yet been defined.
**		Stype should indicate either TS_STRUCT or TS_UNION.
*/

/* Sclass == SC_RW (reserved word)
**	Stoken holds the token code to return when the lexer finds this word.
**	Skey contains a reserved-word token type key, one of the TKTY_ values.
*/
#define Stoken Scontents.s_val.s_int
#define Skey  Scontents.s_var.s_rwkey

/* Sclass == SC_MACRO (preprocessor macro definition)
**	Smacptr points to the macro body (a dynamically allocated string).
**		This may be NULL for special types of macros.
**	Svalue says how many arguments it takes, or indicates a special value.
**		See the documentation in CCINP for details.
*/
#define Smacptr Scontents.s_var.s_macptr

/* Sclass == SC_TAG - Structure, union, or enum tag
** Sclass == SC_MEMBER - Structure or union member (component)
** Sclass == SC_ENUM - Enum list member
**	See the discussion of structure tags and members farther on
**	for a thorough explanation.
*/
#define Ssmoff Svalue

/* Sclass == SC_TYPEDEF
**	This symbol is a "typedef name" and is lexically considered a
** type-specifier keyword.
**	Stype points to the C type which this symbol represents.
*/

/* Sclass == SC_EXTERN or SC_AEXTERN
**   SC_EXTERN means the object (var or fun) was explicitly declared "extern".
**   SC_AEXTERN means that "extern" was ASSUMED -- it was not stated.
** When parsing top-level declarations, SC_AEXTERN is the default storage class
** when no explicit storage class is specified.  This allows KCC
** to distinguish between "extern" that is assumed, and "extern" that
** is stated.  See H&S 4.3.1 and 4.8.  Svalue is used as a flag:
**	Svalue == 0  A declaration reference (outputs EXTERN in asm file)
**	       != 0  A definition (outputs INTERN in asm file)
**	Stype specifies the symbol's C type.
*/

/* Sclass == SC_STATIC
**	The object (var or fun) has static extent and the symbol is not
** exported to the linker.  This can only happen if "static" is explicitly
** stated.
**	Stype specifies the symbol's C type.
**	Svalue is unused except for function types, in which case
**		== 0 means a reference and != 0 a definition, just as for
**		SC_EXTERN and SC_AEXTERN.
*/

/* Sclass == SC_ARG, SC_RARG	- Function parameters
**	In extdef(), Sargp is used to hold a symbol pointer to the next
** SC_ARG in a chain.  In funcdef() this is changed so that Svalue
** is used thereafter.  This is tricky because these two are really union
** co-members and cannot both be used simultaneously!
**	Stype specifies the parameter's C type.
**	Sargp is a symbol pointer to the next parameter (or null if last one)
**	Svalue contains stack offset, similar to SC_AUTO except that it is
**		a positive number (if all args are 1 word, this is same as
**		argument number) and thus needs to be inverted for an actual
**		stack reference.
*/
#define Sargp   Scontents.s_val.s_sym

/* Sclass == SC_REGISTER
**	This isn't really used anywhere.  For the time being,
** the classes SC_RAUTO and SC_RARG remember whether the "register" keyword
** was specified with auto vars or function parameters.  This could be used
** to help the optimizer.
*/


/* Sclass == SC_AUTO, SC_RAUTO, SC_XAUTO, SC_XRAUTO
**  SC_AUTO describes an "auto" variable, within a block.  This is the
**	default storage class when parsing declarations within a block.
**  SC_RAUTO is the same but indicates that the "register" storage class
**	was given in the declaration.
**  SC_XAUTO and SC_XRAUTO are what SC_AUTO and SC_RAUTO are turned
**	into when parsing has left the block within which the variable
**	was declared.  That is, the declaration is no longer active.
**
**	Stype specifies the symbol's C type.
**	Svalue holds the stack offset value, in words.
*/


/* Sclass == SC_LABEL, SC_ULABEL, SC_ISTATIC, SC_STATIC (label)
 *	Ssym points to a label symbol for goto or for static data.
 */
#define Ssym   Scontents.s_val.s_sym

/*
** Certain types of symbols have a prefix character in their names
** as a hack to provide for "overloading classes" or "name spaces"
** [Ref H&S 4.2.4].
** These prefixes (none of which are legal as part of an input
** identifier) are:
**	+ - Structure member symbols	("component names")
**	^ - Structure/enum tag symbols	("struct, union, and enum tags")
**	@ - Goto label symbols		("statement labels")
** The other two name classes ("preprocessor macro names" and "other names")
** do not need a prefix, because the former are handled during preprocessing
** prior to compilation, and the latter are normal.  For reference, here
** is a list of the overloading classes as defined in H&S, with a code:
**   OC=	Overloading Class
**	M	Preprocessor macro names
**	T	Struct/union/enum tags
**	L	Statement labels
**	*	Structure component names (unique class for each structure)
**	-	Normal
*/

#define SPC_SMEM ('+')		/* * Structure/union members */
#define SPC_TAG  ('^')		/* T Structure/union/enum tags */
#define SPC_LABEL ('@')		/* L Statement labels */
#define SPC_MACDEF ('?')	/* Special for hiding the "defined" macro */
#define SPC_IDQUOT ('`')	/* Special for hiding quoted idents */
#define SPC_IAUTO ('<')		/* Special for hiding internal auto vars */
/* Symbol Classes (some relationship to "storage classes") */

enum symbolspec {	/* OC {v=variable,f=function} */
	SC_UNDEF,	/*	Undefined  - should be zero */
	SC_RW,		/* -	Reserved Word */
	SC_MACRO,	/* -	Macro name */
	SC_TAG,		/* T	struct/union/enum tag */
	SC_UTAG,	/* T	undefined struct/union/enum tag */
	SC_MEMBER,	/* * v	struct/union member */
	SC_ENUM,	/* - v	Enumeration constant "member" */
	SC_TYPEDEF,	/* -	Typedef name */
	SC_AEXTERN,	/* - vf Assumed-extern	variable or function */
	SC_EXTERN,	/* - vf Stated-extern	variable or function */
	SC_STATIC,	/* - vf Static		variable or function */
	SC_REGISTER,	/* - v	Register	variable */
	SC_ARG,		/* - v	Formal parameter to function */
	SC_RARG,	/* - v	Register formal parameter */
	SC_AUTO,	/* - v	Auto		variable */
	SC_RAUTO,	/* - v	Register auto	variable */
	SC_ISTATIC,	/* - v	Internal static	variable (within a block) */
	SC_LABEL,	/* L	Goto label */
	SC_ULABEL,	/* L	Undefined goto label */
	SC_ILABEL	/* L	Internal ($xxx) label. Not used in symtab. */
};

/* Symbol flags */
#define SF_XLOCAL	01	/* Local symbol no longer active */
/* (old) #define SF_NLOCAL	02 */	/* Local symbol "new", just defined. */
#define SF_PARAMDECL	04	/* SC_ARG only: parameter declaration seen */
#define SF_SIDEFF	010	/* Side-effect (tag or enum) during parsing.
				** This flag is only set by CCDECL's pbase()
				** for dummy "base" symbol structures
				** and only used to detect null declarations.
				*/
#define SF_MACRO	020	/* SC_MACRO only: another indicator of
				** macro-ness, mainly to keep findsym() fast.
				*/
#define SF_MACEXP	040	/* SC_MACRO only: macro being expanded.
				** This is used to detect and suppress
				** recursive expansions.
				*/
#define SF_MACSHADOW	0100	/* Any class, indicates this symbol is
				** shadowed by a macro symbol (ie has the
				** same identifier).
				*/
				
#if 0
#define SF_REGIS	02	/* User declared this as "register" */
#endif

/*
** Global vs Local symbols
**	Local symbols are kept on the "locsymbol" list and global ones on
** the "symbol" list.  Local symbols can have the following classes:
**	SC_ARG, SC_RARG			(function parameters)
**	SC_AUTO, SC_RAUTO, SC_ISTATIC	(auto, register, static)
**	SC_TAG, SC_UTAG, SC_ENUM, SC_MEMBER (struct/union/enum tags,enums,mems)
**	SC_LABEL, SC_ULABEL, SC_ILABEL	(goto labels)
**
**	When parsing enters a scope block, "beglsym()" is called to set
** a pointer to the start of the list of symbols local to that block.
** All symbols before this pointer will belong to outer blocks; all symbols
** after this pointer will belong to this block or inner blocks.
**	When parsing leaves a block, the symbols local to that block are
** still retained so that code generation can refer to them, but they are
** rendered inactive by setting the SF_XLOCAL (ex-local) flag.  This is
** done by having "compound()" call "endlsym()".  The findsym
** routine will never return a symbol which has this flag set.
** Thus, at any time, the symbols defined within any specific block (and
** not outer or inner ones) are represented by all of the local symbols
** following this remembered "head pointer" which do NOT have SF_XLOCAL set.
**
**	All local symbols -- ie everything on the locsymbol list -- are
** flushed completely when the code generator has finished dealing with
** a function's parse tree.  "ridlsym()" is the function called to do this.
** Note that SC_ARG and SC_RARG are active over the entire body of
** a function.
**
**	Note that SC_ILABEL symbols are never found in the symbol table
** itself.  These are generated by CCLAB and kept on a separate label list.
** Certain symbols may point to these "label symbols", however.
*/
/* TYPE - Type table entry
*/

TYPE {
    int Tspec;			/* Type specifier, set to a TS_ value */
    int Tsize;			/* size in words, or # elements.  See desc */
    int Tflag;			/* Flags, plus size in bits (mask 0777) */
    union {
	TYPE *t_subtype;	/* subtype if not a basic type */
	SYMBOL *t_sym;		/* or tag name of struct or union */
    } t_var;
    TYPE *Trehash;		/* Pointer to next in hash chain */
				/* only used by CCSYM's findtype() */
};

/* Define members for public consumption. "t_" members should never
** be used by code. */
#define Tsmtag t_var.t_sym	/* TS_STRUCT or TS_UNION - tag pointer */
#define Tsubt t_var.t_subtype	/* Subtype - used only by:
				** TS_FUNCT (function returning subtype)
				** TS_ARRAY (array of subtype)
				** TS_PTR   (pointer to subtype)
				*/
/* Tsize normally represents the size of the object in terms of words.
** However, there are some exceptions:
** If TS_STRUCT or TS_UNION and the structure is not yet defined
**	(i.e. Tsmtag->Sclass == SC_UTAG) then Tsize is 0 since size is unknown.
** If TS_ARRAY, Tsize is the # of objects in the array, each of which has
**	the given subtype.  So the total size is Tsize times the size of
**	the subtype.
**	If Tsize is 0, then the size of the array is unknown.  This can
**	happen when the user declares something like "int foo[];"
**	However, only the first dimension of a (possibly multi-dimensional)
**	array can be left unspecified in this way, and obviously it will not
**	work to do a sizeof on this array.
**
** It used to be the case that a type of TS_PTR used Tsize as an array
** indicator.  THIS IS NO LONGER TRUE, but for reference:
**	If Tsize 0, this was a normal TS_PTR to some object and the pointer
**		had the size PTRSIZE.
**	If Tsize non-zero, then this was a hybrid type that represented an
**		array name coerced into a pointer.  Tsize and Tsubt
**		were the same as the Tsize and Tsubt of the array in question.
**		The array type itself could be found by doing a findtype
**		of TS_ARRAY with the given Tsize and Tsubt.
** To repeat: TS_PTR is now just a normal type, and its Tsize always
** represents the pointer size (1 word).
*/

/* Tflag is used to hold both flags and the # of bits occupied by an object
** of this type.  While flags may be used by any type, the size in bits is
** only meaningful for objects of scalar type, and is only really used for
** objects of integral type.
*/
#define tbitsize(t) ((t)->Tflag&0777)	/* Get size in bits for a type */

#define TF_CONST	01000	/* Type is a "const" object */
#define TF_VOLATILE	02000	/* Type is a "volatile" object */
		/*	04000	reserved */
#define TF_INTEG	010000	/* Integral type */
#define TF_FLOAT	020000	/* Floating-point type */
#define TF_SCALAR	040000	/* Scalar type */
#define TF_UNSIGN	0100000	/* Unsigned type */
#define TF_CHAR		0200000 /* Char type */
#define TF_BITF		0400000 /* Bitfield type */
#define TF_STRUCT	01000000 /* Struct or Union type */
#define TF_BYTE		02000000 /* Byte (non-word) type (MACH DEPENDENT) */

#define _TF_UINTEG (TF_INTEG+TF_UNSIGN)	/* to save space in alltypemacro */

/* Quick-check macros.  The TF_ types shouldn't be directly used. */
#define tisinteg(t)  ((t)->Tflag&TF_INTEG)
#define tisfloat(t)  ((t)->Tflag&TF_FLOAT)
#define tisarith(t)  ((t)->Tflag&(TF_INTEG+TF_FLOAT))
#define tisscalar(t) ((t)->Tflag&(TF_INTEG+TF_FLOAT+TF_SCALAR))
#define tischar(t)   ((t)->Tflag&TF_CHAR)
#define tisbitf(t)   ((t)->Tflag&TF_BITF)
#define tisunsign(t) ((t)->Tflag&TF_UNSIGN)
#define tissigned(t) (!tisunsign(t))
#define tisstruct(t) ((t)->Tflag&TF_STRUCT)	/* struct or union */
#define tisbyte(t)   ((t)->Tflag&TF_BYTE)	/* Byte (non-word) object */

/* Same macros, but with a Tspec argument. */
#define tspisinteg(ts)  (_tfltab[ts]&TF_INTEG)
#define tspisfloat(ts)  (_tfltab[ts]&TF_FLOAT)
#define tspisarith(ts)  (_tfltab[ts]&(TF_INTEG+TF_FLOAT))
#define tspisscalar(ts) (_tfltab[ts]&(TF_INTEG+TF_FLOAT+TF_SCALAR))
#define tspischar(ts)   (_tfltab[ts]&TF_CHAR)
#define tspisunsigned(ts) (_tfltab[ts]&TF_UNSIGN)

extern int _tfltab[];	/* Flag table, kept in CCDATA */
/* Type Specifiers */

/* Define moby macro defining all type specs.
**	typespec(enum_name, string, size_in_bits, flags)
**
**	The size_in_bits for bitfields is ostensibly 1 here only so that
**	tables will be initialized properly.  In actuality their size
**	varies (and the same is possible for char).
*/
#define alltypemacro \
 /* Misc types (keep TS_VOID as zero for elegance) */\
    typespec(TS_VOID, "void",	 0,0)	/* (void) */\
    typespec(TS_FUNCT,"function",0,0)	/* Function (rets subtype) */\
 /* Aggregate types */\
    typespec(TS_ARRAY, "array",  0,0)		/* Array (of a subtype) */\
    typespec(TS_STRUCT,"struct", 0,TF_STRUCT)	/* Structure */\
    typespec(TS_UNION, "union",  0,TF_STRUCT)	/* Union */\
 /* Scalar misc types */\
    typespec(TS_PTR, "pointer",TGSIZ_PTR, TF_SCALAR)	/* Ptr (to subtype) */\
    typespec(TS_ENUM,"enum",   TGSIZ_ENUM,TF_SCALAR)	/* Enum */\
 /* Scalar Arithmetic types - Floating-point */\
    typespec(TS_FLOAT, "float", TGSIZ_FLOAT, TF_FLOAT) /* (float) */\
    typespec(TS_DOUBLE,"double",TGSIZ_DOUBLE,TF_FLOAT) /* (double) */\
    typespec(TS_LNGDBL,"lngdbl",TGSIZ_LNGDBL,TF_FLOAT) /* (long double) */\
 /* Scalar Arithmetic types - Integral */\
    typespec(TS_BITF, "bitf",    1,          TF_INTEG+TF_BITF)	/* bitfield */\
    typespec(TS_CHAR, "char",    TGSIZ_CHAR, TF_INTEG+TF_CHAR)	/* char  */\
    typespec(TS_SHORT,"short",   TGSIZ_SHORT,TF_INTEG)		/* short */\
    typespec(TS_INT,  "int",     TGSIZ_INT,  TF_INTEG)		/* int   */\
    typespec(TS_LONG, "long",    TGSIZ_LONG, TF_INTEG)		/* long  */\
    typespec(TS_UBITF,"u_bitf",  1,          _TF_UINTEG+TF_BITF) \
    typespec(TS_UCHAR,"u_char",  TGSIZ_CHAR, _TF_UINTEG+TF_CHAR) \
    typespec(TS_USHORT,"u_short",TGSIZ_SHORT,_TF_UINTEG) \
    typespec(TS_UINT, "u_int",   TGSIZ_INT,  _TF_UINTEG) \
    typespec(TS_ULONG,"u_long",  TGSIZ_LONG, _TF_UINTEG)

/* Define indices */

enum typespecs {
#define typespec(ts,str,bsiz,fl) ts,
	alltypemacro		/* Expand */
#undef typespec
	TS_MAX			/* # types; 1st non-existent typespec index */
};

#if 0 /* Comments on types */

TS_VOID - Void.
	Tsize is 0.
TS_FUNCT - Function returning Tsubt.
	Tsize is 0.
TS_ARRAY - Array of Tsubt.
	Tsize is # of elements in array.  This may be 0 if the size of
	the array is currently unknown.
TS_STRUCT, TS_UNION - Structure/Union of Tsmtag.
	Tsize is # of words in structure.
TS_PTR - Pointer to Tsubt.
	Tsize is 1 (# wds in a pointer).

All arithmetic types plus TS_ENUM:
	Tsize = size in words (if less than 1, is 1).
	Tflag = Low-order bits have size in bits.
	Tsubt/Tsmtag is unused.

All types have Tflag set with appropriate flags.  These are
	(1) the ones specified in the alltypemacro definition
plus	(2) TF_BYTE if the object is a bitfield OR is smaller than a word.
		This is machine dependent!  All other flags are pure C.
plus	(3) TF_CONST or TF_VOLATILE if so declared.

#endif
/* Cast (Type Conversion) types (NODE.Ncast) */

#define allcastmacro \
    /* General-purpose cast types */\
	castspec(CAST_ILL,"ill")	/* convtab[] only: Illegal cast */\
	castspec(CAST_TRIV,"triv")	/* convtab[] only: types must be == */\
	castspec(CAST_NONE,"none")	/* No actual conversion needed */\
    /* Casts to Integer Type */\
	castspec(CAST_IT_IT,"it_it")	/* from Integer Type */\
	castspec(CAST_FP_IT,"fp_it")	/* from Floating-Point type */\
	castspec(CAST_EN_IT,"en_it")	/* from ENumeration type */\
	castspec(CAST_PT_IT,"pt_it")	/* from Pointer Type */\
    /* Casts to Floating-Point type */\
	castspec(CAST_FP_FP,"fp_fp")	/* from Floating-Point type */\
	castspec(CAST_IT_FP,"it_fp")	/* from Integer Type */\
    /* Casts to ENum type */\
	castspec(CAST_EN_EN,"en_en")	/* from ENumeration type */\
	castspec(CAST_IT_EN,"it_en")	/* from Integer Type */\
    /* Casts to Pointer Type */\
	castspec(CAST_PT_PT,"pt_pt")	/* from Pointer Type */\
	castspec(CAST_IT_PT,"it_pt")	/* from Integer Type */\
    /* Misc casts */\
	castspec(CAST_AR_PA,"ar_pa")	/* Array -> Ptr to 1st element */\
	castspec(CAST_FN_PF,"fn_pf")	/* Function -> Pointer to Function */\
	castspec(CAST_VOID,"void")	/* Any type to void type (discard) */


enum castspecs {
#define castspec(op,str) op,
	allcastmacro		/* Expand */
#undef castspec
	CAST_MAX		/* # of cast types */
};

/* Macro to generate a unique index for every possible type cast combo */
#define castidx(from,to) (((to)*TS_MAX)+(from))
/* Structure/Union/Enum tags and members
**
** If a type has Tspec TS_STRUCT, TS_UNION, or TS_ENUM, then it has no subtype
** pointer.  Instead, t_var is interpreted as "Tsmtag" - that is, a pointer
** to a tag symbol (Sclass SC_TAG).  In the following discussion, the word
** "structure" is understood to mean both "struct" and "union".
**
** Struct/Union/Enum types:
**	Tspec - TS_STRUCT, TS_UNION, or TS_ENUM.
**	Tsize - size of the structure, in words.  0 if structure not yet
**			defined.  INTSIZE if an enum type.
**	Tsmtag - pointer to the tag symbol for this type.
**
** Tag symbols:
**	Sclass - SC_TAG (or SC_UTAG if not yet defined).
**	Sname - the tag name, prefixed with SPC_TAG.  This will be
**		a unique internal name if the structure or enum list was
**		not named with a tag at definition time.
**	Stype - pointer to the C type.  This is in effect a backpointer
**		to the type specification described above.
**	Ssmnext - pointer to the first component symbol of this object.
**		This will be NULL if the tag is still undefined (SC_UTAG).
**		For a structure, the components are structure members
**		with Sclass SC_MEMBER.  For an enum, the components are
**		enum constants with Sclass SC_ENUM.
**
** Structure member symbols:
**	Each component of a structure is represented by an unique
** symbol table entry.  The members are linked together in order of
** definition.
**	Sclass - SC_MEMBER
**	Stype - C type of this member.
**	Ssmoff - offset from beginning of structure.
**		If positive, it is a word offset from start of struct.
**		If negative, it is a bitfield.  After making it positive again,
**			the low 12 bits are the P+S fields of a byte pointer,
**			and the remaining high bits are the word offset.
**	Ssmnext - pointer to next member (NULL if this is last one).
**	Ssmtag - pointer back to "parent" structure tag symbol.
**		The sole reason for the existence of Ssmtag is so that
**		it is possible to find out very quickly whether an
**		arbitrarily selected SC_MEMBER symbol does in fact
**		belong to a specific structure.
**
** Enum constant symbols:
**	Each component of an enum list is represented by an unique
** symbol table entry, linked together in order of definition.
** These are almost the same as SC_MEMBERs except that Svalue is used
** instead of Ssmoff.
**	Sclass - SC_ENUM
**	Stype - C type (always "int" for now).
**	Svalue - integer value of this enum constant.
**	Ssmnext - pointer to next component (NULL if this is last one).
**	Ssmtag - pointer back to "parent" tag symbol.
**		This is not really used at the moment but is kept for
**		consistency with SC_MEMBER and (someday) error messages.
**
** Tag, enum constant, and structure member symbols are treated just as
** regular variable symbols are.  They can be made global or local, and in
** particular can be "shadowed" by structure definitions in inner blocks,
** through use of the global/local symbol lists and the SF_XLOCAL flag.
**	Note that each structure member always has its own symbol cell, even
** though the identifier may duplicate that of a another structure's
** member.  They are distinguished by checking the "Ssmtag" pointer,
** which indicates the structure enclosing any particular member.
**	Enum constant symbols likewise are all unique to a particular tag,
** even though the language does not require this (in fact it requires
** that enum constant identifiers be treated in the same overloading class
** as regular variable identifiers!)  This is so the list structure won't
** be screwed up by redefinitions.  However, error messages will be
** generated whenever a duplicate enum constant definition is seen.
**
**	K&R "global" structure members are no longer allowed.
** It would not be particularly hard to allow this, but why bother?
*/

/* Define macro to get pointer to list of structure member symbols */
#define SMEMS(t) ( ((t)->Tspec == TS_STRUCT || (t)->Tspec == TS_UNION) \
	? (t)->Tsmtag->Ssmnext : (SYMBOL *)NULL )
/* This structure is only used by CCSYM in order to initialize the built-in
 * types from the "tnames" table in CCDATA.
 */
#define TYNAME struct _tyname
struct _tyname {	/* built in types */
    char *tnname;	/* Reserved keyword name, e.g. "int" */
    int tntype;		/* type specifier code (set to a TS_ value) */
    int tnsize;		/* how big it is in terms of words, e.g. INTSIZE */
};

/* Structure of entries in rwtab (reserved word table).
 * This is only used by CCSYM in order to initialize the built-in
 * types from the "rwtab" table in CCDATA.
 */
#define RESWD struct _reswd
struct _reswd {		/* reserved word entry */
    char *rw_name;	/* Reserved-word string */
    int	rw_token;	/* Token number for it (plus flags in high bits) */
};
extern RESWD rwtab[];		/* Reserved Word table */
#define RWF_TOKENMASK	0777	/* Mask for token identifier */
#define RWF_ANSI	01000	/* Word is an ANSI addition */
#define RWF_KCC		02000	/* Word is a KCC extension */

/*
** Misc shared storage
*/

EXT SYMBOL bytsym;		/* symbol for $BYTE */

EXT SYMBOL
    *csymbol,		/* current symbol */
    *symbol,		/* symbol table head ptr */
    *minsym;		/* minimum variable ptr (CC, CCSYM) */

extern TYPE *ttable[];	/* hash table of types (CCSYM, CCDATA) */
extern TYPE types[];	/* table of type records (CCDUMP, CCSYM, CCDATA) */