From 41abf82caea71eb7e487d344cb665ed519cc6047 Mon Sep 17 00:00:00 2001 From: Michael Steil Date: Sat, 3 May 2014 22:47:33 -0700 Subject: [PATCH] Fixed macross and slinky to compile with clang 3.3 for i386 Mac OS X --- Makefile | 28 ++++++------ buildStuff1.c | 78 +++++++++++++++---------------- debugPrint.c | 104 +++++++++++++++++++++--------------------- emitStuff.c | 8 ++-- encode.c | 53 ++++++++++----------- expressionSemantics.c | 24 +++++----- garbage.c | 94 +++++++++++++++++++------------------- listing.c | 6 +-- macrossTypes.h | 8 +++- main.c | 4 ++ malloc.c | 6 ++- slinky/Makefile | 8 ++-- statementSemantics.c | 89 ++++++++++++++++++------------------ 13 files changed, 262 insertions(+), 248 deletions(-) diff --git a/Makefile b/Makefile index 84fcd09..f2c25e1 100644 --- a/Makefile +++ b/Makefile @@ -23,17 +23,19 @@ conditionDefs_$(PROC).h driver.c slinkyExpressions.h HEADERS = macrossTypes.h macrossGlobals.h +CFLAGS=-m32 # macross is not 64 bit clean + .c.o: - cc -c -g -DTARGET_CPU=CPU_$(PROC) $*.c + cc $(CFLAGS) -c -g -DTARGET_CPU=CPU_$(PROC) $*.c .c.run: - cc -o $* $*.c + cc $(CFLAGS) -o $* $*.c macross: $(OBJECTS) - cc -g -o macross $(OBJECTS) + cc $(CFLAGS) -g -o macross $(OBJECTS) driver: driver.c - cc -o driver driver.c + cc $(CFLAGS) -o driver driver.c update: .mark kessel "(cd /u0/chip/macross; make macross >&errorfyle)" & @@ -75,7 +77,7 @@ macrossTypes.h: macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ conditionDefs_$(PROC).h actions.o: actions_$(PROC).c $(HEADERS) - cc -c -g -DTARGET_CPU=CPU_$(PROC) actions_$(PROC).c + cc $(CFLAGS) -c -g -DTARGET_CPU=CPU_$(PROC) actions_$(PROC).c mv actions_$(PROC).o actions.o buildStuff1.o: buildStuff1.c $(HEADERS) @@ -87,21 +89,21 @@ buildStuff3.o: buildStuff3.c $(HEADERS) builtInFunctions.o: builtInFunctions.c $(HEADERS) builtInFunsSD.o: builtInFunsSD_$(PROC).c $(HEADERS) - cc -c -g -DTARGET_CPU=CPU_$(PROC) builtInFunsSD_$(PROC).c + cc $(CFLAGS) -c -g -DTARGET_CPU=CPU_$(PROC) builtInFunsSD_$(PROC).c mv builtInFunsSD_$(PROC).o builtInFunsSD.o debugPrint.o: debugPrint.c y.tab.h $(HEADERS) debugPrintSD.o: debugPrintSD_$(PROC).c y.tab.h $(HEADERS) - cc -c -g -DTARGET_CPU=CPU_$(PROC) debugPrintSD_$(PROC).c + cc $(CFLAGS) -c -g -DTARGET_CPU=CPU_$(PROC) debugPrintSD_$(PROC).c mv debugPrintSD_$(PROC).o debugPrintSD.o emitBranch.o: emitBranch_$(PROC).c $(HEADERS) - cc -c -g -DTARGET_CPU=CPU_$(PROC) emitBranch_$(PROC).c + cc $(CFLAGS) -c -g -DTARGET_CPU=CPU_$(PROC) emitBranch_$(PROC).c mv emitBranch_$(PROC).o emitBranch.o emitStuff.o: emitStuff.c $(HEADERS) - cc -c -g -DBYTESWAPPED -DTARGET_CPU=CPU_$(PROC) emitStuff.c + cc $(CFLAGS) -c -g -DBYTESWAPPED -DTARGET_CPU=CPU_$(PROC) emitStuff.c encode.o: encode.c $(HEADERS) @@ -122,7 +124,7 @@ listing.o: listing.c $(HEADERS) lookups.o: lookups.c $(HEADERS) macrossTables.o: macrossTables_$(PROC).c y.tab.h macrossTypes.h - cc -c -g -DTARGET_CPU=CPU_$(PROC) macrossTables_$(PROC).c + cc $(CFLAGS) -c -g -DTARGET_CPU=CPU_$(PROC) macrossTables_$(PROC).c mv macrossTables_$(PROC).o macrossTables.o malloc.o: malloc.c @@ -132,7 +134,7 @@ main.o: main.c $(HEADERS) object.o: object.c $(HEADERS) operandStuffSD.o: operandStuffSD_$(PROC).c $(HEADERS) - cc -c -g -DTARGET_CPU=CPU_$(PROC) operandStuffSD_$(PROC).c + cc $(CFLAGS) -c -g -DTARGET_CPU=CPU_$(PROC) operandStuffSD_$(PROC).c mv operandStuffSD_$(PROC).o operandStuffSD.o parserMisc.o: parserMisc.c y.tab.h $(HEADERS) @@ -144,11 +146,11 @@ statementSemantics.o: statementSemantics.c $(HEADERS) structSemantics.o: structSemantics.c $(HEADERS) tokenStrings.o: tokenStrings_$(PROC).c $(HEADERS) - cc -c -g -DTARGET_CPU=CPU_$(PROC) tokenStrings_$(PROC).c + cc $(CFLAGS) -c -g -DTARGET_CPU=CPU_$(PROC) tokenStrings_$(PROC).c mv tokenStrings_$(PROC).o tokenStrings.o y.tab.o: y.tab.c $(HEADERS) - cc -c -g -DYYDEBUG -DTARGET_CPU=CPU_$(PROC) y.tab.c + cc $(CFLAGS) -c -g -DYYDEBUG -DTARGET_CPU=CPU_$(PROC) y.tab.c y.tab.c y.tab.h: macross_$(PROC).y yacc -d macross_$(PROC).y diff --git a/buildStuff1.c b/buildStuff1.c index 18319e9..3578722 100644 --- a/buildStuff1.c +++ b/buildStuff1.c @@ -45,7 +45,7 @@ buildAlignStatement(expression) expressionType *expression; { return(newStatement(ALIGN_STATEMENT, - (alignStatementBodyType *) expression)); + (statementBodyType) expression)); } statementType * @@ -59,7 +59,7 @@ buildAssertStatement(condition, message) result->condition = condition; result->message = message; - return(newStatement(ASSERT_STATEMENT, result)); + return(newStatement(ASSERT_STATEMENT, (statementBodyType) result)); } statementType * @@ -67,7 +67,7 @@ buildBlockStatement(expressionList) expressionListType *expressionList; { return(newStatement(BLOCK_STATEMENT, - (blockStatementBodyType *) expressionList)); + (statementBodyType) expressionList)); } statementType * @@ -75,7 +75,7 @@ buildByteStatement(expressionList) expressionListType *expressionList; { return(newStatement(BYTE_STATEMENT, - (byteStatementBodyType *) expressionList)); + (statementBodyType) expressionList)); } statementType * @@ -89,7 +89,7 @@ buildConstrainStatement(expression, block) result->constraint = expression; result->constrainedBlock = block; - return(newStatement(CONSTRAIN_STATEMENT, result)); + return(newStatement(CONSTRAIN_STATEMENT, (statementBodyType) result)); } statementType * @@ -97,7 +97,7 @@ buildDbyteStatement(expressionList) expressionListType *expressionList; { return(newStatement(DBYTE_STATEMENT, - (dbyteStatementBodyType *) expressionList)); + (statementBodyType) expressionList)); } statementType * @@ -110,7 +110,7 @@ buildDefineStatement(name, value) result = typeAlloc(defineStatementBodyType); result->theSymbol = lookupOrEnterSymbol(name, UNKNOWN_SYMBOL); result->theValue = value; - return(newStatement(DEFINE_STATEMENT, result)); + return(newStatement(DEFINE_STATEMENT, (statementBodyType) result)); } statementType * @@ -123,7 +123,7 @@ buildDoUntilStatement(body, condition) result = typeAlloc(doUntilStatementBodyType); result->doUntilCondition = condition; result->doUntilLoop = body; - return(newStatement(DO_UNTIL_STATEMENT,result)); + return(newStatement(DO_UNTIL_STATEMENT, (statementBodyType) result)); } statementType * @@ -136,7 +136,7 @@ buildDoWhileStatement(body, condition) result = typeAlloc(doWhileStatementBodyType); result->doWhileCondition = condition; result->doWhileLoop = body; - return(newStatement(DO_WHILE_STATEMENT, result)); + return(newStatement(DO_WHILE_STATEMENT, (statementBodyType) result)); } statementType * @@ -161,7 +161,7 @@ buildExternStatement(identifierList) identifierListType *identifierList; { return(newStatement(EXTERN_STATEMENT, - (externStatementBodyType *) identifierList)); + (statementBodyType) identifierList)); } statementType * @@ -169,7 +169,7 @@ buildFreturnStatement(expression) expressionType *expression; { return(newStatement(FRETURN_STATEMENT, - (freturnStatementBodyType *) expression)); + (statementBodyType) expression)); } statementType * @@ -191,7 +191,7 @@ buildFunctionStatement(name, arguments, body) result->functionName = saveString(name); result->theArguments = arguments; result->theBlock = body; - return(newStatement(FUNCTION_STATEMENT, result)); + return(newStatement(FUNCTION_STATEMENT, (statementBodyType) result)); } statementType * @@ -199,7 +199,7 @@ buildGroupStatement(block) blockType *block; { return(newStatement(GROUP_STATEMENT, - (groupStatementBodyType *) block)); + (statementBodyType) block)); } statementType * @@ -230,7 +230,7 @@ buildIfStatement(head, continuation, continuationKind) else botch("bad continuation kind: %d\n", continuationKind); qfree(head); - return(newStatement(IF_STATEMENT, result)); + return(newStatement(IF_STATEMENT, (statementBodyType) result)); } statementType * @@ -238,7 +238,7 @@ buildIncludeStatement(filename) expressionType *filename; { return(newStatement(INCLUDE_STATEMENT, - (includeStatementBodyType *) filename)); + (statementBodyType) filename)); } statementType * @@ -252,7 +252,7 @@ buildInstructionStatement(opcode, operands) result->kindOfInstruction = OPCODE_INSTRUCTION; result->theInstruction.opcodeUnion = opcode; result->theOperands = operands; - return(newStatement(INSTRUCTION_STATEMENT, result)); + return(newStatement(INSTRUCTION_STATEMENT, (statementBodyType) result)); } statementType * @@ -260,7 +260,7 @@ buildLongStatement(expressionList) expressionListType *expressionList; { return(newStatement(LONG_STATEMENT, - (longStatementBodyType *) expressionList)); + (statementBodyType) expressionList)); } statementType * @@ -275,7 +275,7 @@ buildMacroStatement(macro, arguments, body) result->theMacro = macro; result->theArguments = arguments; result->theBlock = body; - return(newStatement(MACRO_STATEMENT, result)); + return(newStatement(MACRO_STATEMENT, (statementBodyType) result)); } statementType * @@ -289,7 +289,7 @@ buildMacroInstructionStatement(macro, operands) result->kindOfInstruction = MACRO_INSTRUCTION; result->theInstruction.macroUnion = macro; result->theOperands = operands; - return(newStatement(INSTRUCTION_STATEMENT, result)); + return(newStatement(INSTRUCTION_STATEMENT, (statementBodyType) result)); } statementType * @@ -302,7 +302,7 @@ buildMdefineStatement(name, value) result = typeAlloc(mdefineStatementBodyType); result->theSymbol = lookupOrEnterSymbol(name, DEAD_SYMBOL); result->theValue = value; - return(newStatement(MDEFINE_STATEMENT, result)); + return(newStatement(MDEFINE_STATEMENT, (statementBodyType) result)); } statementType * @@ -315,7 +315,7 @@ buildMdoUntilStatement(body, condition) result = typeAlloc(mdoUntilStatementBodyType); result->mdoUntilCondition = condition; result->mdoUntilLoop = body; - return(newStatement(MDO_UNTIL_STATEMENT,result)); + return(newStatement(MDO_UNTIL_STATEMENT, (statementBodyType) result)); } statementType * @@ -328,7 +328,7 @@ buildMdoWhileStatement(body, condition) result = typeAlloc(mdoWhileStatementBodyType); result->mdoWhileCondition = condition; result->mdoWhileLoop = body; - return(newStatement(MDO_WHILE_STATEMENT, result)); + return(newStatement(MDO_WHILE_STATEMENT, (statementBodyType) result)); } statementType * @@ -361,7 +361,7 @@ buildMforStatement(forExpressions, body) result->incrExpression = forExpressions->incrExpression; result->forLoop = body; qfree(forExpressions); - return(newStatement(MFOR_STATEMENT, result)); + return(newStatement(MFOR_STATEMENT, (statementBodyType) result)); } statementType * @@ -392,7 +392,7 @@ buildMifStatement(head, continuation, continuationKind) else botch("bad mif continuation kind: %d\n", continuationKind); qfree(head); - return(newStatement(MIF_STATEMENT, result)); + return(newStatement(MIF_STATEMENT, (statementBodyType) result)); } statementType * @@ -405,7 +405,7 @@ buildMswitchStatement(switchExpression, cases) result = typeAlloc(mswitchStatementBodyType); result->switchExpression = switchExpression; result->cases = cases; - return(newStatement(MSWITCH_STATEMENT, result)); + return(newStatement(MSWITCH_STATEMENT, (statementBodyType) result)); } statementType * @@ -420,7 +420,7 @@ buildMvariableStatement(name, value, dimension) result->theSymbol = lookupOrEnterSymbol(name, DEAD_SYMBOL); result->theValue = value; result->theDimension = dimension; - return(newStatement(MVARIABLE_STATEMENT, result)); + return(newStatement(MVARIABLE_STATEMENT, (statementBodyType) result)); } statementType * @@ -433,13 +433,13 @@ buildMwhileStatement(condition, body) result = typeAlloc(mwhileStatementBodyType); result->mwhileCondition = condition; result->mwhileLoop = body; - return(newStatement(MWHILE_STATEMENT, result)); + return(newStatement(MWHILE_STATEMENT, (statementBodyType) result)); } statementType * buildNullStatement() { - return(newStatement(NULL_STATEMENT, NULL)); + return(newStatement(NULL_STATEMENT, (statementBodyType){ .ifUnion = NULL })); } statementType * @@ -447,7 +447,7 @@ buildOrgStatement(expression) expressionType *expression; { return(newStatement(ORG_STATEMENT, - (orgStatementBodyType *) expression)); + (statementBodyType) expression)); } statementType * @@ -455,13 +455,13 @@ buildPerformStatement(expression) expressionType *expression; { return(newStatement(PERFORM_STATEMENT, - (performStatementBodyType *) expression)); + (statementBodyType) expression)); } statementType * buildRelStatement() { - return(newStatement(REL_STATEMENT, NULL)); + return(newStatement(REL_STATEMENT, (statementBodyType){ .ifUnion = NULL })); } statementType * @@ -469,7 +469,7 @@ buildStartStatement(expression) expressionType *expression; { return(newStatement(START_STATEMENT, - (startStatementBodyType *) expression)); + (statementBodyType) expression)); } statementType * @@ -477,7 +477,7 @@ buildStringStatement(expressionList) expressionListType *expressionList; { return(newStatement(STRING_STATEMENT, - (stringStatementBodyType *) expressionList)); + (statementBodyType) expressionList)); } statementType * @@ -490,7 +490,7 @@ buildStructStatement(name, body) result = typeAlloc(structStatementBodyType); result->structBody = body; result->structName = name; - return(newStatement(STRUCT_STATEMENT, result)); + return(newStatement(STRUCT_STATEMENT, (statementBodyType) result)); } statementType * @@ -498,7 +498,7 @@ buildTargetStatement(expression) expressionType *expression; { return(newStatement(TARGET_STATEMENT, - (targetStatementBodyType *) expression)); + (statementBodyType) expression)); } statementType * @@ -506,7 +506,7 @@ buildUndefineStatement(identifierList) identifierListType *identifierList; { return(newStatement(UNDEFINE_STATEMENT, - (undefineStatementBodyType *) identifierList)); + (statementBodyType) identifierList)); } statementType * @@ -521,7 +521,7 @@ buildVariableStatement(name, value, dimension) result->theSymbol = lookupOrEnterSymbol(name, VARIABLE_SYMBOL); result->theValue = value; result->theDimension = dimension; - return(newStatement(VARIABLE_STATEMENT, result)); + return(newStatement(VARIABLE_STATEMENT, (statementBodyType) result)); } statementType * @@ -534,7 +534,7 @@ buildWhileStatement(condition, body) result = typeAlloc(whileStatementBodyType); result->whileCondition = condition; result->whileLoop = body; - return(newStatement(WHILE_STATEMENT, result)); + return(newStatement(WHILE_STATEMENT, (statementBodyType) result)); } statementType * @@ -542,6 +542,6 @@ buildWordStatement(expressionList) expressionListType *expressionList; { return(newStatement(WORD_STATEMENT, - (wordStatementBodyType *) expressionList)); + (statementBodyType) expressionList)); } diff --git a/debugPrint.c b/debugPrint.c index 630252a..34742ce 100644 --- a/debugPrint.c +++ b/debugPrint.c @@ -394,15 +394,15 @@ printExpression(expression) switch (expression->kindOfTerm) { case ARRAY_EXPR: - printArrayTerm(expression->expressionTerm); + printArrayTerm(expression->expressionTerm.arrayUnion); break; case ASSIGN_EXPR: - printAssignmentTerm(expression->expressionTerm); + printAssignmentTerm(expression->expressionTerm.binopUnion); break; case BINOP_EXPR: - printBinopTerm(expression->expressionTerm); + printBinopTerm(expression->expressionTerm.binopUnion); break; case CONDITION_CODE_EXPR: @@ -410,7 +410,7 @@ printExpression(expression) break; case FUNCTION_CALL_EXPR: - printFunctionCall(expression->expressionTerm); + printFunctionCall(expression->expressionTerm.functionCallUnion); break; case HERE_EXPR: @@ -418,19 +418,19 @@ printExpression(expression) break; case IDENTIFIER_EXPR: - printIdentifier(expression->expressionTerm); + printIdentifier(expression->expressionTerm.symbolTableUnion); break; case NUMBER_EXPR: - printNumber(expression->expressionTerm); + printNumber(expression->expressionTerm.numberUnion); break; case POSTOP_EXPR: - printPostopTerm(expression->expressionTerm); + printPostopTerm(expression->expressionTerm.postOpUnion); break; case PREOP_EXPR: - printPreopTerm(expression->expressionTerm); + printPreopTerm(expression->expressionTerm.preOpUnion); break; case STRING_EXPR: @@ -438,15 +438,15 @@ printExpression(expression) break; case SUBEXPRESSION_EXPR: - printExpression(expression->expressionTerm); + printExpression(expression->expressionTerm.expressionUnion); break; case UNOP_EXPR: - printUnopTerm(expression->expressionTerm); + printUnopTerm(expression->expressionTerm.unopUnion); break; case VALUE_EXPR: - printValue(expression->expressionTerm); + printValue(expression->expressionTerm.valueUnion); break; default: @@ -659,7 +659,7 @@ printIfStatement(ifStatement) printBlock(ifStatement->consequence); tab(); printf("(else:\n"); tablevel++; - printIfStatement(ifStatement->continuation); + printIfStatement(ifStatement->continuation.blockUnion); tablevel--; tab(); printf(")\n"); } @@ -679,11 +679,11 @@ printInstructionStatement(instructionStatement) nullPrint(instructionStatement); switch(instructionStatement->kindOfInstruction) { case OPCODE_INSTRUCTION: - printOpcode(instructionStatement->theInstruction); + printOpcode(instructionStatement->theInstruction.opcodeUnion); break; case MACRO_INSTRUCTION: - printMacro(instructionStatement->theInstruction); + printMacro(instructionStatement->theInstruction.macroUnion); break; default: @@ -759,7 +759,7 @@ printMifStatement(mifStatement) printBlock(mifStatement->mifConsequence); tab(); printf("(melse:\n"); tablevel++; - printMifStatement(mifStatement->mifContinuation); + printMifStatement(mifStatement->mifContinuation.mifContinuationBodyUnion); tablevel--; tab(); printf(")\n"); } @@ -906,107 +906,107 @@ printStatementBody(kind, body) switch (kind) { case ALIGN_STATEMENT: - printAlignStatement(body); + printAlignStatement(body.alignUnion); break; case ASSERT_STATEMENT: - printAssertStatement(body); + printAssertStatement(body.assertUnion); break; case BLOCK_STATEMENT: - printBlockStatement(body); + printBlockStatement(body.blockUnion); break; case BYTE_STATEMENT: - printByteStatement(body); + printByteStatement(body.byteUnion); break; case CONSTRAIN_STATEMENT: - printConstrainStatement(body); + printConstrainStatement(body.constrainUnion); break; case DBYTE_STATEMENT: - printDbyteStatement(body); + printDbyteStatement(body.dbyteUnion); break; case DEFINE_STATEMENT: - printDefineStatement(body); + printDefineStatement(body.defineUnion); break; case DO_UNTIL_STATEMENT: - printDoUntilStatement(body); + printDoUntilStatement(body.doUntilUnion); break; case DO_WHILE_STATEMENT: - printDoWhileStatement(body); + printDoWhileStatement(body.doWhileUnion); break; case EXTERN_STATEMENT: - printExternStatement(body); + printExternStatement(body.externUnion); break; case FRETURN_STATEMENT: - printFreturnStatement(body); + printFreturnStatement(body.freturnUnion); break; case FUNCTION_STATEMENT: - printFunctionStatement(body); + printFunctionStatement(body.functionUnion); break; case GROUP_STATEMENT: - printBlock(body); + printBlock(body.groupUnion); break; case IF_STATEMENT: - printIfStatement(body); + printIfStatement(body.ifUnion); break; case INCLUDE_STATEMENT: - printIncludeStatement(body); + printIncludeStatement(body.includeUnion); break; case INSTRUCTION_STATEMENT: - printInstructionStatement(body); + printInstructionStatement(body.instructionUnion); break; case LONG_STATEMENT: - printLongStatement(body); + printLongStatement(body.longUnion); break; case MACRO_STATEMENT: - printMacroStatement(body); + printMacroStatement(body.macroUnion); break; case MDEFINE_STATEMENT: - printMdefineStatement(body); + printMdefineStatement(body.defineUnion); break; case MDO_UNTIL_STATEMENT: - printMdoUntilStatement(body); + printMdoUntilStatement(body.mdoUntilUnion); break; case MDO_WHILE_STATEMENT: - printMdoWhileStatement(body); + printMdoWhileStatement(body.mdoWhileUnion); break; case MFOR_STATEMENT: - printMforStatement(body); + printMforStatement(body.mforUnion); break; case MIF_STATEMENT: - printMifStatement(body); + printMifStatement(body.mifUnion); break; case MSWITCH_STATEMENT: - printMswitchStatement(body); + printMswitchStatement(body.mswitchUnion); break; case MVARIABLE_STATEMENT: - printMvariableStatement(body); + printMvariableStatement(body.mvariableUnion); break; case MWHILE_STATEMENT: - printMwhileStatement(body); + printMwhileStatement(body.mwhileUnion); break; case NULL_STATEMENT: @@ -1014,47 +1014,47 @@ printStatementBody(kind, body) break; case ORG_STATEMENT: - printOrgStatement(body); + printOrgStatement(body.orgUnion); break; case PERFORM_STATEMENT: - printPerformStatement(body); + printPerformStatement(body.performUnion); break; case REL_STATEMENT: - printRelStatement(body); + printRelStatement(body.relUnion); break; case START_STATEMENT: - printStartStatement(body); + printStartStatement(body.startUnion); break; case STRING_STATEMENT: - printStringStatement(body); + printStringStatement(body.stringUnion); break; case STRUCT_STATEMENT: - printStructStatement(body); + printStructStatement(body.structUnion); break; case TARGET_STATEMENT: - printTargetStatement(body); + printTargetStatement(body.targetUnion); break; case UNDEFINE_STATEMENT: - printUndefineStatement(body); + printUndefineStatement(body.undefineUnion); break; case VARIABLE_STATEMENT: - printVariableStatement(body); + printVariableStatement(body.variableUnion); break; case WHILE_STATEMENT: - printWhileStatement(body); + printWhileStatement(body.whileUnion); break; case WORD_STATEMENT: - printWordStatement(body); + printWordStatement(body.wordUnion); break; default: diff --git a/emitStuff.c b/emitStuff.c index c97ed27..a650e60 100644 --- a/emitStuff.c +++ b/emitStuff.c @@ -175,7 +175,7 @@ emitWord(wordValue) convert.bytePart[loByte]); putByte(currentLocationCounter.value++, convert.bytePart[hiByte]); -#else if TARGET_CPU == CPU_68000 +#elif TARGET_CPU == CPU_68000 putByte(currentLocationCounter.value++, convert.bytePart[hiByte]); putByte(currentLocationCounter.value++, @@ -185,7 +185,7 @@ emitWord(wordValue) #if TARGET_CPU == CPU_6502 mapByte(currentFieldOffset++, convert.bytePart[loByte]); mapByte(currentFieldOffset++, convert.bytePart[hiByte]); -#else if TARGET_CPU == CPU_68000 +#elif TARGET_CPU == CPU_68000 mapByte(currentFieldOffset++, convert.bytePart[hiByte]); mapByte(currentFieldOffset++, convert.bytePart[loByte]); #endif @@ -236,7 +236,7 @@ emitLong(longValue) convert.bytePart[thirdByte]); putByte(currentLocationCounter.value++, convert.bytePart[hiByte]); -#else if TARGET_CPU == CPU_68000 +#elif TARGET_CPU == CPU_68000 putByte(currentLocationCounter.value++, convert.bytePart[hiByte]); putByte(currentLocationCounter.value++, @@ -252,7 +252,7 @@ emitLong(longValue) mapByte(currentFieldOffset++, convert.bytePart[secondByte]); mapByte(currentFieldOffset++, convert.bytePart[thirdByte]); mapByte(currentFieldOffset++, convert.bytePart[hiByte]); -#else if TARGET_CPU == CPU_68000 +#elif TARGET_CPU == CPU_68000 mapByte(currentFieldOffset++, convert.bytePart[hiByte]); mapByte(currentFieldOffset++, convert.bytePart[thirdByte]); mapByte(currentFieldOffset++, convert.bytePart[secondByte]); diff --git a/encode.c b/encode.c index 1e0dffb..b40caf0 100644 --- a/encode.c +++ b/encode.c @@ -44,9 +44,8 @@ encodeBigword(bigword) } bool -encodeAssignmentTerm(assignmentTerm, kindOfFixup) +encodeAssignmentTerm(assignmentTerm) binopTermType *assignmentTerm; - fixupKindType kindOfFixup; { nullEncode(assignmentTerm); if ((assignmentKindType)assignmentTerm->binop != ASSIGN_ASSIGN) { @@ -62,10 +61,8 @@ encodeAssignmentTerm(assignmentTerm, kindOfFixup) } bool -encodeBinopTerm(binopTerm, isTopLevel, kindOfFixup) +encodeBinopTerm(binopTerm) binopTermType *binopTerm; - bool isTopLevel; - fixupKindType kindOfFixup; { bool encodeExpression(); @@ -384,19 +381,19 @@ encodeExpression(expression) break; case ASSIGN_EXPR: - return(encodeAssignmentTerm(expression->expressionTerm)); + return(encodeAssignmentTerm(expression->expressionTerm.binopUnion)); break; case BINOP_EXPR: - return(encodeBinopTerm(expression->expressionTerm)); + return(encodeBinopTerm(expression->expressionTerm.binopUnion)); break; case CONDITION_CODE_EXPR: - return(encodeCondition(expression->expressionTerm)); + return(encodeCondition(expression->expressionTerm.conditionTypeUnion)); break; case FUNCTION_CALL_EXPR: - return(encodeFunctionCall(expression->expressionTerm)); + return(encodeFunctionCall(expression->expressionTerm.functionCallUnion)); break; case HERE_EXPR: @@ -404,35 +401,35 @@ encodeExpression(expression) break; case IDENTIFIER_EXPR: - return(encodeIdentifier(expression->expressionTerm)); + return(encodeIdentifier(expression->expressionTerm.identifierUnion)); break; case NUMBER_EXPR: - return(encodeNumber(expression->expressionTerm)); + return(encodeNumber(expression->expressionTerm.numberUnion)); break; case POSTOP_EXPR: - return(encodePostopTerm(expression->expressionTerm)); + return(encodePostopTerm(expression->expressionTerm.postOpUnion)); break; case PREOP_EXPR: - return(encodePreopTerm(expression->expressionTerm)); + return(encodePreopTerm(expression->expressionTerm.preOpUnion)); break; case SUBEXPRESSION_EXPR: - encodeExpression(expression->expressionTerm); + encodeExpression(expression->expressionTerm.expressionUnion); break; case STRING_EXPR: - return(encodeString(expression->expressionTerm)); + return(encodeString(expression->expressionTerm.stringUnion)); break; case UNOP_EXPR: - return(encodeUnopTerm(expression->expressionTerm)); + return(encodeUnopTerm(expression->expressionTerm.unopUnion)); break; case VALUE_EXPR: - return(encodeValue(expression->expressionTerm)); + return(encodeValue(expression->expressionTerm.valueUnion)); break; default: @@ -614,43 +611,43 @@ encodeStatement(statement) return(FALSE); case ASSERT_STATEMENT: - return(encodeAssertStatement(statement->statementBody)); + return(encodeAssertStatement(statement->statementBody.assertUnion)); case FRETURN_STATEMENT: - return(encodeFreturnStatement(statement->statementBody)); + return(encodeFreturnStatement(statement->statementBody.freturnUnion)); case GROUP_STATEMENT: return(encodeBlock(statement->statementBody)); case MDEFINE_STATEMENT: - return(encodeMdefineStatement(statement->statementBody)); + return(encodeMdefineStatement(statement->statementBody.defineUnion)); case MDO_UNTIL_STATEMENT: - return(encodeMdoUntilStatement(statement->statementBody)); + return(encodeMdoUntilStatement(statement->statementBody.mdoUntilUnion)); case MDO_WHILE_STATEMENT: - return(encodeMdoWhileStatement(statement->statementBody)); + return(encodeMdoWhileStatement(statement->statementBody.mdoWhileUnion)); case MFOR_STATEMENT: - return(encodeMforStatement(statement->statementBody)); + return(encodeMforStatement(statement->statementBody.mforUnion)); case MIF_STATEMENT: - return(encodeMifStatement(statement->statementBody)); + return(encodeMifStatement(statement->statementBody.mifUnion)); case MSWITCH_STATEMENT: - return(encodeMswitchStatement(statement->statementBody)); + return(encodeMswitchStatement(statement->statementBody.mswitchUnion)); case MVARIABLE_STATEMENT: - return(encodeMvariableStatement(statement->statementBody)); + return(encodeMvariableStatement(statement->statementBody.mvariableUnion)); case MWHILE_STATEMENT: - return(encodeMwhileStatement(statement->statementBody)); + return(encodeMwhileStatement(statement->statementBody.mwhileUnion)); case NULL_STATEMENT: return(TRUE); case PERFORM_STATEMENT: - return(encodeExpression(statement->statementBody)); + return(encodeExpression(statement->statementBody.expressionUnion)); default: botch("encodeStatementBody doesn't know kind %d\n", diff --git a/expressionSemantics.c b/expressionSemantics.c index a91d6a8..a71fdcd 100644 --- a/expressionSemantics.c +++ b/expressionSemantics.c @@ -1063,25 +1063,25 @@ evaluateExpressionInternally(expression, isTopLevel, kindOfFixup,isStandalone) switch (expression->kindOfTerm) { case ARRAY_EXPR: - return(evaluateArrayTerm(expression->expressionTerm)); + return(evaluateArrayTerm(expression->expressionTerm.arrayUnion)); break; case ASSIGN_EXPR: - return(evaluateAssignmentTerm(expression->expressionTerm, + return(evaluateAssignmentTerm(expression->expressionTerm.binopUnion, kindOfFixup)); break; case BINOP_EXPR: - return(evaluateBinopTerm(expression->expressionTerm, + return(evaluateBinopTerm(expression->expressionTerm.binopUnion, isTopLevel, kindOfFixup)); break; case CONDITION_CODE_EXPR: - return(evaluateCondition(expression->expressionTerm)); + return(evaluateCondition(expression->expressionTerm.conditionTypeUnion)); break; case FUNCTION_CALL_EXPR: - return(evaluateFunctionCall(expression->expressionTerm, + return(evaluateFunctionCall(expression->expressionTerm.functionCallUnion, kindOfFixup, isStandalone)); break; @@ -1090,37 +1090,37 @@ evaluateExpressionInternally(expression, isTopLevel, kindOfFixup,isStandalone) break; case IDENTIFIER_EXPR: - result = evaluateIdentifier(expression->expressionTerm, + result = evaluateIdentifier(expression->expressionTerm.symbolTableUnion, isTopLevel, kindOfFixup); return(result); break; case NUMBER_EXPR: - return(evaluateNumber(expression->expressionTerm)); + return(evaluateNumber(expression->expressionTerm.numberUnion)); break; case POSTOP_EXPR: - return(evaluatePostopTerm(expression->expressionTerm)); + return(evaluatePostopTerm(expression->expressionTerm.postOpUnion)); break; case PREOP_EXPR: - return(evaluatePreopTerm(expression->expressionTerm)); + return(evaluatePreopTerm(expression->expressionTerm.preOpUnion)); break; case SUBEXPRESSION_EXPR: expand(moreExpression("(")); result = evaluateExpressionInternally(expression-> - expressionTerm, isTopLevel, kindOfFixup, FALSE); + expressionTerm.expressionUnion, isTopLevel, kindOfFixup, FALSE); expand(moreExpression(")")); return(result); break; case STRING_EXPR: - return(evaluateString(expression->expressionTerm)); + return(evaluateString(expression->expressionTerm.stringUnion)); break; case UNOP_EXPR: - return(evaluateUnopTerm(expression->expressionTerm, + return(evaluateUnopTerm(expression->expressionTerm.unopUnion, kindOfFixup)); break; diff --git a/garbage.c b/garbage.c index 9166a25..525c658 100644 --- a/garbage.c +++ b/garbage.c @@ -110,35 +110,35 @@ freeExpression(expression) break; case ARRAY_EXPR: - freeArrayTerm(expression->expressionTerm); + freeArrayTerm(expression->expressionTerm.arrayUnion); break; case ASSIGN_EXPR: - freeAssignmentTerm(expression->expressionTerm); + freeAssignmentTerm(expression->expressionTerm.binopUnion); break; case BINOP_EXPR: - freeBinopTerm(expression->expressionTerm); + freeBinopTerm(expression->expressionTerm.binopUnion); break; case FUNCTION_CALL_EXPR: - freeFunctionCall(expression->expressionTerm); + freeFunctionCall(expression->expressionTerm.functionCallUnion); break; case POSTOP_EXPR: - freePostopTerm(expression->expressionTerm); + freePostopTerm(expression->expressionTerm.postOpUnion); break; case PREOP_EXPR: - freePreopTerm(expression->expressionTerm); + freePreopTerm(expression->expressionTerm.preOpUnion); break; case SUBEXPRESSION_EXPR: - freeExpression(expression->expressionTerm); + freeExpression(expression->expressionTerm.expressionUnion); break; case UNOP_EXPR: - freeUnopTerm(expression->expressionTerm); + freeUnopTerm(expression->expressionTerm.unopUnion); break; default: @@ -362,7 +362,7 @@ freeIfStatement(ifStatement) if (ifStatement->consequence != NULL) freeBlock(ifStatement->consequence); if (ifStatement->continuation.continuationBodyUnion != NULL) { - freeIfStatement(ifStatement->continuation); + freeIfStatement((void *)ifStatement->continuation.blockUnion); } free(ifStatement); } @@ -422,7 +422,7 @@ freeMacroStatement(macroStatement) void freeMdefineStatement(mdefineStatement) - defineStatementBodyType *mdefineStatement; + defineStatementBodyType *mdefineStatement; // MIST: shouldn't this be "mdefineStatementBodyType"? { valueType *freeDefineExpression(); @@ -616,107 +616,107 @@ freeStatementBody(kind, body) switch (kind) { case ALIGN_STATEMENT: - freeAlignStatement(body); + freeAlignStatement(body.alignUnion); break; case ASSERT_STATEMENT: - freeAssertStatement(body); + freeAssertStatement(body.assertUnion); break; case BLOCK_STATEMENT: - freeBlockStatement(body); + freeBlockStatement(body.blockUnion); break; case BYTE_STATEMENT: - freeByteStatement(body); + freeByteStatement(body.byteUnion); break; case CONSTRAIN_STATEMENT: - freeConstrainStatement(body); + freeConstrainStatement(body.constrainUnion); break; case DBYTE_STATEMENT: - freeDbyteStatement(body); + freeDbyteStatement(body.dbyteUnion); break; case DEFINE_STATEMENT: - freeDefineStatement(body); + freeDefineStatement(body.defineUnion); break; case DO_UNTIL_STATEMENT: - freeDoUntilStatement(body); + freeDoUntilStatement(body.doUntilUnion); break; case DO_WHILE_STATEMENT: - freeDoWhileStatement(body); + freeDoWhileStatement(body.doWhileUnion); break; case EXTERN_STATEMENT: - freeExternStatement(body); + freeExternStatement(body.externUnion); break; case FRETURN_STATEMENT: - freeFreturnStatement(body); + freeFreturnStatement(body.freturnUnion); break; case FUNCTION_STATEMENT: - freeFunctionStatement(body); + freeFunctionStatement(body.functionUnion); break; case GROUP_STATEMENT: - freeBlock(body); + freeBlock(body.groupUnion); break; case IF_STATEMENT: - freeIfStatement(body); + freeIfStatement(body.ifUnion); break; case INCLUDE_STATEMENT: - freeIncludeStatement(body); + freeIncludeStatement(body.includeUnion); break; case INSTRUCTION_STATEMENT: - freeInstructionStatement(body); + freeInstructionStatement(body.instructionUnion); break; case LONG_STATEMENT: - freeLongStatement(body); + freeLongStatement(body.longUnion); break; case MACRO_STATEMENT: - freeMacroStatement(body); + freeMacroStatement(body.macroUnion); break; case MDEFINE_STATEMENT: - freeMdefineStatement(body); + freeMdefineStatement(body.defineUnion); break; case MDO_UNTIL_STATEMENT: - freeMdoUntilStatement(body); + freeMdoUntilStatement(body.mdoUntilUnion); break; case MDO_WHILE_STATEMENT: - freeMdoWhileStatement(body); + freeMdoWhileStatement(body.mdoWhileUnion); break; case MIF_STATEMENT: - freeMifStatement(body); + freeMifStatement(body.mifUnion); break; case MSWITCH_STATEMENT: - freeMswitchStatement(body); + freeMswitchStatement(body.mswitchUnion); break; case MFOR_STATEMENT: - freeMforStatement(body); + freeMforStatement(body.mforUnion); break; case MVARIABLE_STATEMENT: - freeMvariableStatement(body); + freeMvariableStatement(body.mvariableUnion); break; case MWHILE_STATEMENT: - freeMwhileStatement(body); + freeMwhileStatement(body.mwhileUnion); break; case NULL_STATEMENT: @@ -724,47 +724,47 @@ freeStatementBody(kind, body) break; case ORG_STATEMENT: - freeOrgStatement(body); + freeOrgStatement(body.orgUnion); break; case PERFORM_STATEMENT: - freePerformStatement(body); + freePerformStatement(body.performUnion); break; case REL_STATEMENT: - freeRelStatement(body); + freeRelStatement(body.relUnion); break; case START_STATEMENT: - freeStartStatement(body); + freeStartStatement(body.startUnion); break; case STRING_STATEMENT: - freeStringStatement(body); + freeStringStatement(body.stringUnion); break; case STRUCT_STATEMENT: - freeStructStatement(body); + freeStructStatement(body.structUnion); break; case TARGET_STATEMENT: - freeTargetStatement(body); + freeTargetStatement(body.targetUnion); break; case UNDEFINE_STATEMENT: - freeUndefineStatement(body); + freeUndefineStatement(body.undefineUnion); break; case VARIABLE_STATEMENT: - freeVariableStatement(body); + freeVariableStatement(body.variableUnion); break; case WHILE_STATEMENT: - freeWhileStatement(body); + freeWhileStatement(body.whileUnion); break; case WORD_STATEMENT: - freeWordStatement(body); + freeWordStatement(body.wordUnion); break; default: diff --git a/listing.c b/listing.c index 667542c..281b8a8 100644 --- a/listing.c +++ b/listing.c @@ -11,7 +11,7 @@ static char lineBuffer1[LINE_BUFFER_SIZE]; static char lineBuffer2[LINE_BUFFER_SIZE]; -static int cumulativeLineNumber = 0; +int cumulativeLineNumber = 0; static char macroLineBuffer[LINE_BUFFER_SIZE]; static char nextMacroLineBuffer[LINE_BUFFER_SIZE]; static int macroAddress; @@ -351,7 +351,7 @@ printListingLine(numberOfBytes, byteAddress, text, kind) else #if TARGET_CPU == CPU_6502 fprintf(listFileOutput, "%04x ", byteAddress); -#else if TARGET_CPU == CPU_68000 +#elif TARGET_CPU == CPU_68000 fprintf(listFileOutput, "%06x ", byteAddress); #endif @@ -364,7 +364,7 @@ printListingLine(numberOfBytes, byteAddress, text, kind) fprintf(listFileOutput, " "); } else { fprintf(listFileOutput, " "); -#else if TARGET_CPU == CPU_68000 +#elif TARGET_CPU == CPU_68000 for (i=0; i&errorfyle)" & diff --git a/statementSemantics.c b/statementSemantics.c index ac4e287..54adf64 100644 --- a/statementSemantics.c +++ b/statementSemantics.c @@ -19,6 +19,7 @@ static bool insideConstraintBlock = FALSE; bool nullStatementFlag = FALSE; #define nullAssemble(thing) if (thing==NULL) return; +#define nullAssembleNULL(thing) if (thing==NULL) return NULL; #define sideEffectBomb() if (beneathFunction) {\ error(SIDE_EFFECT_ERROR, currentFunctionName);\ break; } @@ -43,7 +44,7 @@ assembleBlockInsideIf(block, ongoingFixupList) { simpleFixupListType *assembleStatement(); - nullAssemble(block); + nullAssembleNULL(block); return(assembleStatement(block, TRUE, ongoingFixupList)); } @@ -581,7 +582,7 @@ assembleIfStatement(ifStatement, terminalIf, ongoingFixupList) return(NULL); } - nullAssemble(ifStatement); + nullAssembleNULL(ifStatement); fixupLocation2 = ongoingFixupList; if (ifStatement->ifCondition != ALWAYS_COND && ifStatement-> ifCondition != NEVER_COND) { @@ -608,7 +609,7 @@ assembleIfStatement(ifStatement, terminalIf, ongoingFixupList) ifStatement->ifCondition != ALWAYS_COND) { expand((tabIndent(), moreText("} else "))); fixupLocation2 = assembleIfStatement(ifStatement-> - continuation, terminalIf, fixupLocation2); + continuation.continuationBodyUnion, terminalIf, fixupLocation2); } else { expand((tabIndent(), moreText("}"), endLine())); } @@ -647,7 +648,7 @@ assembleIfStatementOldStyle(ifStatement) fixupBranch(fixupLocation1, currentLocationCounter); if (ifStatement->continuation.continuationBodyUnion != NULL) { expand((tabIndent(), moreText("} else "))); - assembleIfStatementOldStyle(ifStatement->continuation); + assembleIfStatementOldStyle(ifStatement->continuation.continuationBodyUnion); } else { expand((tabIndent(), moreText("}"), endLine())); } @@ -692,14 +693,14 @@ assembleInstructionStatement(instructionStatement, cumulativeLineNumber) cumulativeLineNumber); expand((startLine(), expandLabel(), tabIndent())); assembleMachineInstruction(instructionStatement-> - theInstruction, instructionStatement->theOperands); + theInstruction.opcodeUnion, instructionStatement->theOperands); break; case MACRO_INSTRUCTION: if (amListing() && !amExpanding()) saveIndexForListing(INSTRUCTION_STATEMENT, cumulativeLineNumber); - assembleMacro(instructionStatement->theInstruction, + assembleMacro(instructionStatement->theInstruction.macroUnion, instructionStatement->theOperands); break; @@ -1256,128 +1257,128 @@ assembleStatementBody(kind, body, cumulativeLineNumber, worryAboutIf, case ALIGN_STATEMENT: sideEffectBomb(); - assembleAlignStatement(body); + assembleAlignStatement(body.alignUnion); if (amListing()) saveIndexForListing(ALIGN_STATEMENT, cumulativeLineNumber); break; case ASSERT_STATEMENT: - assembleAssertStatement(body); + assembleAssertStatement(body.assertUnion); break; case BLOCK_STATEMENT: sideEffectBomb(); - assembleBlockStatement(body); + assembleBlockStatement(body.blockUnion); break; case BYTE_STATEMENT: sideEffectBomb(); - assembleByteStatement(body); + assembleByteStatement(body.byteUnion); break; case CONSTRAIN_STATEMENT: sideEffectBomb(); - assembleConstrainStatement(body); + assembleConstrainStatement(body.constrainUnion); break; case DBYTE_STATEMENT: sideEffectBomb(); - assembleDbyteStatement(body); + assembleDbyteStatement(body.dbyteUnion); break; case DEFINE_STATEMENT: sideEffectBomb(); - assembleDefineStatement(body); + assembleDefineStatement(body.defineUnion); break; case DO_UNTIL_STATEMENT: sideEffectBomb(); - assembleDoUntilStatement(body); + assembleDoUntilStatement(body.doUntilUnion); break; case DO_WHILE_STATEMENT: sideEffectBomb(); - assembleDoWhileStatement(body); + assembleDoWhileStatement(body.doWhileUnion); break; case EXTERN_STATEMENT: sideEffectBomb(); - assembleExternStatement(body); + assembleExternStatement(body.externUnion); break; case FRETURN_STATEMENT: - assembleFreturnStatement(body); + assembleFreturnStatement(body.freturnUnion); /* result = FALSE;*/ break; case FUNCTION_STATEMENT: - assembleFunctionStatement(body); + assembleFunctionStatement(body.functionUnion); break; case GROUP_STATEMENT: - assembleGroupStatement(body); + assembleGroupStatement(body.groupUnion); break; case IF_STATEMENT: sideEffectBomb(); if (worryAboutIf) { - *ifFixupList = assembleIfStatement(body, worryAboutIf, + *ifFixupList = assembleIfStatement(body.ifUnion, worryAboutIf, *ifFixupList); } else { - assembleIfStatement(body, worryAboutIf, NULL); + assembleIfStatement(body.ifUnion, worryAboutIf, NULL); } break; case INCLUDE_STATEMENT: sideEffectBomb(); - assembleIncludeStatement(body); + assembleIncludeStatement(body.includeUnion); break; case INSTRUCTION_STATEMENT: sideEffectBomb(); - assembleInstructionStatement(body, cumulativeLineNumber); + assembleInstructionStatement(body.instructionUnion, cumulativeLineNumber); break; case LONG_STATEMENT: sideEffectBomb(); - assembleLongStatement(body); + assembleLongStatement(body.longUnion); break; case MACRO_STATEMENT: - assembleMacroStatement(body); + assembleMacroStatement(body.macroUnion); break; case MDEFINE_STATEMENT: - assembleMdefineStatement(body); + assembleMdefineStatement(body.defineUnion); break; case MDO_UNTIL_STATEMENT: - assembleMdoUntilStatement(body); + assembleMdoUntilStatement(body.mdoUntilUnion); break; case MDO_WHILE_STATEMENT: - assembleMdoWhileStatement(body); + assembleMdoWhileStatement(body.mdoWhileUnion); break; case MFOR_STATEMENT: - assembleMforStatement(body); + assembleMforStatement(body.mforUnion); break; case MIF_STATEMENT: - assembleMifStatement(body, cumulativeLineNumber); + assembleMifStatement(body.mifUnion, cumulativeLineNumber); break; case MSWITCH_STATEMENT: - assembleMswitchStatement(body); + assembleMswitchStatement(body.mswitchUnion); break; case MVARIABLE_STATEMENT: - assembleMvariableStatement(body); + assembleMvariableStatement(body.mvariableUnion); break; case MWHILE_STATEMENT: - assembleMwhileStatement(body); + assembleMwhileStatement(body.mwhileUnion); break; case NULL_STATEMENT: @@ -1388,61 +1389,61 @@ assembleStatementBody(kind, body, cumulativeLineNumber, worryAboutIf, case ORG_STATEMENT: sideEffectBomb(); - assembleOrgStatement(body); + assembleOrgStatement(body.orgUnion); if (amListing()) saveIndexForListing(ORG_STATEMENT, cumulativeLineNumber); break; case PERFORM_STATEMENT: - assemblePerformStatement(body); + assemblePerformStatement(body.performUnion); break; case REL_STATEMENT: sideEffectBomb(); - assembleRelStatement(body); + assembleRelStatement(body.relUnion); if (amListing()) saveIndexForListing(REL_STATEMENT, cumulativeLineNumber); break; case START_STATEMENT: - assembleStartStatement(body); + assembleStartStatement(body.startUnion); break; case STRING_STATEMENT: sideEffectBomb(); - assembleStringStatement(body); + assembleStringStatement(body.stringUnion); break; case STRUCT_STATEMENT: sideEffectBomb(); - assembleStructStatement(body); + assembleStructStatement(body.structUnion); break; case TARGET_STATEMENT: sideEffectBomb(); - assembleTargetStatement(body); + assembleTargetStatement(body.targetUnion); break; case UNDEFINE_STATEMENT: sideEffectBomb(); - assembleUndefineStatement(body); + assembleUndefineStatement(body.undefineUnion); break; case VARIABLE_STATEMENT: sideEffectBomb(); - assembleVariableStatement(body); + assembleVariableStatement(body.variableUnion); break; case WHILE_STATEMENT: sideEffectBomb(); - assembleWhileStatement(body); + assembleWhileStatement(body.whileUnion); break; case WORD_STATEMENT: sideEffectBomb(); - assembleWordStatement(body); + assembleWordStatement(body.wordUnion); break; default: