macross/buildStuff1.c

500 lines
14 KiB
C
Raw Normal View History

2016-01-14 15:23:33 +00:00
/*
* 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.
*/
/*
buildStuff1.c -- Routines to build parse-tree structures for the
Macross assembler. This module is target processor
independent.
Chip Morningstar -- Lucasfilm Ltd.
1-November-1984
*/
#include "macrossTypes.h"
#include "macrossGlobals.h"
#include "errorStuff.h"
#include "lookups.h"
#include "parserMisc.h"
/* Generic routine to create statement nodes */
statementType *
newStatement(statementKindType kind, statementBodyType body)
{
statementType *result;
result = typeAlloc(statementType);
result->kindOfStatement = kind;
result->labels = NULL;
result->statementBody = body;
result->nextStatement = NULL;
result->fileName = currentFileName;
result->lineNumber = currentLineNumber;
result->cumulativeLineNumber = cumulativeLineNumber;
return(result);
}
/*
These routines specifically build top-level parse-tree nodes corresponding
to the different types of Macross statements. There is one such routine of
the form "buildXxxxStatement" for each kind of Macross statement.
*/
statementType *
buildAlignStatement(expressionType *expression)
{
return(newStatement(ALIGN_STATEMENT,
(statementBodyType) expression));
}
statementType *
buildAssertStatement(expressionType *condition, expressionType *message)
{
assertStatementBodyType *result;
result = typeAlloc(assertStatementBodyType);
result->condition = condition;
result->message = message;
return(newStatement(ASSERT_STATEMENT, (statementBodyType) result));
}
statementType *
buildBlockStatement(expressionListType *expressionList)
{
return(newStatement(BLOCK_STATEMENT,
(statementBodyType) expressionList));
}
statementType *
buildByteStatement(expressionListType *expressionList)
{
return(newStatement(BYTE_STATEMENT,
(statementBodyType) expressionList));
}
statementType *
buildConstrainStatement(expressionType *expression, blockType *block)
{
constrainStatementBodyType *result;
result = typeAlloc(constrainStatementBodyType);
result->constraint = expression;
result->constrainedBlock = block;
return(newStatement(CONSTRAIN_STATEMENT, (statementBodyType) result));
}
statementType *
buildDbyteStatement(expressionListType *expressionList)
{
return(newStatement(DBYTE_STATEMENT,
(statementBodyType) expressionList));
}
statementType *
buildDefineStatement(stringType *name, expressionType *value)
{
defineStatementBodyType *result;
result = typeAlloc(defineStatementBodyType);
result->theSymbol = lookupOrEnterSymbol(name, UNKNOWN_SYMBOL);
result->theValue = value;
return(newStatement(DEFINE_STATEMENT, (statementBodyType) result));
}
statementType *
buildDoUntilStatement(blockType *body, conditionType condition)
{
doUntilStatementBodyType *result;
result = typeAlloc(doUntilStatementBodyType);
result->doUntilCondition = condition;
result->doUntilLoop = body;
return(newStatement(DO_UNTIL_STATEMENT, (statementBodyType) result));
}
statementType *
buildDoWhileStatement(blockType *body, conditionType condition)
{
doWhileStatementBodyType *result;
result = typeAlloc(doWhileStatementBodyType);
result->doWhileCondition = condition;
result->doWhileLoop = body;
return(newStatement(DO_WHILE_STATEMENT, (statementBodyType) result));
}
statementType *
buildDoStatement(blockType *body, doEndType *end)
{
statementType *result;
if (end->doEndKind == UNTIL_END)
result = buildDoUntilStatement(body, end->doEndCondition);
else if (end->doEndKind == WHILE_END)
result = buildDoWhileStatement(body, end->doEndCondition);
else
botch("bad do-end kind: %d\n", end->doEndCondition);
qfree(end);
return(result);
}
statementType *
buildExternStatement(identifierListType *identifierList)
{
return(newStatement(EXTERN_STATEMENT,
(statementBodyType) identifierList));
}
statementType *
buildFreturnStatement(expressionType *expression)
{
return(newStatement(FRETURN_STATEMENT,
(statementBodyType) expression));
}
statementType *
buildFunctionStatement(stringType *name, argumentDefinitionListType *arguments, blockType *body)
{
functionStatementBodyType *result;
symbolTableEntryType *testSymbol;
testSymbol = lookupOrEnterSymbol(name, FUNCTION_SYMBOL);
if (testSymbol->context->usage != FUNCTION_SYMBOL && testSymbol->
context->usage != UNKNOWN_FUNCTION_SYMBOL) {
error(SYMBOL_ALREADY_THERE_ERROR, symbName(testSymbol));
return(NULL);
}
result = typeAlloc(functionStatementBodyType);
result->functionName = saveString(name);
result->theArguments = arguments;
result->theBlock = body;
return(newStatement(FUNCTION_STATEMENT, (statementBodyType) result));
}
statementType *
buildGroupStatement(blockType *block)
{
return(newStatement(GROUP_STATEMENT,
(statementBodyType) block));
}
statementType *
buildIfStatement(ifHeadType *head, ifContinuationType continuation, ifContinuationKindType continuationKind)
{
ifStatementBodyType *result;
result = typeAlloc(ifStatementBodyType);
result->ifCondition = head->headCondition;
result->consequence = head->headBody;
if (continuationKind == NO_CONTINUATION)
result->continuation.blockUnion = NULL;
else if (continuationKind == ELSE_CONTINUATION) {
result->continuation.continuationBodyUnion =
typeAlloc(ifContinuationBodyType);
result->continuation.continuationBodyUnion->ifCondition =
ALWAYS_COND;
result->continuation.continuationBodyUnion->consequence =
continuation.blockUnion;
result->continuation.continuationBodyUnion->
continuation.continuationBodyUnion = NULL;
} else if (continuationKind == ELSEIF_CONTINUATION)
result->continuation = continuation;
else
botch("bad continuation kind: %d\n", continuationKind);
qfree(head);
return(newStatement(IF_STATEMENT, (statementBodyType) result));
}
statementType *
buildIncludeStatement(expressionType *filename)
{
return(newStatement(INCLUDE_STATEMENT,
(statementBodyType) filename));
}
statementType *
buildInstructionStatement(opcodeTableEntryType *opcode, operandListType *operands)
{
instructionStatementBodyType *result;
result = typeAlloc(instructionStatementBodyType);
result->kindOfInstruction = OPCODE_INSTRUCTION;
result->theInstruction.opcodeUnion = opcode;
result->theOperands = operands;
return(newStatement(INSTRUCTION_STATEMENT, (statementBodyType) result));
}
statementType *
buildLongStatement(expressionListType *expressionList)
{
return(newStatement(LONG_STATEMENT,
(statementBodyType) expressionList));
}
statementType *
buildMacroStatement(macroTableEntryType *macro, argumentDefinitionListType *arguments, blockType *body)
{
macroStatementBodyType *result;
result = typeAlloc(macroStatementBodyType);
result->theMacro = macro;
result->theArguments = arguments;
result->theBlock = body;
return(newStatement(MACRO_STATEMENT, (statementBodyType) result));
}
statementType *
buildMacroInstructionStatement(macroTableEntryType *macro, operandListType *operands)
{
instructionStatementBodyType *result;
result = typeAlloc(instructionStatementBodyType);
result->kindOfInstruction = MACRO_INSTRUCTION;
result->theInstruction.macroUnion = macro;
result->theOperands = operands;
return(newStatement(INSTRUCTION_STATEMENT, (statementBodyType) result));
}
statementType *
buildMdefineStatement(stringType *name, expressionType *value)
{
mdefineStatementBodyType *result;
result = typeAlloc(mdefineStatementBodyType);
result->theSymbol = lookupOrEnterSymbol(name, DEAD_SYMBOL);
result->theValue = value;
return(newStatement(MDEFINE_STATEMENT, (statementBodyType) result));
}
statementType *
buildMdoUntilStatement(blockType *body, struct expressionTermStruct *condition)
{
mdoUntilStatementBodyType *result;
result = typeAlloc(mdoUntilStatementBodyType);
result->mdoUntilCondition = condition;
result->mdoUntilLoop = body;
return(newStatement(MDO_UNTIL_STATEMENT, (statementBodyType) result));
}
statementType *
buildMdoWhileStatement(blockType *body, expressionType *condition)
{
mdoWhileStatementBodyType *result;
result = typeAlloc(mdoWhileStatementBodyType);
result->mdoWhileCondition = condition;
result->mdoWhileLoop = body;
return(newStatement(MDO_WHILE_STATEMENT, (statementBodyType) result));
}
statementType *
buildMdoStatement(blockType *body, mdoEndType *end)
{
statementType *result;
if (end->mdoEndKind == UNTIL_END)
result = buildMdoUntilStatement(body, end->mdoEndCondition);
else if (end->mdoEndKind == WHILE_END)
result = buildMdoWhileStatement(body, end->mdoEndCondition);
else
botch("bad mdo-end kind: %d\n", end->mdoEndCondition);
qfree(end);
return(result);
}
statementType *
buildMforStatement(forExpressionsType *forExpressions, blockType *body)
{
mforStatementBodyType *result;
result = typeAlloc(mforStatementBodyType);
result->initExpression = forExpressions->initExpression;
result->testExpression = forExpressions->testExpression;
result->incrExpression = forExpressions->incrExpression;
result->forLoop = body;
qfree(forExpressions);
return(newStatement(MFOR_STATEMENT, (statementBodyType) result));
}
statementType *
buildMifStatement(mifHeadType *head, mifContinuationType continuation, ifContinuationKindType continuationKind)
{
mifStatementBodyType *result;
result = typeAlloc(mifStatementBodyType);
result->mifCondition = head->headCondition;
result->mifConsequence = head->headBody;
if (continuationKind == NO_CONTINUATION)
result->mifContinuation.mifContinuationBodyUnion = NULL;
else if (continuationKind == ELSE_CONTINUATION) {
result->mifContinuation.mifContinuationBodyUnion =
typeAlloc(mifContinuationBodyType);
result->mifContinuation.mifContinuationBodyUnion->
mifCondition = NULL;
result->mifContinuation.mifContinuationBodyUnion->
mifConsequence = continuation.mifBlockUnion;
result->mifContinuation.mifContinuationBodyUnion->
mifContinuation.mifContinuationBodyUnion = NULL;
} else if (continuationKind == ELSEIF_CONTINUATION)
result->mifContinuation = continuation;
else
botch("bad mif continuation kind: %d\n", continuationKind);
qfree(head);
return(newStatement(MIF_STATEMENT, (statementBodyType) result));
}
statementType *
buildMswitchStatement(expressionType *switchExpression, caseListType *cases)
{
mswitchStatementBodyType *result;
result = typeAlloc(mswitchStatementBodyType);
result->switchExpression = switchExpression;
result->cases = cases;
return(newStatement(MSWITCH_STATEMENT, (statementBodyType) result));
}
statementType *
buildMvariableStatement(stringType *name, expressionListType *value, expressionType *dimension)
{
mvariableStatementBodyType *result;
result = typeAlloc(mvariableStatementBodyType);
result->theSymbol = lookupOrEnterSymbol(name, DEAD_SYMBOL);
result->theValue = value;
result->theDimension = dimension;
return(newStatement(MVARIABLE_STATEMENT, (statementBodyType) result));
}
statementType *
buildMwhileStatement(expressionType *condition, blockType *body)
{
mwhileStatementBodyType *result;
result = typeAlloc(mwhileStatementBodyType);
result->mwhileCondition = condition;
result->mwhileLoop = body;
return(newStatement(MWHILE_STATEMENT, (statementBodyType) result));
}
statementType *
buildNullStatement(void)
{
return(newStatement(NULL_STATEMENT, (statementBodyType){ .ifUnion = NULL }));
}
statementType *
buildOrgStatement(expressionType *expression)
{
return(newStatement(ORG_STATEMENT,
(statementBodyType) expression));
}
statementType *
buildPerformStatement(expressionType *expression)
{
return(newStatement(PERFORM_STATEMENT,
(statementBodyType) expression));
}
statementType *
buildRelStatement(void)
{
return(newStatement(REL_STATEMENT, (statementBodyType){ .ifUnion = NULL }));
}
statementType *
buildStartStatement(expressionType *expression)
{
return(newStatement(START_STATEMENT,
(statementBodyType) expression));
}
statementType *
buildStringStatement(expressionListType *expressionList)
{
return(newStatement(STRING_STATEMENT,
(statementBodyType) expressionList));
}
statementType *
buildStructStatement(symbolTableEntryType *name, blockType *body)
{
structStatementBodyType *result;
result = typeAlloc(structStatementBodyType);
result->structBody = body;
result->structName = name;
return(newStatement(STRUCT_STATEMENT, (statementBodyType) result));
}
statementType *
buildTargetStatement(expressionType *expression)
{
return(newStatement(TARGET_STATEMENT,
(statementBodyType) expression));
}
statementType *
buildUndefineStatement(identifierListType *identifierList)
{
return(newStatement(UNDEFINE_STATEMENT,
(statementBodyType) identifierList));
}
statementType *
buildVariableStatement(stringType *name, expressionListType *value, expressionType *dimension)
{
variableStatementBodyType *result;
result = typeAlloc(variableStatementBodyType);
result->theSymbol = lookupOrEnterSymbol(name, VARIABLE_SYMBOL);
result->theValue = value;
result->theDimension = dimension;
return(newStatement(VARIABLE_STATEMENT, (statementBodyType) result));
}
statementType *
buildWhileStatement(conditionType condition, blockType *body)
{
whileStatementBodyType *result;
result = typeAlloc(whileStatementBodyType);
result->whileCondition = condition;
result->whileLoop = body;
return(newStatement(WHILE_STATEMENT, (statementBodyType) result));
}
statementType *
buildWordStatement(expressionListType *expressionList)
{
return(newStatement(WORD_STATEMENT,
(statementBodyType) expressionList));
}