codegenerator.c

decafc的源代码

			 	 TRUE,
			 	 symbolTablePtr);
		GenerateAssignVarCode(addressVarID, expAddressVarID);
		/*
		if (isNewExp == TRUE) {
			GenerateNameCode(classNodePtr,
				 	 nameNodePtr,
				 	 TRUE,
				 	 symbolTablePtr);
			fprintf(CFileFp,
				STRING_ASSIGN_NEW_OBJ_OFFSET,
				addressVarID);

		} else {
			expAddressVarID = addressVarID;
			GetNextAddressVarID();
			GenerateNameCode(classNodePtr,
				 	 nameNodePtr,
				 	 TRUE,
				 	 symbolTablePtr);
			GenerateAssignVarCode(addressVarID, expAddressVarID);
		}
		*/
	}
}

static Boolean GenerateExpressionCode(
			NodePtr		classNodePtr,
			NodePtr		expNodePtr,
			SymbolTablePtr	symbolTablePtr)
{
	int	expAddressVarID;

	if (expNodePtr == NULL) {
		return(TRUE);
	}

	switch (expNodePtr->type) {
		case NODE_TYPE_NAME:
		  // needLValue = FALSE;
		  GenerateNameCode(classNodePtr,
				   expNodePtr,
				   TRUE,
				   symbolTablePtr);
		  // isNewExp = FALSE;
		  return(FALSE);

		case NODE_TYPE_NUMBER:
		  // isNewExp = FALSE;
		  return(TRUE);

		case NODE_TYPE_KEYWORD:
		  // isNewExp = FALSE;
		  return (GenerateKeywordCode(expNodePtr));

		case NODE_TYPE_FUNCTION_EXP:
		  GenerateFunctionCallCode(
			classNodePtr,
			expNodePtr,
			symbolTablePtr);

		  expAddressVarID = addressVarID;
		  GetNextAddressVarID();

		  fprintf(CFileFp,
			  STRING_TMP_VAR_FMT,
			  addressVarID,
			  addressVarID + 1);

		  fprintf(CFileFp,
			  STRING_ASSIGN_VAR_FMT,
			  addressVarID,
			  expAddressVarID);

		  // isNewExp = FALSE;
		  return(FALSE);

		case NODE_TYPE_READ_EXP:
		  GenerateReadExpCode(classNodePtr, expNodePtr, symbolTablePtr);
		  // isNewExp = FALSE;
		  return(FALSE);

		case NODE_TYPE_NEW_EXP:
		  GenerateNewExpCode(classNodePtr, expNodePtr, symbolTablePtr);
		  // isNewExp = TRUE;
		  return(FALSE);

		case NODE_TYPE_UNARY_EXP:
		  // isNewExp = FALSE;
		  return(GenerateUnaryExpCode(
				classNodePtr,
				expNodePtr,
				symbolTablePtr));

		default:
		  GenerateBinaryExpCode(
				classNodePtr,
				expNodePtr,
				symbolTablePtr);
		  // isNewExp = FALSE;
		  return(FALSE);
	}
}

static void GenerateReadExpCode(
			NodePtr		classNodePtr,
			NodePtr		nameNodePtr,
			SymbolTablePtr	symbolTablePtr)
{
	GetNextAddressVarID();

	fprintf(CFileFp,
		STRING_TMP_VAR_FMT,
		addressVarID,
		addressVarID + 1);

	fprintf(CFileFp,
		STRING_READ,
		addressVarID);
}

