ifStatementBodyType *
extractIfBody(statementType *ifStatement)
{
ifStatementBodyType *result;
result = ifStatement->statementBody.ifUnion;
if (ifStatement->labels != NULL)
botch("extract if body with non-null labels\n", 0, 0, 0);
else if (ifStatement->nextStatement != NULL)
botch("extract if body with non-null next\n", 0, 0, 0);
else
qfree(ifStatement);
return(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));
}
int
acheck(int k, double d, double v, double dvdx, double dvdy)
{
ExpectedAnswer *e = &expected[k];
int nbad = 0;
/* There should be no round-off error in this simple example, so we */
/* use exact comparisons, rather than, say, relative differences. */
if (v != d*e->v)
nbad += botch(e, 0, v, d*e->v);
if (dvdx != d*e->dvdx)
nbad += botch(e, "x", dvdx, d*e->dvdx);
if (dvdy != d*e->dvdy)
nbad += botch(e, "y", dvdy, d*e->dvdy);
return nbad;
}
statementType *
convertDefineToMdefine(statementType *defineStatement)
{
if (defineStatement->kindOfStatement != DEFINE_STATEMENT)
botch("convertDefineToMdefine got statement kind: %d\n",
defineStatement->kindOfStatement, 0, 0);
defineStatement->kindOfStatement = MDEFINE_STATEMENT;
return(defineStatement);
}
stringType *
extractString(operandType *textExpression)
{
stringType *result;
if (textExpression->kindOfOperand != STRING_OPND)
botch("extract string got handed an opnd kind: %d\n",
textExpression->kindOfOperand, 0, 0);
result = textExpression->theOperand.stringUnion;
qfree(textExpression);
return(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);
}
conditionType
invertConditionCode(conditionType conditionCode)
{
#define cc (int)conditionCode
if ((int)CARRY_COND<=cc && cc<=(int)ALWAYS_COND)
return((conditionType)
(cc - (int)CARRY_COND + (int)NOT_CARRY_COND));
else if ((int)NOT_CARRY_COND<=cc && cc<=(int)NEVER_COND)
return((conditionType)
(cc + (int)CARRY_COND - (int)NOT_CARRY_COND));
else
botch("invertConditionCode given %d, not a condition code\n");
}
void
freeOperand(operandType *operand)
{
nullFree(operand);
switch (operand->kindOfOperand) {
case EXPRESSION_OPND:
case IMMEDIATE_OPND:
case INDIRECT_OPND:
case POST_INDEXED_Y_OPND:
case PRE_INDEXED_X_OPND:
case X_INDEXED_OPND:
case Y_INDEXED_OPND:
freeExpression(operand->theOperand.expressionUnion);
break;
case A_REGISTER_OPND:
case X_REGISTER_OPND:
case Y_REGISTER_OPND:
break;
case X_SELECTED_OPND:
case Y_SELECTED_OPND:
case PRE_SELECTED_X_OPND:
freeSelectionList(operand->theOperand.xSelectedUnion);
break;
case STRING_OPND:
freeString(operand->theOperand.stringUnion);
break;
case BLOCK_OPND:
freeBlock(operand->theOperand.blockUnion);
break;
default:
botch("bad operand kind in freeOperand %d\n",
operand->kindOfOperand);
break;
}
freeOperand(operand->nextOperand);
free(operand);
}
operandType *
buildOperand(operandKindType kindOfOperand, anyOldThing *arg)
{
operandType *result;
result = typeAlloc(operandType);
result->kindOfOperand = kindOfOperand;
result->nextOperand = NULL;
switch (kindOfOperand) {
case EXPRESSION_OPND:
result->theOperand.expressionUnion =
(expressionOperandBodyType *) arg;
break;
case IMMEDIATE_OPND:
result->theOperand.immediateUnion =
(immediateOperandBodyType *) arg;
break;
case INDIRECT_OPND:
result->theOperand.indirectUnion =
(indirectOperandBodyType *) arg;
break;
case A_REGISTER_OPND:
result->theOperand.aRegisterUnion =
(aRegisterOperandBodyType *) NULL;
break;
case X_REGISTER_OPND:
result->theOperand.xRegisterUnion =
(xRegisterOperandBodyType *) NULL;
break;
case Y_REGISTER_OPND:
result->theOperand.yRegisterUnion =
(yRegisterOperandBodyType *) NULL;
break;
case POST_INDEXED_Y_OPND:
result->theOperand.postIndexedYUnion =
(postIndexedYOperandBodyType *) arg;
break;
case PRE_INDEXED_X_OPND:
result->theOperand.preIndexedXUnion =
(preIndexedXOperandBodyType *) arg;
break;
case X_INDEXED_OPND:
result->theOperand.xIndexedUnion =
(xIndexedOperandBodyType *) arg;
break;
case Y_INDEXED_OPND:
result->theOperand.yIndexedUnion =
(yIndexedOperandBodyType *) arg;
break;
case X_SELECTED_OPND:
result->theOperand.xSelectedUnion =
(xSelectedOperandBodyType *) arg;
break;
case Y_SELECTED_OPND:
result->theOperand.ySelectedUnion =
(ySelectedOperandBodyType *) arg;
break;
case PRE_SELECTED_X_OPND:
result->theOperand.preSelectedUnion =
(preSelectedOperandBodyType *) arg;
break;
case STRING_OPND:
result->theOperand.stringUnion =
(stringOperandBodyType *) arg;
break;
case BLOCK_OPND:
result->theOperand.blockUnion = (blockOperandBodyType *) arg;
break;
default:
botch("unknown operand kind: %d\n", kindOfOperand);
break;
}
return(result);
}
valueType *
evaluateOperand(operandType *operand)
{
valueType *result;
bool saveExpansion;
expressionType *expression;
nullEvaluate(operand);
if (operand->kindOfOperand != EXPRESSION_OPND)
newFixupAddressMode = operand->kindOfOperand;
switch (operand->kindOfOperand) {
case EXPRESSION_OPND:
case IMMEDIATE_OPND:
case INDIRECT_OPND:
case POST_INDEXED_Y_OPND:
case PRE_INDEXED_X_OPND:
case X_INDEXED_OPND:
case Y_INDEXED_OPND:
result = evaluateExpression(operand->theOperand.expressionUnion,
performingFixups ? NO_FIXUP : OPERAND_FIXUP);
nullEvaluate(result);
if (operand->kindOfOperand != EXPRESSION_OPND) {
if (result->addressMode != EXPRESSION_OPND) {
error(BAD_ADDRESS_MODE_ERROR);
result->kindOfValue = FAIL;
} else {
result->addressMode = operand->kindOfOperand;
}
}
break;
case A_REGISTER_OPND:
case X_REGISTER_OPND:
case Y_REGISTER_OPND:
result = newValue(UNDEFINED_VALUE, 0, operand->
kindOfOperand);
break;
case X_SELECTED_OPND:
case Y_SELECTED_OPND:
case PRE_SELECTED_X_OPND:
result = evaluateSelectionList(operand->theOperand.xSelectedUnion);
if (result->addressMode != EXPRESSION_OPND) {
error(BAD_ADDRESS_MODE_ERROR);
result->kindOfValue = FAIL;
} else {
result->addressMode = operand->kindOfOperand;
}
break;
case STRING_OPND:
result = newValue(STRING_VALUE, operand->theOperand.stringUnion,
STRING_OPND);
break;
case BLOCK_OPND:
if (standaloneExpansionFlag)
forceExpansion();
sideEffectFlag = TRUE;
assembleBlock(operand->theOperand.blockUnion);
expansionOn();
result = newValue(FAIL, 0, BLOCK_OPND);
break;
default:
botch("bad operand kind in evaluateOperand %d\n",
operand->kindOfOperand);
break;
}
return(result);
}
expressionTermType *
buildExpressionTerm(expressionTermKindType kindOfExpressionTerm, anyOldThing *arg1, anyOldThing *arg2, anyOldThing *arg3)
{
expressionType *result;
result = typeAlloc(expressionType);
result->kindOfTerm = kindOfExpressionTerm;
switch (kindOfExpressionTerm) {
case IDENTIFIER_EXPR:
result->expressionTerm.identifierUnion =
(identifierTermType *) arg1;
break;
case ARRAY_EXPR:
result->expressionTerm.arrayUnion =
buildArrayTerm((expressionType *) arg1,
(expressionType *) arg2);
break;
case FUNCTION_CALL_EXPR:
result->expressionTerm.functionCallUnion =
(functionCallTermType *) arg1;
break;
case NUMBER_EXPR:
result->expressionTerm.numberUnion = (numberTermType) arg1;
break;
case STRING_EXPR:
result->expressionTerm.stringUnion = (stringTermType *) arg1;
break;
case SUBEXPRESSION_EXPR:
result->expressionTerm.subexpressionUnion =
(subexpressionTermType *) arg1;
break;
case UNOP_EXPR:
result->expressionTerm.unopUnion =
buildUnopTerm((unopKindType) arg1,
(expressionType *) arg2);
break;
case ASSIGN_EXPR:
case BINOP_EXPR:
result->expressionTerm.binopUnion =
buildBinopTerm((binopKindType) arg1,
(expressionType *) arg2,
(expressionType *) arg3);
break;
case PREOP_EXPR:
result->expressionTerm.preOpUnion =
buildPreOpTerm((preOpKindType) arg1,
(expressionType *) arg2);
break;
case POSTOP_EXPR:
result->expressionTerm.postOpUnion =
buildPostOpTerm((postOpKindType) arg1,
(expressionType *) arg2);
break;
case HERE_EXPR:
result->expressionTerm.hereUnion = (hereTermType *) NULL;
break;
case CONDITION_CODE_EXPR:
result->expressionTerm.conditionCodeUnion =
(conditionCodeTermType) arg1;
break;
default:
botch("invalid expression term kind: %d\n",
kindOfExpressionTerm);
break;
}
return(result);
}
bool
encodeStatement(statementType *statement)
{
switch(statement->kindOfStatement) {
case ALIGN_STATEMENT:
case BLOCK_STATEMENT:
case BYTE_STATEMENT:
case CONSTRAIN_STATEMENT:
case DBYTE_STATEMENT:
case DEFINE_STATEMENT:
case DO_UNTIL_STATEMENT:
case DO_WHILE_STATEMENT:
case EXTERN_STATEMENT:
case FUNCTION_STATEMENT:
case IF_STATEMENT:
case INCLUDE_STATEMENT:
case INSTRUCTION_STATEMENT:
case LONG_STATEMENT:
case MACRO_STATEMENT:
case ORG_STATEMENT:
case REL_STATEMENT:
case START_STATEMENT:
case STRING_STATEMENT:
case STRUCT_STATEMENT:
case TARGET_STATEMENT:
case UNDEFINE_STATEMENT:
case VARIABLE_STATEMENT:
case WHILE_STATEMENT:
case WORD_STATEMENT:
error(ILLEGAL_STATEMENT_IN_OBJECT_FILE_FUNCTION_ERROR,
statementKindString(statement->kindOfStatement));
return(FALSE);
case ASSERT_STATEMENT:
return(encodeAssertStatement(statement->statementBody.assertUnion));
case FRETURN_STATEMENT:
return(encodeFreturnStatement(statement->statementBody.freturnUnion));
case GROUP_STATEMENT:
return(encodeBlock(statement->statementBody.groupUnion));
case MDEFINE_STATEMENT:
return(encodeMdefineStatement(statement->statementBody.defineUnion));
case MDO_UNTIL_STATEMENT:
return(encodeMdoUntilStatement(statement->statementBody.mdoUntilUnion));
case MDO_WHILE_STATEMENT:
return(encodeMdoWhileStatement(statement->statementBody.mdoWhileUnion));
case MFOR_STATEMENT:
return(encodeMforStatement(statement->statementBody.mforUnion));
case MIF_STATEMENT:
return(encodeMifStatement(statement->statementBody.mifUnion));
case MSWITCH_STATEMENT:
return(encodeMswitchStatement(statement->statementBody.mswitchUnion));
case MVARIABLE_STATEMENT:
return(encodeMvariableStatement(statement->statementBody.mvariableUnion));
case MWHILE_STATEMENT:
return(encodeMwhileStatement(statement->statementBody.mwhileUnion));
case NULL_STATEMENT:
return(TRUE);
case PERFORM_STATEMENT:
return(encodeExpression(statement->statementBody.expressionUnion));
default:
botch("encodeStatementBody doesn't know kind %d\n",
statement->kindOfStatement);
return(FALSE);
}
}
bool
encodeExpression(expressionType *expression)
{
nullEncode(expression);
switch (expression->kindOfTerm) {
case ARRAY_EXPR:
error(ARRAY_TERM_IN_OBJECT_EXPRESSION_ERROR);
return(FALSE);
break;
case ASSIGN_EXPR:
return(encodeAssignmentTerm(expression->expressionTerm.binopUnion));
break;
case BINOP_EXPR:
return(encodeBinopTerm(expression->expressionTerm.binopUnion));
break;
case CONDITION_CODE_EXPR:
return(encodeCondition(expression->expressionTerm.conditionTypeUnion));
break;
case FUNCTION_CALL_EXPR:
return(encodeFunctionCall(expression->expressionTerm.functionCallUnion));
break;
case HERE_EXPR:
return(encodeHere());
break;
case IDENTIFIER_EXPR:
return(encodeIdentifier(expression->expressionTerm.identifierUnion));
break;
case NUMBER_EXPR:
return(encodeNumber(expression->expressionTerm.numberUnion));
break;
case POSTOP_EXPR:
return(encodePostopTerm(expression->expressionTerm.postOpUnion));
break;
case PREOP_EXPR:
return(encodePreopTerm(expression->expressionTerm.preOpUnion));
break;
case SUBEXPRESSION_EXPR:
encodeExpression(expression->expressionTerm.expressionUnion);
break;
case STRING_EXPR:
return(encodeString(expression->expressionTerm.stringUnion));
break;
case UNOP_EXPR:
return(encodeUnopTerm(expression->expressionTerm.unopUnion));
break;
case VALUE_EXPR:
return(encodeValue(expression->expressionTerm.valueUnion));
break;
default:
botch("encodeExpression: funny expression kind %d\n",
expression->kindOfTerm);
break;
}
}
