/*
 * 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.
 */
/*
	operandStuff_68000.c -- Various target processor routines to handle
			operands in the Macross assembler (68000 version).

	Chip Morningstar -- Lucasfilm Ltd.

	26-April-1985
*/

#include "macrossTypes.h"
#include "macrossGlobals.h"

/* corresponds to routines in buildStuff2.c */

  operandType *
buildOperand(kindOfOperand, arg1, arg2, arg3, arg4)
  operandKindType	kindOfOperand;
  int			arg1;
  int			arg2;
  int			arg3;
  int			arg4;
{
	operandType	*result;

	result = typeAlloc(operandType);
	result->kindOfOperand = kindOfOperand;
	result->nextOperand = NULL;
	switch (kindOfOperand) {

	case EXPRESSION_OPND:
		result->theOperand.expressionUnion =
			(expressionOperandBodyType *) arg1;
		break;

	case STRING_OPND:
		result->theOperand.stringUnion =
			(stringOperandBodyType *) arg1;
		break;

	case BLOCK_OPND:
		result->theOperand.blockUnion = (blockOperandBodyType *) arg1;
		break;

	case D_REGISTER_OPND:
		result->theOperand.dRegisterUnion =
			(dRegisterOperandBodyType *) NULL;
		setRegister(result->kindOfOperand, arg1);
		break;

	case A_REGISTER_OPND:
		result->theOperand.aRegisterUnion =
			(aRegisterOperandBodyType *) NULL;
		setRegister(result->kindOfOperand, arg1);
		break;

	case A_REGISTER_INDIRECT_OPND:
		result->theOperand.aRegisterIndirectUnion =
			(aRegisterIndirectOperandBodyType *) NULL;
		setRegister(result->kindOfOperand, arg1);
		break;

	case POSTINCREMENT_OPND:
		result->theOperand.postincrementUnion =
			(postincrementOperandBodyType *) NULL;
		setRegister(result->kindOfOperand, arg1);
		break;

	case PREDECREMENT_OPND:
		result->theOperand.predecrementUnion =
			(predecrementOperandBodyType *) NULL;
		setRegister(result->kindOfOperand, arg1);
		break;

	case DISPLACEMENT_OPND:
		result->theOperand.displacementUnion =
			(displacementOperandBodyType *) arg2;
		setRegister(result->kindOfOperand, arg1);
		break;

	case SELECTED_OPND:
		result->theOperand.selectionUnion =
			(selectedOperandBodyType *) arg2;
		setRegister(result->kindOfOperand, arg1);
		break;

	case INDEXED_OPND:
		result->theOperand.indexedUnion =
			(indexedOperandBodyType *) arg1;
		setRegister(result->kindOfOperand, arg2);
		setIndexRegister(result->kindOfOperand, arg3);
		setWL(result->kindOfOperand, (int)arg4);
		break;

	case INDEX_SELECTED_OPND:
		result->theOperand.indexSelectedUnion =
			(indexSelectedOperandBodyType *) arg1;
		setRegister(result->kindOfOperand, arg2);
		setIndexRegister(result->kindOfOperand, arg3);
		setWL(result->kindOfOperand, (int)arg4);
		break;

	case PC_DISPLACEMENT_OPND:
		result->theOperand.pcDisplacementUnion =
			(pcDisplacementOperandBodyType *) arg1;
		break;

	case PC_INDEXED_OPND:
		result->theOperand.pcIndexedUnion =
			(pcIndexedOperandBodyType *) arg1;
		setIndexRegister(result->kindOfOperand, arg2);
		setWL(result->kindOfOperand, (int)arg3);
		break;

	case IMMEDIATE_OPND:
		result->theOperand.immediateUnion =
			(immediateOperandBodyType *) arg1;
		break;

	case ABSOLUTE_SHORT_OPND:
		result->theOperand.absoluteShortUnion =
			(absoluteShortOperandBodyType *) arg1;
		break;

	case ABSOLUTE_LONG_OPND:
		result->theOperand.absoluteLongUnion =
			(absoluteLongOperandBodyType *) arg1;
		break;

	case CC_REGISTER_OPND:
		result->theOperand.ccRegisterUnion =
			(ccRegisterOperandBodyType *) NULL;
		break;

	case STATUS_REGISTER_OPND:
		result->theOperand.statusRegisterUnion =
			(statusRegisterOperandBodyType *) NULL;
		break;

	case USP_REGISTER_OPND:
		result->theOperand.uspRegisterUnion =
			(uspRegisterOperandBodyType *) NULL;
		break;

	case CONTROL_REGISTER_OPND:
		result->theOperand.controlRegisterUnion =
			(controlRegisterOperandBodyType *) NULL;
		setRegister(result->kindOfOperand, arg1);
		break;

	default:
		botch("unknown operand kind: %d\n", kindOfOperand);
		break;
	}
	return(result);
}

