macross/garbage.c

/*
 * 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 "garbage.h"
#include "operandStuff.h"
#include "parserMisc.h"
#include "y.tab.h"

#define nullFree(thing) if (thing == NULL) return;

void
freeArrayTerm(arrayTermType *arrayTerm)
{
	nullFree(arrayTerm);
	freeExpression(arrayTerm->arrayName);
	freeExpression(arrayTerm->arrayIndex);
	free(arrayTerm);
}

  void
freeAssignmentTerm(binopTermType *assignmentTerm)
{
	nullFree(assignmentTerm);
	freeExpression(assignmentTerm->rightArgument);
	free(assignmentTerm);
}

  void
freeBinopTerm(binopTermType *binopTerm)
{
	nullFree(binopTerm);
	freeExpression(binopTerm->leftArgument);
	if (binopTerm->binop != SELECT)
		freeExpression(binopTerm->rightArgument);
	free(binopTerm);
}

  void
freeFunctionCall(functionCallTermType *functionCall)
{
	nullFree(functionCall);
	freeOperandList(functionCall->parameters);
	free(functionCall);
}

  void
freePostopTerm(postOpTermType *postopTerm)
{
	nullFree(postopTerm);
	free(postopTerm);
}

  void
freePreopTerm(preOpTermType *preopTerm)
{
	nullFree(preopTerm);
	free(preopTerm);
}

  void
freeString(stringType *string)
{
	nullFree(string);
	free(string);
}

  void
freeUnopTerm(unopTermType *unopTerm)
{
	nullFree(unopTerm);
	freeExpression(unopTerm->unopArgument);
	free(unopTerm);
}

  void
freeExpression(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(expressionListType *expressionList)
{
	expressionListType	*newExpressionList;

	while (expressionList != NULL) {
		freeExpression(expressionList->theExpression);
		newExpressionList = expressionList->nextExpression;
		free(expressionList);
		expressionList = newExpressionList;
	}
}

  void
freeIdentifierList(identifierListType *identifierList)
{
	identifierListType	*newIdentifierList;

	while (identifierList != NULL) {
		newIdentifierList = identifierList->nextIdentifier;
		free(identifierList);
		identifierList = newIdentifierList;
	}
}

  void
freeSelectionList(selectionListType *selectionList)
{
	freeIdentifierList(selectionList);
}

  void
freeBlock(blockType *block)
{
	void	freeStatement(statementType *statement);

	nullFree(block);
	freeStatement(block);
}

  void
freeCase(caseType *aCase)
{
	freeExpressionList(aCase->caseTags);
	freeBlock(aCase->caseBody);
	free(aCase);
}

  void
freeCaseList(caseListType *caseList)
{
	caseListType	*newCaseList;

	while (caseList != NULL) {
		freeCase(caseList->theCase);
		newCaseList = caseList->nextCase;
		free(caseList);
		caseList = newCaseList;
	}
}

  void
freeOperandList(operandListType *operandList)
{
	freeOperand(operandList);
}

  void
freeMacro(operandListType *operands)
{
	freeOperandList(operands);
}

  void
freeMachineInstruction(operandListType *operands)
{
	freeOperandList(operands);
}

  void
freeAlignStatement(alignStatementBodyType *alignStatement)
{
	nullFree(alignStatement);
	freeExpression(alignStatement);
}

  void
freeAssertStatement(assertStatementBodyType *assertStatement)
{
	nullFree(assertStatement);
	freeExpression(assertStatement->condition);
	freeExpression(assertStatement->message);
	free(assertStatement);
}

  void
freeBlockStatement(blockStatementBodyType *blockStatement)
{
	nullFree(blockStatement);
	freeExpressionList(blockStatement);
}

  void
freeByteStatement(byteStatementBodyType *byteStatement)
{
	byteStatementBodyType	*newByteStatement;

	nullFree(byteStatement);
	while (byteStatement != NULL) {
		freeExpression(byteStatement->theExpression);
		newByteStatement = byteStatement->nextExpression;
		free(byteStatement);
		byteStatement = newByteStatement;
	}
}

  void
freeConstrainStatement(constrainStatementBodyType *constrainStatement)
{
	nullFree(constrainStatement);
	freeExpression(constrainStatement->constraint);
	freeBlock(constrainStatement->constrainedBlock);
	free(constrainStatement);
}

  void
freeDbyteStatement(dbyteStatementBodyType *dbyteStatement)
{
	dbyteStatementBodyType	*newDbyteStatement;

	nullFree(dbyteStatement);
	while (dbyteStatement != NULL) {
		freeExpression(dbyteStatement->theExpression);
		newDbyteStatement = dbyteStatement->nextExpression;
		free(dbyteStatement);
		dbyteStatement = newDbyteStatement;
	}
}

  void
freeDefineStatement(defineStatementBodyType *defineStatement)
{
	nullFree(defineStatement);
	freeExpression(defineStatement->theValue);
	free(defineStatement);
}

  void
freeDoUntilStatement(doUntilStatementBodyType *doUntilStatement)
{
	nullFree(doUntilStatement);
	freeBlock(doUntilStatement->doUntilLoop);
	free(doUntilStatement);
}

  void
freeDoWhileStatement(doWhileStatementBodyType *doWhileStatement)
{
	nullFree(doWhileStatement);
	freeBlock(doWhileStatement->doWhileLoop);
	free(doWhileStatement);
}

  void
freeExternStatement(externStatementBodyType *externStatement)
{
	freeIdentifierList(externStatement);
}

  void
freeFreturnStatement(freturnStatementBodyType *freturnStatement)
{
	nullFree(freturnStatement);
	freeExpression(freturnStatement);
}

  void
freeFunctionStatement(functionStatementBodyType *functionStatement)
{
	nullFree(functionStatement);
	free(functionStatement->functionName);
	free(functionStatement);
}

  void
freeIfStatement(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(includeStatementBodyType *includeStatement)
{
	nullFree(includeStatement);
	freeExpression(includeStatement);
}

  void
freeInstructionStatement(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(longStatementBodyType *longStatement)
{
	longStatementBodyType	*newLongStatement;

	nullFree(longStatement);
	while (longStatement != NULL) {
		freeExpression(longStatement->theExpression);
		newLongStatement = longStatement->nextExpression;
		free(longStatement);
		longStatement = newLongStatement;
	}
}

  void
freeMacroStatement(macroStatementBodyType *macroStatement)
{
	nullFree(macroStatement);
	free(macroStatement);
}

  void
freeMdefineStatement(defineStatementBodyType *mdefineStatement)
                              	                   /* MIST: shouldn't this be "mdefineStatementBodyType"? */
{
	valueType		*freeDefineExpression();

	nullFree(mdefineStatement);
	freeExpression(mdefineStatement->theValue);
	free(mdefineStatement);
}

  void
freeMdoUntilStatement(mdoUntilStatementBodyType *mdoUntilStatement)
{
	nullFree(mdoUntilStatement);
	freeBlock(mdoUntilStatement->mdoUntilLoop);
	freeExpression(mdoUntilStatement->mdoUntilCondition);
}

  void
freeMdoWhileStatement(mdoWhileStatementBodyType *mdoWhileStatement)
{
	nullFree(mdoWhileStatement);
	freeBlock(mdoWhileStatement->mdoWhileLoop);
	freeExpression(mdoWhileStatement->mdoWhileCondition);
	free(mdoWhileStatement);
}

  void
freeMifStatement(mifStatementBodyType *mifStatement)
{
	nullFree(mifStatement);
	freeExpression(mifStatement->mifCondition);
	freeBlock(mifStatement->mifConsequence);
	freeMifStatement(mifStatement->mifContinuation.
		mifContinuationBodyUnion);
	free(mifStatement);
}

  void
freeMswitchStatement(mswitchStatementBodyType *mswitchStatement)
{
	freeExpression(mswitchStatement->switchExpression);
	freeCaseList(mswitchStatement->cases);
	free(mswitchStatement);
}

  void
freeMforStatement(mforStatementBodyType *mforStatement)
{
	nullFree(mforStatement);
	freeExpression(mforStatement->initExpression);
	freeExpression(mforStatement->testExpression);
	freeExpression(mforStatement->incrExpression);
	freeBlock(mforStatement->forLoop);
	free(mforStatement);
}

  void
