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
macross/statementSemantics.c

1437 lines
40 KiB
C
Raw Permalink Blame History

/*
* Copyright (c) 1987 Fujitsu
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/*
statementSemantics.c -- Routines to eat up a parse tree and spit out
code.
Chip Morningstar -- Lucasfilm Ltd.
12-November-1984
*/
#include "macrossTypes.h"
#include "macrossGlobals.h"
#include "actions.h"
#include "debugPrint.h"
#include "emitBranch.h"
#include "emitStuff.h"
#include "errorStuff.h"
#include "expressionSemantics.h"
#include "fixups.h"
#include "garbage.h"
#include "lexer.h"
#include "listing.h"
#include "lookups.h"
#include "operandStuff.h"
#include "parserMisc.h"
#include "semanticMisc.h"
#include "statementSemantics.h"
#include "structSemantics.h"
#include "tokenStrings.h"
operandType *dbOperand; /* safe temps for dbx hacking */
expressionType *dbExpression;
symbolTableEntryType *dbSymbol;
bool newIncludeFile = FALSE;
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; }
#define expansionOff() {saveExpansion=expandMacros; expandMacros=FALSE;}
#define expansionOn() expandMacros=saveExpansion;
void
assembleBlock(blockType *block)
{
nullAssemble(block);
assembleStatement(block, FALSE, NULL);
}
simpleFixupListType *
assembleBlockInsideIf(blockType *block, simpleFixupListType *ongoingFixupList)
{
nullAssembleNULL(block);
return(assembleStatement(block, TRUE, ongoingFixupList));
}
bool
operandCheck(opcodeTableEntryType *opcode, int numberOfOperands, valueType **evaluatedOperands)
{
int i;
for (i=0; i<numberOfOperands; i++) {
if ((operandClassTable[(int)operandKindField(
evaluatedOperands[i]->addressMode)] & opcode->
permissibleOperandModes) == 0) {
error(ILLEGAL_OPERAND_TYPE_ERROR, opcode->mnemonic);
return(FALSE);
}
}
return(TRUE);
}
void
assembleMachineInstruction(opcodeTableEntryType *opcode, operandListType *operands)
{
int i;
int op;
valueType *evaluatedOperands[MAX_NUMBER_OF_OPERANDS];
valueType *value;
nullAssemble(opcode);
expand(moreText("%s\t", opcode->mnemonic));
for (op=1; operands!=NULL && op<=opcode->maxNumberOfOperands;
op++, operands=operands->nextOperand) {
newFixupAddressMode = EXPRESSION_OPND;
evaluatedOperands[op-1] = value = evaluateOperand(operands);
fixupAddressMode[op-1] = newFixupAddressMode;
currentOperandNumber++;
expand(isUndefined(value) ? (finishOperand = TRUE) :
expandOperand(value->addressMode,
operandBuffer[op-1]));
if (value==NULL || value->kindOfValue == FAIL){
error(BAD_INSTRUCTION_OPERAND_ERROR, opcode->
mnemonic);
if (freeFlag)
for (i=1; i<op; i++)
free(evaluatedOperands[i-1]);
currentOperandNumber = 0;
return;
}
}
currentOperandNumber = 0;
op--;
if (operands != NULL) {
error(TOO_MANY_INSTRUCTION_OPERANDS_ERROR, opcode->mnemonic,
opcode->maxNumberOfOperands);
} else if (op < opcode->minNumberOfOperands) {
error(TOO_FEW_INSTRUCTION_OPERANDS_ERROR, opcode->mnemonic,
opcode->minNumberOfOperands);
} else if (operandCheck(opcode, op, evaluatedOperands)) {
(*instructionActionTable[(int)opcode->addressClass])(opcode,
op, evaluatedOperands);
}
expand((expandOperands(op), endLine()));
if (freeFlag)
for (i=0; i<op; i++)
free(evaluatedOperands[i]);
}
void
assembleMacro(macroTableEntryType *macroInstruction, operandListType *operands)
{
int numberBound;
identifierListType *savedLocalVariableList;
int savedLabelTagNumber;
bool savedErrorFlag;
bool saveListingOn;
environmentType newEnvironment;
nullAssemble(macroInstruction);
if (macroInstruction->body == NULL) {
error(UNDEFINED_MACRO_ERROR, macroInstruction->macroName);
return;
}
pushEnvironment(newEnvironment);
savedLocalVariableList = currentLocalVariableList;
currentLocalVariableList = NULL;
savedLabelTagNumber = currentLabelTagNumber;
currentLabelTagNumber = nextLabelTagNumber++;
savedErrorFlag = errorFlag;
errorFlag = FALSE;
saveListingOn = listingOn;
if ((numberBound = bindMacroArguments(macroInstruction->arguments,
operands, macroInstruction->macroName)) > 0) {
macroCallDepth++;
listingOn = amExpanding();
assembleBlock(macroInstruction->body);
macroCallDepth--;
} else
numberBound = -numberBound;
if (numberBound > 1)
unbindArguments(macroInstruction->arguments, numberBound-1);
unbindLocalVariables(currentLocalVariableList);
if (errorFlag)
error(ERROR_INSIDE_MACRO_ERROR, macroInstruction->macroName);
else
errorFlag = savedErrorFlag;
currentLabelTagNumber = savedLabelTagNumber;
currentLocalVariableList = savedLocalVariableList;
listingOn = saveListingOn;
popEnvironment();
}
void
assembleAlignStatement(alignStatementBodyType *alignStatement)
{
int alignment;
bool saveExpansion;
nullAssemble(alignStatement);
expansionOff();
alignment = intValue(evaluateExpression(alignStatement, NO_FIXUP));
expansionOn();
expand((moreText("align\t0x%x", alignment), endLine()));
if (alignment > 0)
if (currentCodeMode == ABSOLUTE_BUFFER) {
if (structNestingDepth == 0)
currentLocationCounter.value = alignment *
((currentLocationCounter.value +
alignment - 1) / alignment);
else
currentFieldOffset = alignment *
((currentFieldOffset + alignment -
1) / alignment);
} else {
if (insideConstraintBlock)
error(ALIGN_INSIDE_CONSTRAIN_ERROR);
else
addBreak(ALIGN_BREAK, alignment);
}
else
error(IMPROPER_ALIGNMENT_VALUE_ERROR);
}
void
assembleAssertStatement(assertStatementBodyType *assertStatement)
{
valueType *test;
valueType *message;
bool saveExpansion;
expansionOff();
test = evaluateExpression(assertStatement->condition, NO_FIXUP);
expansionOn();
if (test == NULL || test->kindOfValue != ABSOLUTE_VALUE) {
error(INVALID_ASSERT_CONDITION_ERROR);
} else if (!test->value) {
if (assertStatement->message == NULL)
error(ASSERT_ERROR);
else {
expansionOff();
message = evaluateExpression(assertStatement->message,
NO_FIXUP);
expansionOn();
if (message == NULL || message->kindOfValue !=
STRING_VALUE)
error(INVALID_ASSERT_MESSAGE_ERROR);
else
error(ASSERT_WITH_MESSAGE_ERROR, message->
value);
}
}
}
void
assembleBlockStatement(blockStatementBodyType *blockStatement)
{
valueType *blockIncrement;
int blockSize;
blockSize = 0;
nullAssemble(blockStatement);
expand(moreText("block\t"));
while (blockStatement != NULL) {
blockIncrement = evaluateExpression(blockStatement->
theExpression, NO_FIXUP);
blockSize += intValue(blockIncrement);
blockStatement = blockStatement->nextExpression;
expand((expandExpression(NULL, NULL), blockStatement!=NULL ?
moreText(", ") : 0));
qfree(blockIncrement);
}
expand(endLine());
if (blockSize >= 0) {
if (structNestingDepth != 0) {
while (blockSize-- > 0)
emitByte(0);
} else if (currentCodeMode == RELOCATABLE_BUFFER) {
while (blockSize-- > 0)
emitByte(0);
} else {
if (produceLinkableObject)
reserveAbsolute(currentLocationCounter.value,
blockSize);
currentLocationCounter.value += blockSize;
}
} else
error(NEGATIVE_BLOCK_SIZE_ERROR);
}
void
assembleByteStatement(byteStatementBodyType *byteStatement)
{
valueType *byteValue;
nullAssemble(byteStatement);
expand(moreText("byte\t"));
while (byteStatement != NULL) {
byteValue = evaluateExpression(byteStatement->theExpression,
BYTE_FIXUP);
if (byteValue->kindOfValue == STRING_VALUE) {
emitString(byteValue->value);
} else {
putFixupsHere(BYTE_FIXUP, 0);
emitByteValue(byteValue);
}
qfree(byteValue);
byteStatement = byteStatement->nextExpression;
expand((expandExpression(NULL, NULL), byteStatement != NULL ?
moreText(", ") : 0));
}
expand(endLine());
}
void
assembleConstrainStatement(constrainStatementBodyType *constrainStatement)
{
valueType *constraintValue;
int constraint;
addressType startAddress;
addressType endAddress;
bool saveExpansion;
expansionOff();
constraintValue = evaluateExpression(constrainStatement->constraint,
NO_FIXUP);
expansionOn();
if (constraintValue == NULL || constraintValue->kindOfValue !=
ABSOLUTE_VALUE) {
error(INVALID_CONSTRAINT_VALUE_ERROR);
return;
}
constraint = constraintValue->value;
expand((moreText("constrain (0x%x) {", constraint), endLine(),
tabCount++));
if (currentCodeMode == ABSOLUTE_BUFFER) {
startAddress = currentLocationCounter.value;
assembleBlock(constrainStatement->constrainedBlock);
endAddress = currentLocationCounter.value;
if ((startAddress / constraint) != (endAddress / constraint))
error(CONSTRAINT_ERROR, constraint);
} else {
if (insideConstraintBlock) {
error(CONSTRAIN_INSIDE_CONSTRAIN_ERROR);
assembleBlock(constrainStatement->constrainedBlock);
} else {
insideConstraintBlock = TRUE;
addBreak(CONSTRAIN_BREAK, constraint);
assembleBlock(constrainStatement->constrainedBlock);
addBreak(END_CONSTRAIN_BREAK, 0);
insideConstraintBlock = FALSE;
}
}
expand((tabCount--, startLineMarked(), tabIndent(), moreText("}"),
endLine()));
}
void
assembleDbyteStatement(dbyteStatementBodyType *dbyteStatement)
{
valueType *wordValue;
nullAssemble(dbyteStatement);
expand(moreText("dbyte\t"));
while (dbyteStatement != NULL) {
wordValue = swabValue(evaluateExpression(dbyteStatement->
theExpression, DBYTE_FIXUP));
dbyteStatement = dbyteStatement->nextExpression;
expand((expandExpression(NULL, NULL), dbyteStatement != NULL ?
moreText(", ") : 0));
putFixupsHere(DBYTE_FIXUP, 0);
emitWordValue(wordValue);
qfree(wordValue);
}
expand(endLine());
}
void
assembleDefineStatement(defineStatementBodyType *defineStatement)
{
symbolTableEntryType *symbolToDefine;
symbolInContextType *contextToDefine;
bool saveExpansion;
nullAssemble(defineStatement);
symbolToDefine = effectiveSymbol(defineStatement->theSymbol,
&contextToDefine);
if (isDefinable(contextToDefine)) {
expand(moreText("define %s = ", symbName(symbolToDefine)));
if (contextToDefine->usage == DEAD_SYMBOL) {
reincarnateSymbol(contextToDefine, DEFINE_SYMBOL);
} else if (contextToDefine->usage == NESTED_UNKNOWN_SYMBOL) {
contextToDefine->usage = DEFINE_SYMBOL;
}
if (alreadyDefined(contextToDefine))
error(REDEFINITION_OF_SYMBOL_ERROR, symbName(
symbolToDefine));
else {
if (defineStatement->theValue != NULL) {
contextToDefine->value =
evaluateDefineExpression(
defineStatement->theValue);
contextToDefine->usage = DEFINE_SYMBOL;
expand(expandExpression(NULL, NULL));
} else
contextToDefine->value = newValue(FAIL, 0,
EXPRESSION_OPND);
contextToDefine->environmentNumber =
GLOBAL_ENVIRONMENT_NUMBER;
contextToDefine->attributes |= DEFINED_VARIABLE_ATT;
}
expand(endLine());
} else {
error(SYMBOL_ALREADY_THERE_ERROR, symbName(symbolToDefine));
}
}
void
assembleDoUntilStatement(doUntilStatementBodyType *doUntilStatement)
{
valueType topOfLoop;
nullAssemble(doUntilStatement);
topOfLoop = currentLocationCounter;
if (doUntilStatement->doUntilCondition == NEVER_COND)
topOfLoop.value -= targetOffset;
expand((moreText("do {"), endLine(), tabCount++));
assembleBlock(doUntilStatement->doUntilLoop);
expand((tabCount--, startLineMarked(), tabIndent(),
moreText("} until %s", conditionString(doUntilStatement->
doUntilCondition)), endLine()));
if (doUntilStatement->doUntilCondition == ALWAYS_COND) {
return;
} else if (doUntilStatement->doUntilCondition != NEVER_COND) {
emitRelativeBranch(invertConditionCode(doUntilStatement->
doUntilCondition), &topOfLoop, NULL);
} else {
emitJump(&topOfLoop, NULL);
}
}
void
assembleDoWhileStatement(doWhileStatementBodyType *doWhileStatement)
{
valueType topOfLoop;
nullAssemble(doWhileStatement);
topOfLoop = currentLocationCounter;
if (doWhileStatement->doWhileCondition == ALWAYS_COND)
topOfLoop.value -= targetOffset;
expand((moreText("do {"), endLine(), tabCount++));
assembleBlock(doWhileStatement->doWhileLoop);
expand((tabCount--, startLineMarked(), tabIndent(),
moreText("} while %s", conditionString(doWhileStatement->
doWhileCondition)), endLine()));
if (doWhileStatement->doWhileCondition == NEVER_COND) {
return;
} else if (doWhileStatement->doWhileCondition != ALWAYS_COND) {
emitRelativeBranch(doWhileStatement->doWhileCondition,
&topOfLoop, NULL);
} else {
emitJump(&topOfLoop, NULL);
}
}
void
assembleExternStatement(externStatementBodyType *externStatement)
{
symbolInContextType *context;
symbolTableEntryType *theSymbol;
expand(moreText("extern\t"));
while (externStatement != NULL) {
theSymbol = effectiveSymbol(externStatement->theSymbol,
&context);
expand(moreText("%s", symbName(theSymbol)));
if (context != NULL) {
if (context->usage == LABEL_SYMBOL || context->usage
== EXTERNAL_SYMBOL || context->usage
== UNKNOWN_SYMBOL || context->usage
== NESTED_UNKNOWN_SYMBOL) {
context->attributes |= GLOBAL_ATT;
} else {
error(BAD_KIND_OF_SYMBOL_TO_MAKE_EXTERNAL_ERROR,
usageString(context->usage));
}
}
externStatement = externStatement->nextIdentifier;
expand(externStatement != NULL ? moreText(", ") : 0);
}
expand(endLine());
}
void
assembleFreturnStatement(freturnStatementBodyType *freturnStatement)
{
freturnExit = TRUE;
resultOfLastFunctionCall = evaluateExpression(freturnStatement,
NO_FIXUP_OK);
}
void
assembleFunctionStatement(functionStatementBodyType *functionStatement)
{
symbolTableEntryType *newFunctionSymbol;
functionDefinitionType *newFunction;
symbolInContextType *context;
nullAssemble(functionStatement);
if (currentEnvironment != &globalEnvironment) {
error(FUNCTION_DEFINITION_INSIDE_FUNCTION_ERROR);
return;
}
newFunctionSymbol = lookupOrEnterSymbol(functionStatement->
functionName, FUNCTION_SYMBOL);
context = getBaseContext(newFunctionSymbol);
if (context->usage != FUNCTION_SYMBOL) {
if (context->usage == UNKNOWN_FUNCTION_SYMBOL) {
context->usage = FUNCTION_SYMBOL;
} else {
error(SYMBOL_ALREADY_THERE_ERROR, symbName(
newFunctionSymbol));
return;
}
} else if (isDefined(context->value)) {
error(FUNCTION_ALREADY_EXISTS_ERROR, symbName(
newFunctionSymbol));
return;
}
newFunction = typeAlloc(functionDefinitionType);
newFunction->functionName = newFunctionSymbol;
newFunction->arguments = functionStatement->theArguments;
newFunction->body = functionStatement->theBlock;
newFunction->ordinal = -1;
newFunction->nextExternalFunction = NULL;
context->value = newValue(FUNCTION_VALUE, newFunction,
EXPRESSION_OPND);
context->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER;
}
void
assembleGroupStatement(blockType *groupStatement)
{
expand((startLineMarked(), tabIndent(), moreText("{"), endLine(),
tabCount++));
assembleBlock(groupStatement);
expand((tabCount--, startLineMarked(), tabIndent(), moreText("}"),
endLine()));
}
simpleFixupListType *
assembleIfStatement(ifStatementBodyType *ifStatement, bool terminalIf, simpleFixupListType *ongoingFixupList)
{
valueType fixupLocation1[COMPOUND_BRANCH_MAX];
simpleFixupListType *fixupLocation2;
if (backwardsCompatibleIfFlag) {
assembleIfStatementOldStyle(ifStatement);
return(NULL);
}
nullAssembleNULL(ifStatement);
fixupLocation2 = ongoingFixupList;
if (ifStatement->ifCondition != ALWAYS_COND && ifStatement->
ifCondition != NEVER_COND) {
emitRelativeBranch(invertConditionCode(ifStatement->
ifCondition), NULL, fixupLocation1);
expand((moreText("if %s {", conditionString(ifStatement->
ifCondition)), endLine(), tabCount++));
} else if (ifStatement->ifCondition == ALWAYS_COND) {
expand((moreText("{"), endLine(), tabCount++));
}
if (ifStatement->consequence != NULL && ifStatement->ifCondition !=
NEVER_COND)
fixupLocation2 = assembleBlockInsideIf(ifStatement->
consequence, fixupLocation2);
expand((tabCount--, startLineMarked()));
if (ifStatement->continuation.continuationBodyUnion != NULL &&
ifStatement->ifCondition != NEVER_COND &&
ifStatement->ifCondition != ALWAYS_COND)
fixupLocation2 = emitJump(NULL, fixupLocation2);
if (ifStatement->ifCondition != ALWAYS_COND && ifStatement->
ifCondition != NEVER_COND)
fixupBranch(fixupLocation1, currentLocationCounter);
if (ifStatement->continuation.continuationBodyUnion != NULL &&
ifStatement->ifCondition != ALWAYS_COND) {
expand((tabIndent(), moreText("} else ")));
fixupLocation2 = assembleIfStatement(ifStatement->
continuation.continuationBodyUnion, terminalIf, fixupLocation2);
} else {
expand((tabIndent(), moreText("}"), endLine()));
}
if (terminalIf) {
return(fixupLocation2);
} else {
fixupJump(fixupLocation2, currentLocationCounter);
return(NULL);
}
}
void
assembleIfStatementOldStyle(ifStatementBodyType *ifStatement)
{
valueType fixupLocation1[COMPOUND_BRANCH_MAX];
simpleFixupListType *fixupLocation2;
nullAssemble(ifStatement);
if (ifStatement->ifCondition != ALWAYS_COND) {
emitRelativeBranch(invertConditionCode(ifStatement->
ifCondition), NULL, fixupLocation1);
expand((moreText("if %s {", conditionString(ifStatement->
ifCondition)), endLine(), tabCount++));
} else {
expand((moreText("{"), endLine(), tabCount++));
}
if (ifStatement->consequence != NULL)
assembleBlock(ifStatement->consequence);
expand((tabCount--, startLineMarked()));
if (ifStatement->continuation.continuationBodyUnion != NULL)
fixupLocation2 = emitJump(NULL, NULL);
if (ifStatement->ifCondition != ALWAYS_COND)
fixupBranch(fixupLocation1, currentLocationCounter);
if (ifStatement->continuation.continuationBodyUnion != NULL) {
expand((tabIndent(), moreText("} else ")));
assembleIfStatementOldStyle(ifStatement->continuation.continuationBodyUnion);
} else {
expand((tabIndent(), moreText("}"), endLine()));
}
if (ifStatement->continuation.continuationBodyUnion != NULL)
fixupJump(fixupLocation2, currentLocationCounter);
}
void
assembleIncludeStatement(includeStatementBodyType *includeStatement)
{
stringType *fileName;
valueType *possibleFileName;
bool saveExpansion;
expansionOff();
possibleFileName = evaluateExpression(includeStatement, NO_FIXUP);
expansionOn();
if (possibleFileName->kindOfValue == STRING_VALUE) {
fileName = (stringType *)possibleFileName->value;
newIncludeFile = TRUE;
expand((moreText("include \"%s\"", fileName), endLine()));
pushInputFileStack(saveString(fileName));
} else {
error(INCLUDE_FILE_NOT_A_STRING_VALUE_ERROR);
}
}
void
assembleInstructionStatement(instructionStatementBodyType *instructionStatement, int cumulativeLineNumber)
{
nullAssemble(instructionStatement);
switch(instructionStatement->kindOfInstruction) {
case OPCODE_INSTRUCTION:
if (amListing())
saveIndexForListing(INSTRUCTION_STATEMENT,
cumulativeLineNumber);
expand((startLine(), expandLabel(), tabIndent()));
assembleMachineInstruction(instructionStatement->
theInstruction.opcodeUnion, instructionStatement->theOperands);
break;
case MACRO_INSTRUCTION:
if (amListing() && !amExpanding())
saveIndexForListing(INSTRUCTION_STATEMENT,
cumulativeLineNumber);
assembleMacro(instructionStatement->theInstruction.macroUnion,
instructionStatement->theOperands);
break;
default:
botch("bad instruction type=%d\n", instructionStatement->
kindOfInstruction, 0, 0);
break;
}
}
void
assembleLongStatement(longStatementBodyType *longStatement)
{
valueType *longValue;
nullAssemble(longStatement);
expand(moreText("long\t"));
while (longStatement != NULL) {
longValue = evaluateExpression(longStatement->theExpression,
LONG_FIXUP);
longStatement = longStatement->nextExpression;
expand((expandExpression(NULL, NULL), longStatement != NULL ?
moreText(", ") : 0));
putFixupsHere(LONG_FIXUP, 0);
emitLongValue(longValue);
qfree(longValue);
}
expand(endLine());
}
void
assembleMacroStatement(macroStatementBodyType *macroStatement)
{
macroTableEntryType *newMacro;
nullAssemble(macroStatement);
if (currentEnvironment != &globalEnvironment) {
error(MACRO_DEFINITION_INSIDE_MACRO_ERROR);
return;
}
newMacro = macroStatement->theMacro;
if (newMacro == NULL)
return;
if (newMacro->body != NULL) {
error(MACRO_ALREADY_EXISTS_ERROR, macroStatement->theMacro->
macroName);
return;
}
newMacro->arguments = macroStatement->theArguments;
newMacro->body = macroStatement->theBlock;
}
void
assembleMdefineStatement(defineStatementBodyType *mdefineStatement)
{
bool saveExpansion;
nullAssemble(mdefineStatement);
expansionOff();
pushBinding(mdefineStatement->theSymbol, evaluateDefineExpression(
mdefineStatement->theValue), MDEFINE_SYMBOL);
expansionOn();
addNewLocalVariable(mdefineStatement->theSymbol);
}
void
assembleMdoUntilStatement(mdoUntilStatementBodyType *mdoUntilStatement)
{
bool saveListingOn;
nullAssemble(mdoUntilStatement);
saveListingOn = listingOn;
do {
assembleBlock(mdoUntilStatement->mdoUntilLoop);
listingOn = amExpanding();
} while (!booleanTest(mdoUntilStatement->mdoUntilCondition));
listingOn = saveListingOn;
}
void
assembleMdoWhileStatement(mdoWhileStatementBodyType *mdoWhileStatement)
{
bool saveListingOn;
nullAssemble(mdoWhileStatement);
saveListingOn = listingOn;
do {
assembleBlock(mdoWhileStatement->mdoWhileLoop);
listingOn = amExpanding();
} while (booleanTest(mdoWhileStatement->mdoWhileCondition));
listingOn = saveListingOn;
}
void
assembleMforStatement(mforStatementBodyType *mforStatement)
{
bool saveListingOn;
bool saveExpansion;
nullAssemble(mforStatement);
saveListingOn = listingOn;
expansionOff();
for (evaluateExpression(mforStatement->initExpression, NO_FIXUP);
booleanTest(mforStatement->testExpression);
evaluateExpression(mforStatement->incrExpression, NO_FIXUP)) {
expansionOn();
assembleBlock(mforStatement->forLoop);
listingOn = amExpanding();
expansionOff();
}
expansionOn();
listingOn = saveListingOn;
}
void
assembleMifStatement(mifStatementBodyType *mifStatement, int cumulativeLineNumber)
{
while (mifStatement != NULL) {
if (mifStatement->mifCondition == NULL) {
assembleBlock(mifStatement->mifConsequence);
break;
} else if (booleanTest(mifStatement->mifCondition)) {
assembleBlock(mifStatement->mifConsequence);
break;
} else {
mifStatement = mifStatement->mifContinuation.
mifContinuationBodyUnion;
}
}
if (amListing())
saveEndMifForListing(cumulativeLineNumber);
}
void
assembleMswitchStatement(mswitchStatementBodyType *mswitchStatement)
{
valueType *switchValue;
caseListType *caseList;
caseType *theCase;
bool matched;
expressionListType *tagExpressionList;
valueType *tagValue;
bool saveExpansion;
expansionOff();
switchValue = evaluateExpression(mswitchStatement->switchExpression,
NO_FIXUP);
expansionOn();
if (switchValue->kindOfValue != ABSOLUTE_VALUE && switchValue->kindOfValue
!= STRING_VALUE) {
error(INVALID_SWITCH_VALUE_KIND, valueKindString(switchValue->
kindOfValue));
return;
}
for (caseList=mswitchStatement->cases; caseList!=NULL; caseList=caseList->
nextCase) {
theCase = caseList->theCase;
if (theCase->caseTags == NULL) {
assembleBlock(theCase->caseBody);
break;
} else {
matched = FALSE;
for (tagExpressionList=theCase->caseTags; tagExpressionList!=NULL;
tagExpressionList=tagExpressionList->nextExpression) {
expansionOff();
tagValue = evaluateExpression(tagExpressionList->
theExpression, NO_FIXUP);
expansionOn();
if (tagValue->kindOfValue != ABSOLUTE_VALUE && tagValue->
kindOfValue != STRING_VALUE) {
error(INVALID_CASE_VALUE_KIND, valueKindString(tagValue->
kindOfValue));
continue;
}
if (tagValue->kindOfValue != switchValue->kindOfValue)
continue;
if (tagValue->kindOfValue == ABSOLUTE_VALUE) {
if (tagValue->value != switchValue->value)
continue;
} else {
if (strcmplc(tagValue->value, switchValue->value) != 0)
continue;
}
matched = TRUE;
break;
}
if (matched) {
assembleBlock(theCase->caseBody);
break;
}
}
}
}
void
assembleMvariableStatement(mvariableStatementBodyType *mvariableStatement)
{
identifierListType *newLocalVariable;
int initCount;
bool saveExpansion;
nullAssemble(mvariableStatement);
expansionOff();
if (mvariableStatement->theDimension == NULL) {
if ((initCount = expressionListLength(mvariableStatement->
theValue)) == 1) {
pushBinding(mvariableStatement->theSymbol,
evaluateExpression(mvariableStatement->
theValue->theExpression, NO_FIXUP),
MVARIABLE_SYMBOL);
} else if (initCount > 1) {
error(TOO_MANY_VARIABLE_INITIALIZERS_ERROR);
} else {
pushBinding(mvariableStatement->theSymbol, NULL,
MVARIABLE_SYMBOL);
}
} else {
pushBinding(mvariableStatement->theSymbol, createArray(
mvariableStatement->theDimension, mvariableStatement->
theValue), MVARIABLE_SYMBOL);
}
expansionOn();
newLocalVariable = typeAlloc(identifierListType);
newLocalVariable->theSymbol = mvariableStatement->theSymbol;
newLocalVariable->nextIdentifier = currentLocalVariableList;
currentLocalVariableList = newLocalVariable;
}
void
assembleMwhileStatement(mwhileStatementBodyType *mwhileStatement)
{
bool saveListingOn;
nullAssemble(mwhileStatement);
saveListingOn = listingOn;
while (booleanTest(mwhileStatement->mwhileCondition)) {
assembleBlock(mwhileStatement->mwhileLoop);
listingOn = amExpanding();
}
listingOn = saveListingOn;
}
void
assembleOrgStatement(orgStatementBodyType *orgStatement)
{
valueType *orgAddress;
bool saveExpansion;
nullAssemble(orgStatement);
targetOffset = 0;
expansionOff();
orgAddress = evaluateExpression(orgStatement, NO_FIXUP);
expansionOn();
if (absoluteValue(orgAddress) || relocatableValue(orgAddress)) {
if (relocatableValue(&currentLocationCounter) &&
absoluteValue(orgAddress)) {
savedRelocatableCurrentLocationCounter =
currentLocationCounter;
currentCodeMode = ABSOLUTE_BUFFER;
}
currentLocationCounter.kindOfValue = orgAddress->kindOfValue;
currentLocationCounter.value = orgAddress->value;
expand((moreText("org\t0x%x", orgAddress->value), endLine()));
} else {
error(BAD_ORG_ADDRESS_ERROR, valueKindString(orgAddress->
kindOfValue));
}
qfree(orgAddress);
}
void
assemblePerformStatement(performStatementBodyType *performStatement)
{
nullAssemble(performStatement);
sideEffectFlag = FALSE;
evaluateExpressionStandalone(performStatement);
if (!sideEffectFlag)
warning(PERFORM_WITHOUT_SIDE_EFFECT_ERROR);
}
void
assembleRelStatement(relStatementBodyType *relStatement)
{
targetOffset = 0;
if (!relocatableValue(&currentLocationCounter)) {
currentLocationCounter =
savedRelocatableCurrentLocationCounter;
currentCodeMode = RELOCATABLE_BUFFER;
}
expand((moreText("rel"), endLine()));
addBreak(BREAK_BREAK, 0);
}
void
assembleStartStatement(startStatementBodyType *startStatement)
{
nullAssemble(startStatement);
expand(moreText("start\t"));
if (haveUserStartAddress) {
expand((moreText("*fail*"), endLine()));
error(START_ADDRESS_ALREADY_GIVEN_ERROR);
} else {
startAddress = evaluateExpression(startStatement,NO_FIXUP_OK);
if (startAddress->kindOfValue == UNDEFINED_VALUE) {
startAddress = (valueType *)generateFixupExpression(
startStatement);
haveUserStartAddress = TRUE;
fixupStartAddress = TRUE;
} else if (startAddress->kindOfValue != ABSOLUTE_VALUE &&
startAddress->kindOfValue!=RELOCATABLE_VALUE){
expand((moreText("*fail*"), endLine()));
error(BAD_START_ADDRESS_ERROR);
} else {
expand((expandExpression(NULL, NULL), endLine()));
haveUserStartAddress = TRUE;
fixupStartAddress = FALSE;
}
}
}
void
assembleStringStatement(stringStatementBodyType *stringStatement)
{
valueType *byteValue;
nullAssemble(stringStatement);
expand(moreText("string\t"));
while (stringStatement != NULL) {
byteValue = evaluateExpression(stringStatement->theExpression,
BYTE_FIXUP);
if (byteValue->kindOfValue == STRING_VALUE) {
emitString(byteValue->value);
emitByte('\0');
} else {
putFixupsHere(BYTE_FIXUP, 0);
emitByteValue(byteValue);
}
qfree(byteValue);
stringStatement = stringStatement->nextExpression;
expand((expandExpression(NULL, NULL), stringStatement != NULL ?
moreText(", ") : 0));
}
expand(endLine());
}
void
assembleStructStatement(structStatementBodyType *structStatement)
{
nullAssemble(structStatement);
if (structStatement->structBody == NULL)
instantiateStruct(structStatement);
else
assembleStructDefinition(structStatement);
}
void
assembleTargetStatement(targetStatementBodyType *targetStatement)
{
valueType *targetAddress;
bool saveExpansion;
nullAssemble(targetStatement);
targetOffset = 0;
expansionOff();
targetAddress = evaluateExpression(targetStatement, NO_FIXUP);
expansionOn();
if (absoluteValue(targetAddress)) {
expand((moreText("target\t0x%x", targetAddress->
value), endLine()));
targetOffset = currentLocationCounter.value -
targetAddress->value;
} else {
error(BAD_TARGET_ADDRESS_ERROR, valueKindString(
targetAddress->kindOfValue));
}
qfree(targetAddress);
}
void
assembleUndefineStatement(undefineStatementBodyType *undefineStatement)
{
expand(moreText("undefine\t"));
while (undefineStatement != NULL) {
expand(moreText("%s", symbName(undefineStatement->theSymbol)));
purgeSymbol(effectiveSymbol(undefineStatement->theSymbol,
NULL));
undefineStatement = undefineStatement->nextIdentifier;
expand(undefineStatement != NULL ? moreText(", ") : 0);
}
expand(endLine());
}
void
assembleVariableStatement(variableStatementBodyType *variableStatement)
{
symbolTableEntryType *newVariable;
symbolInContextType *contextForVariable;
int initCount;
nullAssemble(variableStatement);
newVariable = effectiveSymbol(variableStatement->theSymbol,
&contextForVariable);
if (isPotentialVariable(contextForVariable)) {
expand(moreText("variable %s = ", symbName(newVariable)));
if (contextForVariable->usage == DEAD_SYMBOL) {
reincarnateSymbol(contextForVariable, VARIABLE_SYMBOL);
} else if (contextForVariable->usage == NESTED_UNKNOWN_SYMBOL) {
contextForVariable->usage = VARIABLE_SYMBOL;
}
if (alreadyDefined(contextForVariable)) {
error(REDEFINITION_OF_SYMBOL_ERROR, symbName(newVariable));
} else {
if (variableStatement->theDimension == NULL) {
if ((initCount = expressionListLength(variableStatement->
theValue)) == 1) {
contextForVariable->value = evaluateExpression(
variableStatement->theValue->theExpression, NO_FIXUP);
expand(expandExpression(NULL, NULL));
} else {
if (initCount > 1)
error(TOO_MANY_VARIABLE_INITIALIZERS_ERROR);
expand(moreText("*fail*"));
contextForVariable->value = newValue(FAIL, 0,
EXPRESSION_OPND);
}
} else {
contextForVariable->value = createArray(variableStatement->
theDimension, variableStatement->theValue);
}
contextForVariable->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER;
contextForVariable->attributes |= DEFINED_VARIABLE_ATT;
}
expand(endLine());
} else {
error(SYMBOL_ALREADY_THERE_ERROR, symbName(newVariable));
}
}
void
assembleWhileStatement(whileStatementBodyType *whileStatement)
{
valueType topOfLoop;
valueType fixupLocation[COMPOUND_BRANCH_MAX];
nullAssemble(whileStatement);
if (whileStatement->whileCondition == NEVER_COND) {
return;
} else if (whileStatement->whileCondition != ALWAYS_COND) {
emitRelativeBranch(invertConditionCode(whileStatement->
whileCondition), NULL, fixupLocation);
topOfLoop = currentLocationCounter;
} else {
topOfLoop = currentLocationCounter;
topOfLoop.value -= targetOffset;
}
expand((moreText("while %s {", conditionString(whileStatement->
whileCondition)), endLine(), tabCount++));
assembleBlock(whileStatement->whileLoop);
expand((tabCount--, startLineMarked(), tabIndent(), moreText("}"),
endLine()));
if (whileStatement->whileCondition != ALWAYS_COND) {
emitRelativeBranch(whileStatement->whileCondition, &topOfLoop,
NULL);
fixupBranch(fixupLocation, currentLocationCounter);
} else {
emitJump(&topOfLoop, NULL);
}
}
void
assembleWordStatement(wordStatementBodyType *wordStatement)
{
valueType *word;
nullAssemble(wordStatement);
expand(moreText("word\t"));
while (wordStatement != NULL) {
word = evaluateExpression(wordStatement->theExpression,
WORD_FIXUP);
wordStatement = wordStatement->nextExpression;
expand((expandExpression(NULL, NULL), wordStatement != NULL ?
moreText(", ") : 0));
putFixupsHere(WORD_FIXUP, 0);
emitWordValue(word);
qfree(word);
}
expand(endLine());
}
bool
assembleStatementBody(statementKindType kind, statementBodyType body, int cumulativeLineNumber, bool worryAboutIf, simpleFixupListType **ifFixupList)
{
bool result;
result = TRUE;
if (amListing() && kind != INSTRUCTION_STATEMENT && !beneathFunction)
saveIndexForListing(kind, cumulativeLineNumber);
switch (kind) {
case ALIGN_STATEMENT:
sideEffectBomb();
assembleAlignStatement(body.alignUnion);
if (amListing())
saveIndexForListing(ALIGN_STATEMENT,
cumulativeLineNumber);
break;
case ASSERT_STATEMENT:
assembleAssertStatement(body.assertUnion);
break;
case BLOCK_STATEMENT:
sideEffectBomb();
assembleBlockStatement(body.blockUnion);
break;
case BYTE_STATEMENT:
sideEffectBomb();
assembleByteStatement(body.byteUnion);
break;
case CONSTRAIN_STATEMENT:
sideEffectBomb();
assembleConstrainStatement(body.constrainUnion);
break;
case DBYTE_STATEMENT:
sideEffectBomb();
assembleDbyteStatement(body.dbyteUnion);
break;
case DEFINE_STATEMENT:
sideEffectBomb();
assembleDefineStatement(body.defineUnion);
break;
case DO_UNTIL_STATEMENT:
sideEffectBomb();
assembleDoUntilStatement(body.doUntilUnion);
break;
case DO_WHILE_STATEMENT:
sideEffectBomb();
assembleDoWhileStatement(body.doWhileUnion);
break;
case EXTERN_STATEMENT:
sideEffectBomb();
assembleExternStatement(body.externUnion);
break;
case FRETURN_STATEMENT:
assembleFreturnStatement(body.freturnUnion);
/* result = FALSE;*/
break;
case FUNCTION_STATEMENT:
assembleFunctionStatement(body.functionUnion);
break;
case GROUP_STATEMENT:
assembleGroupStatement(body.groupUnion);
break;
case IF_STATEMENT:
sideEffectBomb();
if (worryAboutIf) {
*ifFixupList = assembleIfStatement(body.ifUnion, worryAboutIf,
*ifFixupList);
} else {
assembleIfStatement(body.ifUnion, worryAboutIf, NULL);
}
break;
case INCLUDE_STATEMENT:
sideEffectBomb();
assembleIncludeStatement(body.includeUnion);
break;
case INSTRUCTION_STATEMENT:
sideEffectBomb();
assembleInstructionStatement(body.instructionUnion, cumulativeLineNumber);
break;
case LONG_STATEMENT:
sideEffectBomb();
assembleLongStatement(body.longUnion);
break;
case MACRO_STATEMENT:
assembleMacroStatement(body.macroUnion);
break;
case MDEFINE_STATEMENT:
assembleMdefineStatement(body.defineUnion);
break;
case MDO_UNTIL_STATEMENT:
assembleMdoUntilStatement(body.mdoUntilUnion);
break;
case MDO_WHILE_STATEMENT:
assembleMdoWhileStatement(body.mdoWhileUnion);
break;
case MFOR_STATEMENT:
assembleMforStatement(body.mforUnion);
break;
case MIF_STATEMENT:
assembleMifStatement(body.mifUnion, cumulativeLineNumber);
break;
case MSWITCH_STATEMENT:
assembleMswitchStatement(body.mswitchUnion);
break;
case MVARIABLE_STATEMENT:
assembleMvariableStatement(body.mvariableUnion);
break;
case MWHILE_STATEMENT:
assembleMwhileStatement(body.mwhileUnion);
break;
case NULL_STATEMENT:
nullStatementFlag = TRUE;
expand(labeledLine() ? (startLineMarked(), expandLabel(),
endLine()) : 0);
break;
case ORG_STATEMENT:
sideEffectBomb();
assembleOrgStatement(body.orgUnion);
if (amListing())
saveIndexForListing(ORG_STATEMENT,
cumulativeLineNumber);
break;
case PERFORM_STATEMENT:
assemblePerformStatement(body.performUnion);
break;
case REL_STATEMENT:
sideEffectBomb();
assembleRelStatement(body.relUnion);
if (amListing())
saveIndexForListing(REL_STATEMENT,
cumulativeLineNumber);
break;
case START_STATEMENT:
assembleStartStatement(body.startUnion);
break;
case STRING_STATEMENT:
sideEffectBomb();
assembleStringStatement(body.stringUnion);
break;
case STRUCT_STATEMENT:
sideEffectBomb();
assembleStructStatement(body.structUnion);
break;
case TARGET_STATEMENT:
sideEffectBomb();
assembleTargetStatement(body.targetUnion);
break;
case UNDEFINE_STATEMENT:
sideEffectBomb();
assembleUndefineStatement(body.undefineUnion);
break;
case VARIABLE_STATEMENT:
sideEffectBomb();
assembleVariableStatement(body.variableUnion);
break;
case WHILE_STATEMENT:
sideEffectBomb();
assembleWhileStatement(body.whileUnion);
break;
case WORD_STATEMENT:
sideEffectBomb();
assembleWordStatement(body.wordUnion);
break;
default:
botch("assembleStatementBody doesn't know kind %d\n", kind, 0, 0);
break;
}
/* return(result);*/
return(!freturnExit);
}
void
assembleLabelList(labelListType *labelList)
{
while (labelList != NULL) {
if (structNestingDepth == 0)
valueLabel(labelList->theLabel,
newValue(currentLocationCounter.kindOfValue,
currentLocationCounter.value,
EXPRESSION_OPND));
else
valueField(labelList->theLabel, newValue(FIELD_VALUE,
currentFieldOffset, EXPRESSION_OPND));
labelList = labelList->nextLabel;
}
}
simpleFixupListType *
assembleStatement(statementType *statement, bool insideIf, simpleFixupListType *ongoingFixupList)
{
char *saveFileName;
int saveLineNumber;
int saveCumulativeLineNumber;
simpleFixupListType *result;
statementEvaluationDepth++;
expand(flushExpressionString());
saveFileName = currentFileName;
saveLineNumber = currentLineNumber;
result = ongoingFixupList;
while (statement != NULL) {
currentFileName = statement->fileName;
currentLineNumber = statement->lineNumber;
expand(listableStatement(statement->kindOfStatement) ?
startLine() : 0);
assembleLabelList(statement->labels);
expand(listableStatement(statement->kindOfStatement) ?
(expandLabel(), tabIndent()) : 0);
if (assembleStatementBody(statement->kindOfStatement,
statement->statementBody, statement->
cumulativeLineNumber, insideIf &&
isLastStatementInBlock(statement), &result)) {
statementType *next = statement->nextStatement;
if (freeFlag && statementEvaluationDepth == 1)
freeStatement(statement);
statement = next;
} else {
if (freeFlag && statementEvaluationDepth == 1)
freeStatement(statement);
freturnExit = TRUE;
break;
}
}
if (!newIncludeFile) {
currentFileName = saveFileName;
currentLineNumber = saveLineNumber;
} else {
newIncludeFile = FALSE;
}
statementEvaluationDepth--;
return(result);
}
void
eatStatement(statementType *statement)
{
if (debug) {
printf("assembling:\n");
printStatement(statement);
}
assembleStatement(statement, FALSE, NULL);
}
Reference in New Issue View Git Blame Copy Permalink