macrossTypes.h

/*
 * Copyright (c) 1987 Fujitsu
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
/*
	macrossTypes.h -- Data type definitions for the Macross assembler.

	Chip Morningstar -- Lucasfilm Ltd.

	1-November-1984

*/

#ifndef MACROSS_TYPES_H_
#define MACROSS_TYPES_H_

#include <stdlib.h>
#include <stdio.h>

/*
   Stuff for sorting out which target processor we are going to be an
   assembler for, this time around.
*/

/* TARGET_CPU gets defined as one of these on the 'cc' commmand line using
	the "-D" option */
#define CPU_6502	1
#define CPU_68000	2

#if TARGET_CPU == CPU_6502
#define OPERAND_DEFS	"operandDefs_6502.h"
#define OPERAND_BODY	"operandBody_6502.h"
#define CONDITION_DEFS	"conditionDefs_6502.h"
#define TARGET_CPU_STRING	"6502"

#elif TARGET_CPU == CPU_68000
#define OPERAND_DEFS	"operandDefs_68000.h"
#define OPERAND_BODY	"operandBody_68000.h"
#define CONDITION_DEFS	"conditionDefs_68000.h"
#define TARGET_CPU_STRING	"MC68000"

#endif

/*
   General types -- These data types are just useful for dealing with the
   world at large.
*/

typedef int		 	 nullType;	/* for nothingness */

typedef char		 	 anyOldThing;	/* for storage allocators */

typedef int			 bool;		/* for logical operations */
#define FALSE 0
#define TRUE  1

typedef unsigned char		 byte;

typedef unsigned short		 wordType;

typedef unsigned long		 longType;

typedef unsigned long		 bigWord;

typedef union {					/* lets us build or take */
		wordType wordPart;		/* apart a word while    */
		byte	 bytePart[2];		/* keeping control over  */
			       } byteToWordType;/* byte order.		 */
/* which element of bytePart is the low order byte and which is the high
   order byte is host-system dependent! */

typedef union {					/* lets us build or take */
		longType longPart;		/* apart a long while    */
		byte     bytePart[4];		/* keeping control over  */
			       } byteToLongType;/* byte order.		 */
/* which element of bytePart is the low order byte and which is the high
   order byte is host-system dependent! */

typedef char			 stringType;	/* sometimes...because
						   although a char is not a
string, a pointer to a char *is* a pointer to a string and pointers are what
we care about.  We never declare anything to be 'stringType' but we'll declare
lots of things 'stringType *' */

typedef long			 addressType;	/* address on the target
						   processor, not the host
						   processor */

/*
   Values: the values of Macross expressions, instruction operands, and so on
   are kept track of internally using objects of 'valueType'.  This is a
   struct consisting of the value itself together with something telling what
   kind of value it is (string, relocatable address, etc.) and what address
   mode is associated with it (direct, indirect, etc.).
 */

typedef enum {
	ABSOLUTE_VALUE, DATA_VALUE, RELOCATABLE_VALUE, BSS_VALUE,
	STRUCT_VALUE, FIELD_VALUE, MACRO_VALUE, OPERAND_VALUE, STRING_VALUE,
	CONDITION_VALUE, UNDEFINED_VALUE, FUNCTION_VALUE, BLOCK_VALUE, 
	BUILT_IN_FUNCTION_VALUE, ARRAY_VALUE, FAIL
			       } valueKindType;
#define NUM_OF_VALUE_KINDS	16	/* C really could benefit from a
				'cardinality-of-enumerated-type' operator */

#define ABSOLUTE_VALUE_BIT		0x0001
#define DATA_VALUE_BIT			0x0002
#define RELOCATABLE_VALUE_BIT		0x0004
#define BSS_VALUE_BIT			0x0008
#define STRUCT_VALUE_BIT		0x0010
#define FIELD_VALUE_BIT			0x0020
#define MACRO_VALUE_BIT			0x0040
#define OPERAND_VALUE_BIT		0x0080
#define STRING_VALUE_BIT		0x0100
#define CONDITION_VALUE_BIT		0x0200
#define UNDEFINED_VALUE_BIT		0x0400
#define FUNCTION_VALUE_BIT		0x0800
#define BLOCK_VALUE_BIT			0x1000
#define BUILT_IN_FUNCTION_VALUE_BIT	0x2000
#define ARRAY_VALUE_BIT			0x4000
#define FAIL_BIT			0x8000

#include OPERAND_DEFS

typedef struct {
		valueKindType	 kindOfValue;
		int		 value;
		operandKindType	 addressMode;
			       } valueType;

typedef struct {
		int		 arraySize;
		valueType      **arrayContents;
			       } arrayType;

/*
   Input files are kept track of using 'fileNameListType'.  A linked list of
   these structs is built with one entry for each input file given on the
   command line.  Include files are pushed onto the head of this list.  Thus,
   the standard action upon reading an EOF is to pop the list.  When the list
   is empty, we're done!
 */

typedef struct fileNameListStruct {
		char				*name;
		FILE				*fildes;
		bool		 		 openFlag;
		int				 lineNumber;
		struct fileNameListStruct	*nextFileName;
			       } fileNameListType;

typedef struct commandLineDefineStruct {
		char				*name;
		int				 value;
		struct commandLineDefineStruct	*nextDefine;
			       } commandLineDefineType;

/*
   Internal tables
*/

/* Symbol table: all user-defined symbols are kept in the symbol table.  Each
   symbol has but one entry.  Associated with each such entry is a list of
   'symbolInContextType's that contain information pertaining to particular
   uses of individual symbols.  This is how we handle scoping in function and
   macro calls. */

typedef int			 symbolAttributesType; /* Symbol attributes */
#define GLOBAL_ATT		0x01		/* are orthogonal to symbol */
#define ZERO_PAGE_ATT		0x02		/* type */
#define DEFINED_VARIABLE_ATT	0x04
#define SYMBOL_USED_ATT		0x08
#define SPECIAL_FUNCTION_ATT	0x10
#define TENTATIVE_GLOBAL_ATT	0x20

typedef enum {
		STRUCT_NAME_SYMBOL, STRUCT_FIELD_SYMBOL, MACRO_SYMBOL,
		ARGUMENT_SYMBOL, LABEL_SYMBOL, EXTERNAL_SYMBOL,
		VARIABLE_SYMBOL, MVARIABLE_SYMBOL, UNKNOWN_SYMBOL,
		DEAD_SYMBOL, FUNCTION_SYMBOL, BUILT_IN_FUNCTION_SYMBOL,
		NESTED_UNKNOWN_SYMBOL, DEFINE_SYMBOL, MDEFINE_SYMBOL,
		UNKNOWN_FUNCTION_SYMBOL, UNKNOWN_MACRO_SYMBOL,
			       } symbolUsageKindType;
#define NUM_OF_SYM_USAGES 17

typedef struct symbolInContextStruct {
		valueType			*value;
		symbolUsageKindType		 usage;
		symbolAttributesType		 attributes;
		int				 referenceCount;
		struct symbolInContextStruct	*pushedContexts;
		int				 environmentNumber;
		int				 definingLineNumber;
		char				*definingFileName;
			       } symbolInContextType;
#define GLOBAL_ENVIRONMENT_NUMBER	0

typedef struct environmentStruct {
		int				 environmentNumber;
		struct environmentStruct	*previousEnvironment;
			       } environmentType;

#define pushEnvironment(newEnv) {\
			newEnv.environmentNumber = nextEnvironmentNumber++;\
			newEnv.previousEnvironment = currentEnvironment;\
			currentEnvironment = &newEnv;\
		}

#define popEnvironment()	currentEnvironment = currentEnvironment->\
						     previousEnvironment;

typedef struct symbolTableEntryStruct {
		stringType			*symbolName;
		struct symbolTableEntryStruct	*nextSymbol;
		symbolInContextType		*context;
		int				 ordinal;
		int				 referenceCount;
			       } symbolTableEntryType;

#define symbName(sptr) 		((sptr)->symbolName)

/* symbolClass bits */
#define	SYMBOL_UNDEFINED	0x00
#define SYMBOL_ABSOLUTE		0x02
#define SYMBOL_RELOCATABLE	0x04
#define SYMBOL_EXTERNAL		0x01

typedef struct {
	byte			 symbolClass; /* see above */
	int			 symbolValue;
		       } objectSymbolType;

/* These structs are used to allow us to put symbols in the object file */

#define MODE_ABSOLUTE		0
#define MODE_RELOCATABLE	1

#define REF_BYTE		0
#define REF_WORD		1
#define REF_DBYTE		2
#define REF_LONG		3

typedef struct {
	bigWord		 referenceAddress : 24, /* target machine address */
			 referenceMode     : 1, /* see above MODE_xx defines*/
			 referenceRelative : 1, /* TRUE==is relative */
			 referenceKind     : 3, /* see above REF_xx defines */
			 referenceExternal : 1, /* TRUE==is ref to external */
			 : 2; /* unused bits */
	int		 referenceExpression;	/* local expression ordinal */
		       } expressionReferenceType;

#define ExpressionType		 struct expressionTermStruct

typedef struct expressionReferenceListStruct {
		expressionReferenceType		      relocation;
		struct expressionReferenceListStruct *nextReference;
		ExpressionType			     *expressionReferenced;
			       } expressionReferenceListType;

/* These are sort of 'forward references' to types used in the construction of
   parse trees, but they are refered to by various internal tables and so have
   to go here, rather than with the other parse-tree types.  */

#define BlockType		 struct statementStruct

#define IdentifierListType	 struct identifierListStruct
#define IdentifierListHeadType	 struct identifierListHeadStruct

typedef symbolTableEntryType	 argumentType;

typedef struct argumentDefinitionListStruct {
		argumentType				*theArgument;
		struct argumentDefinitionListStruct	*nextArgument;
			       } argumentDefinitionListType;

typedef struct {
		argumentType			*theArgument;
		argumentDefinitionListType	*nextArgument;
		argumentDefinitionListType	*tail;
		bool				 arrayTag;
			       } argumentListHeadType;

/* Macros: */
typedef struct macroTableEntryStruct {
		stringType			*macroName;
		struct macroTableEntryStruct	*nextMacro;
		argumentDefinitionListType	*arguments;
		BlockType			*body;
			       } macroTableEntryType;

/* Functions: */
typedef struct functionDefinitionStruct {
		symbolTableEntryType		*functionName;
		argumentDefinitionListType	*arguments;
		BlockType			*body;
		int				 ordinal;
		struct functionDefinitionStruct *nextExternalFunction;
			       } functionDefinitionType;

typedef struct opcodeTableEntryStruct {
		stringType			*mnemonic;
		struct opcodeTableEntryStruct	*nextOpcode;
		unsigned int			 opcode;
		addressClassType		 addressClass;
		int				 permissibleOperandModes;
		int				 minNumberOfOperands;
		int				 maxNumberOfOperands;
		int				 subClass;
			       } opcodeTableEntryType;

/* Macross keywords: */
typedef struct keywordTableEntryStruct {
		stringType			*string;
		struct keywordTableEntryStruct	*nextKeyword;
		int				 token;
			       } keywordTableEntryType;

/* All the various things that are stored in tables, like keywords, symbols
   and macro names, are stored with a common format to the head of the struct
   that defines them, so that a set of generic table handling routines may be
   written.  These routines look at the following type: */

typedef struct genericTableEntryStruct {
		stringType			*string;
		struct genericTableEntryStruct	*next;
			       } genericTableEntryType;
/*
   Parser types -- These data types define the parse-tree data structure
   which is constructed during the parse phase of assembly.  This is the form
   in which statements are stored internally prior to being turned into
   object code, as well as the form in which macros and functions are
   remembered.

   The exposition of the types is by necessity bottom-up.  That's C.
*/

typedef int			 postOpKindType;

typedef struct {
		postOpKindType		 postOp;
		ExpressionType		*postOpArgument;
			       } postOpTermType;

typedef int			 preOpKindType;

typedef struct {
		preOpKindType		 preOp;
		ExpressionType		*preOpArgument;
			       } preOpTermType;

typedef int			 unopKindType;

typedef int			 binopKindType;

typedef enum {
		ASSIGN_ASSIGN, ADD_ASSIGN, SUB_ASSIGN, MUL_ASSIGN, DIV_ASSIGN,
		MOD_ASSIGN, AND_ASSIGN, OR_ASSIGN, XOR_ASSIGN,
		LEFT_SHIFT_ASSIGN, RIGHT_SHIFT_ASSIGN, NO_ASSIGN
			       } assignmentKindType;

typedef struct {
		unopKindType		 unop;
		ExpressionType		*unopArgument;
			       } unopTermType;

typedef struct {
		binopKindType		 binop;
		ExpressionType		*leftArgument;
		ExpressionType		*rightArgument;
			       } binopTermType;

#define ExpressionListType	 struct expressionListStruct

typedef struct {
		ExpressionType		*arrayName;
		ExpressionType		*arrayIndex;
			       } arrayTermType;

typedef ExpressionType		 subexpressionTermType;

typedef int			 numberTermType;

#define OperandListType		 struct operandStruct

typedef struct {
		symbolTableEntryType	*functionName;
		OperandListType		*parameters;
			       } functionCallTermType;

typedef symbolTableEntryType	 identifierTermType;

typedef nullType		 hereTermType;

#include CONDITION_DEFS

typedef struct conditionTableEntryStruct {
		stringType			 *string;
		struct conditionTableEntryStruct *nextCondition;
		conditionType			  code;
			       } conditionTableEntryType;

typedef conditionType		 conditionCodeTermType;

typedef stringType		 stringTermType;

typedef enum {
		IDENTIFIER_EXPR, FUNCTION_CALL_EXPR, NUMBER_EXPR,
		SUBEXPRESSION_EXPR, UNOP_EXPR, BINOP_EXPR, PREOP_EXPR,
		POSTOP_EXPR, HERE_EXPR, ASSIGN_EXPR, CONDITION_CODE_EXPR,
		STRING_EXPR, VALUE_EXPR, ARRAY_EXPR,
			       } expressionTermKindType;

typedef union expressionTermBodyUnion {
		identifierTermType	*identifierUnion;
		functionCallTermType	*functionCallUnion;
		numberTermType		 numberUnion;
		conditionCodeTermType	 conditionCodeUnion;
		subexpressionTermType	*subexpressionUnion;
		unopTermType		*unopUnion;
		binopTermType		*binopUnion;
		preOpTermType		*preOpUnion;
		postOpTermType		*postOpUnion;
		hereTermType		*hereUnion;
		stringTermType		*stringUnion;
		arrayTermType		*arrayUnion;
		valueType		*valueUnion;
		symbolTableEntryType	*symbolTableUnion;
		conditionType		 conditionTypeUnion;
		void			*expressionUnion; /* this should be expressionTermType, but there's a cycle */
			       } expressionTermBodyType;

typedef struct expressionTermStruct {
		expressionTermKindType	 kindOfTerm;
		expressionTermBodyType	 expressionTerm;
			       } expressionTermType;

typedef expressionTermType	 expressionType;

typedef enum {
		BYTE_FIXUP, WORD_FIXUP, NO_FIXUP, OPERAND_FIXUP,
		BYTE_RELATIVE_FIXUP, DBYTE_FIXUP, NO_FIXUP_OK, LONG_FIXUP,
		WORD_RELATIVE_FIXUP,
			       } fixupKindType;

typedef enum {
		ABSOLUTE_BUFFER, RELOCATABLE_BUFFER, 
			       } codeBufferKindType;
#define LAST_BUFFER_KIND  ((int)RELOCATABLE_BUFFER)
#define STRUCT_BUFFER	  (LAST_BUFFER_KIND + 1)

typedef struct fixupListStruct {
		addressType			 locationToFixup;
		codeBufferKindType		 codeMode;
		fixupKindType			 kindOfFixup;
		expressionType			*theFixupExpression;
		int				 targetOffset;
		stringType			*fileName;
		int				 lineNumber;
		struct fixupListStruct		*nextFixup;
			       } fixupListType;

typedef struct simpleFixupListStruct {
		valueType			 locationToFixup;
		struct simpleFixupListStruct	*nextFixup;
			       } simpleFixupListType;

typedef expressionType		 performStatementBodyType;

typedef expressionType		 orgStatementBodyType;

typedef expressionType		 targetStatementBodyType;

typedef expressionType		 startStatementBodyType;

typedef struct identifierListStruct {
		symbolTableEntryType		*theSymbol;
		struct identifierListStruct	*nextIdentifier;
			       } identifierListType;

typedef struct identifierListHeadStruct {
		symbolTableEntryType		*theSymbol;
		struct identifierListStruct	*nextIdentifier;
		identifierListType		*tail;
			       } identifierListHeadType;

typedef identifierListType	 externStatementBodyType;

#define StatementListType	 struct statementStruct

typedef BlockType		 structBodyType;

typedef struct {
		structBodyType		*structBody;
		symbolTableEntryType	*structName;
			       } structStatementBodyType;

typedef enum {
		UNTIL_END, WHILE_END
			       } doEndKindType;

typedef struct {
		doEndKindType		 mdoEndKind;
		expressionType		*mdoEndCondition;
			       } mdoEndType;

typedef struct {
		expressionType		*mdoUntilCondition;
		BlockType		*mdoUntilLoop;
			       } mdoUntilStatementBodyType;

typedef struct {
		expressionType		*mdoWhileCondition;
		BlockType		*mdoWhileLoop;
			       } mdoWhileStatementBodyType;

typedef struct {
		expressionType		*mwhileCondition;
		BlockType		*mwhileLoop;
			       } mwhileStatementBodyType;

typedef struct {
		expressionType		*initExpression;
		expressionType		*testExpression;
		expressionType		*incrExpression;
			       } forExpressionsType;

typedef struct {
		expressionType		*initExpression;
		expressionType		*testExpression;
		expressionType		*incrExpression;
		BlockType		*forLoop;
			       } mforStatementBodyType;

#define MifStatementBodyType	 struct mifStatementBodyStruct

typedef MifStatementBodyType	 mifContinuationBodyType;

typedef union {
		mifContinuationBodyType		*mifContinuationBodyUnion;
		BlockType			*mifBlockUnion;
			       } mifContinuationType;

typedef struct {
		expressionType		*headCondition;
		BlockType		*headBody;
			       } mifHeadType;

typedef struct mifStatementBodyStruct {
		expressionType		*mifCondition;
		BlockType		*mifConsequence;
		mifContinuationType	 mifContinuation;
			       } mifStatementBodyType;

typedef identifierListType	 undefineStatementBodyType;

typedef struct {
		macroTableEntryType	   *theMacro;
		argumentDefinitionListType *theArguments;
		BlockType		   *theBlock;
			       } macroStatementBodyType;

typedef struct {
		stringType		*functionName;
		argumentDefinitionListType *theArguments;
		BlockType		*theBlock;
			       } functionStatementBodyType;

typedef struct {
		symbolTableEntryType	*theSymbol;
		expressionType		*theValue;
			       } defineStatementBodyType;

typedef struct {
		symbolTableEntryType	*theSymbol;
		expressionType		*theValue;
			       } mdefineStatementBodyType;

typedef struct {
		symbolTableEntryType	*theSymbol;
		ExpressionListType	*theValue;
		expressionType		*theDimension;
			       } variableStatementBodyType;

typedef struct {
		symbolTableEntryType	*theSymbol;
		ExpressionListType	*theValue;
		expressionType		*theDimension;
			       } mvariableStatementBodyType;

typedef identifierListType	 selectionListType;
typedef identifierListHeadType	 selectionListHeadType;

#include OPERAND_BODY

typedef struct operandStruct {
		operandKindType		 kindOfOperand;
		operandBodyType		 theOperand;
		struct operandStruct	*nextOperand;
			       } operandType;

typedef struct {
		operandKindType		 kindOfOperand;
		valueType		*theOperand;
			       } operandValueType;

typedef expressionType		 freturnStatementBodyType;

typedef operandType		 operandListType;

typedef struct {
		operandKindType		 kindOfOperand;
		operandBodyType		 theOperand;
		operandListType		*nextOperand;
		operandListType		*tail;
			       } operandListHeadType;

typedef union {
		opcodeTableEntryType	*opcodeUnion;
		macroTableEntryType	*macroUnion;
			       } instructionType;

typedef enum {
		OPCODE_INSTRUCTION, MACRO_INSTRUCTION
			       } instructionKindType;

typedef struct {
		instructionKindType	 kindOfInstruction;
		instructionType		 theInstruction;
		operandListType		*theOperands;
			       } instructionStatementBodyType;