static void GenerateNewExpCode(
			NodePtr		classNodePtr,
			NodePtr		expNodePtr,
			SymbolTablePtr	symbolTablePtr)
{
	NodePtr	newClassNodePtr = NULL;
	NodePtr	newClassVarDecListNodePtr = NULL;
	NodePtr	indexListNodePtr = NULL;
	int	classVarNumber;
	int	tmpAddressVarID;


	if ((expNodePtr->children[1] == NULL) ||
	    (expNodePtr->children[1]->type == NODE_TYPE_ARG_LIST)) {
		newClassNodePtr = ClassNodeOfType(expNodePtr->typePtr);
		newClassVarDecListNodePtr =
			newClassNodePtr->children[1]->children[0];
		if (newClassVarDecListNodePtr == NULL) {
		  classVarNumber = 0;
		} else {
		  classVarNumber =
		    newClassVarDecListNodePtr->numberOfChildren;
		}

		GenerateReallocHeapCode1(classVarNumber);

		if (expNodePtr->children[1] != NULL) {
		  GenerateProtectEnvCode();

		  GenerateNewEnvCode(
			classNodePtr,
			expNodePtr->children[1],
			symbolTablePtr);

		  GenerateCallCode(
			newClassNodePtr->children[0]->info.lexeme,
			newClassNodePtr->children[0]->info.lexeme);

		  GenerateRestoreEnvCode();
		}

		fprintf(CFileFp,
			STRING_TMP_VAR_FMT,
			addressVarID,
			addressVarID + 1);

		fprintf(CFileFp,
			STRING_ASSIGN_OBJ_OFFSET_FMT,
			addressVarID);
	} else {
		indexListNodePtr = expNodePtr->children[1];
		// printf("indexListNodePtr has %d children\n",
		       // indexListNodePtr->numberOfChildren);

		fprintf(CFileFp,
			STRING_TMP_VAR_FMT,
			addressVarID,
			addressVarID + 1);
		tmpAddressVarID = addressVarID;
		GetNextAddressVarID();

		if (GenerateExpressionCode(
			classNodePtr,
			indexListNodePtr->children[0],
			symbolTablePtr) == TRUE) {
		  fprintf(CFileFp,
			  STRING_ASSIGN_CONST_FMT,
			  tmpAddressVarID,
			  indexListNodePtr->children[0]->info.value +
			  FIRST_CLASS_VAR_OFFSET);
		} else {
			fprintf(CFileFp,
				STRING_ASSIGN_VAR_1_FMT,
				tmpAddressVarID,
				addressVarID,
			  	FIRST_CLASS_VAR_OFFSET);
		}

		GenerateReallocHeapCode2(tmpAddressVarID);

		fprintf(CFileFp,
			STRING_TMP_VAR_FMT,
			addressVarID,
			addressVarID + 1);

		fprintf(CFileFp,
			STRING_ASSIGN_OBJ_OFFSET_FMT,
			addressVarID);
	}
}

static Boolean GenerateUnaryExpCode(
			NodePtr		classNodePtr,
			NodePtr		expNodePtr,
			SymbolTablePtr	symbolTablePtr)
{
	int	tmpAddressVarID;
	Boolean	isNumber;

	isNumber = GenerateExpressionCode(
			classNodePtr,
			expNodePtr->children[0],
			symbolTablePtr);

	tmpAddressVarID = addressVarID;
	GetNextAddressVarID();

	fprintf(CFileFp,
		STRING_TMP_VAR_FMT,
		addressVarID,
		addressVarID + 1);

	if (isNumber == TRUE) {
		fprintf(CFileFp,
			STRING_UNARY_EXP_1_FMT,
			addressVarID,
			expNodePtr->info.lexeme,
			expNodePtr->children[0]->info.lexeme);
	} else {
		fprintf(CFileFp,
			STRING_UNARY_EXP_2_FMT,
			addressVarID,
			expNodePtr->info.lexeme,
			tmpAddressVarID);
	}

	#ifdef 0
	fprintf(CFileFp,
		STRING_LOCAL_VAR_FMT,
		addressVarID,
		addressVarID + FIRST_LOCAL_VAR_OFFSET);
	tmpAddressVarID = addressVarID;

	if (GenerateExpressionCode(
			classNodePtr,
			expNodePtr->children[0],
			symbolTablePtr) == TRUE) {
		fprintf(CFileFp,
			STRING_UNARY_EXP_1_FMT,
			tmpAddressVarID,
			expNodePtr->info.lexeme,
			expNodePtr->children[0]->info.lexeme);
	} else {
		fprintf(CFileFp,
			STRING_UNARY_EXP_2_FMT,
			tmpAddressVarID,
			expNodePtr->info.lexeme,
			addressVarID);
	}
	#endif
}

static void GenerateBinaryExpCode(
			NodePtr		classNodePtr,
			NodePtr		expNodePtr,
			SymbolTablePtr	symbolTablePtr)
{
	NodePtr	expNode1Ptr = NULL;
	NodePtr	expNode2Ptr = NULL;
	Boolean	exp1IsNumber;
	Boolean	exp2IsNumber;
	int	addressVarID1;
	int	addressVarID2;

	expNode1Ptr = expNodePtr->children[0];
	expNode2Ptr = expNodePtr->children[1];

	exp1IsNumber = GenerateExpressionCode(
			classNodePtr, 
			expNode1Ptr,
			symbolTablePtr);

	addressVarID1 = addressVarID;
	GetNextAddressVarID();

	exp2IsNumber = GenerateExpressionCode(
			classNodePtr, 
			expNode2Ptr,
			symbolTablePtr);

	addressVarID2 = addressVarID;
	GetNextAddressVarID();

	fprintf(CFileFp,
		STRING_TMP_VAR_FMT,
		addressVarID,
		addressVarID + 1);

	if (exp1IsNumber == TRUE) {
		if (exp2IsNumber == TRUE) {
			fprintf(CFileFp,
				STRING_BINARY_EXP_1_FMT,
				addressVarID,
				expNode1Ptr->info.value,
				expNodePtr->info.lexeme,
				expNode1Ptr->info.value);
		} else {
			fprintf(CFileFp,
				STRING_BINARY_EXP_2_FMT,
				addressVarID,
				expNode1Ptr->info.value,
				expNodePtr->info.lexeme,
				addressVarID2);
		}
	} else {
		if (exp2IsNumber == TRUE) {
			fprintf(CFileFp,
				STRING_BINARY_EXP_3_FMT,
				addressVarID,
				addressVarID1,
				expNodePtr->info.lexeme,
				expNode2Ptr->info.value);
		} else {
			fprintf(CFileFp,
				STRING_BINARY_EXP_4_FMT,
				addressVarID,
				addressVarID1,
				expNodePtr->info.lexeme,
				addressVarID2);
		}
	}
}

static void GenerateNameCode(
			NodePtr		classNodePtr,
			NodePtr		nameNodePtr,
			Boolean		isTop,
			SymbolTablePtr	symbolTablePtr)
{
	NodePtr	varNodePtr = NULL;
	NodePtr	attributeNodePtr = NULL;
	NodePtr	subClassNodePtr = NULL;

	if (nameNodePtr == NULL) {
		return;
	}

	fprintf(CFileFp, STRING_NEW_LINE);

	varNodePtr = nameNodePtr->children[0];

	switch (varNodePtr->type) {
		case NODE_TYPE_KEYWORD:
		  GenerateThisObjectAddressCode();
		  break;

		case NODE_TYPE_IDENTIFIER:
		  GenerateIdentifierCode(
			classNodePtr,
			varNodePtr,
			isTop,
			symbolTablePtr);
		  break;

		case NODE_TYPE_ARRAY_ACCESS:
		  GenerateArrayAccessCode(
			classNodePtr,
			varNodePtr,
			isTop,
			symbolTablePtr);
		  break;

		default:
		  break;
	}

	if (nameNodePtr->numberOfChildren > 1) {
		if (IsArrayType(varNodePtr->typePtr) == TRUE) {
		  attributeNodePtr = nameNodePtr->children[1]->children[0];
                  if (strcmp(attributeNodePtr->info.lexeme,
                             STRING_LENGTH) == 0) {
		    GenerateGetArrayLengthCode();
		    return;
		  }
		} else {
		  subClassNodePtr = ClassNodeOfType(varNodePtr->typePtr);
		  GenerateCheckNullCode();
		  GenerateNameCode(subClassNodePtr,
				   nameNodePtr->children[1],
				   FALSE,
				   subClassNodePtr->info.symbolTablePtr);
		}
	}

	fprintf(CFileFp, STRING_NEW_LINE);
}