freeMvariableStatement(mvariableStatementBodyType *mvariableStatement)
{
	nullFree(mvariableStatement);
	if ((int)mvariableStatement->theDimension != -1)
		freeExpression(mvariableStatement->theDimension);
	freeExpressionList(mvariableStatement->theValue);
	free(mvariableStatement);
}

  void
freeMwhileStatement(mwhileStatementBodyType *mwhileStatement)
{
	nullFree(mwhileStatement);
	freeExpression(mwhileStatement->mwhileCondition);
	freeBlock(mwhileStatement->mwhileLoop);
	free(mwhileStatement);
}

  void
freeOrgStatement(orgStatementBodyType *orgStatement)
{
	nullFree(orgStatement);
	freeExpression(orgStatement);
}

  void
freePerformStatement(performStatementBodyType *performStatement)
{
	nullFree(performStatement);
	freeExpression(performStatement);
}

  void
freeRelStatement(relStatementBodyType *relStatement)
{
}

  void
freeStartStatement(startStatementBodyType *startStatement)
{
	nullFree(startStatement);
	freeExpression(startStatement);
}

  void
freeStringStatement(stringStatementBodyType *stringStatement)
{
	stringStatementBodyType	*newStringStatement;

	nullFree(stringStatement);
	while (stringStatement != NULL) {
		freeExpression(stringStatement->theExpression);
		newStringStatement = stringStatement->nextExpression;
		free(stringStatement);
		stringStatement = newStringStatement;
	}
}

  void
freeStructStatement(structStatementBodyType *structStatement)
{
	nullFree(structStatement);
	freeBlock(structStatement->structBody);
	free(structStatement);
}

  void
freeTargetStatement(targetStatementBodyType *targetStatement)
{
	nullFree(targetStatement);
	freeExpression(targetStatement);
}

  void
freeUndefineStatement(undefineStatementBodyType *undefineStatement)
{
	freeIdentifierList(undefineStatement);
}

  void
freeVariableStatement(variableStatementBodyType *variableStatement)
{
	nullFree(variableStatement);
	if ((int)variableStatement->theDimension != -1)
		freeExpression(variableStatement->theDimension);
	freeExpressionList(variableStatement->theValue);
	free(variableStatement);
}

  void
freeWhileStatement(whileStatementBodyType *whileStatement)
{
	nullFree(whileStatement);
	freeBlock(whileStatement->whileLoop);
	free(whileStatement);
}

  void
freeWordStatement(wordStatementBodyType *wordStatement)
{
	wordStatementBodyType	*newWordStatement;

	nullFree(wordStatement);
	while (wordStatement != NULL) {
		freeExpression(wordStatement->theExpression);
		newWordStatement = wordStatement->nextExpression;
		free(wordStatement);
		wordStatement = newWordStatement;
	}
}

  void
freeStatementBody(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(labelListType *labelList)
{
	labelListType	*nextLabel;

	while (labelList != NULL) {
		nextLabel = labelList->nextLabel;
		free(labelList);
		labelList = nextLabel;
	}
}

  void
freeStatement(statementType *statement)
{
	statementType	*newStatement;

	while (statement != NULL) {
		freeLabelList(statement->labels);
		freeStatementBody(statement->kindOfStatement, statement->
			statementBody);
		newStatement = statement->nextStatement;
		free(statement);
		statement = newStatement;
	}
}

  void
freeArray(arrayType *array)
{
	int	i;

	if (array->arraySize > 0) {
		for (i=0; i<array->arraySize; i++)
			freeValue((array->arrayContents)[i]);
		free(array->arrayContents);
	}
	free(array);
}

  void
freeValue(valueType *value)
{
	if (value->kindOfValue == STRING_VALUE)
		freeString(value->value);
	else if (value->kindOfValue == ARRAY_VALUE)
		freeArray(value->value);
	free(value);
}