typedef expressionType		 includeStatementBodyType;

typedef struct expressionListStruct {
		expressionType		    *theExpression;
		struct expressionListStruct *nextExpression;
			       } expressionListType;

typedef struct {
		expressionType		*theExpression;
		expressionListType	*nextExpression;
		expressionListType	*tail;
			       } expressionListHeadType;

typedef expressionListType	 stringStatementBodyType;

typedef expressionListType	 byteStatementBodyType;

typedef expressionListType	 dbyteStatementBodyType;

typedef expressionType		 alignStatementBodyType;

typedef expressionListType	 wordStatementBodyType;

typedef expressionListType	 longStatementBodyType;

typedef struct {
		doEndKindType		 doEndKind;
		conditionType		 doEndCondition;
			       } doEndType;

typedef struct {
		conditionType		 doUntilCondition;
		BlockType		*doUntilLoop;
			       } doUntilStatementBodyType;

typedef struct {
		conditionType		 doWhileCondition;
		BlockType		*doWhileLoop;
			       } doWhileStatementBodyType;

typedef struct {
		conditionType		 whileCondition;
		BlockType		*whileLoop;
			       } whileStatementBodyType;

#define IfStatementBodyType	 struct ifStatementBodyStruct

typedef enum {
		NO_CONTINUATION, ELSE_CONTINUATION, ELSEIF_CONTINUATION
			       } ifContinuationKindType;

typedef IfStatementBodyType	 ifContinuationBodyType;

typedef union {
		ifContinuationBodyType		*continuationBodyUnion;
		BlockType			*blockUnion;
			       } ifContinuationType;

typedef struct {
		conditionType		 headCondition;
		BlockType		*headBody;
			       } ifHeadType;

typedef struct ifStatementBodyStruct {
		conditionType		 ifCondition;
		BlockType		*consequence;
		ifContinuationType	 continuation;
			       } ifStatementBodyType;

typedef struct {
		expressionType		*constraint;
		BlockType		*constrainedBlock;
			       } constrainStatementBodyType;

typedef struct {
		expressionType		*condition;
		expressionType		*message;
			       } assertStatementBodyType;

typedef struct {
		expressionListType	*caseTags;
		BlockType		*caseBody;
			       } caseType;

typedef struct caseListStruct {
		caseType		*theCase;
		struct caseListStruct	*nextCase;
			       } caseListType;

typedef struct {
		caseType		*theCase;
		caseListType		*nextCase;
		caseListType		*tail;
			       } caseListHeadType;

typedef struct {
		expressionType		*switchExpression;
		caseListType		*cases;
			       } mswitchStatementBodyType;

typedef nullType		 relStatementBodyType;

typedef expressionListType	 blockStatementBodyType;

typedef BlockType		 groupStatementBodyType;

typedef union {
		ifStatementBodyType		*ifUnion;
		whileStatementBodyType		*whileUnion;
		doWhileStatementBodyType	*doWhileUnion;
		doUntilStatementBodyType	*doUntilUnion;
		wordStatementBodyType		*wordUnion;
		dbyteStatementBodyType		*dbyteUnion;
		byteStatementBodyType		*byteUnion;
		stringStatementBodyType		*stringUnion;
		blockStatementBodyType		*blockUnion;
		structStatementBodyType		*structUnion;
		instructionStatementBodyType	*instructionUnion;
		defineStatementBodyType		*defineUnion;
		mdefineStatementBodyType	*mdefineUnion;
		variableStatementBodyType	*variableUnion;
		mvariableStatementBodyType	*mvariableUnion;
		macroStatementBodyType		*macroUnion;
		functionStatementBodyType	*functionUnion;
		undefineStatementBodyType	*undefineUnion;
		mifStatementBodyType		*mifUnion;
		freturnStatementBodyType	*freturnUnion;
		mforStatementBodyType		*mforUnion;
		mwhileStatementBodyType		*mwhileUnion;
		mdoWhileStatementBodyType	*mdoWhileUnion;
		mdoUntilStatementBodyType	*mdoUntilUnion;
		includeStatementBodyType	*includeUnion;
		externStatementBodyType		*externUnion;
		startStatementBodyType		*startUnion;
		alignStatementBodyType		*alignUnion;
		orgStatementBodyType		*orgUnion;
		targetStatementBodyType		*targetUnion;
		relStatementBodyType		*relUnion;
		performStatementBodyType	*performUnion;
		groupStatementBodyType		*groupUnion;
		constrainStatementBodyType	*constrainUnion;
		assertStatementBodyType		*assertUnion;
		mswitchStatementBodyType	*mswitchUnion;
		longStatementBodyType		*longUnion;
		expressionType			*expressionUnion;
			       } statementBodyType;

