macross/garbage.c

851 lines
17 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.
*/
/*
garbage.c -- Routines to eat up a parse tree and throw it away
Chip Morningstar -- Lucasfilm Ltd.
4-February-1985
*/
#include "macrossTypes.h"
#include "macrossGlobals.h"
#include "y.tab.h"
#define nullFree(thing) if (thing == NULL) return;
void
freeArrayTerm(arrayTerm)
arrayTermType *arrayTerm;
{
void freeExpression();
nullFree(arrayTerm);
freeExpression(arrayTerm->arrayName);
freeExpression(arrayTerm->arrayIndex);
free(arrayTerm);
}
void
freeAssignmentTerm(assignmentTerm)
binopTermType *assignmentTerm;
{
void freeExpression();
nullFree(assignmentTerm);
freeExpression(assignmentTerm->rightArgument);
free(assignmentTerm);
}
void
freeBinopTerm(binopTerm)
binopTermType *binopTerm;
{
void freeExpression();
nullFree(binopTerm);
freeExpression(binopTerm->leftArgument);
if (binopTerm->binop != SELECT)
freeExpression(binopTerm->rightArgument);
free(binopTerm);
}
void
freeFunctionCall(functionCall)
functionCallTermType *functionCall;
{
void freeOperandList();
nullFree(functionCall);
freeOperandList(functionCall->parameters);
free(functionCall);
}
void
freePostopTerm(postopTerm)
postOpTermType *postopTerm;
{
nullFree(postopTerm);
free(postopTerm);
}
void
freePreopTerm(preopTerm)
preOpTermType *preopTerm;
{
nullFree(preopTerm);
free(preopTerm);
}
void
freeString(string)
stringType *string;
{
nullFree(string);
free(string);
}
void
freeUnopTerm(unopTerm)
unopTermType *unopTerm;
{
void freeExpression();
nullFree(unopTerm);
freeExpression(unopTerm->unopArgument);
free(unopTerm);
}
void
freeExpression(expression)
expressionType *expression;
{
nullFree(expression);
switch (expression->kindOfTerm) {
case CONDITION_CODE_EXPR:
case HERE_EXPR:
case IDENTIFIER_EXPR:
case NUMBER_EXPR:
case VALUE_EXPR:
case STRING_EXPR:
break;
case ARRAY_EXPR:
freeArrayTerm(expression->expressionTerm.arrayUnion);
break;
case ASSIGN_EXPR:
freeAssignmentTerm(expression->expressionTerm.binopUnion);
break;
case BINOP_EXPR:
freeBinopTerm(expression->expressionTerm.binopUnion);
break;
case FUNCTION_CALL_EXPR:
freeFunctionCall(expression->expressionTerm.functionCallUnion);
break;
case POSTOP_EXPR:
freePostopTerm(expression->expressionTerm.postOpUnion);
break;
case PREOP_EXPR:
freePreopTerm(expression->expressionTerm.preOpUnion);
break;
case SUBEXPRESSION_EXPR:
freeExpression(expression->expressionTerm.expressionUnion);
break;
case UNOP_EXPR:
freeUnopTerm(expression->expressionTerm.unopUnion);
break;
default:
botch("freeExpression: funny expression kind %d\n",
expression->kindOfTerm);
break;
}
free(expression);
}
void
freeExpressionList(expressionList)
expressionListType *expressionList;
{
expressionListType *newExpressionList;
while (expressionList != NULL) {
freeExpression(expressionList->theExpression);
newExpressionList = expressionList->nextExpression;
free(expressionList);
expressionList = newExpressionList;
}
}
void
freeIdentifierList(identifierList)
identifierListType *identifierList;
{
identifierListType *newIdentifierList;
while (identifierList != NULL) {
newIdentifierList = identifierList->nextIdentifier;
free(identifierList);
identifierList = newIdentifierList;
}
}
void
freeSelectionList(selectionList)
selectionListType *selectionList;
{
freeIdentifierList(selectionList);
}
void
freeBlock(block)
blockType *block;
{
void freeStatement();
nullFree(block);
freeStatement(block);
}
void
freeCase(aCase)
caseType *aCase;
{
freeExpressionList(aCase->caseTags);
freeBlock(aCase->caseBody);
free(aCase);
}
void
freeCaseList(caseList)
caseListType *caseList;
{
caseListType *newCaseList;
while (caseList != NULL) {
freeCase(caseList->theCase);
newCaseList = caseList->nextCase;
free(caseList);
caseList = newCaseList;
}
}
void
freeOperandList(operandList)
operandListType *operandList;
{
freeOperand(operandList);
}
void
freeMacro(operands)
operandListType *operands;
{
freeOperandList(operands);
}
void
freeMachineInstruction(operands)
operandListType *operands;
{
freeOperandList(operands);
}
void
freeAlignStatement(alignStatement)
alignStatementBodyType *alignStatement;
{
nullFree(alignStatement);
freeExpression(alignStatement);
}
void
freeAssertStatement(assertStatement)
assertStatementBodyType *assertStatement;
{
nullFree(assertStatement);
freeExpression(assertStatement->condition);
freeExpression(assertStatement->message);
free(assertStatement);
}
void
freeBlockStatement(blockStatement)
blockStatementBodyType *blockStatement;
{
nullFree(blockStatement);
freeExpressionList(blockStatement);
}
void
freeByteStatement(byteStatement)
byteStatementBodyType *byteStatement;
{
byteStatementBodyType *newByteStatement;
nullFree(byteStatement);
while (byteStatement != NULL) {
freeExpression(byteStatement->theExpression);
newByteStatement = byteStatement->nextExpression;
free(byteStatement);
byteStatement = newByteStatement;
}
}
void
freeConstrainStatement(constrainStatement)
constrainStatementBodyType *constrainStatement;
{
nullFree(constrainStatement);
freeExpression(constrainStatement->constraint);
freeBlock(constrainStatement->constrainedBlock);
free(constrainStatement);
}
void
freeDbyteStatement(dbyteStatement)
dbyteStatementBodyType *dbyteStatement;
{
dbyteStatementBodyType *newDbyteStatement;
nullFree(dbyteStatement);
while (dbyteStatement != NULL) {
freeExpression(dbyteStatement->theExpression);
newDbyteStatement = dbyteStatement->nextExpression;
free(dbyteStatement);
dbyteStatement = newDbyteStatement;
}
}
void
freeDefineStatement(defineStatement)
defineStatementBodyType *defineStatement;
{
nullFree(defineStatement);
freeExpression(defineStatement->theValue);
free(defineStatement);
}
void
freeDoUntilStatement(doUntilStatement)
doUntilStatementBodyType *doUntilStatement;
{
nullFree(doUntilStatement);
freeBlock(doUntilStatement->doUntilLoop);
free(doUntilStatement);
}
void
freeDoWhileStatement(doWhileStatement)
doWhileStatementBodyType *doWhileStatement;
{
nullFree(doWhileStatement);
freeBlock(doWhileStatement->doWhileLoop);
free(doWhileStatement);
}
void
freeExternStatement(externStatement)
externStatementBodyType *externStatement;
{
freeIdentifierList(externStatement);
}
void
freeFreturnStatement(freturnStatement)
freturnStatementBodyType *freturnStatement;
{
nullFree(freturnStatement);
freeExpression(freturnStatement);
}
void
freeFunctionStatement(functionStatement)
functionStatementBodyType *functionStatement;
{
nullFree(functionStatement);
free(functionStatement->functionName);
free(functionStatement);
}
void
freeIfStatement(ifStatement)
ifStatementBodyType *ifStatement;
{
nullFree(ifStatement);
if (ifStatement->consequence != NULL)
freeBlock(ifStatement->consequence);
if (ifStatement->continuation.continuationBodyUnion != NULL) {
freeIfStatement((void *)ifStatement->continuation.blockUnion);
}
free(ifStatement);
}
void
freeIncludeStatement(includeStatement)
includeStatementBodyType *includeStatement;
{
nullFree(includeStatement);
freeExpression(includeStatement);
}
void
freeInstructionStatement(instructionStatement)
instructionStatementBodyType *instructionStatement;
{
nullFree(instructionStatement);
switch(instructionStatement->kindOfInstruction) {
case OPCODE_INSTRUCTION:
freeMachineInstruction(instructionStatement->theOperands);
break;
case MACRO_INSTRUCTION:
freeMacro(instructionStatement->theOperands);
break;
default:
botch("bad instruction type=%d\n", instructionStatement->
kindOfInstruction);
break;
}
}
void
freeLongStatement(longStatement)
longStatementBodyType *longStatement;
{
longStatementBodyType *newLongStatement;
nullFree(longStatement);
while (longStatement != NULL) {
freeExpression(longStatement->theExpression);
newLongStatement = longStatement->nextExpression;
free(longStatement);
longStatement = newLongStatement;
}
}
void
freeMacroStatement(macroStatement)
macroStatementBodyType *macroStatement;
{
nullFree(macroStatement);
free(macroStatement);
}
void
freeMdefineStatement(mdefineStatement)
defineStatementBodyType *mdefineStatement; // MIST: shouldn't this be "mdefineStatementBodyType"?
{
valueType *freeDefineExpression();
nullFree(mdefineStatement);
freeExpression(mdefineStatement->theValue);
free(mdefineStatement);
}
void
freeMdoUntilStatement(mdoUntilStatement)
mdoUntilStatementBodyType *mdoUntilStatement;
{
nullFree(mdoUntilStatement);
freeBlock(mdoUntilStatement->mdoUntilLoop);
freeExpression(mdoUntilStatement->mdoUntilCondition);
}
void
freeMdoWhileStatement(mdoWhileStatement)
mdoWhileStatementBodyType *mdoWhileStatement;
{
nullFree(mdoWhileStatement);
freeBlock(mdoWhileStatement->mdoWhileLoop);
freeExpression(mdoWhileStatement->mdoWhileCondition);
free(mdoWhileStatement);
}
void
freeMifStatement(mifStatement)
mifStatementBodyType *mifStatement;
{
nullFree(mifStatement);
freeExpression(mifStatement->mifCondition);
freeBlock(mifStatement->mifConsequence);
freeMifStatement(mifStatement->mifContinuation.
mifContinuationBodyUnion);
free(mifStatement);
}
void
freeMswitchStatement(mswitchStatement)
mswitchStatementBodyType *mswitchStatement;
{
freeExpression(mswitchStatement->switchExpression);
freeCaseList(mswitchStatement->cases);
free(mswitchStatement);
}
void
freeMforStatement(mforStatement)
mforStatementBodyType *mforStatement;
{
nullFree(mforStatement);
freeExpression(mforStatement->initExpression);
freeExpression(mforStatement->testExpression);
freeExpression(mforStatement->incrExpression);
freeBlock(mforStatement->forLoop);
free(mforStatement);
}
void
freeMvariableStatement(mvariableStatement)
mvariableStatementBodyType *mvariableStatement;
{
nullFree(mvariableStatement);
if ((int)mvariableStatement->theDimension != -1)
freeExpression(mvariableStatement->theDimension);
freeExpressionList(mvariableStatement->theValue);
free(mvariableStatement);
}
void
freeMwhileStatement(mwhileStatement)
mwhileStatementBodyType *mwhileStatement;
{
nullFree(mwhileStatement);
freeExpression(mwhileStatement->mwhileCondition);
freeBlock(mwhileStatement->mwhileLoop);
free(mwhileStatement);
}
void
freeOrgStatement(orgStatement)
orgStatementBodyType *orgStatement;
{
nullFree(orgStatement);
freeExpression(orgStatement);
}
void
freePerformStatement(performStatement)
performStatementBodyType *performStatement;
{
nullFree(performStatement);
freeExpression(performStatement);
}
void
freeRelStatement(relStatement)
relStatementBodyType *relStatement;
{
}
void
freeStartStatement(startStatement)
startStatementBodyType *startStatement;
{
nullFree(startStatement);
freeExpression(startStatement);
}
void
freeStringStatement(stringStatement)
stringStatementBodyType *stringStatement;
{
stringStatementBodyType *newStringStatement;
nullFree(stringStatement);
while (stringStatement != NULL) {
freeExpression(stringStatement->theExpression);
newStringStatement = stringStatement->nextExpression;
free(stringStatement);
stringStatement = newStringStatement;
}
}
void
freeStructStatement(structStatement)
structStatementBodyType *structStatement;
{
nullFree(structStatement);
freeBlock(structStatement->structBody);
free(structStatement);
}
void
freeTargetStatement(targetStatement)
targetStatementBodyType *targetStatement;
{
nullFree(targetStatement);
freeExpression(targetStatement);
}
void
freeUndefineStatement(undefineStatement)
undefineStatementBodyType *undefineStatement;
{
freeIdentifierList(undefineStatement);
}
void
freeVariableStatement(variableStatement)
variableStatementBodyType *variableStatement;
{
nullFree(variableStatement);
if ((int)variableStatement->theDimension != -1)
freeExpression(variableStatement->theDimension);
freeExpressionList(variableStatement->theValue);
free(variableStatement);
}
void
freeWhileStatement(whileStatement)
whileStatementBodyType *whileStatement;
{
nullFree(whileStatement);
freeBlock(whileStatement->whileLoop);
free(whileStatement);
}
void
freeWordStatement(wordStatement)
wordStatementBodyType *wordStatement;
{
wordStatementBodyType *newWordStatement;
nullFree(wordStatement);
while (wordStatement != NULL) {
freeExpression(wordStatement->theExpression);
newWordStatement = wordStatement->nextExpression;
free(wordStatement);
wordStatement = newWordStatement;
}
}
void
freeStatementBody(kind, body)
statementKindType kind;
statementBodyType body;
{
switch (kind) {
case ALIGN_STATEMENT:
freeAlignStatement(body.alignUnion);
break;
case ASSERT_STATEMENT:
freeAssertStatement(body.assertUnion);
break;
case BLOCK_STATEMENT:
freeBlockStatement(body.blockUnion);
break;
case BYTE_STATEMENT:
freeByteStatement(body.byteUnion);
break;
case CONSTRAIN_STATEMENT:
freeConstrainStatement(body.constrainUnion);
break;
case DBYTE_STATEMENT:
freeDbyteStatement(body.dbyteUnion);
break;
case DEFINE_STATEMENT:
freeDefineStatement(body.defineUnion);
break;
case DO_UNTIL_STATEMENT:
freeDoUntilStatement(body.doUntilUnion);
break;
case DO_WHILE_STATEMENT:
freeDoWhileStatement(body.doWhileUnion);
break;
case EXTERN_STATEMENT:
freeExternStatement(body.externUnion);
break;
case FRETURN_STATEMENT:
freeFreturnStatement(body.freturnUnion);
break;
case FUNCTION_STATEMENT:
freeFunctionStatement(body.functionUnion);
break;
case GROUP_STATEMENT:
freeBlock(body.groupUnion);
break;
case IF_STATEMENT:
freeIfStatement(body.ifUnion);
break;
case INCLUDE_STATEMENT:
freeIncludeStatement(body.includeUnion);
break;
case INSTRUCTION_STATEMENT:
freeInstructionStatement(body.instructionUnion);
break;
case LONG_STATEMENT:
freeLongStatement(body.longUnion);
break;
case MACRO_STATEMENT:
freeMacroStatement(body.macroUnion);
break;
case MDEFINE_STATEMENT:
freeMdefineStatement(body.defineUnion);
break;
case MDO_UNTIL_STATEMENT:
freeMdoUntilStatement(body.mdoUntilUnion);
break;
case MDO_WHILE_STATEMENT:
freeMdoWhileStatement(body.mdoWhileUnion);
break;
case MIF_STATEMENT:
freeMifStatement(body.mifUnion);
break;
case MSWITCH_STATEMENT:
freeMswitchStatement(body.mswitchUnion);
break;
case MFOR_STATEMENT:
freeMforStatement(body.mforUnion);
break;
case MVARIABLE_STATEMENT:
freeMvariableStatement(body.mvariableUnion);
break;
case MWHILE_STATEMENT:
freeMwhileStatement(body.mwhileUnion);
break;
case NULL_STATEMENT:
/* do nothing */
break;
case ORG_STATEMENT:
freeOrgStatement(body.orgUnion);
break;
case PERFORM_STATEMENT:
freePerformStatement(body.performUnion);
break;
case REL_STATEMENT:
freeRelStatement(body.relUnion);
break;
case START_STATEMENT:
freeStartStatement(body.startUnion);
break;
case STRING_STATEMENT:
freeStringStatement(body.stringUnion);
break;
case STRUCT_STATEMENT:
freeStructStatement(body.structUnion);
break;
case TARGET_STATEMENT:
freeTargetStatement(body.targetUnion);
break;
case UNDEFINE_STATEMENT:
freeUndefineStatement(body.undefineUnion);
break;
case VARIABLE_STATEMENT:
freeVariableStatement(body.variableUnion);
break;
case WHILE_STATEMENT:
freeWhileStatement(body.whileUnion);
break;
case WORD_STATEMENT:
freeWordStatement(body.wordUnion);
break;
default:
botch("freeStatementBody doesn't know kind %d\n", kind);
break;
}
}
void
freeLabelList(labelList)
labelListType *labelList;
{
labelListType *nextLabel;
while (labelList != NULL) {
nextLabel = labelList->nextLabel;
free(labelList);
labelList = nextLabel;
}
}
void
freeStatement(statement)
statementType *statement;
{
statementType *newStatement;
while (statement != NULL) {
freeLabelList(statement->labels);
freeStatementBody(statement->kindOfStatement, statement->
statementBody);
newStatement = statement->nextStatement;
free(statement);
statement = newStatement;
}
}
void
freeArray(array)
arrayType *array;
{
int i;
void freeValue();
if (array->arraySize > 0) {
for (i=0; i<array->arraySize; i++)
freeValue((array->arrayContents)[i]);
free(array->arrayContents);
}
free(array);
}
void
freeValue(value)
valueType *value;
{
if (value->kindOfValue == STRING_VALUE)
freeString(value->value);
else if (value->kindOfValue == ARRAY_VALUE)
freeArray(value->value);
free(value);
}