optimizer.c

decafc的源代码

/****************************************************************************
 * File name:	optimizer.c						    *
 * Description: optimizer for decafc					    *
 * Input:       none							    *
 * Output:      none							    *
 * Author:      Luojian Chen                                                *
 * Date:        April 20, 1997						    *
 ****************************************************************************/


#include "optimizer.h"


extern ElementPtr	intTypePtr;

extern void	DeleteNode(NodePtr);
extern NodePtr	CreateNode(NodeType, ...);


void	OptimizeUnaryPlusExp(NodePtr *);
void	OptimizeUnaryMinusExp(NodePtr *);
void	OptimizeNotExp(NodePtr *);
void	OptimizeEqualExp(NodePtr *);
void	OptimizeNotEqualExp(NodePtr *);
void	OptimizeLessEqualExp(NodePtr *);
void	OptimizeGreaterEqualExp(NodePtr *);
void	OptimizeLessExp(NodePtr *);
void	OptimizeGreaterExp(NodePtr *);
void	OptimizePlusExp(NodePtr *);
void	OptimizeMinusExp(NodePtr *);
void	OptimizeOrExp(NodePtr *);
void	OptimizeMultiplyExp(NodePtr *);
void	OptimizeDivideExp(NodePtr *);
void	OptimizeModularExp(NodePtr *);
void	OptimizeAndExp(NodePtr *);


