/**
* Parse an expression
*
* @param token the initial token.
* @return the root of the generated parse subtree.
* @throws Exception if an error occurred.
*/
private ICodeNode parseExpression(Token token) throws Exception {
// Parse a simple expression and make the root of its tree
// the root node.
ICodeNode rootNode = parseSimpleExpression(token);
TypeSpec resultType = rootNode != null ? rootNode.getTypeSpec() : Predefined.undefinedType;
token = currentToken();
TokenType tokenType = token.getType();
// Look for a relational operator.
if (REL_OPS.contains(tokenType)) {
// Create a new operator node and adopt the current tree as its first child
ICodeNodeType nodeType = REL_OPS_MAP.get(tokenType);
ICodeNode opNode = ICodeFactory.createICodeNode(nodeType);
opNode.addChild(rootNode);
token = nextToken(); // consume the operator
// Parse the second simple expression.
// The operator node adopts the simple expression's tree as its second child.
ICodeNode simExprNode = parseSimpleExpression(token);
opNode.addChild(simExprNode);
// The operator node becomes the new root node.
rootNode = opNode;
// Type check: The operands must be comparison compatible.
TypeSpec simExprType =
simExprNode != null ? simExprNode.getTypeSpec() : Predefined.undefinedType;
if (TypeChecker.areComparisionCompatible(resultType, simExprType))
resultType = Predefined.booleanType;
else {
errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
resultType = Predefined.undefinedType;
}
}
if (rootNode != null) rootNode.setTypeSpec(resultType);
return rootNode;
}
/**
* Parse a term.
*
* @param token the initial token.
* @return the root of the generated parse subtree.
* @throws Exception if an error occurred.
*/
private ICodeNode parseTerm(Token token) throws Exception {
// Parse a factor and makes its node the root node.
ICodeNode rootNode = parseFactor(token);
TypeSpec resultType = rootNode != null ? rootNode.getTypeSpec() : Predefined.undefinedType;
token = currentToken();
TokenType tokenType = token.getType();
// Loop over multiplicative operators.
while (MULT_OPS.contains(tokenType)) {
TokenType operator = tokenType;
// Create a new operator node and adopt the current tree as its first child.
ICodeNodeType nodeType = MULT_OPS_OPS_MAP.get(operator);
ICodeNode opNode = ICodeFactory.createICodeNode(nodeType);
opNode.addChild(rootNode);
token = nextToken(); // consume the operator
// Parse another factor.
// The operator node adopts the term's tree as its secomd child.
ICodeNode factorNode = parseFactor(token);
opNode.addChild(factorNode);
TypeSpec factorType =
factorNode != null ? factorNode.getTypeSpec() : Predefined.undefinedType;
// The operator node becomes the new root node.
rootNode = opNode;
// Determine the result type.
switch ((PascalTokenType) operator) {
case STAR:
{
// Both operands integer ==> integer result.
if (TypeChecker.areBothInteger(resultType, factorType)) {
resultType = Predefined.integerType;
}
// Both real operands or one real and one integer operand
// ==> real result.
else if (TypeChecker.isAtLeastOneReal(resultType, factorType)) {
resultType = Predefined.realType;
} else {
errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
}
break;
}
case SLASH:
{
// All integer and real operand combinations
// ==> real result.
if (TypeChecker.areBothInteger(resultType, factorType)
|| TypeChecker.isAtLeastOneReal(resultType, factorType)) {
resultType = Predefined.realType;
} else {
errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
}
break;
}
case DIV:
case MOD:
{
// Both operands integer ==> integer result.
if (TypeChecker.areBothInteger(resultType, factorType)) {
resultType = Predefined.integerType;
} else {
errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
}
break;
}
case AND:
{
// Both operands boolean ==> boolean result.
if (TypeChecker.areBothBoolean(resultType, factorType)) {
resultType = Predefined.booleanType;
} else {
errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
}
break;
}
}
// The operator node becomes the new root node.
rootNode.setTypeSpec(resultType);
token = currentToken();
tokenType = token.getType();
}
return rootNode;
}
/**
* Parse a factor.
*
* @param token the initial token.
* @return the root of the generated parse subtree.
* @throws Exception if an error occurred.
*/
private ICodeNode parseFactor(Token token) throws Exception {
TokenType tokenType = token.getType();
ICodeNode rootNode = null;
switch ((PascalTokenType) tokenType) {
case IDENTIFIER:
{
return parseIdentifier(token);
}
case INTEGER:
{
// Create an INTEGER_CONSTANT node as the root node
rootNode = ICodeFactory.createICodeNode(INTEGER_CONSTANT);
rootNode.setAttribute(VALUE, token.getValue());
token = nextToken(); // consume the number
rootNode.setTypeSpec(Predefined.integerType);
break;
}
case REAL:
{
// Create an REAL_CONSTANT node as the root node.
rootNode = ICodeFactory.createICodeNode(REAL_CONSTANT);
rootNode.setAttribute(VALUE, token.getValue());
token = nextToken(); // consume the number
rootNode.setTypeSpec(Predefined.realType);
break;
}
case STRING:
{
String value = (String) token.getValue();
// Create a STRING_CONSTANT node as the root node.
rootNode = ICodeFactory.createICodeNode(STRING_CONSTANT);
rootNode.setAttribute(VALUE, value);
TypeSpec resultType =
value.length() == 1 ? Predefined.charType : TypeFactory.createStringType(value);
token = nextToken(); // consume the string
rootNode.setTypeSpec(resultType);
break;
}
case NOT:
{
token = nextToken(); // consume the NOT
// Create a NOT node as the root node.
rootNode = ICodeFactory.createICodeNode(ICodeNodeTypeImpl.NOT);
// Parse the factor. The NOT node adopts the factor node as its child.
ICodeNode factorNode = parseFactor(token);
rootNode.addChild(factorNode);
// Type check: the factor must be boolean.
TypeSpec factorType =
factorNode != null ? factorNode.getTypeSpec() : Predefined.undefinedType;
if (!TypeChecker.isBoolean(factorType))
errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
rootNode.setTypeSpec(Predefined.booleanType);
break;
}
case LEFT_PAREN:
{
token = nextToken(); // consume the (
// Parse an expression and make its node the root node.
rootNode = parseExpression(token);
TypeSpec resultType =
rootNode != null ? rootNode.getTypeSpec() : Predefined.undefinedType;
// Look for the matching ) token.
token = currentToken();
if (token.getType() == RIGHT_PAREN) token = nextToken(); // consume the )
else errorHandler.flag(token, MISSING_RIGHT_PAREN, this);
rootNode.setTypeSpec(resultType);
break;
}
default:
{
errorHandler.flag(token, UNEXPECTED_TOKEN, this);
break;
}
}
return rootNode;
}
/**
* Parse a simple expression.
*
* @param token the initial token.
* @return the root of the generated parse subtree.
* @throws Exception if an error occurred.
*/
private ICodeNode parseSimpleExpression(Token token) throws Exception {
Token signToken = null;
TokenType signType = null; // type of leading sign (if any)
// Look for a leading + or - sign
TokenType tokenType = token.getType();
if ((tokenType == PLUS) || (tokenType == MINUS)) {
signType = tokenType;
signToken = token;
token = nextToken(); // consume the + or -
}
// Parse a term and make the root of its tree the root node.
ICodeNode rootNode = parseTerm(token);
TypeSpec resultType = rootNode != null ? rootNode.getTypeSpec() : Predefined.undefinedType;
// Type check: Leading sign.
if ((signType != null) && (!TypeChecker.isIntegerOrReal(resultType)))
errorHandler.flag(signToken, INCOMPATIBLE_TYPES, this);
// Was there a leading - sign?
if (signType == MINUS) {
// Create a NEGATE node and adopt the current tree as its child.
// The NEGATE node becomes the new root node.
ICodeNode negateNode = ICodeFactory.createICodeNode(NEGATE);
negateNode.addChild(rootNode);
negateNode.setTypeSpec(rootNode.getTypeSpec());
rootNode = negateNode;
}
token = currentToken();
tokenType = token.getType();
// Loop over additive operators.
while (ADD_OPS.contains(tokenType)) {
TokenType operator = tokenType;
// Create a new operator node and adopt the current tree as its first child.
ICodeNodeType nodeType = ADD_OPS_OPS_MAP.get(operator);
ICodeNode opNode = ICodeFactory.createICodeNode(nodeType);
opNode.addChild(rootNode);
token = nextToken(); // consume the operator
// Parse another term.
// The operator node adopts the term's tree as its second child.
ICodeNode termNode = parseTerm(token);
opNode.addChild(termNode);
TypeSpec termType = termNode != null ? termNode.getTypeSpec() : Predefined.undefinedType;
// The operator node becomes the new root node.
rootNode = opNode;
switch ((PascalTokenType) operator) {
case PLUS:
case MINUS:
{
// Both operands integer => integer result.
if (TypeChecker.areBothInteger(resultType, termType))
resultType = Predefined.integerType;
// Both real operands or one real and one integer operand => real result.
else if (TypeChecker.isAtLeastOneReal(resultType, termType))
resultType = Predefined.realType;
else errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
break;
}
case OR:
{
// Both operands boolean ==> boolean result.
if (TypeChecker.areBothBoolean(resultType, termType))
resultType = Predefined.booleanType;
else errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
break;
}
}
rootNode.setTypeSpec(resultType);
token = currentToken();
tokenType = token.getType();
}
return rootNode;
}