/* corresponds to routines in fixups.c */

  operandListType *
duplicateOperandForFixup(operand, isSpecialFunctionOperand)
  operandListType	*operand;
  bool			 isSpecialFunctionOperand;
{
	operandListType	*result;

	expressionType	*duplicateExpressionForFixup();

	result = typeAlloc(operandListType);
	result->kindOfOperand = operand->kindOfOperand;
	result->nextOperand = NULL;
	if (operand->kindOfOperand != EXPRESSION_OPND)
		newFixupAddressMode = operand->kindOfOperand;
	switch (operandKindField(operand->kindOfOperand)) {

	case EXPRESSION_OPND:
	case DISPLACEMENT_OPND:
	case SELECTED_OPND:
	case INDEXED_OPND:
	case INDEX_SELECTED_OPND:
	case PC_DISPLACEMENT_OPND:
	case PC_INDEXED_OPND:
	case IMMEDIATE_OPND:
	case ABSOLUTE_SHORT_OPND:
	case ABSOLUTE_LONG_OPND:
		result->theOperand.expressionUnion =
			duplicateExpressionForFixup(operand->theOperand,
			FALSE, isSpecialFunctionOperand);
		break;
	case D_REGISTER_OPND:
	case A_REGISTER_OPND:
	case A_REGISTER_INDIRECT_OPND:
	case POSTINCREMENT_OPND:
	case PREDECREMENT_OPND:
	case CC_REGISTER_OPND:
	case STATUS_REGISTER_OPND:
	case USP_REGISTER_OPND:
	case CONTROL_REGISTER_OPND:
		result->theOperand = operand->theOperand;
		break;
	case STRING_OPND:
		result->theOperand = operand->theOperand;
		break;
	case BLOCK_OPND:
		error(CANT_FORWARD_REFERENCE_BLOCK_ERROR);
		result = NULL;
		break;
	}
	return(result);
}

/* corresponds to routines in garbage.c */

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

  void
freeOperand(operand)
  operandType	*operand;
{
	nullFree(operand);
	switch (operandKindField(operand->kindOfOperand)) {

	case EXPRESSION_OPND:
	case DISPLACEMENT_OPND:
	case INDEXED_OPND:
	case PC_DISPLACEMENT_OPND:
	case PC_INDEXED_OPND:
	case IMMEDIATE_OPND:
	case ABSOLUTE_SHORT_OPND:
	case ABSOLUTE_LONG_OPND:
		freeExpression(operand->theOperand);
		break;

	case D_REGISTER_OPND:
	case A_REGISTER_OPND:
	case A_REGISTER_INDIRECT_OPND:
	case POSTINCREMENT_OPND:
	case PREDECREMENT_OPND:
	case CC_REGISTER_OPND:
	case STATUS_REGISTER_OPND:
	case USP_REGISTER_OPND:
	case CONTROL_REGISTER_OPND:
		break;

	case SELECTED_OPND:
	case INDEX_SELECTED_OPND:
		freeSelectionList(operand->theOperand);
		break;

	case STRING_OPND:
		freeString(operand->theOperand);
		break;

	case BLOCK_OPND:
		freeBlock(operand->theOperand);
		break;

	default:
		botch("bad operand kind in freeOperand %d\n",
						operand->kindOfOperand);
		break;
	}
	freeOperand(operand->nextOperand);
	free(operand);
}

/* corresponds to routines in listing.c */

  void
expandOperand(addressMode, buffer)
  operandKindType	 addressMode;
  char			*buffer;
{
	char	*bufferPtr;

	bufferPtr = buffer;
	switch (operandKindField(addressMode)) {
	case D_REGISTER_OPND:
		moreTextOptional(buffer, &bufferPtr, "d");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		break;
	case A_REGISTER_OPND:
		moreTextOptional(buffer, &bufferPtr, "a");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		break;
	case A_REGISTER_INDIRECT_OPND:
		moreTextOptional(buffer, &bufferPtr, "[a");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		moreTextOptional(buffer, &bufferPtr, "]");
		break;
	case POSTINCREMENT_OPND:
		moreTextOptional(buffer, &bufferPtr, "[a");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		moreTextOptional(buffer, &bufferPtr, "]+");
		break;
	case PREDECREMENT_OPND:
		moreTextOptional(buffer, &bufferPtr, "-[a");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		moreTextOptional(buffer, &bufferPtr, "]");
		break;
	case IMMEDIATE_OPND:
		moreTextOptional(buffer, &bufferPtr, "#");
		break;
	case CC_REGISTER_OPND:
		moreTextOptional(buffer, &bufferPtr, "ccr");
		break;
	case STATUS_REGISTER_OPND:
		moreTextOptional(buffer, &bufferPtr, "sr");
		break;
	case USP_REGISTER_OPND:
		moreTextOptional(buffer, &bufferPtr, "usp");
		break;
	case CONTROL_REGISTER_OPND:
		if (getRegister(addressMode) == 1)
			moreTextOptional(buffer, &bufferPtr, "sfc");
		else if (getRegister(addressMode) == 2)
			moreTextOptional(buffer, &bufferPtr, "dfc");
		else
			moreTextOptional(buffer, &bufferPtr, "vbr");
		break;
	case SELECTED_OPND:
		moreTextOptional(buffer, &bufferPtr, "a");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		break;
	case INDEX_SELECTED_OPND:
		moreTextOptional(buffer, &bufferPtr, "a");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		if (getIndexRegister(addressMode)<8) {
			moreTextOptional(buffer, &bufferPtr, "[a");
			expandNum(buffer, &bufferPtr,
				getIndexRegister(addressMode));
		} else {
			moreTextOptional(buffer, &bufferPtr, "[d");
			expandNum(buffer, &bufferPtr,
				getIndexRegister(addressMode)-8);
		}
		moreTextOptional(buffer, &bufferPtr, "]");
		break;

	default:
		break;
	}
	expandExpression(buffer, &bufferPtr);
	switch(operandKindField(addressMode)) {
	case DISPLACEMENT_OPND:
		moreTextOptional(buffer, &bufferPtr, "[a");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		moreTextOptional(buffer, &bufferPtr, "]");
		break;
	case INDEXED_OPND:
		moreTextOptional(buffer, &bufferPtr, "[a");
		expandNum(buffer, &bufferPtr, getRegister(addressMode));
		moreTextOptional(buffer, &bufferPtr, ",");
		if (getIndexRegister(addressMode)<8) {
			moreTextOptional(buffer, &bufferPtr, "a");
			expandNum(buffer, &bufferPtr,
				getIndexRegister(addressMode));
		} else {
			moreTextOptional(buffer, &bufferPtr, "d");
			expandNum(buffer, &bufferPtr,
				getIndexRegister(addressMode)-8);
		}
		moreTextOptional(buffer, &bufferPtr, ".");
		if (getWL(addressMode))
			moreTextOptional(buffer, &bufferPtr, "l]");
		else
			moreTextOptional(buffer, &bufferPtr, "w]");
		break;
	case PC_DISPLACEMENT_OPND:
		moreTextOptional(buffer, &bufferPtr, "[pc]");
		break;
	case PC_INDEXED_OPND:
		moreTextOptional(buffer, &bufferPtr, "[pc,");
		if (getIndexRegister(addressMode)<8) {
			moreTextOptional(buffer, &bufferPtr, "a");
			expandNum(buffer, &bufferPtr,
				getIndexRegister(addressMode));
		} else {
			moreTextOptional(buffer, &bufferPtr, "d");
			expandNum(buffer, &bufferPtr,
				getIndexRegister(addressMode)-8);
		}
		moreTextOptional(buffer, &bufferPtr, ".");
		if (getWL(addressMode))
			moreTextOptional(buffer, &bufferPtr, "l]");
		else
			moreTextOptional(buffer, &bufferPtr, "w]");
		break;
	case ABSOLUTE_SHORT_OPND:
		moreTextOptional(buffer, &bufferPtr, ".w");
		break;
	case ABSOLUTE_LONG_OPND:
		moreTextOptional(buffer, &bufferPtr, ".l");
		break;
	default:
		break;
	}
}

/* corresponds to routines in expressionSemantics.c */

#define nullEvaluate(thing)   if (thing==NULL) return(NULL);
#define fail(err)	      if (!expressionFailed) {\
				      error(err);\
				      expressionFailed = TRUE;\
			      }