void OptimizeUnaryPlusExp(NodePtr	*unaryPlusExpNodePtrPtr)
{
	NodePtr	childNodePtr = NULL;

	if (*unaryPlusExpNodePtrPtr == NULL) {
		return;
	}

	childNodePtr = (*unaryPlusExpNodePtrPtr)->children[0];

	if (childNodePtr->type == NODE_TYPE_NUMBER) {
		*unaryPlusExpNodePtrPtr = childNodePtr;
		(*unaryPlusExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizeUnaryMiusExp(NodePtr	*unaryMinusExpNodePtrPtr)
{
	NodePtr	childNodePtr = NULL;

	if (*unaryMinusExpNodePtrPtr == NULL) {
		return;
	}

	childNodePtr = (*unaryMinusExpNodePtrPtr)->children[0];

	if (childNodePtr->type == NODE_TYPE_NUMBER) {
		childNodePtr->info.value = -childNodePtr->info.value;
		*unaryMinusExpNodePtrPtr = childNodePtr;
		(*unaryMinusExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizeNotExp(NodePtr	*notExpNodePtrPtr)
{
	NodePtr	childNodePtr = NULL;

	if (*notExpNodePtrPtr == NULL) {
		return;
	}

	childNodePtr = (*notExpNodePtrPtr)->children[0];

	if (childNodePtr->type == NODE_TYPE_NUMBER) {
		if (childNodePtr->info.value == 0) {
			childNodePtr->info.value = 1;
		} else {
			childNodePtr->info.value = 0;
		}

		*notExpNodePtrPtr = childNodePtr;
		(*notExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizeEqualExp(NodePtr	*equalExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*equalExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*equalExpNodePtrPtr)->children[0];
	exp2NodePtr = (*equalExpNodePtrPtr)->children[1];

	if ((exp1NodePtr->type == NODE_TYPE_NUMBER) &&
	    (exp2NodePtr->type == NODE_TYPE_NUMBER)) {
		if (exp1NodePtr->info.value == exp2NodePtr->info.value) {
			value = 1;
		} else {
			value = 0;
		}

		DeleteNode(*equalExpNodePtrPtr);
		*equalExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER,
					      value,
					      0);
		(*equalExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizeNotEqualExp(NodePtr	*notEqualExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*notEqualExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*notEqualExpNodePtrPtr)->children[0];
	exp2NodePtr = (*notEqualExpNodePtrPtr)->children[1];

	if ((exp1NodePtr->type == NODE_TYPE_NUMBER) &&
	    (exp2NodePtr->type == NODE_TYPE_NUMBER)) {
		if (exp1NodePtr->info.value != exp2NodePtr->info.value) {
			value = 1;
		} else {
			value = 0;
		}

		DeleteNode(*notEqualExpNodePtrPtr);
		*notEqualExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER,
						    value,
						    0);
		(*notEqualExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizeLessEqualExp(NodePtr	*lessEqualExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*lessEqualExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*lessEqualExpNodePtrPtr)->children[0];
	exp2NodePtr = (*lessEqualExpNodePtrPtr)->children[1];

	if ((exp1NodePtr->type == NODE_TYPE_NUMBER) &&
	    (exp2NodePtr->type == NODE_TYPE_NUMBER)) {
		if (exp1NodePtr->info.value <= exp2NodePtr->info.value) {
			value = 1;
		} else {
			value = 0;
		}

		DeleteNode(*lessEqualExpNodePtrPtr);
		*lessEqualExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER,
					      value,
					      0);
		(*lessEqualExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizeGreaterEqualExp(NodePtr	*greaterEqualExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*greaterEqualExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*greaterEqualExpNodePtrPtr)->children[0];
	exp2NodePtr = (*greaterEqualExpNodePtrPtr)->children[1];

	if ((exp1NodePtr->type == NODE_TYPE_NUMBER) &&
	    (exp2NodePtr->type == NODE_TYPE_NUMBER)) {
		if (exp1NodePtr->info.value >= exp2NodePtr->info.value) {
			value = 1;
		} else {
			value = 0;
		}

		DeleteNode(*greaterEqualExpNodePtrPtr);
		*greaterEqualExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER,
					      value,
					      0);
		(*greaterEqualExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizeLessExp(NodePtr	*lessExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*lessExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*lessExpNodePtrPtr)->children[0];
	exp2NodePtr = (*lessExpNodePtrPtr)->children[1];

	if ((exp1NodePtr->type == NODE_TYPE_NUMBER) &&
	    (exp2NodePtr->type == NODE_TYPE_NUMBER)) {
		if (exp1NodePtr->info.value < exp2NodePtr->info.value) {
			value = 1;
		} else {
			value = 0;
		}

		DeleteNode(*lessExpNodePtrPtr);
		*lessExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER,
					      value,
					      0);
		(*lessExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizeGreaterExp(NodePtr	*greaterExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*greaterExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*greaterExpNodePtrPtr)->children[0];
	exp2NodePtr = (*greaterExpNodePtrPtr)->children[1];

	if ((exp1NodePtr->type == NODE_TYPE_NUMBER) &&
	    (exp2NodePtr->type == NODE_TYPE_NUMBER)) {
		if (exp1NodePtr->info.value > exp2NodePtr->info.value) {
			value = 1;
		} else {
			value = 0;
		}

		DeleteNode(*greaterExpNodePtrPtr);
		*greaterExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER,
					      value,
					      0);
		(*greaterExpNodePtrPtr)->typePtr = intTypePtr;
	}
}

void OptimizePlusExp(NodePtr	*plusExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*plusExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*plusExpNodePtrPtr)->children[0];
	exp2NodePtr = (*plusExpNodePtrPtr)->children[1];

	if (exp1NodePtr->type == NODE_TYPE_NUMBER) {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    value = exp1NodePtr->info.value + exp2NodePtr->info.value;
	    DeleteNode(*plusExpNodePtrPtr);
	    *plusExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	    (*plusExpNodePtrPtr)->typePtr = intTypePtr;
	  } else {
	    if (exp1NodePtr->info.value == 0) {
	      DeleteNode(exp1NodePtr);
	      *plusExpNodePtrPtr = exp2NodePtr;
	    }
	  }
	} else {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    if (exp2NodePtr->info.value == 0) {
	      DeleteNode(exp2NodePtr);
	      *plusExpNodePtrPtr = exp1NodePtr;
	    }
	  }
	}
}

void OptimizeMinusExp(NodePtr	*minusExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*minusExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*minusExpNodePtrPtr)->children[0];
	exp2NodePtr = (*minusExpNodePtrPtr)->children[1];

	if (exp1NodePtr->type == NODE_TYPE_NUMBER) {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    value = exp1NodePtr->info.value - exp2NodePtr->info.value;
	    DeleteNode(*minusExpNodePtrPtr);
	    *minusExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	    (*minusExpNodePtrPtr)->typePtr = intTypePtr;
	  }
	} else {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    if (exp2NodePtr->info.value == 0) {
	      DeleteNode(exp2NodePtr);
	      *minusExpNodePtrPtr = exp1NodePtr;
	    }
	  }
	}
}

void OptimizeOrExp(NodePtr	*orExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*orExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*orExpNodePtrPtr)->children[0];
	exp2NodePtr = (*orExpNodePtrPtr)->children[1];

	if (exp1NodePtr->type == NODE_TYPE_NUMBER) {
	  if (exp1NodePtr->info.value != 0) {
	    value = 1;
	    DeleteNode(*orExpNodePtrPtr);
	    *orExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	    (*orExpNodePtrPtr)->typePtr = intTypePtr;
	  } else {
	    if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	      if (exp2NodePtr->info.value != 0) {
		value = 1;
	      } else {
		value = 0;
	      }
	      DeleteNode(*orExpNodePtrPtr);
	      *orExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	      (*orExpNodePtrPtr)->typePtr = intTypePtr;
	    } else {
	      DeleteNode(*orExpNodePtrPtr);
	      *orExpNodePtrPtr = exp2NodePtr;
	    }
	  }
	} else {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    if (exp2NodePtr->info.value != 0) {
	      value = 1;
	      DeleteNode(*orExpNodePtrPtr);
	      *orExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	      (*orExpNodePtrPtr)->typePtr = intTypePtr;
	    } else {
	      DeleteNode(*orExpNodePtrPtr);
	      *orExpNodePtrPtr = exp1NodePtr;
	    }
	  }
	}
}

void OptimizeMultiplyExp(NodePtr	*multiplyExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*multiplyExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*multiplyExpNodePtrPtr)->children[0];
	exp2NodePtr = (*multiplyExpNodePtrPtr)->children[1];

	if (exp1NodePtr->type == NODE_TYPE_NUMBER) {
	  if (exp1NodePtr->info.value == 0) {
	    value = 0;
	    DeleteNode(*multiplyExpNodePtrPtr);
	    *multiplyExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	    (*multiplyExpNodePtrPtr)->typePtr = intTypePtr;
	  } else {
	    if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	      value = exp1NodePtr->info.value * exp2NodePtr->info.value;
	      DeleteNode(*multiplyExpNodePtrPtr);
	      *multiplyExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	      (*multiplyExpNodePtrPtr)->typePtr = intTypePtr;
	    } else {
	      if (exp1NodePtr->info.value == 1) {
	        DeleteNode(*multiplyExpNodePtrPtr);
	        *multiplyExpNodePtrPtr = exp2NodePtr; 
	      }
	    }
	  }
	} else {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    if (exp2NodePtr->info.value == 0) {
	      value = 0;
	      DeleteNode(*multiplyExpNodePtrPtr);
	      *multiplyExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	      (*multiplyExpNodePtrPtr)->typePtr = intTypePtr;
	    } else {
	      if (exp2NodePtr->info.value == 1) {
	        DeleteNode(*multiplyExpNodePtrPtr);
	        *multiplyExpNodePtrPtr = exp1NodePtr; 
	      }
	    }
	  }
	}
}