typedef enum {
		IF_STATEMENT, WHILE_STATEMENT, DO_WHILE_STATEMENT,
		DO_UNTIL_STATEMENT, WORD_STATEMENT, DBYTE_STATEMENT,
		BYTE_STATEMENT, STRING_STATEMENT, STRUCT_STATEMENT,
		INSTRUCTION_STATEMENT, DEFINE_STATEMENT,
		UNDEFINE_STATEMENT, MIF_STATEMENT,
		FRETURN_STATEMENT, MFOR_STATEMENT, MDO_WHILE_STATEMENT,
		MDO_UNTIL_STATEMENT, INCLUDE_STATEMENT, EXTERN_STATEMENT,
		START_STATEMENT, ALIGN_STATEMENT, ORG_STATEMENT,
		REL_STATEMENT, PERFORM_STATEMENT, BLOCK_STATEMENT,
		MWHILE_STATEMENT, MDEFINE_STATEMENT, NULL_STATEMENT,
		GROUP_STATEMENT, MACRO_STATEMENT, FUNCTION_STATEMENT,
		VARIABLE_STATEMENT, MVARIABLE_STATEMENT, CONSTRAIN_STATEMENT,
		ASSERT_STATEMENT, MSWITCH_STATEMENT, LONG_STATEMENT,
		TARGET_STATEMENT,
			       } statementKindType;

typedef struct labelStruct {
		symbolTableEntryType	*theLabel;
		struct labelStruct	*nextLabel;
			       } labelType;

typedef labelType			 labelListType;

typedef struct {
		symbolTableEntryType	*theLabel;
		labelListType		*nextLabel;
		labelListType		*tail;
			       } labelListHeadType;

typedef struct statementStruct {
		statementKindType	 kindOfStatement;
		labelListType		*labels;
		statementBodyType	 statementBody;
		struct statementStruct	*nextStatement;
		stringType		*fileName;
		int			 lineNumber;
		int			 cumulativeLineNumber;
			       } statementType;

typedef statementType		 statementListType;

typedef statementListType	 blockType;

typedef struct {
		statementKindType	 kindOfStatement;
		labelListType		*labels;
		statementBodyType	 statementBody;
		statementListType	*nextStatement;
		stringType		*fileName;
		int			 lineNumber;
		int			 cumulativeLineNumber;
		statementListType	*tail;
			       } statementListHeadType;

typedef	statementListType	 programType;

/* End of parse-tree types */


#define UNASSIGNED	NULL

#define MAX_NAME_SIZE	300


/* Struct instances */

#define MAXIMUM_ALLOWED_STRUCT_SIZE	255

typedef struct {
		int				 structSize;
		byte				*structMap;
		fixupListType			*structFixups;
		expressionReferenceListType	*structReferences;
			       } structInstanceType;


/* Code output buffers */

#define CODE_BUFFER_SIZE	      1024
#if TARGET_CPU == CPU_6502
#define CODE_BUFFERS_IN_ADDRESS_SPACE	64

#elif TARGET_CPU == CPU_68000
#define CODE_BUFFERS_IN_ADDRESS_SPACE	256

#endif

#define bufferNumber(addr)	((addr)/CODE_BUFFER_SIZE)
#define bufferPosition(addr)	((addr)%CODE_BUFFER_SIZE)

typedef byte				 codeBufferType[CODE_BUFFER_SIZE];

typedef enum {
		BREAK_BREAK, ALIGN_BREAK, CONSTRAIN_BREAK,
		END_CONSTRAIN_BREAK,
			      } codeBreakKindType;

typedef struct codeBreakStruct {
		codeBreakKindType	 kindOfBreak;
		addressType		 breakAddress;
		int			 breakData;
		struct codeBreakStruct	*nextBreak;
			      } codeBreakType;

typedef struct {
		addressType		 codeStartAddress;
		addressType		 codeEndAddress;
		codeBufferType		*codeBuffer;
			       } codeSegmentType;

typedef struct {
		addressType		 regionStartAddress;
		addressType		 regionEndAddress;
		codeSegmentType		*codeSegments[
					       CODE_BUFFERS_IN_ADDRESS_SPACE];
			       } codeRegionType;

typedef struct reservationListStruct {
		addressType			 startAddress;
		int				 blockSize;
		struct reservationListStruct	*nextReservation;
			      } reservationListType;

#define LINE_BUFFER_SIZE 300

/* Error types */

typedef enum {
		DEFINE_ASSIGNMENT_WRONG_ERROR,
		DIGIT_OUT_OF_RADIX_ERROR,
		UNCLOSED_CHARACTER_CONSTANT_ERROR,
		UNCLOSED_STRING_CONSTANT_ERROR,
		OCTAL_CHARACTER_TOO_BIG_ERROR,
		UNRECOGNIZED_SOMETHING_OR_OTHER_ERROR,
		UNCLOSED_COMMENT_ERROR,
		UNCLOSED_LINE_COMMENT_ERROR,
		UNABLE_TO_OPEN_PASS_2_FILE_ERROR,
		BAD_ORG_ADDRESS_ERROR,
		NEGATIVE_BLOCK_SIZE_ERROR,
		UNASSIGNABLE_SYMBOL_TYPE_ERROR,
		INCOMPATIBLE_ASSIGNMENT_OPERANDS_ERROR,
		INCOMPATIBLE_BINOP_OPERANDS_ERROR,
		UNPOSTINCREMENTABLE_OPERAND_ERROR,
		UNPOSTDECREMENTABLE_OPERAND_ERROR,
		UNPREINCREMENTABLE_OPERAND_ERROR,
		UNPREDECREMENTABLE_OPERAND_ERROR,
		INCOMPATIBLE_UNOP_OPERAND_ERROR,
		VALUE_IS_NOT_AN_ADDRESS_ERROR,
		VALUE_IS_NOT_AN_INT_ERROR,
		IMPROPER_ALIGNMENT_VALUE_ERROR,
		OPERATOR_ASSIGNMENT_ON_NULL_TARGET_ERROR,
		TOO_MANY_INSTRUCTION_OPERANDS_ERROR,
		ILLEGAL_OPERAND_TYPE_ERROR,
		BYTE_VALUE_TOO_LARGE_ERROR,
		WORD_VALUE_TOO_LARGE_ERROR,
		BAD_INSTRUCTION_OPERAND_ERROR,
		DIVIDE_BY_ZERO_ERROR,
		UNDEFINED_SYMBOL_ERROR,
		RELATIVE_OFFSET_TOO_LARGE_ERROR,
		LABEL_ALREADY_DEFINED_ERROR,
		CANT_OPEN_OBJECT_FILE_ERROR,
		BAD_KIND_OF_SYMBOL_TO_MAKE_EXTERNAL_ERROR,
		MORE_THAN_ONE_OUTPUT_FILE_ERROR,
		BAD_COMMAND_LINE_FLAG_ERROR,
		NO_DASH_O_FILE_NAME_ERROR,
		UNABLE_TO_OPEN_INPUT_FILE_ERROR,
		UNABLE_TO_OPEN_INCLUDE_FILE_ERROR,
		INVALID_BOOLEAN_VALUE_ERROR,
		SYMBOL_ALREADY_THERE_ERROR,
		UNDECLARED_VARIABLE_ERROR,
		REDEFINITION_OF_SYMBOL_ERROR,
		NOT_A_STRUCT_NAME_ERROR,
		STRUCT_TOO_BIG_ERROR,
		FIELD_ALREADY_DEFINED_ERROR,
		STRUCT_DEFINITION_INSIDE_STRUCT_DEFINITION_ERROR,
		VALUE_IS_NOT_A_FIELD_ERROR,
		MACRO_ALREADY_EXISTS_ERROR,
		MACRO_DEFINITION_INSIDE_MACRO_ERROR,
		TOO_MANY_ARGUMENTS_TO_MACRO_ERROR,
		FUNCTION_DEFINITION_INSIDE_FUNCTION_ERROR,
		FUNCTION_ALREADY_EXISTS_ERROR,
		TOO_MANY_ARGUMENTS_TO_FUNCTION_ERROR,
		NOT_A_FUNCTION_ERROR,
		FUNCTION_DID_NOT_RETURN_A_VALUE_ERROR,
		BAD_ADDRESS_MODE_ERROR,
		MULTIPLE_ADDRESS_MODES_ERROR,
		INCLUDE_FILE_NOT_A_STRING_VALUE_ERROR,
		START_ADDRESS_ALREADY_GIVEN_ERROR,
		FUNCTION_IS_NOT_A_VALUE_ERROR,
		SIDE_EFFECT_ERROR,
		CANT_FIND_SYMBOL_ERROR,
		ERROR_INSIDE_MACRO_ERROR,
		ERROR_INSIDE_FUNCTION_ERROR,
		NO_LIST_FILE_NAME_ERROR,
		NO_SYMBOL_DUMP_FILE_NAME_ERROR,
		MORE_THAN_ONE_LIST_FILE_ERROR,
		MORE_THAN_ONE_SYMBOL_DUMP_FILE_ERROR,
		CANT_OPEN_LIST_FILE_ERROR,
		CANT_OPEN_SYMBOL_DUMP_FILE_ERROR,
		FILE_NAME_IS_NOT_MACROSS_SOURCE_ERROR,
		OUTPUT_FILE_NAME_IS_MACROSS_SOURCE_ERROR,
		LIST_FILE_NAME_IS_MACROSS_SOURCE_ERROR,
		SYMBOL_DUMP_FILE_NAME_IS_MACROSS_SOURCE_ERROR,
		INVALID_CONSTRAINT_VALUE_ERROR,
		CONSTRAINT_ERROR,
		UNASSIGNED_SYMBOL_ERROR,
		BAD_START_ADDRESS_ERROR,
		ALIGN_INSIDE_CONSTRAIN_ERROR,
		CONSTRAIN_INSIDE_CONSTRAIN_ERROR,
		NON_ADDRESS_WORD_VALUE_ERROR,
		NON_ADDRESS_BYTE_VALUE_ERROR,
		TOO_FEW_INSTRUCTION_OPERANDS_ERROR,
		BAD_COLOR_ARGUMENT_TO_ATASCII_COLOR_ERROR,
		PRINTF_FORMAT_IS_NOT_A_STRING_ERROR,
		BIF_NTH_ARGUMENT_IS_NOT_A_STRING_ERROR, /* name, # */
		NO_ARGUMENTS_TO_BIF_ERROR, /* name */
		BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, /* name */
		TOO_FEW_ARGUMENTS_TO_BIF_ERROR, /* name */
		BIF_NTH_ARGUMENT_IS_NOT_ABSOLUTE_VALUE_ERROR, /* name, # */
		BAD_SUBSTRING_INDICES_ERROR,
		INVALID_ASSERT_CONDITION_ERROR,
		INVALID_ASSERT_MESSAGE_ERROR,
		ASSERT_WITH_MESSAGE_ERROR,
		ASSERT_ERROR,
		INVALID_SWITCH_VALUE_KIND,
		INVALID_CASE_VALUE_KIND,
		CANT_FORWARD_REFERENCE_BLOCK_ERROR,
		MACRO_EXPANSION_WITHOUT_LISTING_ERROR,
		INAPPROPRIATE_ADDRESS_MODES_ERROR,
		CANT_DO_BYTE_ADDRESS_OP_ERROR,
		QUICK_DATA_OUT_OF_RANGE_ERROR,
		CCR_OP_IS_BYTE_OP_ERROR,
		SR_OP_IS_WORD_OP_ERROR,
		SHIFT_OP_IS_WORD_OP_ERROR,
		CMP_ADDRESS_NOT_BYTE_OP_ERROR,
		USP_MOVE_IS_LONG_OP_ERROR,
		CCR_MOVE_IS_WORD_OP_ERROR,
		SR_MOVE_IS_WORD_OP_ERROR,
		CR_MOVE_IS_LONG_OP_ERROR,
		ADDRESS_MOVE_NOT_BYTE_OP_ERROR,
		TRAP_DATA_TOO_LARGE_ERROR,
		RELATIVE_OFFSET_VALUE_TOO_LARGE_ERROR,
		CANT_DO_OP_FROM_A_REGISTER_ERROR,
		FORWARD_REFERENCE_NOT_ALLOWED_HERE_ERROR,
		ADDRESS_OUTSIDE_ADDRESS_SPACE_ERROR,
		APPLY_ARGUMENT_IS_NOT_MACRO_ERROR,
		CANT_TARGET_IN_RELOCATABLE_MODE_ERROR,
		BAD_TARGET_ADDRESS_ERROR,
		UNDEFINED_MACRO_ERROR,
		BAD_POSITION_ARGUMENT_TO_NTH_CHAR_ERROR,
		SYMBOL_DEFINE_VALUE_NOT_EXPRESSION_OPND_ERROR,
		ATTEMPT_TO_INDEX_NON_ARRAY_ERROR,
		NON_INTEGER_INDEX_ERROR,
		ARRAY_INDEX_OUT_OF_RANGE_ERROR,
		TOO_MANY_VARIABLE_INITIALIZERS_ERROR,
		NEGATIVE_ARRAY_INDEX_ERROR,
		NON_ADDRESS_LONG_VALUE_ERROR,
		CANT_POSTPREOP_STRING_ERROR,
		NON_CHARACTER_STRING_ASSIGNMENT_ERROR,
		NEGATIVE_ARRAY_SIZE_TO_MAKEARRAY_ERROR,
		TOO_MANY_INITIALIZATION_ARGS_TO_MAKEARRAY_ERROR,
		VALUELESS_ARRAY_ELEMENT_ERROR,
		CANT_USE_PREOP_WITH_FORWARD_REFERENCE_ERROR,
		CANT_USE_POSTOP_WITH_FORWARD_REFERENCE_ERROR,
		CANT_USE_ASSIGNMENT_WITH_FORWARD_REFERENCE_ERROR,
		TOO_MANY_ERRORS_ERROR,
		EXPRESSION_TOO_BIG_TO_FIT_IN_OBJECT_ERROR,
		FUNNY_ASSIGNMENT_KIND_IN_OBJECT_EXPRESSION_ERROR,
		TEMP_SYMBOL_IN_OBJECT_ERROR,
		BLOCK_OPERAND_IN_OBJECT_EXPRESSION_ERROR,
		REGISTER_OPERAND_IN_OBJECT_EXPRESSION_ERROR,
		SELECTION_OPERAND_IN_OBJECT_EXPRESSION_ERROR,
		WRONG_KIND_OF_VALUE_IN_OBJECT_EXPRESSION_ERROR,
		ARRAY_TERM_IN_OBJECT_EXPRESSION_ERROR,
		ILLEGAL_STATEMENT_IN_OBJECT_FILE_FUNCTION_ERROR,
		ARRAY_MVARIABLE_IN_OBJECT_FUNCTION_ERROR,
		BUILT_IN_FUNCTION_NOT_AVAILABLE_IN_OBJECT_ERROR,
		NO_DASH_D_FILE_NAME_ERROR,
		BAD_COMMAND_LINE_DEFINE_ERROR,
		PERFORM_WITHOUT_SIDE_EFFECT_ERROR,
			       } errorType;

#define ERROR_LIMIT 300

/* Misc. macros: */

#define qfree(thing)	if (freeFlag) free(thing);
#define qsfree(thing)	if (freeFlag&&statementEvaluationDepth<=1)free(thing);
#define toLowerCase(c)	(lowerCaseCharacterTable[(c)])
#define dupValue(new, v) {(new)=typeAlloc(valueType);*(new)= *(v);}
#define amListing()	(listingOn && !listingControlCounter)
#define amExpanding()	(expandMacros && !beneathFunction && \
				macroCallDepth > 0)
#define expand(x)	if(amExpanding()){x;}

#define EXPAND 1
/* Boy, is this macro useful! */

#define typeAlloc(type)	(type *)malloc(sizeof(type))

#endif