#define fail1(err,arg)	      if (!expressionFailed) {\
				      error(err,arg);\
				      expressionFailed = TRUE;\
			      }
#define fail2(err,arg1,arg2)	      if (!expressionFailed) {\
				      error(err,arg1,arg2);\
				      expressionFailed = TRUE;\
			      }

#define qfree2(a,b)	if (freeFlag) { free(a); free(b); }

#define expansionOff() {saveExpansion=expandMacros; expandMacros=FALSE;}
#define forceExpansion() {saveExpansion=expandMacros; expandMacros=TRUE;}
#define expansionOn()	expandMacros=saveExpansion;

  valueType *
evaluateOperand(operand)
  operandType	*operand;
{
	valueType		*result;
	bool			 saveExpansion;
	expressionType		*expression;

	valueType		*evaluateExpression();
	valueType		*evaluateSelectionList();
	valueType		*newValue();

	nullEvaluate(operand);
	if (operand->kindOfOperand != EXPRESSION_OPND)
		newFixupAddressMode = operand->kindOfOperand;
	switch (operandKindField(operand->kindOfOperand)) {

	case EXPRESSION_OPND:
	case DISPLACEMENT_OPND:
	case INDEXED_OPND:
	case PC_DISPLACEMENT_OPND:
	case PC_INDEXED_OPND:
	case IMMEDIATE_OPND:
	case ABSOLUTE_SHORT_OPND:
	case ABSOLUTE_LONG_OPND:
		result = evaluateExpression(operand->theOperand,
			performingFixups ? NO_FIXUP : OPERAND_FIXUP);
		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 SELECTED_OPND:
	case INDEX_SELECTED_OPND:
		result = evaluateSelectionList(operand->theOperand);
		if (result->addressMode != EXPRESSION_OPND) {
			error(BAD_ADDRESS_MODE_ERROR);
			result->kindOfValue = FAIL;
		} else {
			result->addressMode = operand->kindOfOperand;
		}
		break;

	case D_REGISTER_OPND:
	case A_REGISTER_OPND:
	case A_REGISTER_INDIRECT_OPND:
	case POSTINCREMENT_OPND:
	case PREDECREMENT_OPND:
	case CC_REGISTER_OPND:
	case STATUS_REGISTER_OPND:
	case USP_REGISTER_OPND:
	case CONTROL_REGISTER_OPND:
		result = newValue(ABSOLUTE_VALUE, 0, operand->
			kindOfOperand);
		break;

	case STRING_OPND:
		result = newValue(STRING_VALUE, operand->theOperand,
			STRING_OPND);
		break;

	case BLOCK_OPND:
		if (standaloneExpansionFlag)
			forceExpansion();
		assembleBlock(operand->theOperand);
		expansionOn();
		result = newValue(FAIL, 0, BLOCK_OPND);
		break;

	default:
		botch("bad operand kind in evaluateOperand %d\n",
						operand->kindOfOperand);
		break;
	}
	return(result);
}

/* from parserMisc.c */

  conditionType
invertConditionCode(conditionCode)
  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");
}

/* from semanticMisc.c */

  bool
shouldParenthesize(operand)
  operandType	*operand;
{
	expressionTermKindType	 kind;

	switch(operandKindField(operand->kindOfOperand)) {
	case EXPRESSION_OPND:
	case DISPLACEMENT_OPND:
	case INDEXED_OPND:
	case PC_DISPLACEMENT_OPND:
	case PC_INDEXED_OPND:
	case IMMEDIATE_OPND:
	case ABSOLUTE_SHORT_OPND:
	case ABSOLUTE_LONG_OPND:
		kind = operand->theOperand.expressionUnion->kindOfTerm;
		return (kind==UNOP_EXPR || kind==BINOP_EXPR || kind==
			ASSIGN_EXPR);
		break;

	case STRING_OPND:
	case BLOCK_OPND:
	case D_REGISTER_OPND:
	case A_REGISTER_OPND:
	case A_REGISTER_INDIRECT_OPND:
	case POSTINCREMENT_OPND:
	case PREDECREMENT_OPND:
	case CC_REGISTER_OPND:
	case STATUS_REGISTER_OPND:
	case USP_REGISTER_OPND:
	case CONTROL_REGISTER_OPND:
	case SELECTED_OPND:
	case INDEX_SELECTED_OPND:
		return(FALSE);
		break;
	}
}