void OptimizeDivideExp(NodePtr	*divideExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*divideExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*divideExpNodePtrPtr)->children[0];
	exp2NodePtr = (*divideExpNodePtrPtr)->children[1];

	if (exp1NodePtr->type == NODE_TYPE_NUMBER) {
	  if (exp1NodePtr->info.value == 0) {
	    value = 0;
	    DeleteNode(*divideExpNodePtrPtr);
	    *divideExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	    (*divideExpNodePtrPtr)->typePtr = intTypePtr;
	  } else {
	    if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	      if (exp2NodePtr->info.value == 0) {
		ReportError(ERROR_ZERO_DIVISOR,
			    STRING_ZERO,
			    exp2NodePtr->lineNumber,
			    exp2NodePtr->columnNumber);
	      } else {
	        value = exp1NodePtr->info.value / exp2NodePtr->info.value;
	        DeleteNode(*divideExpNodePtrPtr);
	        *divideExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	        (*divideExpNodePtrPtr)->typePtr = intTypePtr;
	      }
	    }
	  }
	} else {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    if (exp2NodePtr->info.value == 0) {
	      ReportError(ERROR_ZERO_DIVISOR,
			  STRING_ZERO,
			  exp2NodePtr->lineNumber,
			  exp2NodePtr->columnNumber);
	    } else {
	      if (exp2NodePtr->info.value == 1) {
	        DeleteNode(*divideExpNodePtrPtr);
	        *divideExpNodePtrPtr = exp1NodePtr; 
	      }
	    }
	  }
	}
}

