6502
/
macross
mirror of https://github.com/Museum-of-Art-and-Digital-Entertainment/macross.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fixed macross and slinky to compile with clang 3.3 for i386 Mac OS X

This commit is contained in:
Michael Steil 2014-05-03 22:47:33 -07:00
parent b259671c6d
commit 41abf82cae
13 changed files with 262 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
Makefile
View File

@ -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

78
buildStuff1.c
View File

@ -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));
}

104
debugPrint.c
View File

@ -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:

8
emitStuff.c
View File

@ -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]);

53
encode.c
View File

@ -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",

24
expressionSemantics.c
View File

@ -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;

94
garbage.c
View File

@ -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:

6
listing.c
View File

@ -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<numberOfBytes; i++) {
fprintf(listFileOutput, "%02x",
getByte(byteAddress++));

8
macrossTypes.h
View File

@ -25,7 +25,7 @@
#define CONDITION_DEFS "conditionDefs_6502.h"
#define TARGET_CPU_STRING "6502"
#else if TARGET_CPU == CPU_68000
#elif TARGET_CPU == CPU_68000
#define OPERAND_DEFS "operandDefs_68000.h"
#define OPERAND_BODY "operandBody_68000.h"
#define CONDITION_DEFS "conditionDefs_68000.h"
@ -417,6 +417,9 @@ typedef union expressionTermBodyUnion {
stringTermType *stringUnion;
arrayTermType *arrayUnion;
valueType *valueUnion;
symbolTableEntryType *symbolTableUnion;
conditionType conditionTypeUnion;
void *expressionUnion; // this should be expressionTermType, but there's a cycle
} expressionTermBodyType;
typedef struct expressionTermStruct {
@ -763,6 +766,7 @@ typedef union {
assertStatementBodyType *assertUnion;
mswitchStatementBodyType *mswitchUnion;
longStatementBodyType *longUnion;
expressionType *expressionUnion;
} statementBodyType;
typedef enum {
@ -848,7 +852,7 @@ typedef struct {
#if TARGET_CPU == CPU_6502
#define CODE_BUFFERS_IN_ADDRESS_SPACE 64
#else if TARGET_CPU == CPU_68000
#elif TARGET_CPU == CPU_68000
#define CODE_BUFFERS_IN_ADDRESS_SPACE 256
#endif

4
main.c
View File

@ -13,7 +13,11 @@ main(argc, argv)
int argc;
char *argv[];
{
#ifdef __APPLE__
char end = get_end();
#else
extern char end;
#endif
char *sbrk();
fflush(stdout);

6
malloc.c
View File

@ -84,6 +84,9 @@ botch(s)
#define ASSERT(p)
#endif
static void morecore(int);
static int findbucket(union overhead *, int);
char *
malloc(nbytes)
register unsigned nbytes;
@ -135,7 +138,7 @@ malloc(nbytes)
/*
* Allocate more memory to the indicated bucket.
*/
static
static void
morecore(bucket)
register bucket;
{
@ -184,6 +187,7 @@ morecore(bucket)
}
}
void
free(cp)
char *cp;
{

8
slinky/Makefile
View File

@ -8,14 +8,16 @@ SOURCES = builtins.c debugPrint.c errorStuff.c expr.c initialize.c\
instantiate.c link.c main.c map.c poke.c read.c relocate.c slinkyTables.c\
write.c slinkyExpressions.h slinkyGlobals.h slinkyTypes.h y.tab.h
CFLAGS=-m32 # slinky is not 64 bit clean
.c.o:
cc -c -g $*.c
cc $(CFLAGS) -c -g $*.c
.c.run:
cc -o $* $*.c
cc $(CFLAGS) -o $* $*.c
slinky: $(OBJECTS)
cc -g -o slinky $(OBJECTS)
cc $(CFLAGS) -g -o slinky $(OBJECTS)
update: .mark
kessel "(cd /u0/chip/macross/slinky; make slinky >&errorfyle)" &

89
statementSemantics.c
View File

@ -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: