Protoize

command:
  protoize -c '-m32 -DTARGET_CPU=CPU_6502' -g $(ls *.c | grep -v 68)

actions_6502.c

@@ -45,11 +45,19 @@
    and operand.
  */
 
-  void
+  
-actionsDir1(opcode, numberOfOperands, evaluatedOperands)
+bool isByteAddress (valueType *value);
-  opcodeTableEntryType	*opcode;
+bool isDefined (valueType *value);
-  int			 numberOfOperands;
+extern void emitByte (byte byteValue);
-  valueType		*evaluatedOperands[];
+bool wordCheck (int value);
+extern void putFixupsHere (fixupKindType kindOfFixupsToPut, int whichFixup);
+extern void emitWord (wordType wordValue);
+bool byteCheck (int value);
+bool isByteOffset (int value);
+extern void error (errorType theError, ...);
+
+void
+actionsDir1(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
 {
 #define	ZERO_PAGE_ADDRESS_BIT		0x00
 #define NON_ZERO_PAGE_ADDRESS_BIT	0x08
@@ -66,10 +74,7 @@ actionsDir1(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsDir2(opcode, numberOfOperands, evaluatedOperands)
+actionsDir2(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 	if (wordCheck(address)) {
 		emitByte(binary);
@@ -79,10 +84,7 @@ actionsDir2(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsDirIndir(opcode, numberOfOperands, evaluatedOperands)
+actionsDirIndir(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 #define DIRECT_ADDRESS_BIT	0x00
 #define INDIRECT_ADDRESS_BIT	0x20
@@ -98,10 +100,7 @@ actionsDirIndir(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsDirX1(opcode, numberOfOperands, evaluatedOperands)
+actionsDirX1(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 #define DIRECT_ADDRESS_ZERO_PAGE_BITS_X1	0x04
 #define A_REGISTER_BITS_X1			0x08
@@ -133,10 +132,7 @@ actionsDirX1(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsDirX2(opcode, numberOfOperands, evaluatedOperands)
+actionsDirX2(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 #define DIRECT_ADDRESS_ZERO_PAGE_BITS_X2	0x00
 #define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_X2	0x08
@@ -165,10 +161,7 @@ actionsDirX2(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsDirX3(opcode, numberOfOperands, evaluatedOperands)
+actionsDirX3(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 	if (class == EXPRESSION_OPND) {
 		if (isByteAddress(operand) && isDefined(operand)) {
@@ -189,10 +182,7 @@ actionsDirX3(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsDirY(opcode, numberOfOperands, evaluatedOperands)
+actionsDirY(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 #define DIRECT_ADDRESS_ZERO_PAGE_BITS_Y		0x00
 #define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_Y	0x08
@@ -217,10 +207,7 @@ actionsDirY(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsImmDir(opcode, numberOfOperands, evaluatedOperands)
+actionsImmDir(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 #define IMMEDIATE_DATA_BITS_ID			0x00
 #define DIRECT_ADDRESS_ZERO_PAGE_BITS_ID	0x04
@@ -245,10 +232,7 @@ actionsImmDir(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsImmDirX(opcode, numberOfOperands, evaluatedOperands)
+actionsImmDirX(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 #define IMMEDIATE_DATA_BITS_IX			0x00
 #define DIRECT_ADDRESS_ZERO_PAGE_BITS_IX	0x04
@@ -284,10 +268,7 @@ actionsImmDirX(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsImmDirY(opcode, numberOfOperands, evaluatedOperands)
+actionsImmDirY(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 #define IMMEDIATE_DATA_BITS_IY			0x00
 #define DIRECT_ADDRESS_ZERO_PAGE_BITS_IY	0x04
@@ -323,10 +304,7 @@ actionsImmDirY(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsImmIndex(opcode, numberOfOperands, evaluatedOperands)
+actionsImmIndex(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 #define PRE_INDEXED_BITS_A			0x00
 #define DIRECT_ADDRESS_ZERO_PAGE_BITS_A		0x04
@@ -383,10 +361,7 @@ actionsImmIndex(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsIndex(opcode, numberOfOperands, evaluatedOperands)
+actionsIndex(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 	if (class == EXPRESSION_OPND) {
 		if (isByteAddress(operand) && isDefined(operand)) {
@@ -428,19 +403,13 @@ actionsIndex(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-actionsNone(opcode, numberOfOperands, evaluatedOperands)
+actionsNone(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 	emitByte(binary);
 }
 
   void
-actionsRelative(opcode, numberOfOperands, evaluatedOperands)
+actionsRelative(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 	int	offset;
 
@@ -465,43 +434,37 @@ actionsRelative(opcode, numberOfOperands, evaluatedOperands)
  */
 
   bool
-isByte(value)
+isByte(int value)
-  int	value;
 {
 	return (-129<value && value<256);
 }
 
   bool
-isByteOffset(value)
+isByteOffset(int value)
-  int	value;
 {
 	return (-129<value && value<128);
 }
 
   bool
-isWordOffset(value)
+isWordOffset(int value)
-  int	value;
 {
 	return (-32769<value && value<32768);
 }
 
   bool
-isByteAddress(value)
+isByteAddress(valueType *value)
-  valueType	*value;
 {
 	return(value->kindOfValue==ABSOLUTE_VALUE && isByte(value->value));
 }
 
   bool
-isWord(value)
+isWord(int value)
-  int	value;
 {
 	return (-32769<value && value<65536);
 }
 
   bool
-byteCheck(value)
+byteCheck(int value)
-  int	value;
 {
 	if (isByte(value)) {
 		return(TRUE);
@@ -512,8 +475,7 @@ byteCheck(value)
 }
 
   bool
-wordCheck(value)
+wordCheck(int value)
-  int	value;
 {
 	if (isWord(value)) {
 		return(TRUE);
@@ -525,8 +487,7 @@ wordCheck(value)
 }
 
   bool
-isDefined(value)
+isDefined(valueType *value)
-  valueType	*value;
 {
 	return(value!=NULL && value->kindOfValue!=UNDEFINED_VALUE);
 }

buildStuff1.c

@@ -33,14 +33,16 @@
 #include "macrossTypes.h"
 #include "macrossGlobals.h"
 
-symbolTableEntryType		*lookupOrEnterSymbol();
+symbolTableEntryType		*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
-char				*saveString();
+char				*saveString(char *s);
 
 /* Generic routine to create statement nodes */
-  statementType *
+  
-newStatement(kind, body)
+extern void botch (char *message, ...);
-  statementKindType	 kind;
+extern void error (errorType theError, ...);
-  statementBodyType	 body;
+
+statementType *
+newStatement(statementKindType kind, statementBodyType body)
 {
 	statementType	*result;
 
@@ -62,17 +64,14 @@ newStatement(kind, body)
  */
 
   statementType *
-buildAlignStatement(expression)
+buildAlignStatement(expressionType *expression)
-  expressionType *expression;
 {
 	return(newStatement(ALIGN_STATEMENT,
 	       (statementBodyType) expression));
 }
 
   statementType *
-buildAssertStatement(condition, message)
+buildAssertStatement(expressionType *condition, expressionType *message)
-  expressionType	*condition;
-  expressionType	*message;
 {
 	assertStatementBodyType	*result;
 
@@ -84,25 +83,21 @@ buildAssertStatement(condition, message)
 }
 
   statementType *
-buildBlockStatement(expressionList)
+buildBlockStatement(expressionListType *expressionList)
-  expressionListType *expressionList;
 {
 	return(newStatement(BLOCK_STATEMENT,
 	       (statementBodyType) expressionList));
 }
 
   statementType *
-buildByteStatement(expressionList)
+buildByteStatement(expressionListType *expressionList)
-  expressionListType *expressionList;
 {
 	return(newStatement(BYTE_STATEMENT,
 	       (statementBodyType) expressionList));
 }
 
   statementType *
-buildConstrainStatement(expression, block)
+buildConstrainStatement(expressionType *expression, blockType *block)
-  expressionType	*expression;
-  blockType		*block;
 {
 	constrainStatementBodyType	*result;
 
@@ -114,17 +109,14 @@ buildConstrainStatement(expression, block)
 }
 
   statementType *
-buildDbyteStatement(expressionList)
+buildDbyteStatement(expressionListType *expressionList)
-  expressionListType *expressionList;
 {
 	return(newStatement(DBYTE_STATEMENT,
 	       (statementBodyType) expressionList));
 }
 
   statementType *
-buildDefineStatement(name, value)
+buildDefineStatement(stringType *name, expressionType *value)
-  stringType		*name;
-  expressionType	*value;
 {
 	defineStatementBodyType	*result;
 
@@ -135,9 +127,7 @@ buildDefineStatement(name, value)
 }
 
   statementType *
-buildDoUntilStatement(body, condition)
+buildDoUntilStatement(blockType *body, conditionType condition)
-  blockType	*body;
-  conditionType	 condition;
 {
 	doUntilStatementBodyType	*result;
 
@@ -148,9 +138,7 @@ buildDoUntilStatement(body, condition)
 }
 
   statementType *
-buildDoWhileStatement(body, condition)
+buildDoWhileStatement(blockType *body, conditionType condition)
-  blockType	*body;
-  conditionType	 condition;
 {
 	doWhileStatementBodyType	*result;
 
@@ -161,9 +149,7 @@ buildDoWhileStatement(body, condition)
 }
 
   statementType *
-buildDoStatement(body, end)
+buildDoStatement(blockType *body, doEndType *end)
-  blockType	*body;
-  doEndType	*end;
 {
 	statementType	*result;
 
@@ -178,26 +164,21 @@ buildDoStatement(body, end)
 }
 
   statementType *
-buildExternStatement(identifierList)
+buildExternStatement(identifierListType *identifierList)
-  identifierListType	*identifierList;
 {
 	return(newStatement(EXTERN_STATEMENT,
 	       (statementBodyType) identifierList));
 }
 
   statementType *
-buildFreturnStatement(expression)
+buildFreturnStatement(expressionType *expression)
-  expressionType	*expression;
 {
 	return(newStatement(FRETURN_STATEMENT,
 	       (statementBodyType) expression));
 }
 
   statementType *
-buildFunctionStatement(name, arguments, body)
+buildFunctionStatement(stringType *name, argumentDefinitionListType *arguments, blockType *body)
-  stringType			*name;
-  argumentDefinitionListType	*arguments;
-  blockType			*body;
 {
 	functionStatementBodyType	*result;
 	symbolTableEntryType		*testSymbol;
@@ -216,18 +197,14 @@ buildFunctionStatement(name, arguments, body)
 }
 
   statementType *
-buildGroupStatement(block)
+buildGroupStatement(blockType *block)
-  blockType		*block;
 {
 	return(newStatement(GROUP_STATEMENT,
 		(statementBodyType) block));
 }
 
   statementType *
-buildIfStatement(head, continuation, continuationKind)
+buildIfStatement(ifHeadType *head, ifContinuationType continuation, ifContinuationKindType continuationKind)
-  ifHeadType			*head;
-  ifContinuationType		 continuation;
-  ifContinuationKindType	 continuationKind;
 {
 	ifStatementBodyType	*result;
 
@@ -255,17 +232,14 @@ buildIfStatement(head, continuation, continuationKind)
 }
 
   statementType *
-buildIncludeStatement(filename)
+buildIncludeStatement(expressionType *filename)
-  expressionType	*filename;
 {
 	return(newStatement(INCLUDE_STATEMENT,
 	       (statementBodyType) filename));
 }
 
   statementType *
-buildInstructionStatement(opcode, operands)
+buildInstructionStatement(opcodeTableEntryType *opcode, operandListType *operands)
-  opcodeTableEntryType	*opcode;
-  operandListType	*operands;
 {
 	instructionStatementBodyType	*result;
 
@@ -277,18 +251,14 @@ buildInstructionStatement(opcode, operands)
 }
 
   statementType *
-buildLongStatement(expressionList)
+buildLongStatement(expressionListType *expressionList)
-  expressionListType	*expressionList;
 {
 	return(newStatement(LONG_STATEMENT,
 	       (statementBodyType)  expressionList));
 }
 
   statementType *
-buildMacroStatement(macro, arguments, body)
+buildMacroStatement(macroTableEntryType *macro, argumentDefinitionListType *arguments, blockType *body)
-  macroTableEntryType		*macro;
-  argumentDefinitionListType	*arguments;
-  blockType			*body;
 {
 	macroStatementBodyType		*result;
 
@@ -300,9 +270,7 @@ buildMacroStatement(macro, arguments, body)
 }
 
   statementType *
-buildMacroInstructionStatement(macro, operands)
+buildMacroInstructionStatement(macroTableEntryType *macro, operandListType *operands)
-  macroTableEntryType	*macro;
-  operandListType	*operands;
 {
 	instructionStatementBodyType	*result;
 
@@ -314,9 +282,7 @@ buildMacroInstructionStatement(macro, operands)
 }
 
   statementType *
-buildMdefineStatement(name, value)
+buildMdefineStatement(stringType *name, expressionType *value)
-  stringType		*name;
-  expressionType	*value;
 {
 	mdefineStatementBodyType	*result;
 
@@ -327,9 +293,7 @@ buildMdefineStatement(name, value)
 }
 
   statementType *
-buildMdoUntilStatement(body, condition)
+buildMdoUntilStatement(blockType *body, struct expressionTermStruct *condition)
-  blockType		*body;
-  ExpressionType	*condition;
 {
 	mdoUntilStatementBodyType	*result;
 
@@ -340,9 +304,7 @@ buildMdoUntilStatement(body, condition)
 }
 
   statementType *
-buildMdoWhileStatement(body, condition)
+buildMdoWhileStatement(blockType *body, expressionType *condition)
-  blockType		*body;
-  expressionType	*condition;
 {
 	mdoWhileStatementBodyType	*result;
 
@@ -353,9 +315,7 @@ buildMdoWhileStatement(body, condition)
 }
 
   statementType *
-buildMdoStatement(body, end)
+buildMdoStatement(blockType *body, mdoEndType *end)
-  blockType	*body;
-  mdoEndType	*end;
 {
 	statementType	*result;
 
@@ -370,9 +330,7 @@ buildMdoStatement(body, end)
 }
 
   statementType *
-buildMforStatement(forExpressions, body)
+buildMforStatement(forExpressionsType *forExpressions, blockType *body)
-  forExpressionsType	*forExpressions;
-  blockType		*body;
 {
 	mforStatementBodyType	*result;
 
@@ -386,10 +344,7 @@ buildMforStatement(forExpressions, body)
 }
 
   statementType *
-buildMifStatement(head, continuation, continuationKind)
+buildMifStatement(mifHeadType *head, mifContinuationType continuation, ifContinuationKindType continuationKind)
-  mifHeadType			*head;
-  mifContinuationType		 continuation;
-  ifContinuationKindType	 continuationKind;
 {
 	mifStatementBodyType	*result;
 
@@ -417,9 +372,7 @@ buildMifStatement(head, continuation, continuationKind)
 }
 
   statementType *
-buildMswitchStatement(switchExpression, cases)
+buildMswitchStatement(expressionType *switchExpression, caseListType *cases)
-  expressionType	*switchExpression;
-  caseListType		*cases;
 {
 	mswitchStatementBodyType	*result;
 
@@ -430,10 +383,7 @@ buildMswitchStatement(switchExpression, cases)
 }
 
   statementType *
-buildMvariableStatement(name, value, dimension)
+buildMvariableStatement(stringType *name, expressionListType *value, expressionType *dimension)
-  stringType		*name;
-  expressionListType	*value;
-  expressionType	*dimension;
 {
 	mvariableStatementBodyType	*result;
 
@@ -445,9 +395,7 @@ buildMvariableStatement(name, value, dimension)
 }
 
   statementType *
-buildMwhileStatement(condition, body)
+buildMwhileStatement(expressionType *condition, blockType *body)
-  expressionType	*condition;
-  blockType		*body;
 {
 	mwhileStatementBodyType	*result;
 
@@ -458,53 +406,47 @@ buildMwhileStatement(condition, body)
 }
 
   statementType *
-buildNullStatement()
+buildNullStatement(void)
 {
 	return(newStatement(NULL_STATEMENT, (statementBodyType){ .ifUnion = NULL }));
 }
 
   statementType *
-buildOrgStatement(expression)
+buildOrgStatement(expressionType *expression)
-  expressionType	*expression;
 {
 	return(newStatement(ORG_STATEMENT,
 	       (statementBodyType) expression));
 }
 
   statementType *
-buildPerformStatement(expression)
+buildPerformStatement(expressionType *expression)
-  expressionType	*expression;
 {
 	return(newStatement(PERFORM_STATEMENT,
 		(statementBodyType) expression));
 }
 
   statementType *
-buildRelStatement()
+buildRelStatement(void)
 {
 	return(newStatement(REL_STATEMENT, (statementBodyType){ .ifUnion = NULL }));
 }
 
   statementType *
-buildStartStatement(expression)
+buildStartStatement(expressionType *expression)
-  expressionType	*expression;
 {
 	return(newStatement(START_STATEMENT,
 	       (statementBodyType) expression));
 }
 
   statementType *
-buildStringStatement(expressionList)
+buildStringStatement(expressionListType *expressionList)
-  expressionListType	*expressionList;
 {
 	return(newStatement(STRING_STATEMENT,
 	       (statementBodyType) expressionList));
 }
 
   statementType *
-buildStructStatement(name, body)
+buildStructStatement(symbolTableEntryType *name, blockType *body)
-  symbolTableEntryType	*name;
-  blockType		*body;
 {
 	structStatementBodyType		*result;
 
@@ -515,26 +457,21 @@ buildStructStatement(name, body)
 }
 
   statementType *
-buildTargetStatement(expression)
+buildTargetStatement(expressionType *expression)
-  expressionType	*expression;
 {
 	return(newStatement(TARGET_STATEMENT,
 	       (statementBodyType) expression));
 }
 
   statementType *
-buildUndefineStatement(identifierList)
+buildUndefineStatement(identifierListType *identifierList)
-  identifierListType	*identifierList;
 {
 	return(newStatement(UNDEFINE_STATEMENT,
 	       (statementBodyType) identifierList));
 }
 
   statementType *
-buildVariableStatement(name, value, dimension)
+buildVariableStatement(stringType *name, expressionListType *value, expressionType *dimension)
-  stringType		*name;
-  expressionListType	*value;
-  expressionType	*dimension;
 {
 	variableStatementBodyType	*result;
 
@@ -546,9 +483,7 @@ buildVariableStatement(name, value, dimension)
 }
 
   statementType *
-buildWhileStatement(condition, body)
+buildWhileStatement(conditionType condition, blockType *body)
-  conditionType		 condition;
-  blockType		*body;
 {
 	whileStatementBodyType	*result;
 
@@ -559,8 +494,7 @@ buildWhileStatement(condition, body)
 }
 
   statementType *
-buildWordStatement(expressionList)
+buildWordStatement(expressionListType *expressionList)
-  expressionListType	*expressionList;
 {
 	return(newStatement(WORD_STATEMENT,
 	       (statementBodyType) expressionList));

buildStuff2.c

@@ -41,10 +41,11 @@
 
 /* Fragments of statement structures */
 
-  caseType *
+  
-buildCase(caseTags, caseBody)
+extern void botch (char *message, ...);
-  expressionListType	*caseTags;
+
-  blockType		*caseBody;
+caseType *
+buildCase(expressionListType *caseTags, blockType *caseBody)
 {
 	caseType	*result;
 
@@ -55,9 +56,7 @@ buildCase(caseTags, caseBody)
 }
 
   doEndType *
-buildDoEnd(condition, kindOfDoEnd)
+buildDoEnd(conditionType condition, doEndKindType kindOfDoEnd)
-  conditionType		 condition;
-  doEndKindType		 kindOfDoEnd;
 {
 	doEndType	*result;
 
@@ -68,10 +67,7 @@ buildDoEnd(condition, kindOfDoEnd)
 }
 
   forExpressionsType *
-buildForExpressions(initExpression, testExpression, incrExpression)
+buildForExpressions(expressionType *initExpression, expressionType *testExpression, expressionType *incrExpression)
-  expressionType	*initExpression;
-  expressionType	*testExpression;
-  expressionType	*incrExpression;
 {
 	forExpressionsType	*result;
 
@@ -83,9 +79,7 @@ buildForExpressions(initExpression, testExpression, incrExpression)
 }
 
   ifHeadType *
-buildIfHead(condition, block)
+buildIfHead(conditionType condition, blockType *block)
-  conditionType	 condition;
-  blockType	*block;
 {
 	ifHeadType	*result;
 
@@ -96,9 +90,7 @@ buildIfHead(condition, block)
 }
 
   mdoEndType *
-buildMdoEnd(condition, kindOfMdoEnd)
+buildMdoEnd(expressionType *condition, doEndKindType kindOfMdoEnd)
-  expressionType	*condition;
-  doEndKindType		 kindOfMdoEnd;
 {
 	mdoEndType	*result;
 
@@ -110,9 +102,7 @@ buildMdoEnd(condition, kindOfMdoEnd)
 
 
   mifHeadType *
-buildMifHead(condition, block)
+buildMifHead(expressionType *condition, blockType *block)
-  expressionType	*condition;
-  blockType		*block;
 {
 	mifHeadType	*result;
 
@@ -126,9 +116,7 @@ buildMifHead(condition, block)
 /* Fragments of expression structures */
 
   arrayTermType *
-buildArrayTerm(array, index)
+buildArrayTerm(expressionType *array, expressionType *index)
-  expressionType	*array;
-  expressionType	*index;
 {
 	arrayTermType	*result;
 
@@ -139,10 +127,7 @@ buildArrayTerm(array, index)
 }
 
   binopTermType *
-buildBinopTerm(binop, leftArgument, rightArgument)
+buildBinopTerm(binopKindType binop, expressionType *leftArgument, expressionType *rightArgument)
-  binopKindType		 binop;
-  expressionType	*leftArgument;
-  expressionType	*rightArgument;
 {
 	binopTermType	*result;
 
@@ -154,12 +139,10 @@ buildBinopTerm(binop, leftArgument, rightArgument)
 }
 
   functionCallTermType *
-buildFunctionCall(functionName, arguments)
+buildFunctionCall(stringType *functionName, operandListType *arguments)
-  stringType		*functionName;
-  operandListType	*arguments;
 {
 	functionCallTermType	*result;
-	symbolTableEntryType	*lookupOrEnterSymbol();
+	symbolTableEntryType	*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
 
 	result = typeAlloc(functionCallTermType);
 	result->functionName = lookupOrEnterSymbol(functionName,
@@ -169,9 +152,7 @@ buildFunctionCall(functionName, arguments)
 }
 
   postOpTermType *
-buildPostOpTerm(postOp, postOpArgument)
+buildPostOpTerm(postOpKindType postOp, expressionType *postOpArgument)
-  postOpKindType	 postOp;
-  expressionType	*postOpArgument;
 {
 	postOpTermType	*result;
 
@@ -182,9 +163,7 @@ buildPostOpTerm(postOp, postOpArgument)
 }
 
   preOpTermType *
-buildPreOpTerm(preOp, preOpArgument)
+buildPreOpTerm(preOpKindType preOp, expressionType *preOpArgument)
-  preOpKindType		 preOp;
-  expressionType	*preOpArgument;
 {
 	preOpTermType	*result;
 
@@ -195,9 +174,7 @@ buildPreOpTerm(preOp, preOpArgument)
 }
 
   unopTermType *
-buildUnopTerm(unop, unopArgument)
+buildUnopTerm(unopKindType unop, expressionType *unopArgument)
-  unopKindType		 unop;
-  expressionType	*unopArgument;
 {
 	unopTermType	*result;
 
@@ -208,15 +185,11 @@ buildUnopTerm(unop, unopArgument)
 }
 
   expressionTermType *  
-buildExpressionTerm(kindOfExpressionTerm, arg1, arg2, arg3)
+buildExpressionTerm(expressionTermKindType kindOfExpressionTerm, anyOldThing *arg1, anyOldThing *arg2, anyOldThing *arg3)
-  expressionTermKindType	 kindOfExpressionTerm;
-  anyOldThing			*arg1;
-  anyOldThing			*arg2;
-  anyOldThing			*arg3;
 {
 	expressionType		*result;
 
-	symbolTableEntryType	*lookupOrEnterSymbol();
+	symbolTableEntryType	*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
 
 	result = typeAlloc(expressionType);
 	result->kindOfTerm = kindOfExpressionTerm;
@@ -298,11 +271,10 @@ buildExpressionTerm(kindOfExpressionTerm, arg1, arg2, arg3)
 /* Other stuff */
 
   macroTableEntryType *
-buildMacroTableEntry(name)
+buildMacroTableEntry(stringType *name)
-  stringType		*name;
 {
 	macroTableEntryType	*result;
-	char			*saveString();
+	char			*saveString(char *s);
 
 	result = typeAlloc(macroTableEntryType);
 	result->macroName = saveString(name);
@@ -313,12 +285,10 @@ buildMacroTableEntry(name)
 }
 
   symbolTableEntryType *
-buildSymbolTableEntry(name, usage)
+buildSymbolTableEntry(stringType *name, symbolUsageKindType usage)
-  stringType		*name;
-  symbolUsageKindType	 usage;
 {
 	symbolTableEntryType	*result;
-	char			*saveString();
+	char			*saveString(char *s);
 
 	result = typeAlloc(symbolTableEntryType);
 	result->symbolName = saveString(name);
@@ -335,10 +305,7 @@ buildSymbolTableEntry(name, usage)
 }
 
   codeBreakType *
-buildCodeBreak(kind, address, data)
+buildCodeBreak(codeBreakKindType kind, addressType address, int data)
-  codeBreakKindType	kind;
-  addressType		address;
-  int			data;
 {
 	codeBreakType	*result;
 
@@ -351,10 +318,7 @@ buildCodeBreak(kind, address, data)
 }
 
   reservationListType *
-buildReservation(startAddress, blockSize, nextReservation)
+buildReservation(addressType startAddress, int blockSize, reservationListType *nextReservation)
-  addressType		 startAddress;
-  int			 blockSize;
-  reservationListType	*nextReservation;
 {
 	reservationListType	*result;
 
@@ -366,9 +330,7 @@ buildReservation(startAddress, blockSize, nextReservation)
 }
 
   simpleFixupListType *
-buildSimpleFixupList(locationToFixup, previousList)
+buildSimpleFixupList(valueType locationToFixup, simpleFixupListType *previousList)
-  valueType		 locationToFixup;
-  simpleFixupListType	*previousList;
 {
 	simpleFixupListType	*result;
 

buildStuff3.c

@@ -43,14 +43,11 @@
  */
 
   argumentListHeadType *
-buildArgumentList(new, rest, arrayTag)
+buildArgumentList(stringType *new, argumentListHeadType *rest, bool arrayTag)
-  stringType		*new;
-  argumentListHeadType	*rest;
-  bool			 arrayTag;
 {
 	argumentListHeadType		*newListHead;
 	argumentDefinitionListType	*newArgument;
-	symbolTableEntryType		*lookupOrEnterSymbol();
+	symbolTableEntryType		*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
 
 	if (rest == NULL) {
 		newListHead = typeAlloc(argumentListHeadType);
@@ -76,9 +73,7 @@ buildArgumentList(new, rest, arrayTag)
 }
 
   caseListHeadType *
-buildCaseList(new, rest)
+buildCaseList(caseType *new, caseListHeadType *rest)
-  caseType		*new;
-  caseListHeadType	*rest;
 {
 	caseListHeadType		*newListHead;
 	caseListType			*newCase;
@@ -103,9 +98,7 @@ buildCaseList(new, rest)
 }
 
   expressionListHeadType *
-buildExpressionList(new, rest)
+buildExpressionList(expressionType *new, expressionListHeadType *rest)
-  expressionType		*new;
-  expressionListHeadType	*rest;
 {
 	expressionListHeadType	*newListHead;
 	expressionListType	*newListEntry;
@@ -130,15 +123,12 @@ buildExpressionList(new, rest)
 }
 
   identifierListHeadType *
-buildIdentifierList(new, rest, usage)
+buildIdentifierList(stringType *new, identifierListHeadType *rest, symbolUsageKindType usage)
-  stringType			*new;
-  identifierListHeadType	*rest;
-  symbolUsageKindType		 usage;
 {
 	identifierListType	*newListEntry;
 	identifierListHeadType	*newListHead;
 
-	symbolTableEntryType	*lookupOrEnterSymbol();
+	symbolTableEntryType	*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
 
 	if (rest == NULL) {
 		newListHead = typeAlloc(identifierListHeadType);
@@ -160,9 +150,7 @@ buildIdentifierList(new, rest, usage)
 }
 
   labelListHeadType *
-buildLabelList(new, rest)
+buildLabelList(symbolTableEntryType *new, labelListHeadType *rest)
-  symbolTableEntryType	*new;
-  labelListHeadType	*rest;
 {
 	labelListHeadType	*newLabelHead;
 	labelListType		*newLabel;
@@ -187,9 +175,7 @@ buildLabelList(new, rest)
 }
 
   operandListHeadType *
-buildOperandList(new, rest)
+buildOperandList(operandType *new, operandListHeadType *rest)
-  operandType		*new;
-  operandListHeadType	*rest;
 {
 	operandListHeadType	*newListHead;
 
@@ -213,17 +199,13 @@ buildOperandList(new, rest)
 }
 
   selectionListHeadType *
-buildSelectionList(new, rest)
+buildSelectionList(selectionListType *new, selectionListHeadType *rest)
-  selectionListType	*new;
-  selectionListHeadType	*rest;
 {
 	return((selectionListHeadType *) buildIdentifierList(new, rest, unknownSymbolTag /* random guess */));
 }
 
   statementListHeadType *
-buildStatementList(new, rest)
+buildStatementList(statementType *new, statementListHeadType *rest)
-  statementType		*new;
-  statementListHeadType	*rest;
 {
 	statementListHeadType	*newListHead;
 

builtInFunctions.c

@@ -42,47 +42,54 @@
    environment
  */
 
-  valueType *
+  
-makeBooleanValue(test)
+extern void error (errorType theError, ...);
-  int	test;
+extern int hashString (char *s);
+extern void assembleMacro (macroTableEntryType *macroInstruction, operandListType *operands);
+extern void saveListingOff (void);
+extern void saveListingOn (void);
+extern bool strcmplc (char *s1, char *s2);
+extern symbolTableEntryType *lookupOrEnterSymbol (stringType *s, symbolUsageKindType kind);
+extern void assembleDefineStatement (defineStatementBodyType *defineStatement);
+extern void freeStatement (statementType *statement);
+
+valueType *
+makeBooleanValue(int test)
 {
 
 	return(newValue(ABSOLUTE_VALUE, test!=0, EXPRESSION_OPND));
 }
 
   valueType *
-makeFailureValue()
+makeFailureValue(void)
 {
 
 	return(newValue(FAIL, 0, EXPRESSION_OPND));
 }
 
   valueType *
-makeIntegerValue(integer)
+makeIntegerValue(int integer)
-  int	integer;
 {
 
 	return(newValue(ABSOLUTE_VALUE, integer, EXPRESSION_OPND));
 }
 
   valueType *
-makeOperandValue(operand)
+makeOperandValue(operandType *operand)
-  operandType	*operand;
 {
 
 	return(newValue(OPERAND_VALUE, operand, EXPRESSION_OPND));
 }
 
   valueType *
-makeStringValue(string)
+makeStringValue(stringType *string)
-  stringType	*string;
 {
 
 	return(newValue(STRING_VALUE, string, STRING_OPND));
 }
 
   valueType *
-makeUndefinedValue()
+makeUndefinedValue(void)
 {
 
 	return(newValue(UNDEFINED_VALUE, 0, EXPRESSION_OPND));
@@ -98,9 +105,7 @@ makeUndefinedValue()
 
 /* Return internal address mode of an operand */
   valueType *
-addressModeBIF(parameterList, kindOfFixup)
+addressModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -115,15 +120,13 @@ addressModeBIF(parameterList, kindOfFixup)
 
 /* Call a macro where the macro name is obtained dynamically from a string */
   valueType *
-applyBIF(parameterList, kindOfFixup)
+applyBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType		*stringValue;
 	stringType		*macroToLookup;
 	macroTableEntryType	*macroToCall;
 
-	macroTableEntryType	*lookupMacroName();
+	macroTableEntryType	*lookupMacroName(char *s, int hashValue);
 
 	if (parameterList == NULL) {
 		error(NO_ARGUMENTS_TO_BIF_ERROR, "apply");
@@ -146,9 +149,7 @@ applyBIF(parameterList, kindOfFixup)
 
 /* return the length of an array */
   valueType *
-arrayLengthBIF(parameterList, kindOfFixup)
+arrayLengthBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*testObjectValue;
 
@@ -188,9 +189,7 @@ static char	 atasciiTable[] = { /* 0xFFs will become 0x00s on output */
 
 /* Convert a string to ATASCII */
   valueType *
-atasciiBIF(parameterList, kindOfFixup)
+atasciiBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	int		 i;
 	valueType	*stringValue;
@@ -215,9 +214,7 @@ atasciiBIF(parameterList, kindOfFixup)
 
 /* Convert a string to ATASCII while setting high-order color bits */
   valueType *
-atasciiColorBIF(parameterList, kindOfFixup)
+atasciiColorBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	int		 i;
 	valueType	*stringValue;
@@ -264,18 +261,14 @@ atasciiColorBIF(parameterList, kindOfFixup)
 
 /* Turn debug mode off and on */
   valueType *
-debugModeOffBIF(parameterList, kindOfFixup)
+debugModeOffBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	debug = FALSE;
 	return(makeBooleanValue(FALSE));
 }
 
   valueType *
-debugModeOnBIF(parameterList, kindOfFixup)
+debugModeOnBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	debug = TRUE;
 	return(makeBooleanValue(TRUE));
@@ -283,18 +276,14 @@ debugModeOnBIF(parameterList, kindOfFixup)
 
 /* Turn display of code emission off and on */
   valueType *
-emitModeOffBIF(parameterList, kindOfFixup)
+emitModeOffBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	emitPrint = FALSE;
 	return(makeBooleanValue(FALSE));
 }
 
   valueType *
-emitModeOnBIF(parameterList, kindOfFixup)
+emitModeOnBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	emitPrint = TRUE;
 	return(makeBooleanValue(TRUE));
@@ -302,9 +291,7 @@ emitModeOnBIF(parameterList, kindOfFixup)
 
 /* Check if an operand is absolute (as opposed to relocatable) */
   valueType *
-isAbsoluteValueBIF(parameterList, kindOfFixup)
+isAbsoluteValueBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -320,9 +307,9 @@ isAbsoluteValueBIF(parameterList, kindOfFixup)
 
 /* Check if operand is code block */
   valueType *
-isBlockBIF(parameterList, kindOfFixup) /* questionable */
+isBlockBIF(operandListType *parameterList, fixupKindType kindOfFixup) /* questionable */
-  operandListType	*parameterList;
+                 	               
-  fixupKindType		 kindOfFixup;
+               		             
 {
 	valueType	*evaluatedParameter;
 
@@ -338,9 +325,7 @@ isBlockBIF(parameterList, kindOfFixup) /* questionable */
 
 /* Check if operand is a BIF */
   valueType *
-isBuiltInFunctionBIF(parameterList, kindOfFixup)
+isBuiltInFunctionBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -356,9 +341,7 @@ isBuiltInFunctionBIF(parameterList, kindOfFixup)
 
 /* Check if operand is a condition code */
   valueType *
-isConditionCodeBIF(parameterList, kindOfFixup)
+isConditionCodeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -374,15 +357,13 @@ isConditionCodeBIF(parameterList, kindOfFixup)
 
 /* Check if a symbol is defined */
   valueType *
-isDefinedBIF(parameterList, kindOfFixup)
+isDefinedBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	expressionType		*expression;
 	symbolInContextType	*context;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
-	symbolTableEntryType	*effectiveSymbol();
+	symbolTableEntryType	*effectiveSymbol(symbolTableEntryType *symbol, symbolInContextType **assignmentTargetContext);
 
 	if (parameterList != NULL) {
 		if (parameterList->kindOfOperand == EXPRESSION_OPND &&
@@ -409,14 +390,12 @@ isDefinedBIF(parameterList, kindOfFixup)
 
 /* Check if a symbol is externally visible */
   valueType *
-isExternalBIF(parameterList, kindOfFixup)
+isExternalBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	expressionType		*expression;
 	symbolInContextType	*context;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
 
 	if (parameterList != NULL && parameterList->kindOfOperand ==
 			EXPRESSION_OPND) {
@@ -432,9 +411,7 @@ isExternalBIF(parameterList, kindOfFixup)
 
 /* Check if an operand is a struct field */
   valueType *
-isFieldBIF(parameterList, kindOfFixup)
+isFieldBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -450,9 +427,7 @@ isFieldBIF(parameterList, kindOfFixup)
 
 /* Check if an operand is a user-defined function */
   valueType *
-isFunctionBIF(parameterList, kindOfFixup)
+isFunctionBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -468,9 +443,7 @@ isFunctionBIF(parameterList, kindOfFixup)
 
 /* Check if an operand value is relocatable */
   valueType *
-isRelocatableValueBIF(parameterList, kindOfFixup)
+isRelocatableValueBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -487,9 +460,7 @@ isRelocatableValueBIF(parameterList, kindOfFixup)
 
 /* Check if an operand is a string */
   valueType *
-isStringBIF(parameterList, kindOfFixup)
+isStringBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -505,9 +476,7 @@ isStringBIF(parameterList, kindOfFixup)
 
 /* Check if an operand is a struct */
   valueType *
-isStructBIF(parameterList, kindOfFixup)
+isStructBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
@@ -523,9 +492,7 @@ isStructBIF(parameterList, kindOfFixup)
 
 /* Check if an operand is a symbol */
   valueType *
-isSymbolBIF(parameterList, kindOfFixup)
+isSymbolBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	expressionType		*expression;
 
@@ -541,9 +508,7 @@ isSymbolBIF(parameterList, kindOfFixup)
 
 /* Turn listing off and on */
   valueType *
-listingOffBIF(parameterList, kindOfFixup)
+listingOffBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	if (listingOn) {
 		if (!listingControlCounter)
@@ -554,9 +519,7 @@ listingOffBIF(parameterList, kindOfFixup)
 }
 
   valueType *
-listingOnBIF(parameterList, kindOfFixup)
+listingOnBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	if (listingOn) {
 		if (--listingControlCounter < 0) {
@@ -575,9 +538,7 @@ listingOnBIF(parameterList, kindOfFixup)
 
 /* Generate an array on the fly */
   valueType *
-makeArrayBIF(parameterList, kindOfFixup)
+makeArrayBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*lengthValue;
 	int		 length;
@@ -619,9 +580,7 @@ makeArrayBIF(parameterList, kindOfFixup)
 
 /* Return the Nth character of a string (as an integer) */
   valueType *
-nthCharBIF(parameterList, kindOfFixup)
+nthCharBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*positionValue;
 	int		 position;
@@ -658,9 +617,7 @@ nthCharBIF(parameterList, kindOfFixup)
 
 /* Pass stuff through to stdio's 'printf' function */
   valueType *
-printfBIF(parameterList, kindOfFixup)
+printfBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	stringType	*formatString;
 	valueType	*stringValue;
@@ -697,9 +654,7 @@ printfBIF(parameterList, kindOfFixup)
 
 /* Concatenate two strings */
   valueType *
-strcatBIF(parameterList, kindOfFixup)
+strcatBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*stringValue;
 	stringType	*string1;
@@ -731,9 +686,7 @@ strcatBIF(parameterList, kindOfFixup)
 
 /* Compare two strings */
   valueType *
-strcmpBIF(parameterList, kindOfFixup)
+strcmpBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*stringValue;
 	stringType	*string1;
@@ -764,9 +717,7 @@ strcmpBIF(parameterList, kindOfFixup)
 
 /* Compare two strings in a case-independent fashion */
   valueType *
-strcmplcBIF(parameterList, kindOfFixup)
+strcmplcBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*stringValue;
 	stringType	*string1;
@@ -797,9 +748,7 @@ strcmplcBIF(parameterList, kindOfFixup)
 
 /* Return the length of a string */
   valueType *
-strlenBIF(parameterList, kindOfFixup)
+strlenBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*stringValue;
 
@@ -815,9 +764,7 @@ strlenBIF(parameterList, kindOfFixup)
 
 /* Return a substring of a string */
   valueType *
-substrBIF(parameterList, kindOfFixup)
+substrBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*stringValue;
 	stringType	*string;
@@ -895,16 +842,14 @@ substrBIF(parameterList, kindOfFixup)
 
 /* Turn a string into a symbol */
   valueType *
-symbolLookupBIF(parameterList, kindOfFixup)
+symbolLookupBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType		*stringValue;
 	stringType		*identifierToLookup;
 
-	expressionTermType	*buildExpressionTerm();
+	expressionTermType	*buildExpressionTerm(expressionTermKindType kindOfExpressionTerm, anyOldThing *arg1, anyOldThing *arg2, anyOldThing *arg3);
-	operandType		*buildOperand();
+	operandType		*buildOperand(operandKindType kindOfOperand, anyOldThing *arg);
-	valueType		*evaluateIdentifier();
+	valueType		*evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup);
 
 	if (parameterList == NULL) {
 		error(NO_ARGUMENTS_TO_BIF_ERROR, "symbolLookup");
@@ -922,13 +867,11 @@ symbolLookupBIF(parameterList, kindOfFixup)
 
 /* Define a string as a symbol */
   valueType *
-symbolDefineBIF(parameterList, kindOfFixup)
+symbolDefineBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType		*stringValue;
 	statementType		*syntheticDefineStatement;
-	statementType		*buildDefineStatement();
+	statementType		*buildDefineStatement(stringType *name, expressionType *value);
 
 	if (parameterList == NULL) {
 		error(NO_ARGUMENTS_TO_BIF_ERROR, "symbolDefine");
@@ -957,15 +900,13 @@ symbolDefineBIF(parameterList, kindOfFixup)
 
 /* Turn a symbol into a string */
   valueType *
-symbolNameBIF(parameterList, kindOfFixup)
+symbolNameBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	expressionType		*expression;
 	symbolInContextType	*context;
 	environmentType		*saveEnvironment;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
 
 	saveEnvironment = currentEnvironment;
 	while (parameterList != NULL && parameterList->kindOfOperand ==
@@ -996,14 +937,12 @@ symbolNameBIF(parameterList, kindOfFixup)
 
 /* Return internal form of what sort of symbol a symbol is */
   valueType *
-symbolUsageBIF(parameterList, kindOfFixup)
+symbolUsageBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	expressionType		*expression;
 	symbolInContextType	*context;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
 
 	if (parameterList != NULL && parameterList->kindOfOperand ==
 			EXPRESSION_OPND) {
@@ -1018,9 +957,7 @@ symbolUsageBIF(parameterList, kindOfFixup)
 
 /* Return internal form of what sort of value a value is */
   valueType *
-valueTypeBIF(parameterList, kindOfFixup)
+valueTypeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 

builtInFunsSD_6502.c

@@ -34,23 +34,21 @@
 #include "macrossGlobals.h"
 
 /* Helper functions, defined in builtInFunctions.c */
-valueType	*makeBooleanValue();
+valueType	*makeBooleanValue(int test);
-valueType	*makeFailureValue();
+valueType	*makeFailureValue(void);
-valueType	*makeIntegerValue();
+valueType	*makeIntegerValue(int integer);
-valueType	*makeOperandValue();
+valueType	*makeOperandValue(operandType *operand);
-valueType	*makeStringValue();
+valueType	*makeStringValue(stringType *string);
-valueType	*makeUndefinedValue();
+valueType	*makeUndefinedValue(void);
 
 
 /* Check if operand is the accumulator */
   valueType *
-isARegisterBIF(parameterList, kindOfFixup)
+isARegisterBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -63,13 +61,11 @@ isARegisterBIF(parameterList, kindOfFixup)
 
 /* Check if an operand's address mode is DIRECT */
   valueType *
-isDirectModeBIF(parameterList, kindOfFixup)
+isDirectModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -82,13 +78,11 @@ isDirectModeBIF(parameterList, kindOfFixup)
 
 /* Check if an operand's address mode is IMMEDIATE */
   valueType *
-isImmediateModeBIF(parameterList, kindOfFixup)
+isImmediateModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -101,13 +95,11 @@ isImmediateModeBIF(parameterList, kindOfFixup)
 
 /* Check if an operand's address mode is INDEXED (either X or Y) */
   valueType *
-isIndexedModeBIF(parameterList, kindOfFixup)
+isIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -123,13 +115,11 @@ isIndexedModeBIF(parameterList, kindOfFixup)
 
 /* Check if an operand's address mode is INDIRECT */
   valueType *
-isIndirectModeBIF(parameterList, kindOfFixup)
+isIndirectModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -142,13 +132,11 @@ isIndirectModeBIF(parameterList, kindOfFixup)
 
 /* Check if an operand's address mode is POST-INDEXED */
   valueType *
-isPostIndexedModeBIF(parameterList, kindOfFixup)
+isPostIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -161,13 +149,11 @@ isPostIndexedModeBIF(parameterList, kindOfFixup)
 
 /* Check if an operand's address mode is PRE-INDEXED */
   valueType *
-isPreIndexedModeBIF(parameterList, kindOfFixup)
+isPreIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -181,13 +167,11 @@ isPreIndexedModeBIF(parameterList, kindOfFixup)
 
 /* Check if an operand's address mode is X-INDEXED */
   valueType *
-isXIndexedModeBIF(parameterList, kindOfFixup)
+isXIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -201,13 +185,11 @@ isXIndexedModeBIF(parameterList, kindOfFixup)
 
 /* Check if an operand is the X index register */
   valueType *
-isXRegisterBIF(parameterList, kindOfFixup)
+isXRegisterBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -220,13 +202,11 @@ isXRegisterBIF(parameterList, kindOfFixup)
 
 /* Check if an operand's address mode is Y-INDEXED */
   valueType *
-isYIndexedModeBIF(parameterList, kindOfFixup)
+isYIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);
@@ -240,13 +220,11 @@ isYIndexedModeBIF(parameterList, kindOfFixup)
 
 /* Check if an operand is the Y index register */
   valueType *
-isYRegisterBIF(parameterList, kindOfFixup)
+isYRegisterBIF(operandListType *parameterList, fixupKindType kindOfFixup)
-  operandListType	*parameterList;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*evaluatedParameter;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
 
 	if (parameterList != NULL) {
 		evaluatedParameter = evaluateOperand(parameterList);

debugPrint.c

@@ -44,8 +44,14 @@ int	tablevel = 0;
 #define nullPrint(thing)   if (thing==NULL) { tab(); printf("()\n"); return; }
 
 /* For keeping nested structures looking pretty */
-  void
+  
-tab()
+extern void printOperandKind (operandKindType kind);
+extern void printToken (int token);
+extern void printCondition (conditionType condition);
+extern void printOperand (operandType *operand);
+
+void
+tab(void)
 {
 	int	n;
 
@@ -62,8 +68,7 @@ tab()
  */
 
   void
-printAssignmentKind(assignmentKind)
+printAssignmentKind(assignmentKindType assignmentKind)
-  assignmentKindType	assignmentKind;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'assignmentKindType'. */
@@ -86,8 +91,7 @@ printAssignmentKind(assignmentKind)
 }
 
   void
-printExpressionKind(kind)
+printExpressionKind(expressionTermKindType kind)
-  expressionTermKindType	kind;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'expressionTermKindType'. */
@@ -112,8 +116,7 @@ printExpressionKind(kind)
 }
 
   stringType *
-statementKindString(kind)
+statementKindString(statementKindType kind)
-  statementKindType	kind;
 {
 /* This table MUST be maintained congruently with the definition of
    the enumerated type 'statementKindType'. */
@@ -161,8 +164,7 @@ static char *statementKindTable[] = {
 }
 
   void
-printStatementKind(kind)
+printStatementKind(statementKindType kind)
-  statementKindType	kind;
 {
 	printf("%s", statementKindString(kind));
 }
@@ -173,8 +175,7 @@ printStatementKind(kind)
  */
 
   void
-printValue(value)
+printValue(valueType *value)
-  valueType	*value;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'valueKindType'. */
@@ -207,8 +208,7 @@ printValue(value)
 }
 
   void
-printSymbol(symbol)
+printSymbol(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 /* This table MUST be maintained congruent with the definition of the
    enumerated type 'symbolUsageKindType'. */
@@ -243,8 +243,7 @@ printSymbol(symbol)
 }
 
   void
-printArgumentDefinitionList(list)
+printArgumentDefinitionList(argumentDefinitionListType *list)
-  argumentDefinitionListType	*list;
 {
 	nullPrint(list);
 	tab(); printf("(arguments:\n");
@@ -258,10 +257,9 @@ printArgumentDefinitionList(list)
 }
 
   void
-printBlock(block)
+printBlock(blockType *block)
-  blockType	*block;
 {
-	void	printStatement();
+	void	printStatement(statementType *statement);
 
 	nullPrint(block);
 	tab(); printf("(block:\n");
@@ -272,10 +270,9 @@ printBlock(block)
 }
 
   void
-printArrayTerm(arrayTerm)
+printArrayTerm(arrayTermType *arrayTerm)
-  arrayTermType	*arrayTerm;
 {
-	void	printIdentifier();
+	void	printIdentifier(symbolTableEntryType *identifier);
 
 	nullPrint(arrayTerm);
 	tab(); printf("(array\n");
@@ -287,8 +284,7 @@ printArrayTerm(arrayTerm)
 }
 
   void
-printAssignmentTerm(assignmentTerm)
+printAssignmentTerm(binopTermType *assignmentTerm)
-  binopTermType	*assignmentTerm;
 {
 
 	nullPrint(assignmentTerm);
@@ -303,10 +299,9 @@ printAssignmentTerm(assignmentTerm)
 }
 
   void
-printBinopTerm(binopTerm)
+printBinopTerm(binopTermType *binopTerm)
-  binopTermType	*binopTerm;
 {
-	void	printIdentifier();
+	void	printIdentifier(symbolTableEntryType *identifier);
 
 	nullPrint(binopTerm);
 	tab(); printf("(binop [");
@@ -323,10 +318,9 @@ printBinopTerm(binopTerm)
 }
 
   void
-printFunctionCall(functionCall)
+printFunctionCall(functionCallTermType *functionCall)
-  functionCallTermType	*functionCall;
 {
-	void	printOperandList();
+	void	printOperandList(operandListType *operandList);
 
 	nullPrint(functionCall);
 	tab(); printf("(function call %s\n", functionCall->functionName->
@@ -338,29 +332,26 @@ printFunctionCall(functionCall)
 }
 
   void
-printHere()
+printHere(void)
 {
 	tab(); printf("(here)\n");
 }
 
   void
-printIdentifier(identifier)
+printIdentifier(symbolTableEntryType *identifier)
-  symbolTableEntryType	*identifier;
 {
 	nullPrint(identifier);
 	printSymbol(identifier);
 }
 
   void
-printNumber(number)
+printNumber(numberTermType number)
-  numberTermType	number;
 {
 	tab(); printf("(number: %d)\n", number);
 }
 
   void
-printPostopTerm(postopTerm)
+printPostopTerm(postOpTermType *postopTerm)
-  postOpTermType	*postopTerm;
 {
 	nullPrint(postopTerm);
 	tab(); printf("(postop [");
@@ -373,8 +364,7 @@ printPostopTerm(postopTerm)
 }
 
   void
-printPreopTerm(preopTerm)
+printPreopTerm(preOpTermType *preopTerm)
-  preOpTermType	*preopTerm;
 {
 	nullPrint(preopTerm);
 	tab(); printf("(preop [");
@@ -387,8 +377,7 @@ printPreopTerm(preopTerm)
 }
 
   void
-printUnopTerm(unopTerm)
+printUnopTerm(unopTermType *unopTerm)
-  unopTermType	*unopTerm;
 {
 	nullPrint(unopTerm);
 	tab(); printf("(unop [");
@@ -401,8 +390,7 @@ printUnopTerm(unopTerm)
 }
 
   void
-printExpression(expression)
+printExpression(expressionType *expression)
-  expressionType	*expression;
 {
 	nullPrint(expression);
 	tab(); printf("(expression: [");
@@ -477,8 +465,7 @@ printExpression(expression)
 }
 
   void
-printExpressionList(expressionList)
+printExpressionList(expressionListType *expressionList)
-  expressionListType	*expressionList;
 {
 	while (expressionList != NULL) {
 		printExpression(expressionList->theExpression);
@@ -487,8 +474,7 @@ printExpressionList(expressionList)
 }
 
   void
-printIdentifierList(identifierList)
+printIdentifierList(identifierListType *identifierList)
-  identifierListType	*identifierList;
 {
 	nullPrint(identifierList);
 	printSymbol(identifierList->theSymbol);
@@ -502,8 +488,7 @@ printIdentifierList(identifierList)
  */
 
   void
-printCase(aCase)
+printCase(caseType *aCase)
-  caseType	*aCase;
 {
 	tab(); printf("(case:\n"); tablevel++;
 	if (aCase->caseTags == NULL) {
@@ -520,8 +505,7 @@ printCase(aCase)
 }
 
   void
-printCaseList(caseList)
+printCaseList(caseListType *caseList)
-  caseListType	*caseList;
 {
 	tab(); printf("(cases:\n");
 	tablevel++;
@@ -534,24 +518,21 @@ printCaseList(caseList)
 }
 
   void
-printMacro(macroInstruction)
+printMacro(macroTableEntryType *macroInstruction)
-  macroTableEntryType	*macroInstruction;
 {
 	nullPrint(macroInstruction);
 	tab(); printf("(macro: %s)\n", macroInstruction->macroName);
 }
 
   void
-printOpcode(opcode)
+printOpcode(opcodeTableEntryType *opcode)
-  opcodeTableEntryType	*opcode;
 {
 	nullPrint(opcode);
 	tab(); printf("(opcode: %s)\n", opcode->mnemonic);
 }
 
   void
-printOperandList(operandList)
+printOperandList(operandListType *operandList)
-  operandListType	*operandList;
 {
 	nullPrint(operandList);
 	printOperand(operandList);
@@ -560,16 +541,14 @@ printOperandList(operandList)
 }
 
   void
-printAlignStatement(alignStatement)
+printAlignStatement(alignStatementBodyType *alignStatement)
-  alignStatementBodyType	*alignStatement;
 {
 	nullPrint(alignStatement);
 	printExpression(alignStatement);
 }
 
   void
-printAssertStatement(assertStatement)
+printAssertStatement(assertStatementBodyType *assertStatement)
-  assertStatementBodyType	*assertStatement;
 {
 	nullPrint(assertStatement);
 	printExpression(assertStatement->condition);
@@ -577,24 +556,21 @@ printAssertStatement(assertStatement)
 }
 
   void
-printBlockStatement(blockStatement)
+printBlockStatement(blockStatementBodyType *blockStatement)
-  blockStatementBodyType	*blockStatement;
 {
 	nullPrint(blockStatement);
 	printExpressionList(blockStatement);
 }
 
   void
-printByteStatement(byteStatement)
+printByteStatement(byteStatementBodyType *byteStatement)
-  byteStatementBodyType	*byteStatement;
 {
 	nullPrint(byteStatement);
 	printExpressionList(byteStatement);
 }
 
   void
-printConstrainStatement(constrainStatement)
+printConstrainStatement(constrainStatementBodyType *constrainStatement)
-  constrainStatementBodyType	*constrainStatement;
 {
 	nullPrint(constrainStatement);
 	printExpression(constrainStatement->constraint);
@@ -602,16 +578,14 @@ printConstrainStatement(constrainStatement)
 }
 
   void
-printDbyteStatement(dbyteStatement)
+printDbyteStatement(dbyteStatementBodyType *dbyteStatement)
-  dbyteStatementBodyType	*dbyteStatement;
 {
 	nullPrint(dbyteStatement);
 	printExpressionList(dbyteStatement);
 }
 
   void
-printDefineStatement(defineStatement)
+printDefineStatement(defineStatementBodyType *defineStatement)
-  defineStatementBodyType	*defineStatement;
 {
 	nullPrint(defineStatement);
 	printSymbol(defineStatement->theSymbol);
@@ -619,8 +593,7 @@ printDefineStatement(defineStatement)
 }
 
   void
-printDoUntilStatement(doUntilStatement)
+printDoUntilStatement(doUntilStatementBodyType *doUntilStatement)
-  doUntilStatementBodyType	*doUntilStatement;
 {
 	nullPrint(doUntilStatement);
 	printBlock(doUntilStatement->doUntilLoop);
@@ -630,8 +603,7 @@ printDoUntilStatement(doUntilStatement)
 }
 
   void
-printDoWhileStatement(doWhileStatement)
+printDoWhileStatement(doWhileStatementBodyType *doWhileStatement)
-  doWhileStatementBodyType	*doWhileStatement;
 {
 	nullPrint(doWhileStatement);
 	printBlock(doWhileStatement->doWhileLoop);
@@ -641,24 +613,21 @@ printDoWhileStatement(doWhileStatement)
 }
 
   void
-printExternStatement(externStatement)
+printExternStatement(externStatementBodyType *externStatement)
-  externStatementBodyType	*externStatement;
 {
 	nullPrint(externStatement);
 	printIdentifierList(externStatement);
 }
 
   void
-printFreturnStatement(freturnStatement)
+printFreturnStatement(freturnStatementBodyType *freturnStatement)
-  freturnStatementBodyType	*freturnStatement;
 {
 	nullPrint(freturnStatement);
 	printExpression(freturnStatement);
 }
 
   void
-printFunctionStatement(functionStatement)
+printFunctionStatement(functionStatementBodyType *functionStatement)
-  functionStatementBodyType	*functionStatement;
 {
 	nullPrint(functionStatement);
 	tab();printf("(function name: %s)\n",functionStatement->functionName);
@@ -667,8 +636,7 @@ printFunctionStatement(functionStatement)
 }
 
   void
-printIfStatement(ifStatement)
+printIfStatement(ifStatementBodyType *ifStatement)
-  ifStatementBodyType	*ifStatement;
 {
 	nullPrint(ifStatement);
 	tab(); printf("(condition: ");
@@ -683,16 +651,14 @@ printIfStatement(ifStatement)
 }
 
   void
-printIncludeStatement(includeStatement)
+printIncludeStatement(includeStatementBodyType *includeStatement)
-  includeStatementBodyType	*includeStatement;
 {
 	nullPrint(includeStatement);
 	printExpression(includeStatement);
 }
 
   void
-printInstructionStatement(instructionStatement)
+printInstructionStatement(instructionStatementBodyType *instructionStatement)
-  instructionStatementBodyType	*instructionStatement;
 {
 	nullPrint(instructionStatement);
 	switch(instructionStatement->kindOfInstruction) {
@@ -713,16 +679,14 @@ printInstructionStatement(instructionStatement)
 }
 
   void
-printLongStatement(longStatement)
+printLongStatement(longStatementBodyType *longStatement)
-  longStatementBodyType	*longStatement;
 {
 	nullPrint(longStatement);
 	printExpressionList(longStatement);
 }
 
   void
-printMacroStatement(macroStatement)
+printMacroStatement(macroStatementBodyType *macroStatement)
-  macroStatementBodyType	*macroStatement;
 {
 	nullPrint(macroStatement);
 	tab(); printf("(macro name: %s)\n", macroStatement->theMacro);
@@ -731,8 +695,7 @@ printMacroStatement(macroStatement)
 }
 
   void
-printMdefineStatement(mdefineStatement)
+printMdefineStatement(defineStatementBodyType *mdefineStatement)
-  defineStatementBodyType	*mdefineStatement;
 {
 	nullPrint(mdefineStatement);
 	printSymbol(mdefineStatement->theSymbol);
@@ -740,8 +703,7 @@ printMdefineStatement(mdefineStatement)
 }
 
   void
-printMdoUntilStatement(mdoUntilStatement)
+printMdoUntilStatement(mdoUntilStatementBodyType *mdoUntilStatement)
-  mdoUntilStatementBodyType	*mdoUntilStatement;
 {
 	nullPrint(mdoUntilStatement);
 	printBlock(mdoUntilStatement->mdoUntilLoop);
@@ -749,8 +711,7 @@ printMdoUntilStatement(mdoUntilStatement)
 }
 
   void
-printMdoWhileStatement(mdoWhileStatement)
+printMdoWhileStatement(mdoWhileStatementBodyType *mdoWhileStatement)
-  mdoWhileStatementBodyType	*mdoWhileStatement;
 {
 	nullPrint(mdoWhileStatement);
 	printBlock(mdoWhileStatement->mdoWhileLoop);
@@ -758,8 +719,7 @@ printMdoWhileStatement(mdoWhileStatement)
 }
 
   void
-printMforStatement(mforStatement)
+printMforStatement(mforStatementBodyType *mforStatement)
-  mforStatementBodyType	*mforStatement;
 {
 	nullPrint(mforStatement);
 	printExpression(mforStatement->initExpression);
@@ -769,8 +729,7 @@ printMforStatement(mforStatement)
 }
 
   void
-printMifStatement(mifStatement)
+printMifStatement(mifStatementBodyType *mifStatement)
-  mifStatementBodyType	*mifStatement;
 {
 	nullPrint(mifStatement);
 	printExpression(mifStatement->mifCondition);
@@ -783,8 +742,7 @@ printMifStatement(mifStatement)
 }
 
   void
-printMswitchStatement(mswitchStatement)
+printMswitchStatement(mswitchStatementBodyType *mswitchStatement)
-  mswitchStatementBodyType	*mswitchStatement;
 {
 	nullPrint(mswitchStatement);
 	printExpression(mswitchStatement->switchExpression);
@@ -792,8 +750,7 @@ printMswitchStatement(mswitchStatement)
 }
 
   void
-printMvariableStatement(mvariableStatement)
+printMvariableStatement(mvariableStatementBodyType *mvariableStatement)
-  mvariableStatementBodyType	*mvariableStatement;
 {
 	nullPrint(mvariableStatement);
 	printSymbol(mvariableStatement->theSymbol);
@@ -801,8 +758,7 @@ printMvariableStatement(mvariableStatement)
 }
 
   void
-printMwhileStatement(mwhileStatement)
+printMwhileStatement(mwhileStatementBodyType *mwhileStatement)
-  mwhileStatementBodyType	*mwhileStatement;
 {
 	nullPrint(mwhileStatement);
 	printExpression(mwhileStatement->mwhileCondition);
@@ -810,47 +766,41 @@ printMwhileStatement(mwhileStatement)
 }
 
   void
-printOrgStatement(orgStatement)
+printOrgStatement(orgStatementBodyType *orgStatement)
-  orgStatementBodyType	*orgStatement;
 {
 	nullPrint(orgStatement);
 	printExpression(orgStatement);
 }
 
   void
-printPerformStatement(performStatement)
+printPerformStatement(performStatementBodyType *performStatement)
-  performStatementBodyType	*performStatement;
 {
 	nullPrint(performStatement);
 	printExpression(performStatement);
 }
 
   void
-printRelStatement(relStatement)
+printRelStatement(relStatementBodyType *relStatement)
-  relStatementBodyType	*relStatement;
 {
 	/* there's nothing here... */
 }
 
   void
-printStartStatement(startStatement)
+printStartStatement(startStatementBodyType *startStatement)
-  startStatementBodyType	*startStatement;
 {
 	nullPrint(startStatement);
 	printExpression(startStatement);
 }
 
   void
-printStringStatement(stringStatement)
+printStringStatement(stringStatementBodyType *stringStatement)
-  stringStatementBodyType	*stringStatement;
 {
 	nullPrint(stringStatement);
 	printExpressionList(stringStatement);
 }
 
   void
-printStructStatement(structStatement)
+printStructStatement(structStatementBodyType *structStatement)
-  structStatementBodyType	*structStatement;
 {
 	nullPrint(structStatement);
 	printSymbol(structStatement->structName);
@@ -858,24 +808,21 @@ printStructStatement(structStatement)
 }
 
   void
-printTargetStatement(targetStatement)
+printTargetStatement(targetStatementBodyType *targetStatement)
-  targetStatementBodyType	*targetStatement;
 {
 	nullPrint(targetStatement);
 	printExpression(targetStatement);
 }
 
   void
-printUndefineStatement(undefineStatement)
+printUndefineStatement(undefineStatementBodyType *undefineStatement)
-  undefineStatementBodyType	*undefineStatement;
 {
 	nullPrint(undefineStatement);
 	printIdentifierList(undefineStatement);
 }
 
   void
-printVariableStatement(variableStatement)
+printVariableStatement(variableStatementBodyType *variableStatement)
-  variableStatementBodyType	*variableStatement;
 {
 	nullPrint(variableStatement);
 	printSymbol(variableStatement->theSymbol);
@@ -883,8 +830,7 @@ printVariableStatement(variableStatement)
 }
 
   void
-printWhileStatement(whileStatement)
+printWhileStatement(whileStatementBodyType *whileStatement)
-  whileStatementBodyType	*whileStatement;
 {
 	nullPrint(whileStatement);
 	tab(); printf("(condition: ");
@@ -894,16 +840,14 @@ printWhileStatement(whileStatement)
 }
 
   void
-printWordStatement(wordStatement)
+printWordStatement(wordStatementBodyType *wordStatement)
-  wordStatementBodyType	*wordStatement;
 {
 	nullPrint(wordStatement);
 	printExpressionList(wordStatement);
 }
 
   void
-printLabelList(labelList)
+printLabelList(labelListType *labelList)
-  labelListType	*labelList;
 {
 	nullPrint(labelList);
 	tab(); printf("(\n");
@@ -917,9 +861,7 @@ printLabelList(labelList)
 }
 
   void
-printStatementBody(kind, body)
+printStatementBody(statementKindType kind, statementBodyType body)
-  statementKindType	kind;
-  statementBodyType	body;
 {
 	switch (kind) {
 
@@ -1082,8 +1024,7 @@ printStatementBody(kind, body)
 }
 
   void
-printStatement(statement)
+printStatement(statementType *statement)
-  statementType	*statement;
 {
 	nullPrint(statement);
 	tab(); printf("(statement[");
@@ -1104,8 +1045,7 @@ printStatement(statement)
  */
 
   void
-printPendingFixupList(fixupList)
+printPendingFixupList(fixupListType *fixupList)
-  fixupListType	*fixupList;
 {
 	printf("fixup list: (");
 	tablevel++;
@@ -1118,10 +1058,7 @@ printPendingFixupList(fixupList)
 }
 
   void
-printCreateFixup(expression, location, kindOfFixup)
+printCreateFixup(expressionType *expression, addressType location, fixupKindType kindOfFixup)
-  expressionType	*expression;
-  addressType		 location;
-  fixupKindType		 kindOfFixup;
 {
 	static char	*fixupStringTable[] = {
 		"BYTE FIXUP",
@@ -1145,7 +1082,7 @@ printCreateFixup(expression, location, kindOfFixup)
  */
 
   void
-printExpressionBuffer()
+printExpressionBuffer(void)
 {
 	int	line;
 	int	i;
@@ -1160,9 +1097,7 @@ printExpressionBuffer()
 }
 
   void
-printOneCodeBuffer(codeSegment, bufferNum)
+printOneCodeBuffer(codeSegmentType *codeSegment, int bufferNum)
-  codeSegmentType	*codeSegment;
-  int			 bufferNum;
 {
     int			 line;
     int			 i;
@@ -1190,8 +1125,7 @@ printOneCodeBuffer(codeSegment, bufferNum)
 }
 
   void
-printCodeBufferSection(codeBufferSection)
+printCodeBufferSection(codeRegionType *codeBufferSection)
-  codeRegionType	*codeBufferSection;
 {
 	bool	anyCodeThereFlag;
 	int	i;
@@ -1209,7 +1143,7 @@ printCodeBufferSection(codeBufferSection)
 }
 
   void
-printCodeBuffers()
+printCodeBuffers(void)
 {
 	printf("absolute code:\n");
 	printCodeBufferSection(&absoluteCodeRegion);

debugPrintSD_6502.c

@@ -39,9 +39,14 @@ int	tablevel;
 /* Fundamental nop print operation */
 #define nullPrint(thing)   if (thing==NULL) { tab(); printf("()\n"); return; }
 
-  void
+  
-printCondition(condition)
+extern void tab (void);
-  conditionType	condition;
+extern void printExpression (expressionType *expression);
+extern void printIdentifierList (identifierListType *identifierList);
+extern void printBlock (blockType *block);
+
+void
+printCondition(conditionType condition)
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'conditionType'. */
@@ -70,8 +75,7 @@ printCondition(condition)
 }
 
   void
-printOperandKind(kind)
+printOperandKind(operandKindType kind)
-  operandKindType	kind;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'operandKindType'. */
@@ -97,8 +101,7 @@ printOperandKind(kind)
 }
 
   void
-printToken(token)
+printToken(int token)
-  int	token;
 {
 /* This table MUST be maintained congruently with the set of '#define's in
    the file 'y.tab.h' as produced by yacc. */
@@ -193,8 +196,7 @@ printToken(token)
 }
 
   void
-printOperand(operand)
+printOperand(operandType *operand)
-  operandType	*operand;
 {
 	nullPrint(operand);
 	tab(); printf("(operand: [");

driver.c

@@ -38,8 +38,7 @@ char	*m68000 = "68000";
 
 char	**mlist;
 
-main(argc, argv)
+main(int argc, char **argv)
-	char **argv;
 {
 	char   *processor = m6502;
 	int	i;

emitBranch_6502.c

@@ -37,11 +37,16 @@
    branching from the current location given a condition to branch upon and a
    target address. */
 
-  void
+  
-emitRelativeBranch(condition, target, fixupLocation)
+extern void emitByte (byte byteValue);
-  conditionType	 condition;
+extern void emitRelativeByteOffset (valueType *target);
-  valueType	*target;
+extern void botch (char *message, ...);
-  valueType	 fixupLocation[COMPOUND_BRANCH_MAX];
+extern void emitWord (wordType wordValue);
+extern void noteAnonymousReference (void);
+extern void emitWordValue (valueType *wordValue);
+
+void
+emitRelativeBranch(conditionType condition, valueType *target, valueType *fixupLocation)
 {
 	int	i;
 
@@ -139,14 +144,12 @@ emitRelativeBranch(condition, target, fixupLocation)
 /* emitJump emits a 6502 jump instruction given the target address */
 
   simpleFixupListType *
-emitJump(target, previousFixups)
+emitJump(valueType *target, simpleFixupListType *previousFixups)
-  valueType		*target;
-  simpleFixupListType	*previousFixups;
 {
 	simpleFixupListType	*result;
 	valueType		 picFixup[COMPOUND_BRANCH_MAX];
 
-	simpleFixupListType	*buildSimpleFixupList();
+	simpleFixupListType	*buildSimpleFixupList(valueType locationToFixup, simpleFixupListType *previousList);
 
 #define JUMP_OPCODE	0x4C
 

emitStuff.c

@@ -62,10 +62,19 @@
 
 /* incarnateCodeBuffer causes code buffer space to actually be allocated */
 
-  void
+  
-incarnateCodeBuffer(bufferNum, bufferKind)
+extern void fatalError (errorType theError, ...);
-  int			bufferNum;
+extern bool byteCheck (int value);
-  codeBufferKindType	bufferKind;
+extern void printValue (valueType *value);
+extern void error (errorType theError, ...);
+extern char *valueKindString (valueKindType valueKind);
+extern bool wordCheck (int value);
+extern bool isByteOffset (int value);
+extern bool isWordOffset (int value);
+extern void noteAnonymousReference (void);
+
+void
+incarnateCodeBuffer(int bufferNum, codeBufferKindType bufferKind)
 {
 	codeSegmentType	*newCodeSegment;
 	codeBufferType	*newCodeBuffer;
@@ -88,9 +97,7 @@ incarnateCodeBuffer(bufferNum, bufferKind)
    care to make sure said buffer actually exists before using it. */
 
   void
-putByte(address, byteValue)
+putByte(addressType address, byte byteValue)
-  addressType	address;
-  byte		byteValue;
 {
 	int		 bufferNum;
 	int		 bufferPos;
@@ -131,9 +138,7 @@ putByte(address, byteValue)
    buffer */
 
   void
-mapByte(address, byteValue)
+mapByte(int address, byte byteValue)
-  int		address;
-  byte		byteValue;
 {
 	if (address < MAXIMUM_ALLOWED_STRUCT_SIZE)
 		structScratchBuffer[address] = byteValue;
@@ -144,8 +149,7 @@ mapByte(address, byteValue)
    code buffer or the current struct assembly buffer */
 
   void
-emitByte(byteValue)
+emitByte(byte byteValue)
-  byte	byteValue;
 {
 	if (debug || emitPrint)
 		if (structNestingDepth == 0)
@@ -165,8 +169,7 @@ emitByte(byteValue)
 /* emitWord similarly emits a word */
 
   void
-emitWord(wordValue)
+emitWord(wordType wordValue)
-  wordType	wordValue;
 {
 	byteToWordType	convert;
 	int		loByte, hiByte;
@@ -216,8 +219,7 @@ emitWord(wordValue)
 /* emitLong similarly emits a long */
 
   void
-emitLong(longValue)
+emitLong(longType longValue)
-  longType	longValue;
 {
 	byteToLongType	convert;
 	int		loByte, secondByte, thirdByte, hiByte;
@@ -286,8 +288,7 @@ emitLong(longValue)
 /* emitByteValue takes the byte to be emitted out of a 'valueType' */
 
   void
-emitByteValue(byteValue)
+emitByteValue(valueType *byteValue)
-  valueType	*byteValue;
 {
     if (byteValue->kindOfValue == ABSOLUTE_VALUE || byteValue->kindOfValue ==
 	    RELOCATABLE_VALUE || byteValue->kindOfValue == UNDEFINED_VALUE) {
@@ -313,8 +314,7 @@ emitByteValue(byteValue)
 /* emitString similarly spits out a string of bytes */
 
   void
-emitString(string)
+emitString(stringType *string)
-  stringType	*string;
 {
 	if (debug || emitPrint)
 		if (structNestingDepth == 0)
@@ -342,8 +342,7 @@ emitString(string)
 /* emitWordValue emits a word out of a 'valueType' */
 
   void
-emitWordValue(wordValue)
+emitWordValue(valueType *wordValue)
-  valueType	*wordValue;
 {
     if (wordValue->kindOfValue == ABSOLUTE_VALUE || wordValue->kindOfValue ==
 	    RELOCATABLE_VALUE || wordValue->kindOfValue == UNDEFINED_VALUE) {
@@ -369,8 +368,7 @@ emitWordValue(wordValue)
 /* emitLongValue emits a long out of a 'valueType' */
 
   void
-emitLongValue(longValue)
+emitLongValue(valueType *longValue)
-  valueType	*longValue;
 {
     if (longValue->kindOfValue == ABSOLUTE_VALUE || longValue->kindOfValue ==
 	    RELOCATABLE_VALUE || longValue->kindOfValue == UNDEFINED_VALUE) {
@@ -396,9 +394,7 @@ emitLongValue(longValue)
 /* pokeByteValue is like 'emitByte' but it's random access */
 
   void
-pokeByteValue(location, value)
+pokeByteValue(addressType location, valueType *value)
-  addressType	 location;
-  valueType	*value;
 {
 	currentLocationCounter.value = location;
 	emitByteValue(value);
@@ -408,9 +404,7 @@ pokeByteValue(location, value)
 /* ditto pokeWordValue */
 
   void
-pokeWordValue(location, value)
+pokeWordValue(addressType location, valueType *value)
-  addressType	 location;
-  valueType	*value;
 {
 	currentLocationCounter.value = location;
 	emitWordValue(value);
@@ -420,9 +414,7 @@ pokeWordValue(location, value)
 /* ditto pokeLongValue */
 
   void
-pokeLongValue(location, value)
+pokeLongValue(addressType location, valueType *value)
-  addressType	 location;
-  valueType	*value;
 {
 	currentLocationCounter.value = location;
 	emitLongValue(value);
@@ -433,9 +425,7 @@ pokeLongValue(location, value)
    relative branches */
 
   void
-pokeRelativeByteValue(location, value)
+pokeRelativeByteValue(addressType location, valueType *value)
-  addressType	 location;
-  valueType	*value;
 {
 	int	offset;
 
@@ -456,9 +446,7 @@ pokeRelativeByteValue(location, value)
    relative branches */
 
   void
-pokeRelativeWordValue(location, value)
+pokeRelativeWordValue(addressType location, valueType *value)
-  addressType	 location;
-  valueType	*value;
 {
 	int	offset;
 
@@ -475,8 +463,7 @@ pokeRelativeWordValue(location, value)
 /* getByte fetches a byte back out of the labyrinth of code buffers */
 
   byte
-getByte(address)
+getByte(addressType address)
-  addressType	address;
 {
 	int		 bufferNum;
 	int		 bufferPos;
@@ -494,8 +481,7 @@ getByte(address)
 }
 
   void
-emitRelativeByteOffset(target)
+emitRelativeByteOffset(valueType *target)
-  valueType	*target;
 {
 	int	saveTargetOffset;
 
@@ -512,8 +498,7 @@ emitRelativeByteOffset(target)
 }
 
   void
-emitRelativeWordOffset(target)
+emitRelativeWordOffset(valueType *target)
-  valueType	*target;
 {
 	int	saveTargetOffset;
 
@@ -531,9 +516,7 @@ emitRelativeWordOffset(target)
    has become known. */
 
   void
-fixupBranch(location, target)
+fixupBranch(valueType *location, valueType target)
-  valueType	 location[COMPOUND_BRANCH_MAX];
-  valueType	 target;
 {
 	valueType	saveCurrentLocation;
 	int		saveTargetOffset;
@@ -554,9 +537,7 @@ fixupBranch(location, target)
 /* fixupJump similarly repairs a jump */
 
   void
-fixupJump(locations, target)
+fixupJump(simpleFixupListType *locations, valueType target)
-  simpleFixupListType	*locations;
-  valueType		 target;
 {
 	valueType		 saveCurrentLocation;
 	simpleFixupListType	*oldLocation;

encode.c

@@ -39,9 +39,20 @@
 
 bool	encodingFunction;
 
-  bool
+  
-encodeByte(aByte)
+extern void error (errorType theError, ...);
-  byte	aByte;
+bool encodeIdentifier (symbolTableEntryType *identifier);
+bool encodeExpression (expressionType *expression);
+bool encodeValue (valueType *value);
+bool encodeOperand (operandType *operand);
+bool encodeString (stringType *string);
+extern char *valueKindString (valueKindType valueKind);
+extern void botch (char *message, ...);
+bool encodeBlock (blockType *block);
+extern stringType *statementKindString (statementKindType kind);
+
+bool
+encodeByte(byte aByte)
 {
 	if (expressionBufferSize < EXPRESSION_BUFFER_LIMIT) {
 		expressionBuffer[expressionBufferSize++] = aByte;
@@ -53,8 +64,7 @@ encodeByte(aByte)
 }
 
   bool
-encodeBigword(bigword)
+encodeBigword(int bigword)
-  int	bigword;
 {
 	int	i;
 	for (i=0; i<sizeof(int); ++i) {
@@ -66,8 +76,7 @@ encodeBigword(bigword)
 }
 
   bool
-encodeAssignmentTerm(assignmentTerm)
+encodeAssignmentTerm(binopTermType *assignmentTerm)
-  binopTermType	*assignmentTerm;
 {
 	nullEncode(assignmentTerm);
 	if ((assignmentKindType)assignmentTerm->binop != ASSIGN_ASSIGN) {
@@ -83,10 +92,9 @@ encodeAssignmentTerm(assignmentTerm)
 }
 
   bool
-encodeBinopTerm(binopTerm)
+encodeBinopTerm(binopTermType *binopTerm)
-  binopTermType	*binopTerm;
 {
-	bool	encodeExpression();
+	bool	encodeExpression(expressionType *expression);
 
 	nullEncode(binopTerm);
 	return (
@@ -98,8 +106,7 @@ encodeBinopTerm(binopTerm)
 }
 
   bool
-encodeCondition(condition)
+encodeCondition(conditionType condition)
-  conditionType	condition;
 {
 	return(
 		encodeByte(CONDITION_CODE_TAG) &&
@@ -108,8 +115,7 @@ encodeCondition(condition)
 }
 
   int
-functionNumber(function)
+functionNumber(functionDefinitionType *function)
-  functionDefinitionType	*function;
 {
 	if (function->ordinal == -1) {
 		function->ordinal = externalFunctionCount++;
@@ -126,8 +132,7 @@ functionNumber(function)
 }
 
   bool
-encodeFunctionCall(functionCall)
+encodeFunctionCall(functionCallTermType *functionCall)
-  functionCallTermType	*functionCall;
 {
 	functionDefinitionType	*theFunction;
 	int			 functionOrdinal;
@@ -177,14 +182,13 @@ encodeFunctionCall(functionCall)
 }
 
   bool
-encodeHere()
+encodeHere(void)
 {
 	return(encodeByte(HERE_TAG));
 }
 
   bool
-encodeIdentifier(identifier)
+encodeIdentifier(symbolTableEntryType *identifier)
-  symbolTableEntryType	*identifier;
 {
 	symbolInContextType	*workingContext;
 	environmentType		*saveEnvironment;
@@ -248,8 +252,7 @@ encodeIdentifier(identifier)
 }
 
   bool
-encodeNumber(number)
+encodeNumber(numberTermType number)
-  numberTermType	number;
 {
 	return(
 		encodeByte(NUMBER_TAG) &&
@@ -258,8 +261,7 @@ encodeNumber(number)
 }
 
   bool
-encodeRelocatableNumber(number)
+encodeRelocatableNumber(numberTermType number)
-  numberTermType	number;
 {
 	return(
 		encodeByte(RELOCATABLE_TAG) &&
@@ -268,8 +270,7 @@ encodeRelocatableNumber(number)
 }
 
   bool
-encodeOperand(operand)
+encodeOperand(operandType *operand)
-  operandType	*operand;
 {
 	switch (operand->kindOfOperand) {
 		case EXPRESSION_OPND:
@@ -303,8 +304,7 @@ encodeOperand(operand)
 }
 
   bool
-encodePostopTerm(postopTerm)
+encodePostopTerm(postOpTermType *postopTerm)
-  postOpTermType	*postopTerm;
 {
 	nullEncode(postopTerm);
 	return(
@@ -315,8 +315,7 @@ encodePostopTerm(postopTerm)
 }
 
   bool
-encodePreopTerm(preopTerm)
+encodePreopTerm(preOpTermType *preopTerm)
-  preOpTermType	*preopTerm;
 {
 	nullEncode(preopTerm);
 	return(
@@ -327,8 +326,7 @@ encodePreopTerm(preopTerm)
 }
 
   bool
-encodeString(string)
+encodeString(stringType *string)
-  stringType	*string;
 {
 	if (!encodeByte(STRING_TAG))
 		return(FALSE);
@@ -340,8 +338,7 @@ encodeString(string)
 }
 
   bool
-encodeUnopTerm(unopTerm)
+encodeUnopTerm(unopTermType *unopTerm)
-  unopTermType	*unopTerm;
 {
 	nullEncode(unopTerm);
 	return(
@@ -352,8 +349,7 @@ encodeUnopTerm(unopTerm)
 }
 
   bool
-encodeValue(value)
+encodeValue(valueType *value)
-  valueType	*value;
 {
 	switch (value->kindOfValue) {
 		case ABSOLUTE_VALUE:
@@ -389,8 +385,7 @@ encodeValue(value)
 }
 
   bool
-encodeExpression(expression)
+encodeExpression(expressionType *expression)
-  expressionType	*expression;
 {
 	nullEncode(expression);
 	switch (expression->kindOfTerm) {
@@ -460,8 +455,7 @@ encodeExpression(expression)
 }
 
   bool
-encodeAssertStatement(assertStatement)
+encodeAssertStatement(assertStatementBodyType *assertStatement)
-  assertStatementBodyType	*assertStatement;
 {
 	return(
 		encodeByte(ASSERT_TAG) &&
@@ -471,8 +465,7 @@ encodeAssertStatement(assertStatement)
 }
 
   bool
-encodeFreturnStatement(freturnStatement)
+encodeFreturnStatement(freturnStatementBodyType *freturnStatement)
-  freturnStatementBodyType	*freturnStatement;
 {
 	return(
 		encodeByte(FRETURN_TAG) &&
@@ -481,8 +474,7 @@ encodeFreturnStatement(freturnStatement)
 }
 
   bool
-encodeMdefineStatement(mdefineStatement)
+encodeMdefineStatement(defineStatementBodyType *mdefineStatement)
-  defineStatementBodyType	*mdefineStatement;
 {
 	return(
 		encodeByte(MDEFINE_TAG) &&
@@ -492,8 +484,7 @@ encodeMdefineStatement(mdefineStatement)
 }
 
   bool
-encodeMdoUntilStatement(mdoUntilStatement)
+encodeMdoUntilStatement(mdoUntilStatementBodyType *mdoUntilStatement)
-  mdoUntilStatementBodyType	*mdoUntilStatement;
 {
 	return(
 		encodeByte(MDOUNTIL_TAG) &&
@@ -503,8 +494,7 @@ encodeMdoUntilStatement(mdoUntilStatement)
 }
 
   bool
-encodeMdoWhileStatement(mdoWhileStatement)
+encodeMdoWhileStatement(mdoWhileStatementBodyType *mdoWhileStatement)
-  mdoWhileStatementBodyType	*mdoWhileStatement;
 {
 	return(
 		encodeByte(MDOWHILE_TAG) &&
@@ -514,8 +504,7 @@ encodeMdoWhileStatement(mdoWhileStatement)
 }
 
   bool
-encodeMforStatement(mforStatement)
+encodeMforStatement(mforStatementBodyType *mforStatement)
-  mforStatementBodyType	*mforStatement;
 {
 	return(
 		encodeByte(MFOR_TAG) &&
@@ -527,8 +516,7 @@ encodeMforStatement(mforStatement)
 }
 
   bool
-encodeMifStatement(mifStatement)
+encodeMifStatement(mifStatementBodyType *mifStatement)
-  mifStatementBodyType	*mifStatement;
 {
 	return(
 		encodeByte(MIF_TAG) &&
@@ -539,8 +527,7 @@ encodeMifStatement(mifStatement)
 }
 
   bool
-encodeMswitchStatement(mswitchStatement)
+encodeMswitchStatement(mswitchStatementBodyType *mswitchStatement)
-  mswitchStatementBodyType	*mswitchStatement;
 {
     caseListType	*caseList;
     caseType		*theCase;
@@ -564,8 +551,7 @@ encodeMswitchStatement(mswitchStatement)
 }
 
   bool
-encodeMvariableStatement(mvariableStatement)
+encodeMvariableStatement(mvariableStatementBodyType *mvariableStatement)
-  mvariableStatementBodyType	*mvariableStatement;
 {
 	int	length;	
 
@@ -585,8 +571,7 @@ encodeMvariableStatement(mvariableStatement)
 }
 
   bool
-encodeMwhileStatement(mwhileStatement)
+encodeMwhileStatement(mwhileStatementBodyType *mwhileStatement)
-  mwhileStatementBodyType	*mwhileStatement;
 {
 	return(
 		encodeByte(MWHILE_TAG) &&
@@ -596,8 +581,7 @@ encodeMwhileStatement(mwhileStatement)
 }
 
   bool
-encodeStatement(statement)
+encodeStatement(statementType *statement)
-  statementType	*statement;
 {
 	switch(statement->kindOfStatement) {
 
@@ -677,8 +661,7 @@ encodeStatement(statement)
 }
 
   bool
-encodeBlock(block)
+encodeBlock(blockType *block)
-  blockType	*block;
 {
 	if (!encodeByte(BLOCK_TAG))
 		return(FALSE);

errorStuff.c

@@ -39,7 +39,12 @@ bool			 nullStatementFlag;
    input up to the end of the line, in a (probably futile) effort to recover
    from the booboo. */
 
-  void
+  
+void verror (errorType theError, va_list ap);
+void fatalError (errorType theError, ...);
+extern void chokePukeAndDie (void);
+
+void
 puntOnError(errorType theError, ...)
 {
 	va_list ap;
@@ -289,8 +294,7 @@ fatalSystemError(errorType theError, ...)
    the error message as a string (this is almost always 'syntax error'). */
 
   void
-yyerror(s)
+yyerror(char *s)
-  char	*s;
 {
 	printf("\"%s\", line %d: %s\n", currentFileName, currentLineNumber,s);
 	fflush(stdout);
@@ -304,8 +308,7 @@ yyerror(s)
    in a sentence). */
 
   char *
-usageString(usageKind)
+usageString(symbolUsageKindType usageKind)
-  symbolUsageKindType	usageKind;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'symbolUsageKindType'. */
@@ -336,8 +339,7 @@ usageString(usageKind)
 /* valueKindString similarly deals with the different kinds of values. */
 
   char *
-valueKindString(valueKind)
+valueKindString(valueKindType valueKind)
-  valueKindType	valueKind;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'valueKindType'. */
@@ -366,8 +368,7 @@ valueKindString(valueKind)
 /* assignmentString similarly handles assignments */
 
   char *
-assignmentString(assignment)
+assignmentString(assignmentKindType assignment)
-  assignmentKindType	assignment;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'assignmentKindType'. */

expressionSemantics.c

@@ -64,10 +64,32 @@ stringType		*dbString;
 #define moreStuff(f) (generatingFixup ? moreExpression(f) : moreText(f))
 #define moreStuff1(f,x) (generatingFixup? moreExpression(f,x) : moreText(f,x))
 
-  anyOldThing *
+  
-arrayLookup(arrayTerm, kindOfThing)
+extern void error (errorType theError, ...);
-  arrayTermType	*arrayTerm;
+extern char *valueKindString (valueKindType valueKind);
-  valueKindType	*kindOfThing;
+extern void moreExpression (char *format, ...);
+extern valueType *evaluateOperand (operandType *operand);
+extern char *tokenString (int token);
+extern char *assignmentString (assignmentKindType assignment);
+extern char *usageString (symbolUsageKindType usageKind);
+extern valueType *makeUndefinedValue (void);
+extern void botch (char *message, ...);
+extern char *conditionString (conditionType condition);
+extern int bindFunctionArguments (argumentDefinitionListType *argumentList, operandListType *parameterList, stringType *functionName);
+extern void assembleBlock (blockType *block);
+extern void unbindArguments (argumentDefinitionListType *argumentList, int numberToUnbind);
+extern void unbindLocalVariables (identifierListType *identifierList);
+extern void reincarnateSymbol (symbolInContextType *context, symbolUsageKindType newUsage);
+extern bool shouldParenthesize (operandType *operand);
+extern void moreText (char *format, ...);
+extern void endLine (void);
+extern void tabIndent (void);
+extern void flushExpressionString (void);
+extern operandType *buildOperand (operandKindType kindOfOperand, anyOldThing *arg);
+extern expressionType *generateFixupExpression (expressionType *expression);
+
+anyOldThing *
+arrayLookup(arrayTermType *arrayTerm, valueKindType *kindOfThing)
 {
 	valueType		*arrayValue;
 	valueType		*indexValue;
@@ -124,8 +146,7 @@ arrayLookup(arrayTerm, kindOfThing)
 }
 
   valueType *
-evaluateArrayTerm(arrayTerm)
+evaluateArrayTerm(arrayTermType *arrayTerm)
-  arrayTermType	*arrayTerm;
 {
 	anyOldThing		*resultThing;
 	valueKindType		 kindOfResult;
@@ -169,9 +190,7 @@ evaluateArrayTerm(arrayTerm)
 }
 
   valueType *
-evaluateAssignmentTerm(assignmentTerm, kindOfFixup)
+evaluateAssignmentTerm(binopTermType *assignmentTerm, fixupKindType kindOfFixup)
-  binopTermType	*assignmentTerm;
-  fixupKindType	 kindOfFixup;
 {
 	symbolTableEntryType	*targetSymbol;
 	valueType		*target;
@@ -363,10 +382,7 @@ evaluateAssignmentTerm(assignmentTerm, kindOfFixup)
 }
 
   valueType *
-evaluateBinopTerm(binopTerm, isTopLevel, kindOfFixup)
+evaluateBinopTerm(binopTermType *binopTerm, bool isTopLevel, fixupKindType kindOfFixup)
-  binopTermType	*binopTerm;
-  bool		 isTopLevel;
-  fixupKindType	 kindOfFixup;
 {
 	valueType		*leftOperand;
 	valueType		*rightOperand;
@@ -580,18 +596,14 @@ evaluateBinopTerm(binopTerm, isTopLevel, kindOfFixup)
 }
 
   valueType *
-evaluateCondition(condition)
+evaluateCondition(conditionType condition)
-  conditionType	condition;
 {
 	expand(moreExpression("%s", conditionString(condition)));
 	return(newValue(CONDITION_VALUE, condition, EXPRESSION_OPND));
 }
 
   valueType *
-evaluateBuiltInFunctionCall(workingContext, parameters, kindOfFixup)
+evaluateBuiltInFunctionCall(symbolInContextType *workingContext, operandListType *parameters, fixupKindType kindOfFixup)
-  symbolInContextType	*workingContext;
-  operandListType	*parameters;
-  fixupKindType		 kindOfFixup;
 {
 	sideEffectFlag = TRUE;
 	return((*builtInFunctionTable[workingContext->value->value].
@@ -599,10 +611,7 @@ evaluateBuiltInFunctionCall(workingContext, parameters, kindOfFixup)
 }
 
   valueType *
-evaluateFunctionCall(functionCall, kindOfFixup, isStandalone)
+evaluateFunctionCall(functionCallTermType *functionCall, fixupKindType kindOfFixup, bool isStandalone)
-  functionCallTermType	*functionCall;
-  fixupKindType		 kindOfFixup;
-  bool			 isStandalone;
 {
 	functionDefinitionType	*theFunction;
 	int			 numberBound;
@@ -682,7 +691,7 @@ evaluateFunctionCall(functionCall, kindOfFixup, isStandalone)
 }
 
   valueType *
-evaluateHere()
+evaluateHere(void)
 {
 	valueType	*result;
 
@@ -694,10 +703,7 @@ evaluateHere()
 }
 
   valueType *
-evaluateIdentifier(identifier, isTopLevel, kindOfFixup)
+evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup)
-  symbolTableEntryType	*identifier;
-  bool			 isTopLevel;
-  fixupKindType		 kindOfFixup;
 {
 	symbolInContextType	*workingContext;
 	valueType		*resultValue;
@@ -821,16 +827,14 @@ evaluateIdentifier(identifier, isTopLevel, kindOfFixup)
 }
 
   valueType *
-evaluateNumber(number)
+evaluateNumber(numberTermType number)
-  numberTermType	number;
 {
 	expand(moreExpression("0x%x", number));
 	return(newValue(ABSOLUTE_VALUE, number, EXPRESSION_OPND));
 }
 
   valueType *
-evaluatePostopTerm(postopTerm)
+evaluatePostopTerm(postOpTermType *postopTerm)
-  postOpTermType	*postopTerm;
 {
 	valueType		*theOperand;
 	valueType	       **theOperandPtr;
@@ -897,8 +901,7 @@ evaluatePostopTerm(postopTerm)
 }
 
   valueType *
-evaluatePreopTerm(preopTerm)
+evaluatePreopTerm(preOpTermType *preopTerm)
-  preOpTermType	*preopTerm;
 {
 	valueType		*theOperand;
 	valueType		*result;
@@ -965,8 +968,7 @@ evaluatePreopTerm(preopTerm)
 }
 
   valueType *
-evaluateString(string)
+evaluateString(stringType *string)
-  stringType	*string;
 {
 	stringType	*newString;
 
@@ -977,9 +979,7 @@ evaluateString(string)
 }
 
   valueType *
-evaluateUnopTerm(unopTerm, kindOfFixup)
+evaluateUnopTerm(unopTermType *unopTerm, fixupKindType kindOfFixup)
-  unopTermType	*unopTerm;
-  fixupKindType	 kindOfFixup;
 {
 	valueType	*theOperand;
 	valueKindType	 resultKindOfValue;
@@ -1031,11 +1031,7 @@ evaluateUnopTerm(unopTerm, kindOfFixup)
 }
 
   valueType *
-evaluateExpressionInternally(expression, isTopLevel, kindOfFixup,isStandalone)
+evaluateExpressionInternally(expressionType *expression, bool isTopLevel, fixupKindType kindOfFixup, bool isStandalone)
-  expressionType	*expression;
-  bool			 isTopLevel;
-  fixupKindType		 kindOfFixup;
-  bool			 isStandalone;
 {
 	valueType	*result;
 
@@ -1125,9 +1121,7 @@ evaluateExpressionInternally(expression, isTopLevel, kindOfFixup,isStandalone)
 }
 
   valueType *
-evaluateExpression(expression, kindOfFixup)
+evaluateExpression(expressionType *expression, fixupKindType kindOfFixup)
-  expressionType	*expression;
-  fixupKindType		 kindOfFixup;
 {
 	valueType	*result;
 
@@ -1148,8 +1142,7 @@ evaluateExpression(expression, kindOfFixup)
 }
 
   void
-evaluateExpressionStandalone(expression)
+evaluateExpressionStandalone(expressionType *expression)
-  expressionType	*expression;
 {
 	bool		 saveExpansion;
 	valueType	*expressionResult;
@@ -1169,8 +1162,7 @@ evaluateExpressionStandalone(expression)
 }
 
   valueType *
-evaluateDefineExpression(expression)
+evaluateDefineExpression(expressionType *expression)
-  expressionType	*expression;
 {
 	nullEvaluate(expression);
 	return(newValue(OPERAND_VALUE, buildOperand(EXPRESSION_OPND,
@@ -1178,8 +1170,7 @@ evaluateDefineExpression(expression)
 }
 
   valueType *
-evaluateSelectionList(selectionList)
+evaluateSelectionList(selectionListType *selectionList)
-  selectionListType	*selectionList;
 {
 	int		 offset;
 

expressionSemantics.h

@@ -9,7 +9,7 @@ valueType *evaluateBinopTerm(binopTermType *assignmentTerm, bool isTopLevel, fix
 valueType *evaluateCondition(conditionType condition);
 valueType *evaluateBuiltInFunctionCall(symbolInContextType *workingContext, operandListType *parameters, fixupKindType kindOfFixup);
 valueType *evaluateFunctionCall(functionCallTermType *functionCall, fixupKindType kindOfFixup, bool isStandalone);
-valueType *evaluateHere();
+valueType *evaluateHere(void);
 valueType *evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup);
 valueType *evaluateNumber(numberTermType number);
 valueType *evaluatePostopTerm(postOpTermType *postopTerm);

fixups.c

@@ -57,12 +57,19 @@ stringType		*dbString = "graphics2.m";
    The routines below collectively duplicate expressions for later evaluation.
  */
 
-  expressionType *
+  
-generateFixupExpression(expression)
+extern void moreExpression (char *format, ...);
-  expressionType	*expression;
+extern bool isUndefined (valueType *value);
+extern char *tokenString (int token);
+extern void error (errorType theError, ...);
+extern char *conditionString (conditionType condition);
+extern void botch (char *message, ...);
+
+expressionType *
+generateFixupExpression(expressionType *expression)
 {
 	expressionType	*result;
-	expressionType	*duplicateExpressionForFixup();
+	expressionType	*duplicateExpressionForFixup(expressionType *expression, bool isTopLevel, bool isSpecialFunctionOperand);
 
 	generatingFixup = TRUE;
 	result = duplicateExpressionForFixup(expression, TRUE, FALSE);
@@ -71,10 +78,7 @@ generateFixupExpression(expression)
 }
 
   expressionType *
-duplicateExpressionForFixup(expression, isTopLevel, isSpecialFunctionOperand)
+duplicateExpressionForFixup(expressionType *expression, bool isTopLevel, bool isSpecialFunctionOperand)
-  expressionType	*expression;
-  bool			 isTopLevel;
-  bool			 isSpecialFunctionOperand;
 {
 	expressionType		*result;
 	expressionType		*originalResult;
@@ -85,15 +89,15 @@ duplicateExpressionForFixup(expression, isTopLevel, isSpecialFunctionOperand)
 	environmentType		*saveEnvironment;
 	bool			 saveExpansion;
 
-	operandType		*duplicateOperandForFixup();
+	operandType		*duplicateOperandForFixup(operandListType *operand, bool isSpecialFunctionOperand);
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
-	functionCallTermType	*duplicateFunctionCall();
+	functionCallTermType	*duplicateFunctionCall(functionCallTermType *functionCall);
-	expressionType		*duplicateArrayReference();
+	expressionType		*duplicateArrayReference(arrayTermType *arrayTerm);
-	valueType		*evaluateIdentifier();
+	valueType		*evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup);
-	valueType		*evaluateHere();
+	valueType		*evaluateHere(void);
-	valueType		*newValue();
+	valueType		*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
-	symbolTableEntryType	*generateLocalLabel();
+	symbolTableEntryType	*generateLocalLabel(symbolTableEntryType *symbol);
-	stringType		*saveString();
+	stringType		*saveString(char *s);
 
     nullDup(expression);
     result = originalResult = typeAlloc(expressionType);
@@ -280,14 +284,13 @@ duplicateExpressionForFixup(expression, isTopLevel, isSpecialFunctionOperand)
 }
 
   functionCallTermType *
-duplicateFunctionCall(functionCall)
+duplicateFunctionCall(functionCallTermType *functionCall)
-  functionCallTermType	*functionCall;
 {
 	functionCallTermType	*result;
 	operandListType        **argument;
 	operandListType		*parameterList;
 
-	operandListType		*duplicateOperandForFixup();
+	operandListType		*duplicateOperandForFixup(operandListType *operand, bool isSpecialFunctionOperand);
 
 	result = typeAlloc(functionCallTermType);
 	result->functionName = functionCall->functionName;
@@ -310,8 +313,7 @@ duplicateFunctionCall(functionCall)
 
 
   expressionType *
-duplicateArrayReference(arrayTerm)
+duplicateArrayReference(arrayTermType *arrayTerm)
-  arrayTermType	*arrayTerm;
 {
 	anyOldThing	*resultThing;
 	valueKindType	 kindOfResult;
@@ -322,9 +324,9 @@ duplicateArrayReference(arrayTerm)
 	bool		 saveExpansion;
 	operandType	*newOperand;
 
-	valueType	*newValue();
+	valueType	*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
-	operandType	*duplicateOperandForFixup();
+	operandType	*duplicateOperandForFixup(operandListType *operand, bool isSpecialFunctionOperand);
-	anyOldThing	*arrayLookup();
+	anyOldThing	*arrayLookup(arrayTermType *arrayTerm, valueKindType *kindOfThing);
 
 	expansionOff();
 	resultThing = arrayLookup(arrayTerm, &kindOfResult);

garbage.c

@@ -33,11 +33,14 @@
 
 #define nullFree(thing) if (thing == NULL) return;
 
-  void
+  
-freeArrayTerm(arrayTerm)
+extern void botch (char *message, ...);
-  arrayTermType	*arrayTerm;
+extern void freeOperand (operandType *operand);
+
+void
+freeArrayTerm(arrayTermType *arrayTerm)
 {
-	void	freeExpression();
+	void	freeExpression(expressionType *expression);
 
 	nullFree(arrayTerm);
 	freeExpression(arrayTerm->arrayName);
@@ -46,10 +49,9 @@ freeArrayTerm(arrayTerm)
 }
 
   void
-freeAssignmentTerm(assignmentTerm)
+freeAssignmentTerm(binopTermType *assignmentTerm)
-  binopTermType	*assignmentTerm;
 {
-	void	freeExpression();
+	void	freeExpression(expressionType *expression);
 
 	nullFree(assignmentTerm);
 	freeExpression(assignmentTerm->rightArgument);
@@ -57,10 +59,9 @@ freeAssignmentTerm(assignmentTerm)
 }
 
   void
-freeBinopTerm(binopTerm)
+freeBinopTerm(binopTermType *binopTerm)
-  binopTermType	*binopTerm;
 {
-	void	freeExpression();
+	void	freeExpression(expressionType *expression);
 
 	nullFree(binopTerm);
 	freeExpression(binopTerm->leftArgument);
@@ -70,10 +71,9 @@ freeBinopTerm(binopTerm)
 }
 
   void
-freeFunctionCall(functionCall)
+freeFunctionCall(functionCallTermType *functionCall)
-  functionCallTermType	*functionCall;
 {
-	void	freeOperandList();
+	void	freeOperandList(operandListType *operandList);
 
 	nullFree(functionCall);
 	freeOperandList(functionCall->parameters);
@@ -81,34 +81,30 @@ freeFunctionCall(functionCall)
 }
 
   void
-freePostopTerm(postopTerm)
+freePostopTerm(postOpTermType *postopTerm)
-  postOpTermType	*postopTerm;
 {
 	nullFree(postopTerm);
 	free(postopTerm);
 }
 
   void
-freePreopTerm(preopTerm)
+freePreopTerm(preOpTermType *preopTerm)
-  preOpTermType	*preopTerm;
 {
 	nullFree(preopTerm);
 	free(preopTerm);
 }
 
   void
-freeString(string)
+freeString(stringType *string)
-  stringType	*string;
 {
 	nullFree(string);
 	free(string);
 }
 
   void
-freeUnopTerm(unopTerm)
+freeUnopTerm(unopTermType *unopTerm)
-  unopTermType	*unopTerm;
 {
-	void	freeExpression();
+	void	freeExpression(expressionType *expression);
 
 	nullFree(unopTerm);
 	freeExpression(unopTerm->unopArgument);
@@ -116,8 +112,7 @@ freeUnopTerm(unopTerm)
 }
 
   void
-freeExpression(expression)
+freeExpression(expressionType *expression)
-  expressionType	*expression;
 {
 	nullFree(expression);
 	switch (expression->kindOfTerm) {
@@ -171,8 +166,7 @@ freeExpression(expression)
 }
 
   void
-freeExpressionList(expressionList)
+freeExpressionList(expressionListType *expressionList)
-  expressionListType	*expressionList;
 {
 	expressionListType	*newExpressionList;
 
@@ -185,8 +179,7 @@ freeExpressionList(expressionList)
 }
 
   void
-freeIdentifierList(identifierList)
+freeIdentifierList(identifierListType *identifierList)
-  identifierListType	*identifierList;
 {
 	identifierListType	*newIdentifierList;
 
@@ -198,25 +191,22 @@ freeIdentifierList(identifierList)
 }
 
   void
-freeSelectionList(selectionList)
+freeSelectionList(selectionListType *selectionList)
-  selectionListType	*selectionList;
 {
 	freeIdentifierList(selectionList);
 }
 
   void
-freeBlock(block)
+freeBlock(blockType *block)
-  blockType	*block;
 {
-	void	freeStatement();
+	void	freeStatement(statementType *statement);
 
 	nullFree(block);
 	freeStatement(block);
 }
 
   void
-freeCase(aCase)
+freeCase(caseType *aCase)
-  caseType	*aCase;
 {
 	freeExpressionList(aCase->caseTags);
 	freeBlock(aCase->caseBody);
@@ -224,8 +214,7 @@ freeCase(aCase)
 }
 
   void
-freeCaseList(caseList)
+freeCaseList(caseListType *caseList)
-  caseListType	*caseList;
 {
 	caseListType	*newCaseList;
 
@@ -238,37 +227,32 @@ freeCaseList(caseList)
 }
 
   void
-freeOperandList(operandList)
+freeOperandList(operandListType *operandList)
-  operandListType	*operandList;
 {
 	freeOperand(operandList);
 }
 
   void
-freeMacro(operands)
+freeMacro(operandListType *operands)
-  operandListType	*operands;
 {
 	freeOperandList(operands);
 }
 
   void
-freeMachineInstruction(operands)
+freeMachineInstruction(operandListType *operands)
-  operandListType	*operands;
 {
 	freeOperandList(operands);
 }
 
   void
-freeAlignStatement(alignStatement)
+freeAlignStatement(alignStatementBodyType *alignStatement)
-  alignStatementBodyType	*alignStatement;
 {
 	nullFree(alignStatement);
 	freeExpression(alignStatement);
 }
 
   void
-freeAssertStatement(assertStatement)
+freeAssertStatement(assertStatementBodyType *assertStatement)
-  assertStatementBodyType	*assertStatement;
 {
 	nullFree(assertStatement);
 	freeExpression(assertStatement->condition);
@@ -277,16 +261,14 @@ freeAssertStatement(assertStatement)
 }
 
   void
-freeBlockStatement(blockStatement)
+freeBlockStatement(blockStatementBodyType *blockStatement)
-  blockStatementBodyType	*blockStatement;
 {
 	nullFree(blockStatement);
 	freeExpressionList(blockStatement);
 }
 
   void
-freeByteStatement(byteStatement)
+freeByteStatement(byteStatementBodyType *byteStatement)
-  byteStatementBodyType	*byteStatement;
 {
 	byteStatementBodyType	*newByteStatement;
 
@@ -300,8 +282,7 @@ freeByteStatement(byteStatement)
 }
 
   void
-freeConstrainStatement(constrainStatement)
+freeConstrainStatement(constrainStatementBodyType *constrainStatement)
-  constrainStatementBodyType	*constrainStatement;
 {
 	nullFree(constrainStatement);
 	freeExpression(constrainStatement->constraint);
@@ -310,8 +291,7 @@ freeConstrainStatement(constrainStatement)
 }
 
   void
-freeDbyteStatement(dbyteStatement)
+freeDbyteStatement(dbyteStatementBodyType *dbyteStatement)
-  dbyteStatementBodyType	*dbyteStatement;
 {
 	dbyteStatementBodyType	*newDbyteStatement;
 
@@ -325,8 +305,7 @@ freeDbyteStatement(dbyteStatement)
 }
 
   void
-freeDefineStatement(defineStatement)
+freeDefineStatement(defineStatementBodyType *defineStatement)
-  defineStatementBodyType	*defineStatement;
 {
 	nullFree(defineStatement);
 	freeExpression(defineStatement->theValue);
@@ -334,8 +313,7 @@ freeDefineStatement(defineStatement)
 }
 
   void
-freeDoUntilStatement(doUntilStatement)
+freeDoUntilStatement(doUntilStatementBodyType *doUntilStatement)
-  doUntilStatementBodyType	*doUntilStatement;
 {
 	nullFree(doUntilStatement);
 	freeBlock(doUntilStatement->doUntilLoop);
@@ -343,8 +321,7 @@ freeDoUntilStatement(doUntilStatement)
 }
 
   void
-freeDoWhileStatement(doWhileStatement)
+freeDoWhileStatement(doWhileStatementBodyType *doWhileStatement)
-  doWhileStatementBodyType	*doWhileStatement;
 {
 	nullFree(doWhileStatement);
 	freeBlock(doWhileStatement->doWhileLoop);
@@ -352,23 +329,20 @@ freeDoWhileStatement(doWhileStatement)
 }
 
   void
-freeExternStatement(externStatement)
+freeExternStatement(externStatementBodyType *externStatement)
-  externStatementBodyType	*externStatement;
 {
 	freeIdentifierList(externStatement);
 }
 
   void
-freeFreturnStatement(freturnStatement)
+freeFreturnStatement(freturnStatementBodyType *freturnStatement)
-  freturnStatementBodyType	*freturnStatement;
 {
 	nullFree(freturnStatement);
 	freeExpression(freturnStatement);
 }
 
   void
-freeFunctionStatement(functionStatement)
+freeFunctionStatement(functionStatementBodyType *functionStatement)
-  functionStatementBodyType	*functionStatement;
 {
 	nullFree(functionStatement);
 	free(functionStatement->functionName);
@@ -376,8 +350,7 @@ freeFunctionStatement(functionStatement)
 }
 
   void
-freeIfStatement(ifStatement)
+freeIfStatement(ifStatementBodyType *ifStatement)
-  ifStatementBodyType	*ifStatement;
 {
 	nullFree(ifStatement);
 	if (ifStatement->consequence != NULL)
@@ -389,16 +362,14 @@ freeIfStatement(ifStatement)
 }
 
   void
-freeIncludeStatement(includeStatement)
+freeIncludeStatement(includeStatementBodyType *includeStatement)
-  includeStatementBodyType	*includeStatement;
 {
 	nullFree(includeStatement);
 	freeExpression(includeStatement);
 }
 
   void
-freeInstructionStatement(instructionStatement)
+freeInstructionStatement(instructionStatementBodyType *instructionStatement)
-  instructionStatementBodyType	*instructionStatement;
 {
 	nullFree(instructionStatement);
 	switch(instructionStatement->kindOfInstruction) {
@@ -419,8 +390,7 @@ freeInstructionStatement(instructionStatement)
 }
 
   void
-freeLongStatement(longStatement)
+freeLongStatement(longStatementBodyType *longStatement)
-  longStatementBodyType	*longStatement;
 {
 	longStatementBodyType	*newLongStatement;
 
@@ -434,16 +404,15 @@ freeLongStatement(longStatement)
 }
 
   void
-freeMacroStatement(macroStatement)
+freeMacroStatement(macroStatementBodyType *macroStatement)
-  macroStatementBodyType	*macroStatement;
 {
 	nullFree(macroStatement);
 	free(macroStatement);
 }
 
   void
-freeMdefineStatement(mdefineStatement)
+freeMdefineStatement(defineStatementBodyType *mdefineStatement)
-       defineStatementBodyType	*mdefineStatement; /* MIST: shouldn't this be "mdefineStatementBodyType"? */
+                              	                   /* MIST: shouldn't this be "mdefineStatementBodyType"? */
 {
 	valueType		*freeDefineExpression();
 
@@ -453,8 +422,7 @@ freeMdefineStatement(mdefineStatement)
 }
 
   void
-freeMdoUntilStatement(mdoUntilStatement)
+freeMdoUntilStatement(mdoUntilStatementBodyType *mdoUntilStatement)
-  mdoUntilStatementBodyType	*mdoUntilStatement;
 {
 	nullFree(mdoUntilStatement);
 	freeBlock(mdoUntilStatement->mdoUntilLoop);
@@ -462,8 +430,7 @@ freeMdoUntilStatement(mdoUntilStatement)
 }
 
   void
-freeMdoWhileStatement(mdoWhileStatement)
+freeMdoWhileStatement(mdoWhileStatementBodyType *mdoWhileStatement)
-  mdoWhileStatementBodyType	*mdoWhileStatement;
 {
 	nullFree(mdoWhileStatement);
 	freeBlock(mdoWhileStatement->mdoWhileLoop);
@@ -472,8 +439,7 @@ freeMdoWhileStatement(mdoWhileStatement)
 }
 
   void
-freeMifStatement(mifStatement)
+freeMifStatement(mifStatementBodyType *mifStatement)
-  mifStatementBodyType	*mifStatement;
 {
 	nullFree(mifStatement);
 	freeExpression(mifStatement->mifCondition);
@@ -484,8 +450,7 @@ freeMifStatement(mifStatement)
 }
 
   void
-freeMswitchStatement(mswitchStatement)
+freeMswitchStatement(mswitchStatementBodyType *mswitchStatement)
-  mswitchStatementBodyType	*mswitchStatement;
 {
 	freeExpression(mswitchStatement->switchExpression);
 	freeCaseList(mswitchStatement->cases);
@@ -493,8 +458,7 @@ freeMswitchStatement(mswitchStatement)
 }
 
   void
-freeMforStatement(mforStatement)
+freeMforStatement(mforStatementBodyType *mforStatement)
-  mforStatementBodyType	*mforStatement;
 {
 	nullFree(mforStatement);
 	freeExpression(mforStatement->initExpression);
@@ -505,8 +469,7 @@ freeMforStatement(mforStatement)
 }
 
   void
-freeMvariableStatement(mvariableStatement)
+freeMvariableStatement(mvariableStatementBodyType *mvariableStatement)
-  mvariableStatementBodyType	*mvariableStatement;
 {
 	nullFree(mvariableStatement);
 	if ((int)mvariableStatement->theDimension != -1)
@@ -516,8 +479,7 @@ freeMvariableStatement(mvariableStatement)
 }
 
   void
-freeMwhileStatement(mwhileStatement)
+freeMwhileStatement(mwhileStatementBodyType *mwhileStatement)
-  mwhileStatementBodyType	*mwhileStatement;
 {
 	nullFree(mwhileStatement);
 	freeExpression(mwhileStatement->mwhileCondition);
@@ -526,38 +488,33 @@ freeMwhileStatement(mwhileStatement)
 }
 
   void
-freeOrgStatement(orgStatement)
+freeOrgStatement(orgStatementBodyType *orgStatement)
-  orgStatementBodyType	*orgStatement;
 {
 	nullFree(orgStatement);
 	freeExpression(orgStatement);
 }
 
   void
-freePerformStatement(performStatement)
+freePerformStatement(performStatementBodyType *performStatement)
-  performStatementBodyType	*performStatement;
 {
 	nullFree(performStatement);
 	freeExpression(performStatement);
 }
 
   void
-freeRelStatement(relStatement)
+freeRelStatement(relStatementBodyType *relStatement)
-  relStatementBodyType	*relStatement;
 {
 }
 
   void
-freeStartStatement(startStatement)
+freeStartStatement(startStatementBodyType *startStatement)
-  startStatementBodyType	*startStatement;
 {
 	nullFree(startStatement);
 	freeExpression(startStatement);
 }
 
   void
-freeStringStatement(stringStatement)
+freeStringStatement(stringStatementBodyType *stringStatement)
-  stringStatementBodyType	*stringStatement;
 {
 	stringStatementBodyType	*newStringStatement;
 
@@ -571,8 +528,7 @@ freeStringStatement(stringStatement)
 }
 
   void
-freeStructStatement(structStatement)
+freeStructStatement(structStatementBodyType *structStatement)
-  structStatementBodyType	*structStatement;
 {
 	nullFree(structStatement);
 	freeBlock(structStatement->structBody);
@@ -580,23 +536,20 @@ freeStructStatement(structStatement)
 }
 
   void
-freeTargetStatement(targetStatement)
+freeTargetStatement(targetStatementBodyType *targetStatement)
-  targetStatementBodyType	*targetStatement;
 {
 	nullFree(targetStatement);
 	freeExpression(targetStatement);
 }
 
   void
-freeUndefineStatement(undefineStatement)
+freeUndefineStatement(undefineStatementBodyType *undefineStatement)
-  undefineStatementBodyType	*undefineStatement;
 {
 	freeIdentifierList(undefineStatement);
 }
 
   void
-freeVariableStatement(variableStatement)
+freeVariableStatement(variableStatementBodyType *variableStatement)
-  variableStatementBodyType	*variableStatement;
 {
 	nullFree(variableStatement);
 	if ((int)variableStatement->theDimension != -1)
@@ -606,8 +559,7 @@ freeVariableStatement(variableStatement)
 }
 
   void
-freeWhileStatement(whileStatement)
+freeWhileStatement(whileStatementBodyType *whileStatement)
-  whileStatementBodyType	*whileStatement;
 {
 	nullFree(whileStatement);
 	freeBlock(whileStatement->whileLoop);
@@ -615,8 +567,7 @@ freeWhileStatement(whileStatement)
 }
 
   void
-freeWordStatement(wordStatement)
+freeWordStatement(wordStatementBodyType *wordStatement)
-  wordStatementBodyType	*wordStatement;
 {
 	wordStatementBodyType	*newWordStatement;
 
@@ -630,9 +581,7 @@ freeWordStatement(wordStatement)
 }
 
   void
-freeStatementBody(kind, body)
+freeStatementBody(statementKindType kind, statementBodyType body)
-  statementKindType	kind;
-  statementBodyType	body;
 {
 	switch (kind) {
 
@@ -795,8 +744,7 @@ freeStatementBody(kind, body)
 }
 
   void
-freeLabelList(labelList)
+freeLabelList(labelListType *labelList)
-  labelListType	*labelList;
 {
 	labelListType	*nextLabel;
 
@@ -808,8 +756,7 @@ freeLabelList(labelList)
 }
 
   void
-freeStatement(statement)
+freeStatement(statementType *statement)
-  statementType	*statement;
 {
 	statementType	*newStatement;
 
@@ -824,11 +771,10 @@ freeStatement(statement)
 }
 
   void
-freeArray(array)
+freeArray(arrayType *array)
-  arrayType	*array;
 {
 	int	i;
-	void	freeValue();
+	void	freeValue(valueType *value);
 
 	if (array->arraySize > 0) {
 		for (i=0; i<array->arraySize; i++)
@@ -839,8 +785,7 @@ freeArray(array)
 }
 
   void
-freeValue(value)
+freeValue(valueType *value)
-  valueType	*value;
 {
 	if (value->kindOfValue == STRING_VALUE)
 		freeString(value->value);

initialize.c

@@ -39,17 +39,27 @@ extern int yydebug;
 static fileNameListType		*bottomOfInputFileStack;
 static char			 *outputFileName;
 
-  void
+  
-chokePukeAndDie()
+extern int unlink (const char *);
+bool isDotMName (stringType *fileName);
+extern void fatalError (errorType theError, ...);
+extern void printVersion (void);
+extern void warning (errorType theError, ...);
+extern void fatalSystemError (errorType theError, ...);
+extern void initializeLexDispatchTable (void);
+extern genericTableEntryType *hashStringEnter (genericTableEntryType *entry, genericTableEntryType **table);
+extern int fancyAtoI (char *buffer, int base);
+extern void error (errorType theError, ...);
+
+void
+chokePukeAndDie(void)
 {
 	unlink(outputFileName);
 	exit(1);
 }
 
   void
-initializeStuff(argc, argv)
+initializeStuff(int argc, char **argv)
-  int	argc;
-  char *argv[];
 {
 	int	  i;
 	int	  j;
@@ -62,13 +72,13 @@ initializeStuff(argc, argv)
 	char	 *symbolDumpFileName;
 	bool	  dontUnlinkTempFiles;
 
-	void	  createHashTables();
+	void	  createHashTables(void);
-	void	  installBuiltInFunctions();
+	void	  installBuiltInFunctions(void);
-	void	  installPredefinedSymbols();
+	void	  installPredefinedSymbols(void);
-	void	  installCommandLineDefineSymbols();
+	void	  installCommandLineDefineSymbols(void);
-	void	  openFirstInputFile();
+	void	  openFirstInputFile(void);
-	void	  queueInputFile();
+	void	  queueInputFile(char *name);
-	void	  noteCommandLineDefine();
+	void	  noteCommandLineDefine(char *arg);
 
 	for (i=0; i<128; i++) {
 		lowerCaseCharacterTable[i] = i;
@@ -381,13 +391,13 @@ initializeStuff(argc, argv)
 }
 
   void
-installBuiltInFunctions()
+installBuiltInFunctions(void)
 {
 	int				 i;
 	symbolTableEntryType		*newFunction;
 
-	symbolTableEntryType		*lookupOrEnterSymbol();
+	symbolTableEntryType		*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
-	valueType			*newValue();
+	valueType			*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 
 	for (i=0; builtInFunctionTable[i].functionName!=NULL; i++) {
 		newFunction = lookupOrEnterSymbol(builtInFunctionTable[i].
@@ -401,13 +411,13 @@ installBuiltInFunctions()
 }
 
   void
-installPredefinedSymbols()
+installPredefinedSymbols(void)
 {
 	int				 i;
 	symbolTableEntryType		*newSymbol;
 
-	symbolTableEntryType		*lookupOrEnterSymbol();
+	symbolTableEntryType		*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
-	valueType			*newValue();
+	valueType			*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 
 	for (i=0; predefinedSymbolTable[i].symbolName!=NULL; i++) {
 		newSymbol = lookupOrEnterSymbol(predefinedSymbolTable[i].
@@ -420,13 +430,13 @@ installPredefinedSymbols()
 }
 
   void
-installCommandLineDefineSymbols()
+installCommandLineDefineSymbols(void)
 {
 	int				 i;
 	symbolTableEntryType		*newSymbol;
 
-	symbolTableEntryType		*lookupOrEnterSymbol();
+	symbolTableEntryType		*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
-	valueType			*newValue();
+	valueType			*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 
 	while (commandLineDefines != NULL) {
 		newSymbol = lookupOrEnterSymbol(commandLineDefines->name,
@@ -439,7 +449,7 @@ installCommandLineDefineSymbols()
 }
 
   void
-createHashTables()
+createHashTables(void)
 {
 	opcodeTableEntryType	*newOpcodeEntry;
 	keywordTableEntryType	*newKeywordEntry;
@@ -459,8 +469,7 @@ createHashTables()
 }
 
   void
-queueInputFile(name)
+queueInputFile(char *name)
-  char	*name;
 {
 	fileNameListType	*newFileName;
 
@@ -479,7 +488,7 @@ queueInputFile(name)
 }
 
   void
-openFirstInputFile()
+openFirstInputFile(void)
 {
 	if (inputFileStack == NULL) {
 		inputFileStack = typeAlloc(fileNameListType);
@@ -504,8 +513,7 @@ openFirstInputFile()
 }
 
   bool
-isDotMName(fileName)
+isDotMName(stringType *fileName)
-  stringType	*fileName;
 {
 	int	length;
 
@@ -515,10 +523,7 @@ isDotMName(fileName)
 }
 
   bool
-parseCommandLineDefine(arg, name, value)
+parseCommandLineDefine(char *arg, char **name, int *value)
-  char	 *arg;
-  char	**name;
-  int	 *value;
 {
 	char	*ptr;
 	char	 c;
@@ -561,14 +566,13 @@ parseCommandLineDefine(arg, name, value)
 }
 
   void
-noteCommandLineDefine(arg)
+noteCommandLineDefine(char *arg)
-  char	*arg;
 {
 	char			*name;
 	int			 value;
 	commandLineDefineType	*newCommandLineDefine;
 
-	bool	 parseCommandLineDefine();
+	bool	 parseCommandLineDefine(char *arg, char **name, int *value);
 
 	if (parseCommandLineDefine(arg, &name, &value)) {
 		newCommandLineDefine = typeAlloc(commandLineDefineType);

lexer.c

@@ -52,8 +52,26 @@ static int	lineBufferPtr = 0;
 #define isNumeric(c)		(numericCharacterTable[c])
 #define isAlphaNumeric(c)	(alphaNumericCharacterTable[c])
 
-  int
+  
-yylex()
+int lexer (void);
+extern void printToken (int token);
+int lexLiteral (char c);
+bool isMacrossLiteralCharacter (char c);
+int readAnotherLine (void);
+extern int hashString (char *s);
+extern opcodeTableEntryType *lookupOpcode (char *s, int hashValue);
+extern int lookupKeyword (char *s, int hashValue);
+extern conditionType lookupConditionCode (char *s, int hashValue);
+extern macroTableEntryType *lookupMacroName (char *s, int hashValue);
+int fancyAtoI (char *buffer, int base);
+int digitValue (char c);
+extern void error (errorType theError, ...);
+int getStringCharacter (FILE *input);
+extern void fatalSystemError (errorType theError, ...);
+extern bool notListable (statementKindType statementKind);
+
+int
+yylex(void)
 {
 	int	result;
 
@@ -67,11 +85,11 @@ yylex()
 }
 
   int
-lexer()
+lexer(void)
 {
 	char	c;
 
-	char	skipWhitespaceAndComments();
+	char	skipWhitespaceAndComments(void);
 
 	if ((c = skipWhitespaceAndComments()) == EOF)
 		return(lexLiteral(c));
@@ -80,15 +98,15 @@ lexer()
 }
 
   void
-initializeLexDispatchTable()
+initializeLexDispatchTable(void)
 {
 	int	c;
-	int	lexIdentifier();
+	int	lexIdentifier(char c);
-	int	lexNumber();
+	int	lexNumber(char c);
-	int	lexLiteral();
+	int	lexLiteral(char c);
-	int	lexCharacterConstant();
+	int	lexCharacterConstant(void);
-	int	lexStringConstant();
+	int	lexStringConstant(void);
-	int	lexOperator();
+	int	lexOperator(char firstC);
 
 	for (c = 0; c < LEX_DISPATCH_TABLE_SIZE; c++) {
 		if (isAlphabetic(c) || c=='$')
@@ -107,8 +125,7 @@ initializeLexDispatchTable()
 }
 
   bool
-isMacrossLiteralCharacter(c)
+isMacrossLiteralCharacter(char c)
-  char	c;
 {
 	return(c==':' || c==',' || c=='@' || c=='#' ||
 	       c=='(' || c==')' || c=='{' || c=='}' || c=='[' || c==']' ||
@@ -116,9 +133,7 @@ isMacrossLiteralCharacter(c)
 }
 
   void
-snarfAlphanumericString(c, buffer)
+snarfAlphanumericString(char c, char *buffer)
-  char	 c;
-  char	*buffer;
 {
 	char	*bufferPtr;
 
@@ -135,10 +150,9 @@ snarfAlphanumericString(c, buffer)
 char	nameBuffer[MAX_NAME_SIZE+1];
 
   int
-lexIdentifier(c)
+lexIdentifier(char c)
-  char	c;
 {
-	char	*saveString();
+	char	*saveString(char *s);
 	int	 hashValue;
 
 	snarfAlphanumericString(c, nameBuffer);
@@ -161,8 +175,7 @@ lexIdentifier(c)
 char	numberBuffer[MAX_NAME_SIZE+1];
 
   int
-lexNumber(c)
+lexNumber(char c)
-  char	c;
 {
 	int	base;
 	int	start;
@@ -189,9 +202,7 @@ lexNumber(c)
 }
 
   int
-fancyAtoI(buffer, base)
+fancyAtoI(char *buffer, int base)
-  char	*buffer;
-  int	 base;
 {
 	int	value;
 	int	digit;
@@ -209,8 +220,7 @@ fancyAtoI(buffer, base)
 }
 
   int
-digitValue(c)
+digitValue(char c)
-  char	c;
 {
 	if (isNumeric(c))
 		return(c - '0');
@@ -219,8 +229,7 @@ digitValue(c)
 }
 
   int
-lexLiteral(c)
+lexLiteral(char c)
-  char	c;
 {
 	static bool	passedEnd = FALSE;
 
@@ -240,7 +249,7 @@ lexLiteral(c)
 }
 
   int
-lexCharacterConstant()
+lexCharacterConstant(void)
 {
 	char	c;
 
@@ -256,13 +265,12 @@ lexCharacterConstant()
 bool	escaped;	/* true if last string character read was an escape
 					     code. */
   int
-getStringCharacter(input)
+getStringCharacter(FILE *input)
-  FILE	*input;
 {
 	char	 c;
 	char	*numberPtr;
 	int	 result;
-	char	 controlCharacter();
+	char	 controlCharacter(char c);
 
 	escaped = FALSE;
 	c = getNextChar();
@@ -292,7 +300,7 @@ getStringCharacter(input)
 char	stringBuffer[MAX_NAME_SIZE + 1];
 
   int
-lexStringConstant()
+lexStringConstant(void)
 {
 	char	*stringPtr;
 	char	 c;
@@ -309,8 +317,7 @@ lexStringConstant()
 }
 
   int
-lexOperator(firstC)
+lexOperator(char firstC)
-  char	firstC;
 {
 	char	secondC;
 	char	thirdC;
@@ -347,8 +354,7 @@ lexOperator(firstC)
 }
 
   char
-controlCharacter(c)
+controlCharacter(char c)
-  char	c;
 {
 #define CONTROL_CHARACTER_MASK (~0100)
 
@@ -356,7 +362,7 @@ controlCharacter(c)
 }
 
   char
-skipWhitespaceAndComments()
+skipWhitespaceAndComments(void)
 {
 	char	c;
 
@@ -394,7 +400,7 @@ skipWhitespaceAndComments()
 }
 
   int
-popInputFileStack()
+popInputFileStack(void)
 {
 	fileNameListType	*oldFile;
 
@@ -425,8 +431,7 @@ popInputFileStack()
 }
 
   void
-pushInputFileStack(fileName)
+pushInputFileStack(stringType *fileName)
-  stringType	*fileName;
 {
 	fileNameListType	*newFileName;
 
@@ -446,7 +451,7 @@ pushInputFileStack(fileName)
 }
 
   void
-resynchronizeInput()
+resynchronizeInput(void)
 {
 	char	c;
 	while ((c = getNextChar())!='\n' && c!=EOF)
@@ -458,8 +463,7 @@ resynchronizeInput()
 static bool	previousLongLineFlag = FALSE;
 
   void
-saveLineForListing(line)
+saveLineForListing(stringType *line)
-  stringType	*line;
 {
 	if (!previousLongLineFlag) {
 		putw(currentLocationCounter.value, saveFileForPass2);
@@ -470,7 +474,7 @@ saveLineForListing(line)
 }
 
   void
-saveEOLForListing()
+saveEOLForListing(void)
 {
 	putw(-1, saveFileForPass2);
 	putw(includeNestingDepth, saveFileForPass2);
@@ -478,9 +482,7 @@ saveEOLForListing()
 }
 
   void
-saveIndexForListing(kindOfStatement, cumulativeLineNumber)
+saveIndexForListing(statementKindType kindOfStatement, int cumulativeLineNumber)
-  statementKindType	kindOfStatement;
-  int			cumulativeLineNumber;
 {
 	if (!amExpanding() || !notListable(kindOfStatement)) {
 		putw(kindOfStatement, indexFileForPass2);
@@ -493,8 +495,7 @@ saveIndexForListing(kindOfStatement, cumulativeLineNumber)
 }
 
   void
-saveEndMifForListing(cumulativeLineNumber)
+saveEndMifForListing(int cumulativeLineNumber)
-  int	cumulativeLineNumber;
 {
 	putw(MIF_STATEMENT, indexFileForPass2);
 	putw(-1, indexFileForPass2);
@@ -505,13 +506,13 @@ saveEndMifForListing(cumulativeLineNumber)
 }
 
   void
-saveListingOff()
+saveListingOff(void)
 {
 	saveIndexForListing(-1, cumulativeLineNumber);
 }
 
   void
-saveListingOn()
+saveListingOn(void)
 {
 	if (currentCodeMode == ABSOLUTE_BUFFER)
 		saveIndexForListing(-1, cumulativeLineNumber);
@@ -520,10 +521,7 @@ saveListingOn()
 }
 
   char *
-myfgets(buffer, length, stream)
+myfgets(char *buffer, int length, FILE *stream)
-  char	*buffer;
-  int	 length;
-  FILE	*stream;
 {
 	char	*result;
 	char	 c;
@@ -546,7 +544,7 @@ myfgets(buffer, length, stream)
 }
 
   int
-readAnotherLine()
+readAnotherLine(void)
 {
 	int	result;
 

listing.c

@@ -44,8 +44,16 @@ static int	 nextMacroAddress;
 static int	 macroDepth;
 static int	 nextMacroDepth;
 
-  void
+  
-outputListing()
+extern void saveLineForListing (stringType *line);
+extern void saveIndexForListing (statementKindType kindOfStatement, int cumulativeLineNumber);
+extern char *myfgets (char *buffer, int length, FILE *stream);
+bool isBlankStatement (statementKindType statementKind);
+extern byte getByte (addressType address);
+extern bool listableStatement (statementKindType kind);
+
+void
+outputListing(void)
 {
 	rewind(saveFileForPass2);
 	rewind(indexFileForPass2);
@@ -54,7 +62,7 @@ outputListing()
 }
 
   void
-terminateListingFiles()
+terminateListingFiles(void)
 {
 	saveLineForListing("\n");
 	saveIndexForListing(NULL_STATEMENT, cumulativeLineNumber);
@@ -96,7 +104,7 @@ terminateListingFiles()
 /* This is the most horrible piece of code I have ever written in my entire
 	life -- cbm */
   void
-generateListing()
+generateListing(void)
 {
 	int			 sourceAddress;
 	int			 sourceDepth;
@@ -297,10 +305,7 @@ generateListing()
 bool	longLineFlag; /* defined in lexer.c */
 
   int
-printMacroLine(numberOfBytes, byteAddress, kind)
+printMacroLine(int numberOfBytes, int byteAddress, statementKindType kind)
-  int			 numberOfBytes;
-  int			 byteAddress;
-  statementKindType	 kind;
 {
 	macroAddress = nextMacroAddress;
 	macroDepth = nextMacroDepth;
@@ -312,11 +317,7 @@ printMacroLine(numberOfBytes, byteAddress, kind)
 }
 
   void
-readSourceFileLine(sourceAddressPtr, sourceDepthPtr, lineBuffer, file)
+readSourceFileLine(int *sourceAddressPtr, int *sourceDepthPtr, char *lineBuffer, FILE *file)
-  int	*sourceAddressPtr;
-  int	*sourceDepthPtr;
-  char	 lineBuffer[];
-  FILE	*file;
 {
 	char	c;
 
@@ -331,10 +332,7 @@ readSourceFileLine(sourceAddressPtr, sourceDepthPtr, lineBuffer, file)
 }
 
   void
-readIndexFileLine(statementKindPtr, indexAddressPtr, indexLineNumberPtr)
+readIndexFileLine(statementKindType *statementKindPtr, int *indexAddressPtr, int *indexLineNumberPtr)
-  statementKindType	*statementKindPtr;
-  int			*indexAddressPtr;
-  int			*indexLineNumberPtr;
 {
 	statementKindType	 statementKindRead;
 	int			 indexAddressRead;
@@ -353,11 +351,7 @@ readIndexFileLine(statementKindPtr, indexAddressPtr, indexLineNumberPtr)
 }
 
   int
-printListingLine(numberOfBytes, byteAddress, text, kind)
+printListingLine(int numberOfBytes, int byteAddress, char *text, statementKindType kind)
-  int			 numberOfBytes;
-  int			 byteAddress;
-  char			*text;
-  statementKindType	 kind;
 {
 	int	i;
 
@@ -408,8 +402,7 @@ printListingLine(numberOfBytes, byteAddress, text, kind)
 
 	
   bool
-isBlockOpener(statementKind)
+isBlockOpener(statementKindType statementKind)
-  statementKindType	statementKind;
 {
 	return (statementKind==IF_STATEMENT ||
 		statementKind==WHILE_STATEMENT ||
@@ -428,8 +421,7 @@ isBlockOpener(statementKind)
 }
 
   bool
-isBlankStatement(statementKind)
+isBlankStatement(statementKindType statementKind)
-  statementKindType	statementKind;
 {
 	return(	statementKind == DEFINE_STATEMENT ||
 		statementKind == NULL_STATEMENT ||
@@ -455,8 +447,7 @@ isBlankStatement(statementKind)
 }
 
   void
-tabPrint(text)
+tabPrint(stringType *text)
-  stringType	*text;
 {
 	int	column;
 	int	spaces;
@@ -477,16 +468,14 @@ tabPrint(text)
 }
 
   void
-printNTimes(aChar, times)
+printNTimes(char aChar, int times)
-  char	aChar;
-  int	times;
 {
 	while (times-- > 0)
             moreText("%c", aChar, 0, 0);
 }
 
   void
-tabIndent()
+tabIndent(void)
 {
 	printNTimes('\t', tabCount);
 }
@@ -499,7 +488,7 @@ static char	 labelString[LINE_BUFFER_SIZE] = { '\0' };
 static char	*labelStringPtr = labelString;
 
   bool
-labeledLine()
+labeledLine(void)
 {
 	return(labelStringPtr != labelString);
 }
@@ -542,9 +531,7 @@ moreText(char *format, ...)
 }
 
   void
-moreLabel(format, arg1)
+moreLabel(char *format, int arg1)
-  char	*format;
-  int	 arg1;
 {
 	sprintf(labelStringPtr, format, arg1);
 	labelStringPtr = labelString + strlen(labelString);
@@ -554,7 +541,7 @@ static addressType	savedCurrentLocationCounterValue;
 static int		savedIncludeNestingDepth;
 
   void
-startLine()
+startLine(void)
 {
 	printNTimes('+', macroCallDepth);
 	savedCurrentLocationCounterValue = currentLocationCounter.value;
@@ -562,7 +549,7 @@ startLine()
 }
 
   void
-endLine()
+endLine(void)
 {
 	if (amListing()) {
 		putw(savedCurrentLocationCounterValue, macroFileForPass2);
@@ -574,16 +561,14 @@ endLine()
 }
 
   void
-flushExpressionString()
+flushExpressionString(void)
 {
 	expressionStringPtr = expressionString;
 	*expressionStringPtr = '\0';
 }
 
   void
-expandExpression(toBuffer, toBufferPtr)
+expandExpression(char *toBuffer, char **toBufferPtr)
-  char	 *toBuffer;
-  char	**toBufferPtr;
 {
 	if (toBuffer == NULL)
 		moreText("%s", expressionString, 0, 0);
@@ -593,25 +578,20 @@ expandExpression(toBuffer, toBufferPtr)
 }
 
   void
-expandNum(buffer, bufferPtr, n)
+expandNum(char *buffer, char **bufferPtr, int n)
-  char	 *buffer;
-  char	**bufferPtr;
-  int	  n;
 {
 	moreTextOptional(buffer, bufferPtr, "%d", n, 0, 0);
 }
 
   void
-flushOperand(n)
+flushOperand(int n)
-  int	n;
 {
 	moreText("%s", operandBuffer[n], 0, 0);
 	operandBuffer[n][0] = '\0';
 }
 
   void
-expandOperands(op)
+expandOperands(int op)
-  int	op;
 {
 	int	i;
 
@@ -625,7 +605,7 @@ expandOperands(op)
 }
 
   void
-expandLabel()
+expandLabel(void)
 {
 	moreText("%s", labelString, 0, 0);
 	labelStringPtr = labelString;
@@ -643,7 +623,7 @@ moreExpression(char *format, ...)
 }
 
   void
-startLineMarked()
+startLineMarked(void)
 {
 	startLine();
 	if (amListing())
@@ -651,8 +631,7 @@ startLineMarked()
 }
 
   bool
-notListable(statementKind)
+notListable(statementKindType statementKind)
-  statementKindType	statementKind;
 {
 	return(!listableStatement(statementKind) &&
 		statementKind != INSTRUCTION_STATEMENT &&

listing.h

@@ -6,9 +6,9 @@
  * Glorious Future Year 1989 the vprintf function does almost exactly
  * what we want. */
 
-void outputListing();
+void outputListing(void);
-void terminateListingFiles();
+void terminateListingFiles(void);
-void generateListing();
+void generateListing(void);
 int printMacroLine(int numberOfBytes, int byteAddress, statementKindType kind);
 void readSourceFileLine(int *sourceAddressPtr, int *sourceDepthPtr, char lineBuffer[], FILE *file);
 void readIndexFileLine(statementKindType *statementKindPtr, int *indexAddressPtr, int *indexLineNumberPtr);
@@ -17,22 +17,22 @@ bool isBlockOpener(statementKindType statementKind);
 bool isBlankStatment(statementKindType statementKind);
 void tabPrint(stringType *text);
 void printNTimes (char aChar, int times);
-void tabIndent();
+void tabIndent(void);
-bool labeledLine();
+bool labeledLine(void);
 void addText(char *buffer, char **bufferPtr, char *format, ...);
 void moreTextOptional(char *buffer, char **bufferPtr, char *format, ...);
 void moreText(char *format, ...);
 void moreLabel(char *format, int arg1);
-void startLine();
+void startLine(void);
-void endLine();
+void endLine(void);
-void flushExpressionString();
+void flushExpressionString(void);
 void expandExpression(char *toBuffer, char **toBufferPtr);
 void expandNum(char *buffer, char **bufferPtr, int n);
 void flushOperand(int n);
 void expandOperands(int op);
-void expandLabel();
+void expandLabel(void);
 void moreExpression(char *format, ...);
-void startLineMarked();
+void startLineMarked(void);
 bool notListable(statementKindType statementKind);
 
 #endif

lookups.c

@@ -36,14 +36,24 @@
    lists that are sorted alphabetically.
  */
 
-  conditionType
+  
-lookupConditionCode(s, hashValue)
+extern void botch (char *message, ...);
-  char	*s;
+extern void freeValue (valueType *value);
-  int	 hashValue;
+extern void error (errorType theError, ...);
+bool strcmplc (char *s1, char *s2);
+int hashString (char *s);
+extern int countParameters (operandListType *parameterList);
+extern arrayType *allocArray (int size, valueType ***contentsPtr);
+extern bool isUsable (valueType *value);
+extern void moreExpression (char *format, ...);
+extern bool isUndefined (valueType *value);
+
+conditionType
+lookupConditionCode(char *s, int hashValue)
 {
 	conditionTableEntryType	*result;
 
-	genericTableEntryType	*prehashedStringLookup();
+	genericTableEntryType	*prehashedStringLookup(char *s, genericTableEntryType **table, int hashValue);
 
 	result = (conditionTableEntryType *) prehashedStringLookup(s,
 		conditionTable, hashValue);
@@ -54,13 +64,11 @@ lookupConditionCode(s, hashValue)
 }
 
   int
-lookupKeyword(s, hashValue)
+lookupKeyword(char *s, int hashValue)
-  char	*s;
-  int	 hashValue;
 {
 	keywordTableEntryType	*result;
 
-	genericTableEntryType	*prehashedStringLookup();
+	genericTableEntryType	*prehashedStringLookup(char *s, genericTableEntryType **table, int hashValue);
 
 	result = (keywordTableEntryType *) prehashedStringLookup(s,
 		keywordTable, hashValue);
@@ -71,22 +79,18 @@ lookupKeyword(s, hashValue)
 }
 
   macroTableEntryType *
-lookupMacroName(s, hashValue)
+lookupMacroName(char *s, int hashValue)
-  char	*s;
-  int	 hashValue;
 {
-	genericTableEntryType	*prehashedStringLookup();
+	genericTableEntryType	*prehashedStringLookup(char *s, genericTableEntryType **table, int hashValue);
 
 	return((macroTableEntryType *) prehashedStringLookup(s, macroTable,
 		hashValue));
 }
 
   opcodeTableEntryType *
-lookupOpcode(s, hashValue)
+lookupOpcode(char *s, int hashValue)
-  char	*s;
-  int	 hashValue;
 {
-	genericTableEntryType	*prehashedStringLookup();
+	genericTableEntryType	*prehashedStringLookup(char *s, genericTableEntryType **table, int hashValue);
 
 	return((opcodeTableEntryType *) prehashedStringLookup(s,
 		opcodeTable, hashValue));
@@ -97,14 +101,12 @@ lookupOpcode(s, hashValue)
    the given kind and return *that* */
 
   symbolTableEntryType *
-lookupOrEnterSymbol(s, kind)
+lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind)
-  stringType		*s;
-  symbolUsageKindType	 kind;
 {
 	symbolTableEntryType	*result;
-	genericTableEntryType	*hashStringLookup();
+	genericTableEntryType	*hashStringLookup(char *s, genericTableEntryType **table);
-	genericTableEntryType	*hashStringEnter();
+	genericTableEntryType	*hashStringEnter(genericTableEntryType *entry, genericTableEntryType **table);
-	symbolTableEntryType	*buildSymbolTableEntry();
+	symbolTableEntryType	*buildSymbolTableEntry(stringType *name, symbolUsageKindType usage);
 
 	if (result = (symbolTableEntryType *)hashStringLookup(s,symbolTable)){
 /*		result->referenceCount++;*/
@@ -116,8 +118,7 @@ lookupOrEnterSymbol(s, kind)
 }
 
   void
-pushSymbol(symbol)
+pushSymbol(symbolTableEntryType *symbol)
-  symbolTableEntryType *symbol;
 {
 	symbolInContextType	*newContext;
 
@@ -127,8 +128,7 @@ pushSymbol(symbol)
 }
 
   void
-popSymbol(symbol)
+popSymbol(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	symbolInContextType	*deadContext;
 
@@ -146,16 +146,15 @@ popSymbol(symbol)
 }
 
   macroTableEntryType *
-createMacro(macroName)
+createMacro(stringType *macroName)
-  stringType	*macroName;
 {
 	macroTableEntryType		*result;
 	symbolTableEntryType		*testSymbol;
 
-	genericTableEntryType		*hashStringLookup();
+	genericTableEntryType		*hashStringLookup(char *s, genericTableEntryType **table);
-	genericTableEntryType		*hashStringEnter();
+	genericTableEntryType		*hashStringEnter(genericTableEntryType *entry, genericTableEntryType **table);
-	macroTableEntryType		*buildMacroTableEntry();
+	macroTableEntryType		*buildMacroTableEntry(stringType *name);
-	symbolTableEntryType		*lookupOrEnterSymbol();
+	symbolTableEntryType		*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
 
 	testSymbol = lookupOrEnterSymbol(macroName, MACRO_SYMBOL);
 	if (testSymbol->context->usage != MACRO_SYMBOL) {
@@ -179,10 +178,7 @@ createMacro(macroName)
  */
 
   genericTableEntryType *
-prehashedStringLookup(s, table, hashValue)
+prehashedStringLookup(char *s, genericTableEntryType **table, int hashValue)
-  char			*s;
-  genericTableEntryType	*table[];
-  int			 hashValue;
 {
 	genericTableEntryType	*result;
 	int			 test;
@@ -202,17 +198,13 @@ prehashedStringLookup(s, table, hashValue)
 }
 
   genericTableEntryType *
-hashStringLookup(s, table)
+hashStringLookup(char *s, genericTableEntryType **table)
-  char			*s;
-  genericTableEntryType	*table[];
 {
 	return(prehashedStringLookup(s, table, hashString(s)));
 }
 
   genericTableEntryType *
-hashStringEnter(entry, table)
+hashStringEnter(genericTableEntryType *entry, genericTableEntryType **table)
-  genericTableEntryType	*entry;
-  genericTableEntryType	*table[];
 {
 	genericTableEntryType	*result;
 	genericTableEntryType	*oldResult;
@@ -252,8 +244,7 @@ hashStringEnter(entry, table)
 }
 
   int
-hashString(s)
+hashString(char *s)
-  char	*s;
 {
 	unsigned	result;
 
@@ -264,9 +255,9 @@ hashString(s)
 }
 
   bool
-strcmplc(s1, s2)	/* string compare in lower case */
+strcmplc(char *s1, char *s2)	/* string compare in lower case */
-  char *s1;		/*  heavily optimized version */
+           		/*  heavily optimized version */
-  char *s2;
+           
 {
 	char	c1;
 	int	result;
@@ -284,9 +275,9 @@ strcmplc(s1, s2)	/* string compare in lower case */
 }
 
   bool
-strcmplct(s1, s2)	/* For tables: s2 is already lower case */
+strcmplct(char *s1, char *s2)	/* For tables: s2 is already lower case */
-  char *s1;		/*  heavily optimized version.  */
+           		/*  heavily optimized version.  */
-  char *s2;
+           
 {
 	char	c1;
 	int	result;
@@ -302,21 +293,18 @@ strcmplct(s1, s2)	/* For tables: s2 is already lower case */
 }
 
   void
-purgeSymbol(symbol)
+purgeSymbol(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	symbolInContextType	*context;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
 
 	if ((context = getWorkingContext(symbol)) != NULL)
 		context->usage = DEAD_SYMBOL;
 }
 
   void
-reincarnateSymbol(context, newUsage)
+reincarnateSymbol(symbolInContextType *context, symbolUsageKindType newUsage)
-  symbolInContextType	*context;
-  symbolUsageKindType	 newUsage;
 {
 	context->attributes = 0;
 	dupValue(context->value, UndefinedValue);
@@ -329,12 +317,9 @@ reincarnateSymbol(context, newUsage)
  */
 
   void
-pushBinding(symbol, newBinding, newUsage)
+pushBinding(symbolTableEntryType *symbol, valueType *newBinding, symbolUsageKindType newUsage)
-  symbolTableEntryType	*symbol;
-  valueType		*newBinding;
-  symbolUsageKindType	 newUsage;
 {
-	valueType	*newValue();
+	valueType	*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 
 	pushSymbol(symbol);
 	if (newBinding == NULL)
@@ -347,17 +332,13 @@ pushBinding(symbol, newBinding, newUsage)
 }
 
   void
-popBinding(symbol)
+popBinding(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	popSymbol(symbol);
 }
 
   int	/* returns number of bindings completed, negative this if failure */
-bindMacroArguments(argumentList, parameterList, macroName)
+bindMacroArguments(argumentDefinitionListType *argumentList, operandListType *parameterList, stringType *macroName)
-  argumentDefinitionListType	*argumentList;
-  operandListType		*parameterList;
-  stringType			*macroName;
 {
 	int			 numberBound;
 	bool			 arrayTag;
@@ -365,7 +346,7 @@ bindMacroArguments(argumentList, parameterList, macroName)
 	valueType	       **arrayContents;
 	int			 i;
 
-	valueType		*newValue();
+	valueType		*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 
 	if (argumentList == NULL)
 		arrayTag = FALSE;
@@ -417,10 +398,7 @@ bindMacroArguments(argumentList, parameterList, macroName)
 }
 
   int	/* returns number of bindings completed, negative this if failure */
-bindFunctionArguments(argumentList, parameterList, functionName)
+bindFunctionArguments(argumentDefinitionListType *argumentList, operandListType *parameterList, stringType *functionName)
-  argumentDefinitionListType	*argumentList;
-  operandListType		*parameterList;
-  stringType			*functionName;
 {
 	valueType	*argument;
 	bool		 arrayTag;
@@ -431,8 +409,8 @@ bindFunctionArguments(argumentList, parameterList, functionName)
 	valueType	*firstArgument;
 	environmentType	*saveEnvironment;
 
-	valueType	*evaluateOperand();
+	valueType	*evaluateOperand(operandType *operand);
-	valueType	*newValue();
+	valueType	*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 
 	if (argumentList == NULL)
 		arrayTag = FALSE;
@@ -515,9 +493,7 @@ bindFunctionArguments(argumentList, parameterList, functionName)
 }
 
   void
-unbindArguments(argumentList, numberToUnbind)
+unbindArguments(argumentDefinitionListType *argumentList, int numberToUnbind)
-  argumentDefinitionListType	*argumentList;
-  int				 numberToUnbind;
 {
 	while (argumentList != NULL  &&  numberToUnbind-- > 0) {
 		popBinding(argumentList->theArgument);
@@ -528,8 +504,7 @@ unbindArguments(argumentList, numberToUnbind)
 }
 
   void
-unbindLocalVariables(identifierList)
+unbindLocalVariables(identifierListType *identifierList)
-  identifierListType	*identifierList;
 {
 	identifierListType	*deadEntry;
 

macrossTables_6502.c

@@ -205,20 +205,20 @@ int operandClassTable[] = {	/* indexed by operandKindType */
 	BLOCK_OPND_BIT,
 };
 
-int	actionsRelative();
+int	actionsRelative(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsDir1();
+int	actionsDir1(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsDir2();
+int	actionsDir2(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsDirIndir();
+int	actionsDirIndir(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsDirX1();
+int	actionsDirX1(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsDirX2();
+int	actionsDirX2(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsDirX3();
+int	actionsDirX3(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsDirY();
+int	actionsDirY(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsImmDir();
+int	actionsImmDir(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsImmDirX();
+int	actionsImmDirX(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsImmDirY();
+int	actionsImmDirY(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsNone();
+int	actionsNone(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsIndex();
+int	actionsIndex(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
-int	actionsImmIndex();
+int	actionsImmIndex(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands);
 
 /* indexed by opcodeClass */
 int		       (*instructionActionTable[])() = {
@@ -303,53 +303,53 @@ valueType		 undefinedValueValue = { UNDEFINED_VALUE, 0,
 					EXPRESSION_OPND };
 valueType		*UndefinedValue = &undefinedValueValue;
 
-valueType	*addressModeBIF();
+valueType	*addressModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*applyBIF();
+valueType	*applyBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*arrayLengthBIF();
+valueType	*arrayLengthBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*atasciiBIF();
+valueType	*atasciiBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*atasciiColorBIF();
+valueType	*atasciiColorBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*debugModeOffBIF();
+valueType	*debugModeOffBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*debugModeOnBIF();
+valueType	*debugModeOnBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*emitModeOffBIF();
+valueType	*emitModeOffBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*emitModeOnBIF();
+valueType	*emitModeOnBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isAbsoluteValueBIF();
+valueType	*isAbsoluteValueBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isARegisterBIF();
+valueType	*isARegisterBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isBlockBIF();
+valueType	*isBlockBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isBuiltInFunctionBIF();
+valueType	*isBuiltInFunctionBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isConditionCodeBIF();
+valueType	*isConditionCodeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isDefinedBIF();
+valueType	*isDefinedBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isDirectModeBIF();
+valueType	*isDirectModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isExternalBIF();
+valueType	*isExternalBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isFieldBIF();
+valueType	*isFieldBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isFunctionBIF();
+valueType	*isFunctionBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isImmediateModeBIF();
+valueType	*isImmediateModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isIndexedModeBIF();
+valueType	*isIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isIndirectModeBIF();
+valueType	*isIndirectModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isPostIndexedModeBIF();
+valueType	*isPostIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isPreIndexedModeBIF();
+valueType	*isPreIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isRelocatableValueBIF();
+valueType	*isRelocatableValueBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isStringBIF();
+valueType	*isStringBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isStructBIF();
+valueType	*isStructBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isSymbolBIF();
+valueType	*isSymbolBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isXIndexedModeBIF();
+valueType	*isXIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isXRegisterBIF();
+valueType	*isXRegisterBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isYIndexedModeBIF();
+valueType	*isYIndexedModeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*isYRegisterBIF();
+valueType	*isYRegisterBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*listingOffBIF();
+valueType	*listingOffBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*listingOnBIF();
+valueType	*listingOnBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*makeArrayBIF();
+valueType	*makeArrayBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*nthCharBIF();
+valueType	*nthCharBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*printfBIF();
+valueType	*printfBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*strcatBIF();
+valueType	*strcatBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*strcmpBIF();
+valueType	*strcmpBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*strcmplcBIF();
+valueType	*strcmplcBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*strlenBIF();
+valueType	*strlenBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*substrBIF();
+valueType	*substrBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*symbolDefineBIF();
+valueType	*symbolDefineBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*symbolLookupBIF();
+valueType	*symbolLookupBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*symbolNameBIF();
+valueType	*symbolNameBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*symbolUsageBIF();
+valueType	*symbolUsageBIF(operandListType *parameterList, fixupKindType kindOfFixup);
-valueType	*valueTypeBIF();
+valueType	*valueTypeBIF(operandListType *parameterList, fixupKindType kindOfFixup);
 
 /* Used to initialize symbols representing built-in functions */
 struct {

main.c

@@ -30,16 +30,20 @@
 #include "macrossTypes.h"
 #include "macrossGlobals.h"
 
-main(argc, argv)
+
-  int	argc;
+extern void initializeStuff (int argc, char **argv);
-  char *argv[];
+extern int yyparse (void);
+extern void finishUp (void);
+extern void chokePukeAndDie (void);
+
+main(int argc, char **argv)
 {
 #ifdef __APPLE__
 	char end = get_end();
 #else
 	extern char	 end;
 #endif
-	char		*sbrk();
+	char		*sbrk(int);
 
 	fflush(stdout);
 	initializeStuff(argc, argv);
@@ -55,7 +59,7 @@ main(argc, argv)
 }
 
   void
-printVersion()
+printVersion(void)
 {
 	printf("Macross %s version 4.20.\n", TARGET_CPU_STRING);
 }

malloc.c

@@ -80,7 +80,7 @@ union	overhead {
  */
 #define	NBUCKETS 30
 static	union overhead *nextf[NBUCKETS];
-extern	char *sbrk();
+extern	char *sbrk(int);
 
 #ifdef MSTATS
 /*
@@ -109,8 +109,7 @@ static void morecore(int);
 static int findbucket(union overhead *, int);
 
 char *
-malloc(nbytes)
+malloc(register unsigned int nbytes)
-	register unsigned nbytes;
 {
   	register union overhead *p;
   	register int bucket = 0;
@@ -160,8 +159,7 @@ malloc(nbytes)
  * Allocate more memory to the indicated bucket.
  */
 static void
-morecore(bucket)
+morecore(register int bucket)
-	register bucket;
 {
   	register union overhead *op;
   	register int rnu;       /* 2^rnu bytes will be requested */
@@ -209,8 +207,7 @@ morecore(bucket)
 }
 
 void
-free(cp)
+free(char *cp)
-	char *cp;
 {   
   	register int size;
 	register union overhead *op;
@@ -252,9 +249,7 @@ free(cp)
 int realloc_srchlen = 4;	/* 4 should be plenty, -1 =>'s whole list */
 
 char *
-realloc(cp, nbytes)
+realloc(char *cp, unsigned int nbytes)
-	char *cp; 
-	unsigned nbytes;
 {   
   	register u_int onb;
 	union overhead *op;
@@ -304,9 +299,7 @@ realloc(cp, nbytes)
  * Return bucket number, or -1 if not found.
  */
 static
-findbucket(freep, srchlen)
+findbucket(union overhead *freep, int srchlen)
-	union overhead *freep;
-	int srchlen;
 {
 	register union overhead *p;
 	register int i, j;

object.c

@@ -36,19 +36,28 @@ static int	symbolTableSize;
 static int	symbolTableStringSize;
 bool		encodingFunction;
 
-  void
+  
-outputObjectFile()
+extern void printCodeBuffers (void);
+extern bool isExternal (symbolTableEntryType *symbol);
+extern bool strcmplc (char *s1, char *s2);
+bool hackableSymbol (symbolTableEntryType *symbol);
+extern void printExpressionBuffer (void);
+extern bool encodeRelocatableNumber (numberTermType number);
+extern void freeExpression (expressionType *expression);
+
+void
+outputObjectFile(void)
 {
-	void	outputPartition();
+	void	outputPartition(void);
-	void	outputReferenceInfo();
+	void	outputReferenceInfo(void);
-	void	outputSymbolTableInfo();
+	void	outputSymbolTableInfo(void);
-	void	outputAbsoluteCode();
+	void	outputAbsoluteCode(void);
-	void	outputRelocatableCode();
+	void	outputRelocatableCode(void);
-	void	outputReservations();
+	void	outputReservations(void);
-	void	outputExpressions();
+	void	outputExpressions(void);
-	void	outputFunctions();
+	void	outputFunctions(void);
-	void	dumpSymbolTable();
+	void	dumpSymbolTable(void);
-	void	enumerateAndCountSymbols();
+	void	enumerateAndCountSymbols(void);
 
 	if (debug || emitPrint)
 		printCodeBuffers();
@@ -72,22 +81,20 @@ outputObjectFile()
 }
 
   void
-outputWord(aWord)
+outputWord(int aWord)
- int	aWord;
 {
 	putc(aWord & 0xFF, objectFileOutput);
 	putc((aWord >> 8) & 0xFF, objectFileOutput);
 }
 
   void
-outputPartition()
+outputPartition(void)
 {
 	outputWord(0xFFFF);
 }
 
   void
-outputBigword(bigword)
+outputBigword(long unsigned int bigword)
-  unsigned long	bigword;
 {
 	int	i;
 
@@ -98,15 +105,13 @@ outputBigword(bigword)
 }
 
   void
-outputByte(aByte)
+outputByte(byte aByte)
- byte	aByte;
 {
 	putc(aByte, objectFileOutput);
 }
 
   void
-outputString(string)
+outputString(stringType *string)
-  stringType	*string;
 {
 	do {
 		putc(*string, objectFileOutput);
@@ -114,8 +119,7 @@ outputString(string)
 }
 
   void
-outputStartAddress(startAddress)
+outputStartAddress(addressType startAddress)
-  addressType	startAddress;
 {
 	outputWord(startAddress);
 	if (produceLinkableObject) {
@@ -128,14 +132,14 @@ outputStartAddress(startAddress)
 }
 
   void
-outputRelocatableCode()
+outputRelocatableCode(void)
 {
 	int		 i;
 	addressType	 codeStartAddress;
 	addressType	 codeEndAddress;
 
-	void		 outputPseudoSegment();
+	void		 outputPseudoSegment(addressType codeStartAddress, addressType codeEndAddress);
-	void		 outputBreak();
+	void		 outputBreak(codeBreakType *codeBreak);
 
 	if (haveUserStartAddress && !fixupStartAddress && startAddress->
 			kindOfValue == RELOCATABLE_VALUE)
@@ -161,8 +165,7 @@ outputRelocatableCode()
 }
 
   void
-outputBreak(codeBreak)
+outputBreak(codeBreakType *codeBreak)
-  codeBreakType	*codeBreak;
 {
 	switch (codeBreak->kindOfBreak) {
 	case BREAK_BREAK:
@@ -185,13 +188,13 @@ outputBreak(codeBreak)
 }
 
   void
-outputAbsoluteCode()
+outputAbsoluteCode(void)
 {
 	int		 i;
 	int		 startSegment;
 	int		 endSegment;
 	int		 nextSegment;
-	void		 outputOneCodeBuffer();
+	void		 outputOneCodeBuffer(codeSegmentType *segment);
 
 	if (haveUserStartAddress && !fixupStartAddress && startAddress->
 			kindOfValue==ABSOLUTE_VALUE)
@@ -223,8 +226,7 @@ outputAbsoluteCode()
 }
 
   void
-outputOneCodeBuffer(segment)
+outputOneCodeBuffer(codeSegmentType *segment)
-  codeSegmentType	*segment;
 {
 	int	i;
 
@@ -238,9 +240,7 @@ outputOneCodeBuffer(segment)
 }
 
   void
-outputPseudoSegment(codeStartAddress, codeEndAddress)
+outputPseudoSegment(addressType codeStartAddress, addressType codeEndAddress)
-  addressType	codeStartAddress;
-  addressType	codeEndAddress;
 {
 	int		 startSegment;
 	int		 endSegment;
@@ -252,8 +252,8 @@ outputPseudoSegment(codeStartAddress, codeEndAddress)
 	int		 segment;
 	codeSegmentType	*segmentPtr;
 
-	void		 outputWord();
+	void		 outputWord(int aWord);
-	void		 outputByte();
+	void		 outputByte(byte aByte);
 
 	outputWord(codeStartAddress);
 	outputWord(codeEndAddress);
@@ -273,8 +273,7 @@ outputPseudoSegment(codeStartAddress, codeEndAddress)
 }
 
   bool
-isObjectSymbol(symbol)
+isObjectSymbol(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	return(symbol != NULL && symbol->context->value != NULL &&
 		symbol->context->value->kindOfValue != FUNCTION_VALUE &&
@@ -289,7 +288,7 @@ isObjectSymbol(symbol)
 }
 
   void
-enumerateAndCountSymbols()
+enumerateAndCountSymbols(void)
 {
 	int			 i;
 	symbolTableEntryType	*symb;
@@ -305,7 +304,7 @@ enumerateAndCountSymbols()
 }
 
   int
-enumerateAndCountReferences()
+enumerateAndCountReferences(void)
 {
     int				 result;
     int				 codeMode;
@@ -323,8 +322,7 @@ enumerateAndCountReferences()
 }
 
   void
-outputReference(reference)
+outputReference(expressionReferenceType *reference)
-  expressionReferenceType	*reference;
 {
 	byte	funnyByte;
 	bigWord	funnyWord;
@@ -346,7 +344,7 @@ outputReference(reference)
 static int	referenceCount;
 
   void
-outputReferenceInfo()
+outputReferenceInfo(void)
 {
 	expressionReferenceListType	*theReferences;
 	int				 codeMode;
@@ -363,12 +361,11 @@ outputReferenceInfo()
 }
 
   void
-outputOneSymbol(symbol)
+outputOneSymbol(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	byte			 symbolClass;
 	valueType		*symbolValue;
-	valueType		*evaluateIdentifier();
+	valueType		*evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup);
 
 	if (symbol->context->usage == DEFINE_SYMBOL)
 		symbolValue = evaluateIdentifier(symbol, FALSE, NO_FIXUP_OK);
@@ -390,7 +387,7 @@ outputOneSymbol(symbol)
 }
 
   void
-outputSymbolTableInfo()
+outputSymbolTableInfo(void)
 {
 	int			 i;
 	symbolTableEntryType	*symb;
@@ -404,16 +401,13 @@ outputSymbolTableInfo()
 }
 
   int
-symbolCompare(symbol1, symbol2)
+symbolCompare(symbolTableEntryType **symbol1, symbolTableEntryType **symbol2)
-  symbolTableEntryType	**symbol1;
-  symbolTableEntryType	**symbol2;
 {
 	return(strcmplc((*symbol1)->symbolName, (*symbol2)->symbolName));
 }
 
   bool
-shouldDumpSymbol(symbol)
+shouldDumpSymbol(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	return(symbolTableDumpOn == 2
 		|| (symbol->context->usage != BUILT_IN_FUNCTION_SYMBOL
@@ -428,7 +422,7 @@ shouldDumpSymbol(symbol)
 }
 
   void
-dumpSymbolTable()
+dumpSymbolTable(void)
 {
 	int			 i;
 	symbolTableEntryType	*symb;
@@ -437,8 +431,8 @@ dumpSymbolTable()
 	int			 symbolPtr;
 	valueType		*value;
 
-	valueType		*evaluateIdentifier();
+	valueType		*evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup);
-	void			 printValueTersely();
+	void			 printValueTersely(valueType *value);
 
 	numberOfSymbols = 0;
 	for (i=0; i<HASH_TABLE_SIZE; i++)
@@ -505,16 +499,14 @@ dumpSymbolTable()
 }
 
   bool
-hackableSymbol(symbol)
+hackableSymbol(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	return(symbol->context->usage == DEFINE_SYMBOL || symbol->context->
 		usage == LABEL_SYMBOL);
 }
 
   void
-printValueTersely(value)
+printValueTersely(valueType *value)
-  valueType	*value;
 {
 	static char *valueKindTable[NUM_OF_VALUE_KINDS] = {
 		"ABS",
@@ -542,7 +534,7 @@ printValueTersely(value)
 }
 
   void
-outputReservations()
+outputReservations(void)
 {
 	while (reservationList != NULL) {
 		outputWord(reservationList->startAddress);
@@ -552,7 +544,7 @@ outputReservations()
 }
 
   void
-outputExpressionBuffer()
+outputExpressionBuffer(void)
 {
 	int	i;
 
@@ -564,13 +556,12 @@ outputExpressionBuffer()
 }
 
   void
-outputOneExpression(expression)
+outputOneExpression(expressionType *expression)
-  expressionType	*expression;
 {
 	expressionType	*newExpression;
 
-	expressionType	*generateFixupExpression();
+	expressionType	*generateFixupExpression(expressionType *expression);
-	bool		 encodeExpression();
+	bool		 encodeExpression(expressionType *expression);
 
 	expressionBufferSize = 0;
 	if (expression == NULL) {
@@ -585,7 +576,7 @@ outputOneExpression(expression)
 }
 
   void
-outputExpressions()
+outputExpressions(void)
 {
     int				 codeMode;
     expressionReferenceListType	*theReferences;
@@ -604,12 +595,11 @@ outputExpressions()
 }
 
   void
-outputOneFunction(function)
+outputOneFunction(functionDefinitionType *function)
-  functionDefinitionType	*function;
 {
 	argumentDefinitionListType	*argumentList;
-	bool				 encodeBlock();
+	bool				 encodeBlock(blockType *block);
-	int				 countArguments();
+	int				 countArguments(functionDefinitionType *function);
 
 	outputByte((byte)countArguments(function));
 	argumentList = function->arguments;
@@ -623,7 +613,7 @@ outputOneFunction(function)
 }
 
   void
-outputFunctions()
+outputFunctions(void)
 {
 	outputBigword(externalFunctionCount);
 	encodingFunction = TRUE;

operandStuffSD_6502.c

@@ -33,10 +33,19 @@
 
 /* corresponds to routines in buildStuff2.c */
 
-  operandType *
+  
-buildOperand(kindOfOperand, arg)
+extern void botch (char *message, ...);
-  operandKindType	 kindOfOperand;
+extern void error (errorType theError, ...);
-  anyOldThing		*arg;
+extern void freeExpression (expressionType *expression);
+extern void freeSelectionList (selectionListType *selectionList);
+extern void freeString (stringType *string);
+extern void freeBlock (blockType *block);
+extern void moreText (char *format, ...);
+extern void expandExpression (char *toBuffer, char **toBufferPtr);
+extern void assembleBlock (blockType *block);
+
+operandType *
+buildOperand(operandKindType kindOfOperand, anyOldThing *arg)
 {
 	operandType	*result;
 
@@ -129,13 +138,11 @@ buildOperand(kindOfOperand, arg)
 /* corresponds to routines in fixups.c */
 
   operandListType *
-duplicateOperandForFixup(operand, isSpecialFunctionOperand)
+duplicateOperandForFixup(operandListType *operand, bool isSpecialFunctionOperand)
-  operandListType	*operand;
-  bool			 isSpecialFunctionOperand;
 {
 	operandListType	*result;
 
-	expressionType	*duplicateExpressionForFixup();
+	expressionType	*duplicateExpressionForFixup(expressionType *expression, bool isTopLevel, bool isSpecialFunctionOperand);
 
 	result = typeAlloc(operandListType);
 	result->kindOfOperand = operand->kindOfOperand;
@@ -182,8 +189,7 @@ duplicateOperandForFixup(operand, isSpecialFunctionOperand)
 #define nullFree(thing) if (thing == NULL) return;
 
   void
-freeOperand(operand)
+freeOperand(operandType *operand)
-  operandType	*operand;
 {
 	nullFree(operand);
 	switch (operand->kindOfOperand) {
@@ -229,9 +235,7 @@ freeOperand(operand)
 /* corresponds to routines in listing.c */
 
   void
-expandOperand(addressMode, buffer)
+expandOperand(operandKindType addressMode, char *buffer)
-  operandKindType	addressMode;
-  char *		buffer;
 {
 	switch (addressMode) {
 	case IMMEDIATE_OPND:		moreText("#"); break;
@@ -279,16 +283,15 @@ expandOperand(addressMode, buffer)
 #define expansionOn()	expandMacros=saveExpansion;
 
   valueType *
-evaluateOperand(operand)
+evaluateOperand(operandType *operand)
-  operandType	*operand;
 {
 	valueType		*result;
 	bool			 saveExpansion;
 	expressionType		*expression;
 
-	valueType		*evaluateExpression();
+	valueType		*evaluateExpression(expressionType *expression, fixupKindType kindOfFixup);
-	valueType		*evaluateSelectionList();
+	valueType		*evaluateSelectionList(selectionListType *selectionList);
-	valueType		*newValue();
+	valueType		*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 
 	nullEvaluate(operand);
 	if (operand->kindOfOperand != EXPRESSION_OPND)
@@ -358,8 +361,7 @@ evaluateOperand(operand)
 /* from parserMisc.c */
 
   conditionType
-invertConditionCode(conditionCode)
+invertConditionCode(conditionType conditionCode)
-  conditionType	conditionCode;
 {
 #define cc (int)conditionCode
 
@@ -376,8 +378,7 @@ invertConditionCode(conditionCode)
 /* from semanticMisc.c */
 
   bool
-shouldParenthesize(operand)
+shouldParenthesize(operandType *operand)
-  operandType	*operand;
 {
 	expressionTermKindType	 kind;
 

parserMisc.c

@@ -37,12 +37,14 @@
 #include <stdarg.h>
 #include <string.h>
 
-  statementType *
+  
-addLabelToStatement(labelList, statement)
+extern void chokePukeAndDie (void);
-  labelListType	*labelList;
+extern void puntOnError (errorType theError, ...);
-  statementType	*statement;
+
+statementType *
+addLabelToStatement(labelListType *labelList, statementType *statement)
 {
-	statementType	*newStatement();
+	statementType	*newStatement(statementKindType kind, statementBodyType body);
 
 	if (statement == NULL)
 		statement = newStatement(NULL_STATEMENT, (statementBodyType){ NULL });
@@ -66,16 +68,14 @@ botch(char *message, ...)
 }
 
   void
-checkDefineAssignmentOperator(assignmentOperator)
+checkDefineAssignmentOperator(assignmentKindType assignmentOperator)
-  assignmentKindType	assignmentOperator;
 {
 	if (assignmentOperator != ASSIGN_ASSIGN)
 		puntOnError(DEFINE_ASSIGNMENT_WRONG_ERROR);
 }
 
   statementType *
-convertDefineToMdefine(defineStatement)
+convertDefineToMdefine(statementType *defineStatement)
-  statementType	*defineStatement;
 {
 	if (defineStatement->kindOfStatement != DEFINE_STATEMENT)
 		botch("convertDefineToMdefine got statement kind: %d\n",
@@ -85,8 +85,7 @@ convertDefineToMdefine(defineStatement)
 }
 
   ifStatementBodyType *
-extractIfBody(ifStatement)
+extractIfBody(statementType *ifStatement)
-  statementType	*ifStatement;
 {
 	ifStatementBodyType	*result;
 
@@ -101,8 +100,7 @@ extractIfBody(ifStatement)
 }
 
   mifStatementBodyType *
-extractMifBody(mifStatement)
+extractMifBody(statementType *mifStatement)
-  statementType	*mifStatement;
 {
 	mifStatementBodyType	*result;
 
@@ -117,8 +115,7 @@ extractMifBody(mifStatement)
 }
 
   stringType *
-extractString(textExpression)
+extractString(operandType *textExpression)
-  operandType	*textExpression;
 {
 	stringType	*result;
 
@@ -131,22 +128,21 @@ extractString(textExpression)
 }
 
   void
-popMacroOrFunctionNestingDepth()
+popMacroOrFunctionNestingDepth(void)
 {
 	if (--macroOrFunctionNestingDepth == 0)
 		unknownSymbolTag = UNKNOWN_SYMBOL;
 }
 
   void
-pushMacroOrFunctionNestingDepth()
+pushMacroOrFunctionNestingDepth(void)
 {
 	macroOrFunctionNestingDepth++;
 	unknownSymbolTag = NESTED_UNKNOWN_SYMBOL;
 }
 
   char *
-saveString(s)
+saveString(char *s)
-  char	*s;
 {
 	char	*result;
 

parserMisc.h

@@ -9,8 +9,8 @@ void convertDefineToMDefine(statementType *defineStatement);
 ifStatementBodyType *extractIfBody(statementType *ifStatement);
 mifStatementBodyType *extractMifBody(statementType *mifStatement);
 stringType *extractString(operandType *textExpression);
-void popMacroOrFunctionNestingDepth();
+void popMacroOrFunctionNestingDepth(void);
-void pushMacroOrFunctionNestingDepth();
+void pushMacroOrFunctionNestingDepth(void);
 char *saveString(char *s);
 
 #endif

semanticMisc.c

@@ -44,21 +44,37 @@
    These are miscellaneous routines called by the primary semantics routines.
  */
 
-  bool
+  
-absoluteValue(address)
+extern void error (errorType theError, ...);
-  valueType	*address;
+extern char *valueKindString (valueKindType valueKind);
+extern void moreLabel (char *format, int arg1);
+extern void reincarnateSymbol (symbolInContextType *context, symbolUsageKindType newUsage);
+extern void printCreateFixup (expressionType *expression, addressType location, fixupKindType kindOfFixup);
+extern void flushExpressionString (void);
+extern void expandOperand (operandKindType addressMode, char *buffer);
+extern void terminateListingFiles (void);
+extern void outputObjectFile (void);
+extern void outputListing (void);
+extern void botch (char *message, ...);
+extern void pokeByteValue (addressType location, valueType *value);
+extern void pokeWordValue (addressType location, valueType *value);
+extern void pokeLongValue (addressType location, valueType *value);
+extern void pokeRelativeByteValue (addressType location, valueType *value);
+extern void pokeRelativeWordValue (addressType location, valueType *value);
+extern void pushBinding (symbolTableEntryType *symbol, valueType *newBinding, symbolUsageKindType newUsage);
+
+bool
+absoluteValue(valueType *address)
 {
 	return(address->kindOfValue == ABSOLUTE_VALUE);
 }
 
   void
-addAttributeToSymbol(symbol, attribute)
+addAttributeToSymbol(symbolTableEntryType *symbol, symbolAttributesType attribute)
-  symbolTableEntryType	*symbol;
-  symbolAttributesType	 attribute;
 {
 	symbolInContextType	*context;
 
-	symbolInContextType	*getBaseContext();
+	symbolInContextType	*getBaseContext(symbolTableEntryType *identifier);
 
 	context = getBaseContext(symbol);
 	if (context != NULL)
@@ -66,8 +82,7 @@ addAttributeToSymbol(symbol, attribute)
 }
 
   addressType
-addressValue(value)
+addressValue(valueType *value)
-  valueType	*value;
 {
 	if (value->kindOfValue==STRING_VALUE ||
 	    value->kindOfValue==CONDITION_VALUE ||
@@ -78,9 +93,7 @@ addressValue(value)
 }
 
   valueKindType
-addValueKind(leftOperand, rightOperand)
+addValueKind(valueType *leftOperand, valueType *rightOperand)
-  valueType	*leftOperand;
-  valueType	*rightOperand;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'valueKindType'. */
@@ -211,15 +224,13 @@ addValueKind(leftOperand, rightOperand)
 }
 
   bool
-alreadyDefined(context)
+alreadyDefined(symbolInContextType *context)
-  symbolInContextType	*context;
 {
 	return((context->attributes & DEFINED_VARIABLE_ATT) != 0);
 }
 
   bool
-booleanTest(expression)
+booleanTest(expressionType *expression)
-  expressionType	*expression;
 {
 	bool		 result;
 	valueType	*expressionResult;
@@ -242,8 +253,7 @@ booleanTest(expression)
 }
 
   int
-countArguments(function)
+countArguments(functionDefinitionType *function)
-  functionDefinitionType	*function;
 {
 	int				 result;
 	argumentDefinitionListType	*arguments;
@@ -258,8 +268,7 @@ countArguments(function)
 }
 
   int
-countParameters(parameterList)
+countParameters(operandListType *parameterList)
-  operandListType	*parameterList;
 {
 	int	result;
 
@@ -272,9 +281,7 @@ countParameters(parameterList)
 }
 
   arrayType *
-allocArray(size, contentsPtr)
+allocArray(int size, valueType ***contentsPtr)
-  int		   size;
-  valueType	***contentsPtr;
 {
 	arrayType	*result;
 	int		 i;
@@ -289,9 +296,7 @@ allocArray(size, contentsPtr)
 }
 
   valueType *
-createArray(dimension, initializers)
+createArray(expressionType *dimension, expressionListType *initializers)
-  expressionType	*dimension;
-  expressionListType	*initializers;
 {
 	int		 initCount;
 	valueType	*arraySizeValue;
@@ -300,7 +305,7 @@ createArray(dimension, initializers)
 	arrayType	*result;
 	int		 i;
 
-	valueType	*newValue();
+	valueType	*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 	
 	initCount = expressionListLength(initializers);
 	if ((int)dimension == -1) {
@@ -327,8 +332,7 @@ createArray(dimension, initializers)
 }
 
   bool
-decrementable(value)
+decrementable(valueType *value)
-  valueType	*value;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'valueKindType'. */
@@ -358,8 +362,7 @@ decrementable(value)
 }
 
   int
-expressionListLength(expressionList)
+expressionListLength(expressionListType *expressionList)
-  expressionListType	*expressionList;
 {
 	int	result;
 
@@ -372,11 +375,10 @@ expressionListLength(expressionList)
 }
 
   int
-fieldValue(symbol)
+fieldValue(symbolTableEntryType *symbol)
-  symbolTableEntryType		*symbol;
 {
 	valueType	*value;
-	valueType	*evaluateIdentifier();
+	valueType	*evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup);
 
 	value = evaluateIdentifier(symbol, FALSE, NO_FIXUP);
 	if (value->kindOfValue != FIELD_VALUE) {
@@ -388,8 +390,7 @@ fieldValue(symbol)
 }
 
   bool
-incrementable(value)
+incrementable(valueType *value)
-  valueType	*value;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'valueKindType'. */
@@ -419,8 +420,7 @@ incrementable(value)
 }
 
   int
-intValue(value)
+intValue(valueType *value)
-  valueType	*value;
 {
 	if (value->kindOfValue != ABSOLUTE_VALUE) {
 		error(VALUE_IS_NOT_AN_INT_ERROR);
@@ -431,8 +431,7 @@ intValue(value)
 }
 
   bool
-isAssignable(context)
+isAssignable(symbolInContextType *context)
-  symbolInContextType	*context;
 {
 	return( context->usage==ARGUMENT_SYMBOL         ||
 		context->usage==VARIABLE_SYMBOL  ||
@@ -440,15 +439,13 @@ isAssignable(context)
 }
 
   bool
-isBuiltInFunction(context)
+isBuiltInFunction(symbolInContextType *context)
-  symbolInContextType	*context;
 {
 	return(context!=NULL && context->usage==BUILT_IN_FUNCTION_SYMBOL);
 }
 
   bool
-isDefinable(context)
+isDefinable(symbolInContextType *context)
-  symbolInContextType	*context;
 {
 	return( context->usage==DEFINE_SYMBOL ||
 		context->usage==DEAD_SYMBOL ||
@@ -457,12 +454,11 @@ isDefinable(context)
 }
 
   bool
-isExternal(symbol)
+isExternal(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	symbolInContextType	*context;
 
-	symbolInContextType	*getBaseContext();
+	symbolInContextType	*getBaseContext(symbolTableEntryType *identifier);
 
 	context = getBaseContext(symbol);
 	return (context!=NULL && (context->attributes & GLOBAL_ATT)!=0 &&
@@ -470,8 +466,7 @@ isExternal(symbol)
 }
 
   bool
-isFailure(value)
+isFailure(valueType *value)
-  valueType	*value;
 {
 	if (value == NULL)
 		return(FALSE);
@@ -480,15 +475,13 @@ isFailure(value)
 }
 
   bool
-isFunction(context)
+isFunction(symbolInContextType *context)
-  symbolInContextType	*context;
 {
 	return(context!=NULL && context->usage==FUNCTION_SYMBOL);
 }
 
   bool
-isLastStatementInBlock(statement)
+isLastStatementInBlock(statementType *statement)
-  statementType	*statement;
 {
 	statement = statement->nextStatement;
 	while (statement != NULL) {
@@ -521,8 +514,7 @@ isLastStatementInBlock(statement)
 }
 
   bool
-isLogicalOp(op)
+isLogicalOp(int op)
-  int	op;
 {
 	return (op==EQUAL_TO || op==GREATER_THAN || op==
 		GREATER_THAN_OR_EQUAL_TO || op==LESS_THAN || op==
@@ -531,8 +523,7 @@ isLogicalOp(op)
 }
 
   bool
-isPotentialVariable(context)
+isPotentialVariable(symbolInContextType *context)
-  symbolInContextType	*context;
 {
 	return( context->usage == VARIABLE_SYMBOL ||
 		context->usage == DEAD_SYMBOL ||
@@ -540,33 +531,26 @@ isPotentialVariable(context)
 }
 
   bool
-isUndefined(value)
+isUndefined(valueType *value)
-  valueType	*value;
 {
 	return(value==NULL || value->kindOfValue==UNDEFINED_VALUE);
 }
 
   bool
-isUsable(value)
+isUsable(valueType *value)
-  valueType	*value;
 {
 	return(value!=NULL && value->kindOfValue!=UNDEFINED_VALUE &&
 			value->kindOfValue!=FAIL);
 }
 
   bool
-logicalXOR(int1, int2)
+logicalXOR(int int1, int int2)
-  int	int1;
-  int	int2;
 {
 	return((int1 && !int2) || (int2 && !int1));
 }
 
   valueType *
-newValue(kindOfValue, value, addressMode)
+newValue(valueKindType kindOfValue, int value, operandKindType addressMode)
-  valueKindType	 	kindOfValue;
-  int		 	value;
-  operandKindType	addressMode;
 {
 	valueType	*result;
 
@@ -578,9 +562,7 @@ newValue(kindOfValue, value, addressMode)
 }
 
   valueKindType
-opValueKind(leftOperand, rightOperand)
+opValueKind(valueType *leftOperand, valueType *rightOperand)
-  valueType	*leftOperand;
-  valueType	*rightOperand;
 {
 	if (leftOperand->kindOfValue==ABSOLUTE_VALUE && rightOperand->
 						kindOfValue==ABSOLUTE_VALUE)
@@ -607,17 +589,14 @@ opValueKind(leftOperand, rightOperand)
 }
 
   bool
-relocatableValue(address)
+relocatableValue(valueType *address)
-  valueType	*address;
 {
 	return( address->kindOfValue==DATA_VALUE ||
 		address->kindOfValue==RELOCATABLE_VALUE );
 }
 
   valueKindType
-selectValueKind(leftOperand, rightOperand)
+selectValueKind(valueType *leftOperand, valueType *rightOperand)
-  valueType	*leftOperand;
-  valueType	*rightOperand;
 {
 	if (rightOperand->kindOfValue!=FIELD_VALUE ||
 	    (leftOperand->kindOfValue!=ABSOLUTE_VALUE &&
@@ -629,9 +608,7 @@ selectValueKind(leftOperand, rightOperand)
 }
 
   valueKindType
-subValueKind(leftOperand, rightOperand)
+subValueKind(valueType *leftOperand, valueType *rightOperand)
-  valueType	*leftOperand;
-  valueType	*rightOperand;
 {
 /* This table MUST be maintained congruently with the definition of the
    enumerated type 'valueKindType'. */
@@ -762,25 +739,22 @@ subValueKind(leftOperand, rightOperand)
 }
 
   int
-swab(i)
+swab(int i)
-  int	i;
 {
 	return(((i & 0xFF) << 8)  |  ((i & 0xFF00) >> 8));
 }
 
   valueType *
-swabValue(value)
+swabValue(valueType *value)
-  valueType *value;
 {
-	valueType	*newValue();
+	valueType	*newValue(valueKindType kindOfValue, int value, operandKindType addressMode);
 
 	return(newValue(value->kindOfValue, swab(value->value), value->
 								addressMode));
 }
 
   valueKindType
-unopValueKind(operand)
+unopValueKind(valueType *operand)
-  valueType	*operand;
 {
 	return(operand->kindOfValue==ABSOLUTE_VALUE || operand->kindOfValue==
 		UNDEFINED_VALUE || operand->kindOfValue==RELOCATABLE_VALUE ?
@@ -788,14 +762,12 @@ unopValueKind(operand)
 }
 
   void
-valueField(symbol, value)
+valueField(symbolTableEntryType *symbol, valueType *value)
-  symbolTableEntryType	*symbol;
-  valueType		*value;
 {
 	symbolInContextType	*workingContext;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
-	symbolTableEntryType	*effectiveSymbol();
+	symbolTableEntryType	*effectiveSymbol(symbolTableEntryType *symbol, symbolInContextType **assignmentTargetContext);
 
 	symbol = effectiveSymbol(symbol, &workingContext);
 	expand(moreLabel("%s:", symbol->symbolName));
@@ -815,15 +787,13 @@ valueField(symbol, value)
 }
 
   void
-valueLabel(symbol, value)
+valueLabel(symbolTableEntryType *symbol, valueType *value)
-  symbolTableEntryType	*symbol;
-  valueType		*value;
 {
 	symbolInContextType	*workingContext;
 
-	symbolTableEntryType	*generateLocalLabel();
+	symbolTableEntryType	*generateLocalLabel(symbolTableEntryType *symbol);
-	symbolInContextType	*getBaseContext();
+	symbolInContextType	*getBaseContext(symbolTableEntryType *identifier);
-	symbolTableEntryType	*effectiveSymbol();
+	symbolTableEntryType	*effectiveSymbol(symbolTableEntryType *symbol, symbolInContextType **assignmentTargetContext);
 
 	symbol = effectiveSymbol(symbol, &workingContext);
 	expand(moreLabel("%s:", symbol->symbolName));
@@ -864,16 +834,11 @@ valueLabel(symbol, value)
  */
 
   void
-createFixup(expression, location, kindOfFixup, codeMode, whichFixup)
+createFixup(expressionType *expression, addressType location, fixupKindType kindOfFixup, codeBufferKindType codeMode, int whichFixup)
-  expressionType	*expression;
-  addressType		 location;
-  fixupKindType		 kindOfFixup;
-  codeBufferKindType	 codeMode;
-  int			 whichFixup;
 {
 	fixupListType	*newFixup;
 
-	expressionType	*generateFixupExpression();
+	expressionType	*generateFixupExpression(expressionType *expression);
 
 	if (debug || emitPrint)
 		printCreateFixup(expression, location, kindOfFixup);
@@ -902,10 +867,10 @@ createFixup(expression, location, kindOfFixup, codeMode, whichFixup)
 }
 
   void
-finishUp()
+finishUp(void)
 {
-	void	performFixups();
+	void	performFixups(fixupListType *fixups);
-	void	performStartAddressFixup();
+	void	performStartAddressFixup(void);
 
 	if (listingOn)
 		terminateListingFiles();
@@ -936,7 +901,7 @@ isReferenceToRemember(reference)
 }
 */
   void
-noteAnonymousReference()
+noteAnonymousReference(void)
 {
 	expressionReferenceListType	*newReference;
 
@@ -958,11 +923,7 @@ noteAnonymousReference()
 }
 
   void
-noteReference(expression, kindOfFixup, location, codeMode)
+noteReference(expressionType *expression, fixupKindType kindOfFixup, addressType location, codeBufferKindType codeMode)
-  expressionType	*expression;
-  fixupKindType		 kindOfFixup;
-  addressType		 location;
-  codeBufferKindType	 codeMode;
 {
 	expressionReferenceListType	*newReference;
 
@@ -1010,8 +971,7 @@ noteReference(expression, kindOfFixup, location, codeMode)
 }
 
   void
-performFixups(fixups)
+performFixups(fixupListType *fixups)
-  fixupListType		*fixups;
 {
 	valueType	*valueToPoke;
 
@@ -1072,11 +1032,11 @@ performFixups(fixups)
 }
 
   void
-performStartAddressFixup()
+performStartAddressFixup(void)
 {
 	expressionType	*startAddressExpression;
 
-	expressionType	*generateFixupExpression();
+	expressionType	*generateFixupExpression(expressionType *expression);
 
 	startAddressExpression = (expressionType *)startAddress;
 	startAddress = evaluateExpression(startAddressExpression,NO_FIXUP_OK);
@@ -1094,9 +1054,7 @@ performStartAddressFixup()
 }
 
   void
-putFixupsHere(kindOfFixupsToPut, whichFixup)
+putFixupsHere(fixupKindType kindOfFixupsToPut, int whichFixup)
-  fixupKindType	kindOfFixupsToPut;
-  int		whichFixup;
 {
 	int	location;
 
@@ -1187,8 +1145,7 @@ putReferencesHere(kindOfReferencesToPut, whichReference)
  */
 
   void
-addNewLocalVariable(symbol)
+addNewLocalVariable(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	identifierListType	*newLocalVariable;
 
@@ -1199,16 +1156,14 @@ addNewLocalVariable(symbol)
 }
 
   symbolTableEntryType *
-effectiveSymbol(symbol, assignmentTargetContext)
+effectiveSymbol(symbolTableEntryType *symbol, symbolInContextType **assignmentTargetContext)
-  symbolTableEntryType	*symbol;
-  symbolInContextType  **assignmentTargetContext;
 {
 	symbolInContextType	*context;
 	operandType		*operand;
 	expressionType		*expression;
 	environmentType		*saveEnvironment;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
 
 	context = getWorkingContext(symbol);
 	saveEnvironment = currentEnvironment;
@@ -1236,18 +1191,16 @@ effectiveSymbol(symbol, assignmentTargetContext)
 }
 
   symbolTableEntryType *
-generateLocalLabel(symbol)
+generateLocalLabel(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
-	stringType		*localLabelString();
+	stringType		*localLabelString(symbolTableEntryType *symbol);
-	symbolTableEntryType	*lookupOrEnterSymbol();
+	symbolTableEntryType	*lookupOrEnterSymbol(stringType *s, symbolUsageKindType kind);
 
 	return(lookupOrEnterSymbol(localLabelString(symbol), LABEL_SYMBOL));
 }
 
   symbolInContextType *
-getBaseContext(identifier)
+getBaseContext(symbolTableEntryType *identifier)
-  symbolTableEntryType	*identifier;
 {
 	symbolInContextType	*result;
 
@@ -1259,8 +1212,7 @@ getBaseContext(identifier)
 }
 
   symbolInContextType *
-getWorkingContext(identifier)
+getWorkingContext(symbolTableEntryType *identifier)
-  symbolTableEntryType	*identifier;
 {
 	symbolInContextType	*result;
 
@@ -1274,13 +1226,12 @@ getWorkingContext(identifier)
 }
 
   stringType *
-localLabelString(symbol)
+localLabelString(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 #define TEMP_SYMBOL_SIZE_LIMIT 200
 	char		 nameUnderConstruction[TEMP_SYMBOL_SIZE_LIMIT];
 
-	stringType	*saveString();
+	stringType	*saveString(char *s);
 
 	sprintf(nameUnderConstruction, "_%d_", localLabelTagValue(symbol));
 	strncat(nameUnderConstruction, &(symbName(symbol)[1]),
@@ -1289,13 +1240,12 @@ localLabelString(symbol)
 }
 
   int
-localLabelTagValue(symbol)
+localLabelTagValue(symbolTableEntryType *symbol)
-  symbolTableEntryType	*symbol;
 {
 	symbolInContextType	*context;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
-	void			 addNewLocalVariable();
+	void			 addNewLocalVariable(symbolTableEntryType *symbol);
 
 	context = getWorkingContext(symbol);
 	if (context == NULL)
@@ -1311,12 +1261,10 @@ localLabelTagValue(symbol)
 }
 
   void
-addBreak(kind, data)
+addBreak(codeBreakKindType kind, int data)
-  codeBreakKindType	kind;
-  int			data;
 {
 	codeBreakType	*newBreak;
-	codeBreakType	*buildCodeBreak();
+	codeBreakType	*buildCodeBreak(codeBreakKindType kind, addressType address, int data);
 
 	newBreak = buildCodeBreak(kind, currentLocationCounter.value, data);
 	if (codeBreakList == NULL) {
@@ -1328,11 +1276,9 @@ addBreak(kind, data)
 }
 
   void
-reserveAbsolute(startAddress, blockSize)
+reserveAbsolute(addressType startAddress, int blockSize)
-  addressType	startAddress;
-  int		blockSize;
 {
-	reservationListType	*buildReservation();
+	reservationListType	*buildReservation(addressType startAddress, int blockSize, reservationListType *nextReservation);
 
 	if (reservationList != NULL && reservationList->startAddress +
 			reservationList->blockSize == startAddress)
@@ -1343,8 +1289,7 @@ reserveAbsolute(startAddress, blockSize)
 }
 
   bool
-listableStatement(kind)
+listableStatement(statementKindType kind)
-  statementKindType	kind;
 {
 	return( kind == ALIGN_STATEMENT || kind == BLOCK_STATEMENT ||
 		kind == BYTE_STATEMENT || kind == CONSTRAIN_STATEMENT ||

semanticMisc.h

@@ -44,11 +44,11 @@ void valueLabel(symbolTableEntryType *symbol, valueType *value);
 
 /* Fixups and references */
 void createFixup(expressionType *expression, addressType location, fixupKindType kindOfFixup, codeBufferKindType codeMode, int whichFixup);
-void finishUp();
+void finishUp(void);
-void noteAnonymousReference();
+void noteAnonymousReference(void);
 void noteReference(expressionType *expression, fixupKindType kindOfFixup, addressType location, codeBufferKindType codeMode);
 void performFixups(fixupListType *fixups);
-void performStartAddressFixup();
+void performStartAddressFixup(void);
 void putFixupsHere(fixupKindType kindOfFixupsToPut, int whichFixup);
 
 /* Contexts and dynamic symbol creation */

statementSemantics.c

@@ -54,28 +54,63 @@ bool			 nullStatementFlag = FALSE;
 #define expansionOff() {saveExpansion=expandMacros; expandMacros=FALSE;}
 #define expansionOn()	expandMacros=saveExpansion;
 
-  void
+  
-assembleBlock(block)
+extern void error (errorType theError, ...);
-  blockType	*block;
+extern void moreText (char *format, ...);
+extern void expandOperands (int op);
+extern void endLine (void);
+extern int bindMacroArguments (argumentDefinitionListType *argumentList, operandListType *parameterList, stringType *macroName);
+extern void unbindArguments (argumentDefinitionListType *argumentList, int numberToUnbind);
+extern void unbindLocalVariables (identifierListType *identifierList);
+extern void expandExpression (char *toBuffer, char **toBufferPtr);
+extern void emitByte (byte byteValue);
+extern void emitString (stringType *string);
+extern void emitByteValue (valueType *byteValue);
+extern void startLineMarked (void);
+extern void tabIndent (void);
+extern void emitWordValue (valueType *wordValue);
+extern void reincarnateSymbol (symbolInContextType *context, symbolUsageKindType newUsage);
+extern char *conditionString (conditionType condition);
+extern char *usageString (symbolUsageKindType usageKind);
+extern symbolTableEntryType *lookupOrEnterSymbol (stringType *s, symbolUsageKindType kind);
+extern bool isDefined (valueType *value);
+extern void fixupBranch (valueType *location, valueType target);
+extern void fixupJump (simpleFixupListType *locations, valueType target);
+extern void pushInputFileStack (stringType *fileName);
+extern void saveIndexForListing (statementKindType kindOfStatement, int cumulativeLineNumber);
+extern void startLine (void);
+extern void expandLabel (void);
+extern void emitLongValue (valueType *longValue);
+extern void pushBinding (symbolTableEntryType *symbol, valueType *newBinding, symbolUsageKindType newUsage);
+extern void saveEndMifForListing (int cumulativeLineNumber);
+extern char *valueKindString (valueKindType valueKind);
+extern bool strcmplc (char *s1, char *s2);
+extern void warning (errorType theError, ...);
+extern expressionType *generateFixupExpression (expressionType *expression);
+extern void instantiateStruct (structStatementBodyType *structStatement);
+extern void assembleStructDefinition (structStatementBodyType *structStatement);
+extern void purgeSymbol (symbolTableEntryType *symbol);
+extern bool labeledLine (void);
+extern void flushExpressionString (void);
+extern void freeStatement (statementType *statement);
+extern void printStatement (statementType *statement);
+
+void
+assembleBlock(blockType *block)
 {
 	nullAssemble(block);
 	assembleStatement(block, FALSE, NULL);
 }
 
   simpleFixupListType *
-assembleBlockInsideIf(block, ongoingFixupList)
+assembleBlockInsideIf(blockType *block, simpleFixupListType *ongoingFixupList)
-  blockType		*block;
-  simpleFixupListType	*ongoingFixupList;
 {
 	nullAssembleNULL(block);
 	return(assembleStatement(block, TRUE, ongoingFixupList));
 }
 
   bool
-operandCheck(opcode, numberOfOperands, evaluatedOperands)
+operandCheck(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
-  opcodeTableEntryType	*opcode;
-  int			 numberOfOperands;
-  valueType		*evaluatedOperands[];
 {
 	int	i;
 
@@ -91,9 +126,7 @@ operandCheck(opcode, numberOfOperands, evaluatedOperands)
 }
 
   void
-assembleMachineInstruction(opcode, operands)
+assembleMachineInstruction(opcodeTableEntryType *opcode, operandListType *operands)
-  opcodeTableEntryType	*opcode;
-  operandListType	*operands;
 {
 	int		 i;
 	int		 op;
@@ -140,9 +173,7 @@ assembleMachineInstruction(opcode, operands)
 }
 
   void
-assembleMacro(macroInstruction, operands)
+assembleMacro(macroTableEntryType *macroInstruction, operandListType *operands)
-  macroTableEntryType	*macroInstruction;
-  operandListType	*operands;
 {
 	int			 numberBound;
 	identifierListType	*savedLocalVariableList;
@@ -186,8 +217,7 @@ assembleMacro(macroInstruction, operands)
 }
 
   void
-assembleAlignStatement(alignStatement)
+assembleAlignStatement(alignStatementBodyType *alignStatement)
-  alignStatementBodyType	*alignStatement;
 {
 	int		 alignment;
 	bool		 saveExpansion;
@@ -218,8 +248,7 @@ assembleAlignStatement(alignStatement)
 }
 
   void
-assembleAssertStatement(assertStatement)
+assembleAssertStatement(assertStatementBodyType *assertStatement)
-  assertStatementBodyType	*assertStatement;
 {
 	valueType	*test;
 	valueType	*message;
@@ -249,8 +278,7 @@ assembleAssertStatement(assertStatement)
 }
 
   void
-assembleBlockStatement(blockStatement)
+assembleBlockStatement(blockStatementBodyType *blockStatement)
-  blockStatementBodyType	*blockStatement;
 {
 	valueType		*blockIncrement;
 	int			 blockSize;
@@ -286,8 +314,7 @@ assembleBlockStatement(blockStatement)
 }
 
   void
-assembleByteStatement(byteStatement)
+assembleByteStatement(byteStatementBodyType *byteStatement)
-  byteStatementBodyType	*byteStatement;
 {
 	valueType		*byteValue;
 
@@ -311,8 +338,7 @@ assembleByteStatement(byteStatement)
 }
 
   void
-assembleConstrainStatement(constrainStatement)
+assembleConstrainStatement(constrainStatementBodyType *constrainStatement)
-  constrainStatementBodyType	*constrainStatement;
 {
 	valueType	*constraintValue;
 	int		 constraint;
@@ -355,8 +381,7 @@ assembleConstrainStatement(constrainStatement)
 }
 
   void
-assembleDbyteStatement(dbyteStatement)
+assembleDbyteStatement(dbyteStatementBodyType *dbyteStatement)
-  dbyteStatementBodyType	*dbyteStatement;
 {
 	valueType		*wordValue;
 
@@ -376,8 +401,7 @@ assembleDbyteStatement(dbyteStatement)
 }
 
   void
-assembleDefineStatement(defineStatement)
+assembleDefineStatement(defineStatementBodyType *defineStatement)
-  defineStatementBodyType	*defineStatement;
 {
 	symbolTableEntryType	*symbolToDefine;
 	symbolInContextType	*contextToDefine;
@@ -417,8 +441,7 @@ assembleDefineStatement(defineStatement)
 }
 
   void
-assembleDoUntilStatement(doUntilStatement)
+assembleDoUntilStatement(doUntilStatementBodyType *doUntilStatement)
-  doUntilStatementBodyType	*doUntilStatement;
 {
 	valueType	topOfLoop;
 
@@ -442,8 +465,7 @@ assembleDoUntilStatement(doUntilStatement)
 }
 
   void
-assembleDoWhileStatement(doWhileStatement)
+assembleDoWhileStatement(doWhileStatementBodyType *doWhileStatement)
-  doWhileStatementBodyType	*doWhileStatement;
 {
 	valueType	topOfLoop;
 
@@ -467,8 +489,7 @@ assembleDoWhileStatement(doWhileStatement)
 }
 
   void
-assembleExternStatement(externStatement)
+assembleExternStatement(externStatementBodyType *externStatement)
-  externStatementBodyType	*externStatement;
 {
 	symbolInContextType	*context;
 	symbolTableEntryType	*theSymbol;
@@ -496,8 +517,7 @@ assembleExternStatement(externStatement)
 }
 
   void
-assembleFreturnStatement(freturnStatement)
+assembleFreturnStatement(freturnStatementBodyType *freturnStatement)
-  freturnStatementBodyType	*freturnStatement;
 {
 	freturnExit = TRUE;
 	resultOfLastFunctionCall = evaluateExpression(freturnStatement,
@@ -505,8 +525,7 @@ assembleFreturnStatement(freturnStatement)
 }
 
   void
-assembleFunctionStatement(functionStatement)
+assembleFunctionStatement(functionStatementBodyType *functionStatement)
-  functionStatementBodyType	*functionStatement;
 {
 	symbolTableEntryType		*newFunctionSymbol;
 	functionDefinitionType		*newFunction;
@@ -545,8 +564,7 @@ assembleFunctionStatement(functionStatement)
 }
 
   void
-assembleGroupStatement(groupStatement)
+assembleGroupStatement(blockType *groupStatement)
-  blockType	*groupStatement;
 {
 	expand((startLineMarked(), tabIndent(), moreText("{"), endLine(),
 		tabCount++));
@@ -556,10 +574,7 @@ assembleGroupStatement(groupStatement)
 }
 
   simpleFixupListType *
-assembleIfStatement(ifStatement, terminalIf, ongoingFixupList)
+assembleIfStatement(ifStatementBodyType *ifStatement, bool terminalIf, simpleFixupListType *ongoingFixupList)
-  ifStatementBodyType	*ifStatement;
-  bool			 terminalIf;
-  simpleFixupListType	*ongoingFixupList;
 {
 	valueType		 fixupLocation1[COMPOUND_BRANCH_MAX];
 	simpleFixupListType	*fixupLocation2;
@@ -609,8 +624,7 @@ assembleIfStatement(ifStatement, terminalIf, ongoingFixupList)
 }
 
   void
-assembleIfStatementOldStyle(ifStatement)
+assembleIfStatementOldStyle(ifStatementBodyType *ifStatement)
-  ifStatementBodyType	*ifStatement;
 {
 	valueType		 fixupLocation1[COMPOUND_BRANCH_MAX];
 	simpleFixupListType	*fixupLocation2;
@@ -642,8 +656,7 @@ assembleIfStatementOldStyle(ifStatement)
 }
 
   void
-assembleIncludeStatement(includeStatement)
+assembleIncludeStatement(includeStatementBodyType *includeStatement)
-  includeStatementBodyType	*includeStatement;
 {
 	stringType	*fileName;
 	valueType	*possibleFileName;
@@ -663,9 +676,7 @@ assembleIncludeStatement(includeStatement)
 }
 
   void
-assembleInstructionStatement(instructionStatement, cumulativeLineNumber)
+assembleInstructionStatement(instructionStatementBodyType *instructionStatement, int cumulativeLineNumber)
-  instructionStatementBodyType	*instructionStatement;
-  int				 cumulativeLineNumber;
 {
 	nullAssemble(instructionStatement);
 	switch(instructionStatement->kindOfInstruction) {
@@ -695,8 +706,7 @@ assembleInstructionStatement(instructionStatement, cumulativeLineNumber)
 }
 
   void
-assembleLongStatement(longStatement)
+assembleLongStatement(longStatementBodyType *longStatement)
-  longStatementBodyType	*longStatement;
 {
 	valueType		*longValue;
 
@@ -716,8 +726,7 @@ assembleLongStatement(longStatement)
 }
 
   void
-assembleMacroStatement(macroStatement)
+assembleMacroStatement(macroStatementBodyType *macroStatement)
-  macroStatementBodyType	*macroStatement;
 {
 	macroTableEntryType		*newMacro;
 
@@ -739,8 +748,7 @@ assembleMacroStatement(macroStatement)
 }
 
   void
-assembleMdefineStatement(mdefineStatement)
+assembleMdefineStatement(defineStatementBodyType *mdefineStatement)
-  defineStatementBodyType	*mdefineStatement;
 {
 	bool			 saveExpansion;
 
@@ -753,8 +761,7 @@ assembleMdefineStatement(mdefineStatement)
 }
 
   void
-assembleMdoUntilStatement(mdoUntilStatement)
+assembleMdoUntilStatement(mdoUntilStatementBodyType *mdoUntilStatement)
-  mdoUntilStatementBodyType	*mdoUntilStatement;
 {
 	bool	saveListingOn;
 
@@ -768,8 +775,7 @@ assembleMdoUntilStatement(mdoUntilStatement)
 }
 
   void
-assembleMdoWhileStatement(mdoWhileStatement)
+assembleMdoWhileStatement(mdoWhileStatementBodyType *mdoWhileStatement)
-  mdoWhileStatementBodyType	*mdoWhileStatement;
 {
 	bool	saveListingOn;
 
@@ -783,8 +789,7 @@ assembleMdoWhileStatement(mdoWhileStatement)
 }
 
   void
-assembleMforStatement(mforStatement)
+assembleMforStatement(mforStatementBodyType *mforStatement)
-  mforStatementBodyType	*mforStatement;
 {
 	bool	saveListingOn;
 	bool	saveExpansion;
@@ -805,9 +810,7 @@ assembleMforStatement(mforStatement)
 }
 
   void
-assembleMifStatement(mifStatement, cumulativeLineNumber)
+assembleMifStatement(mifStatementBodyType *mifStatement, int cumulativeLineNumber)
-  mifStatementBodyType	*mifStatement;
-  int			 cumulativeLineNumber;
 {
 	while (mifStatement != NULL) {
 		if (mifStatement->mifCondition == NULL) {
@@ -826,8 +829,7 @@ assembleMifStatement(mifStatement, cumulativeLineNumber)
 }
 
   void
-assembleMswitchStatement(mswitchStatement)
+assembleMswitchStatement(mswitchStatementBodyType *mswitchStatement)
-  mswitchStatementBodyType	*mswitchStatement;
 {
     valueType		*switchValue;
     caseListType	*caseList;
@@ -888,8 +890,7 @@ assembleMswitchStatement(mswitchStatement)
 }
 
   void
-assembleMvariableStatement(mvariableStatement)
+assembleMvariableStatement(mvariableStatementBodyType *mvariableStatement)
-  mvariableStatementBodyType	*mvariableStatement;
 {
 	identifierListType	*newLocalVariable;
 	int			 initCount;
@@ -923,8 +924,7 @@ assembleMvariableStatement(mvariableStatement)
 }
 
   void
-assembleMwhileStatement(mwhileStatement)
+assembleMwhileStatement(mwhileStatementBodyType *mwhileStatement)
-  mwhileStatementBodyType	*mwhileStatement;
 {
 	bool	saveListingOn;
 
@@ -938,8 +938,7 @@ assembleMwhileStatement(mwhileStatement)
 }
 
   void
-assembleOrgStatement(orgStatement)
+assembleOrgStatement(orgStatementBodyType *orgStatement)
-  orgStatementBodyType	*orgStatement;
 {
 	valueType	*orgAddress;
 	bool		 saveExpansion;
@@ -967,8 +966,7 @@ assembleOrgStatement(orgStatement)
 }
 
   void
-assemblePerformStatement(performStatement)
+assemblePerformStatement(performStatementBodyType *performStatement)
-  performStatementBodyType	*performStatement;
 {
 	nullAssemble(performStatement);
 	sideEffectFlag = FALSE;
@@ -978,8 +976,7 @@ assemblePerformStatement(performStatement)
 }
 
   void
-assembleRelStatement(relStatement)
+assembleRelStatement(relStatementBodyType *relStatement)
-  relStatementBodyType	*relStatement;
 {
 	targetOffset = 0;
 	if (!relocatableValue(&currentLocationCounter)) {
@@ -992,8 +989,7 @@ assembleRelStatement(relStatement)
 }
 
   void
-assembleStartStatement(startStatement)
+assembleStartStatement(startStatementBodyType *startStatement)
-  startStatementBodyType	*startStatement;
 {
 	nullAssemble(startStatement);
 	expand(moreText("start\t"));
@@ -1020,8 +1016,7 @@ assembleStartStatement(startStatement)
 }
 
   void
-assembleStringStatement(stringStatement)
+assembleStringStatement(stringStatementBodyType *stringStatement)
-  stringStatementBodyType	*stringStatement;
 {
 	valueType		*byteValue;
 
@@ -1046,8 +1041,7 @@ assembleStringStatement(stringStatement)
 }
 
   void
-assembleStructStatement(structStatement)
+assembleStructStatement(structStatementBodyType *structStatement)
-  structStatementBodyType	*structStatement;
 {
 	nullAssemble(structStatement);
 	if (structStatement->structBody == NULL)
@@ -1057,8 +1051,7 @@ assembleStructStatement(structStatement)
 }
 
   void
-assembleTargetStatement(targetStatement)
+assembleTargetStatement(targetStatementBodyType *targetStatement)
-  targetStatementBodyType	*targetStatement;
 {
 	valueType	*targetAddress;
 	bool		 saveExpansion;
@@ -1081,8 +1074,7 @@ assembleTargetStatement(targetStatement)
 }
 
   void
-assembleUndefineStatement(undefineStatement)
+assembleUndefineStatement(undefineStatementBodyType *undefineStatement)
-  undefineStatementBodyType	*undefineStatement;
 {
 	expand(moreText("undefine\t"));
 	while (undefineStatement != NULL) {
@@ -1096,8 +1088,7 @@ assembleUndefineStatement(undefineStatement)
 }
 
   void
-assembleVariableStatement(variableStatement)
+assembleVariableStatement(variableStatementBodyType *variableStatement)
-  variableStatementBodyType	*variableStatement;
 {
     symbolTableEntryType	*newVariable;
     symbolInContextType		*contextForVariable;
@@ -1143,8 +1134,7 @@ assembleVariableStatement(variableStatement)
 }
 
   void
-assembleWhileStatement(whileStatement)
+assembleWhileStatement(whileStatementBodyType *whileStatement)
-  whileStatementBodyType	*whileStatement;
 {
 	valueType	 topOfLoop;
 	valueType	 fixupLocation[COMPOUND_BRANCH_MAX];
@@ -1175,8 +1165,7 @@ assembleWhileStatement(whileStatement)
 }
 
   void
-assembleWordStatement(wordStatement)
+assembleWordStatement(wordStatementBodyType *wordStatement)
-  wordStatementBodyType	*wordStatement;
 {
 	valueType		*word;
 
@@ -1411,8 +1400,7 @@ assembleStatementBody(kind, body, cumulativeLineNumber, worryAboutIf,
 }
 
   void
-assembleLabelList(labelList)
+assembleLabelList(labelListType *labelList)
-  labelListType	*labelList;
 {
 	while (labelList != NULL) {
 		if (structNestingDepth == 0)
@@ -1428,10 +1416,7 @@ assembleLabelList(labelList)
 }
 
   simpleFixupListType *
-assembleStatement(statement, insideIf, ongoingFixupList)
+assembleStatement(statementType *statement, bool insideIf, simpleFixupListType *ongoingFixupList)
-  statementType		*statement;
-  bool			 insideIf;
-  simpleFixupListType	*ongoingFixupList;
 {
 	char			*saveFileName;
 	int			 saveLineNumber;
@@ -1477,8 +1462,7 @@ assembleStatement(statement, insideIf, ongoingFixupList)
 }
 
   void
-eatStatement(statement)
+eatStatement(statementType *statement)
-  statementType	*statement;
 {
 	if (debug) {
 		printf("assembling:\n");

structSemantics.c

@@ -30,10 +30,22 @@
 #include "macrossTypes.h"
 #include "macrossGlobals.h"
 
-  void
+  
-putStructFixups(base, fixups)
+extern void botch (char *message, ...);
-  int		 base;
+extern void error (errorType theError, ...);
-  fixupListType	*fixups;
+extern void moreText (char *format, ...);
+extern void endLine (void);
+extern void emitByte (byte byteValue);
+extern bool listableStatement (statementKindType kind);
+extern void startLine (void);
+extern void assembleLabelList (labelListType *labelList);
+extern void expandLabel (void);
+extern void tabIndent (void);
+extern bool assembleStatementBody (statementKindType kind, statementBodyType body, int cumulativeLineNumber, bool worryAboutIf, simpleFixupListType **ifFixupList);
+extern void startLineMarked (void);
+
+void
+putStructFixups(int base, fixupListType *fixups)
 {
 	fixupListType	*newFixup;
 
@@ -54,9 +66,7 @@ putStructFixups(base, fixups)
 }
 
   void
-putStructReferences(base, references)
+putStructReferences(int base, expressionReferenceListType *references)
-  int				 base;
-  expressionReferenceListType	*references;
 {
 	expressionReferenceListType	*newReference;
 	int				 currentMode;
@@ -80,14 +90,13 @@ putStructReferences(base, references)
 }
 
   void
-instantiateStruct(structStatement)
+instantiateStruct(structStatementBodyType *structStatement)
-  structStatementBodyType	*structStatement;
 {
 	int			 i;
 	int			 base;
 	symbolInContextType	*context;
 
-	symbolInContextType	*getWorkingContext();
+	symbolInContextType	*getWorkingContext(symbolTableEntryType *identifier);
 
 #define structInstance	((structInstanceType *)	context->value->value)
 
@@ -112,8 +121,7 @@ instantiateStruct(structStatement)
 }
 
   structInstanceType *
-assembleStructDefinitionBody(structBody)
+assembleStructDefinitionBody(structBodyType *structBody)
-  structBodyType	*structBody;
 {
 	int			 i;
 	simpleFixupListType	*dummy;
@@ -144,13 +152,12 @@ assembleStructDefinitionBody(structBody)
 }
 
   void
-assembleStructDefinition(structStatement)
+assembleStructDefinition(structStatementBodyType *structStatement)
-  structStatementBodyType	*structStatement;
 {
 	symbolTableEntryType	*name;
 	symbolInContextType	*context;
 
-	symbolTableEntryType	*effectiveSymbol();
+	symbolTableEntryType	*effectiveSymbol(symbolTableEntryType *symbol, symbolInContextType **assignmentTargetContext);
 
 	name = effectiveSymbol(structStatement->structName, &context);
 	if (context == NULL)

tokenStrings_6502.c

@@ -34,8 +34,7 @@
 
 /* conditionString similarly deals with condition codes */
   char *
-conditionString(condition)
+conditionString(conditionType condition)
-  conditionType	condition;
 {
 /* This table MUST be maintained congruently with the definition of the
 	enumerated type 'conditionType' */
@@ -67,8 +66,7 @@ conditionString(condition)
 /* tokenString similarly deals with parser tokens */
 
   char *
-tokenString(token)
+tokenString(int token)
-  int	token;
 {
 /* This table MUST be maintained congruently with the token definitions in
    the file 'y.tab.h' as output by yacc. */