void OptimizeModularExp(NodePtr	*modularExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*modularExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*modularExpNodePtrPtr)->children[0];
	exp2NodePtr = (*modularExpNodePtrPtr)->children[1];

	if (exp1NodePtr->type == NODE_TYPE_NUMBER) {
	  if (exp1NodePtr->info.value == 0) {
	    value = 0;
	    DeleteNode(*modularExpNodePtrPtr);
	    *modularExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	    (*modularExpNodePtrPtr)->typePtr = intTypePtr;
	  } else {
	    if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	      if (exp2NodePtr->info.value == 0) {
		ReportError(ERROR_ZERO_DIVISOR,
			    STRING_ZERO,
			    exp2NodePtr->lineNumber,
			    exp2NodePtr->columnNumber);
	      } else {
	        value = exp1NodePtr->info.value % exp2NodePtr->info.value;
	        DeleteNode(*modularExpNodePtrPtr);
	        *modularExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	        (*modularExpNodePtrPtr)->typePtr = intTypePtr;
	      }
	    }
	  }
	} else {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    if (exp2NodePtr->info.value == 0) {
	      ReportError(ERROR_ZERO_DIVISOR,
			  STRING_ZERO,
			  exp2NodePtr->lineNumber,
			  exp2NodePtr->columnNumber);
	    } else {
	      if (exp2NodePtr->info.value == 1) {
	        DeleteNode(*modularExpNodePtrPtr);
	        *modularExpNodePtrPtr = exp1NodePtr; 
	      }
	    }
	  }
	}
}

void OptimizeAndExp(NodePtr	*andExpNodePtrPtr)
{
	NodePtr	exp1NodePtr = NULL;
	NodePtr	exp2NodePtr = NULL;
	int	value;

	if (*andExpNodePtrPtr == NULL) {
		return;
	}

	exp1NodePtr = (*andExpNodePtrPtr)->children[0];
	exp2NodePtr = (*andExpNodePtrPtr)->children[1];

	if (exp1NodePtr->type == NODE_TYPE_NUMBER) {
	  if (exp1NodePtr->info.value == 0) {
	    value = 0;
	    DeleteNode(*andExpNodePtrPtr);
	    *andExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	    (*andExpNodePtrPtr)->typePtr = intTypePtr;
	  } else {
	    if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	      if (exp2NodePtr->info.value == 0) {
		value = 0;
	      } else {
		value = 1;
	      }
	      DeleteNode(*andExpNodePtrPtr);
	      *andExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	      (*andExpNodePtrPtr)->typePtr = intTypePtr;
	    } else {
	      DeleteNode(*andExpNodePtrPtr);
	      *andExpNodePtrPtr = exp2NodePtr;
	    }
	  }
	} else {
	  if (exp2NodePtr->type == NODE_TYPE_NUMBER) {
	    if (exp2NodePtr->info.value == 0) {
	      value = 0;
	      DeleteNode(*andExpNodePtrPtr);
	      *andExpNodePtrPtr = CreateNode(NODE_TYPE_NUMBER, value, 0);
	      (*andExpNodePtrPtr)->typePtr = intTypePtr;
	    } else {
	      DeleteNode(*andExpNodePtrPtr);
	      *andExpNodePtrPtr = exp1NodePtr;
	    }
	  }
	}
}