static void GenerateIdentifierCode(
			NodePtr		classNodePtr,
			NodePtr		varNodePtr,
			Boolean		isTop,
			SymbolTablePtr	symbolTablePtr)
{
	ElementPtr	elementPtr = NULL;

	if (isTop == TRUE) {
		elementPtr = Lookup(symbolTablePtr,
				    varNodePtr->info.lexeme);
		if (elementPtr == NULL) {
		  elementPtr = Lookup(classNodePtr->info.symbolTablePtr,
				      varNodePtr->info.lexeme);
		  GenerateThisObjectAddressCode();
		  GenerateClassVarAddressCode(elementPtr->offset);
		} else {
		  GenerateLocalVarAddressCode(elementPtr->offset);
		}
	} else {
		elementPtr = Lookup(classNodePtr->info.symbolTablePtr,
				    varNodePtr->info.lexeme);
		GenerateClassVarAddressCode(elementPtr->offset);
	}
}

static void GenerateArrayAccessCode(
			NodePtr		classNodePtr,
			NodePtr		varNodePtr,
			Boolean		isTop,
			SymbolTablePtr	symbolTablePtr)
{
	NodePtr	idNodePtr = NULL;
	int	dimension;
	int	idAddressVarID;
	int	expAddressVarID;
	Boolean	isNumber;
	int	i;

	idNodePtr = varNodePtr->children[0];

	dimension = varNodePtr->numberOfChildren - 1;

	GenerateIdentifierCode(
		classNodePtr,
		idNodePtr,
		isTop,
		symbolTablePtr);

	idAddressVarID = addressVarID;

	GenerateCheckNullCode();

	GetNextAddressVarID();

	for (i = 0; i < dimension; i ++) {
		isNumber = GenerateExpressionCode(
				classNodePtr,
				varNodePtr->children[1 + i],
				symbolTablePtr);

		expAddressVarID = addressVarID;
		GetNextAddressVarID();
		fprintf(CFileFp,
			STRING_TMP_VAR_FMT,
			addressVarID,
			addressVarID + 1);
		if (isNumber == TRUE) {
		  fprintf(CFileFp,
			  STRING_ASSIGN_CONST_FMT,
			  addressVarID,
			  varNodePtr->children[1 + i]->info.value +
			  FIRST_CLASS_VAR_OFFSET);
		} else {
		  fprintf(CFileFp,
			  STRING_ASSIGN_VAR_1_FMT,
			  addressVarID,
			  expAddressVarID,
			  FIRST_CLASS_VAR_OFFSET);
		}

		GenerateCheckArrayLengthCode(idAddressVarID, addressVarID);
		expAddressVarID = addressVarID;
		GetNextAddressVarID();
		fprintf(CFileFp,
			STRING_TMP_VAR_FMT,
			addressVarID,
			addressVarID + 1);
		fprintf(CFileFp,
			STRING_ARRAY_INDEX_FMT,
			addressVarID,
			idAddressVarID,
			expAddressVarID);
		fprintf(CFileFp,
			STRING_ARRAY_ADDRESS_FMT,
			addressVarID,
			addressVarID);
	}
		
}

static void GenerateCheckNullCode()
{
	fprintf(CFileFp,
		STRING_SAVE_THIS_OBJ_OFFSET_FMT,
		addressVarID);

	fprintf(CFileFp,
		STRING_CHECK_NULL,
		addressVarID);
}
static void GenerateThisObjectAddressCode()
{
	fprintf(CFileFp,
		STRING_THIS_OBJ_ADDR_FMT,
		addressVarID);
}

static void GenerateClassVarAddressCode(int	offset)
{
	fprintf(CFileFp,
		STRING_CLS_VAR_ADDR_FMT_P1,
		addressVarID,
		addressVarID);
	fprintf(CFileFp,
		STRING_CLS_VAR_ADDR_FMT_P2,
		addressVarID,