/**
* 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 make its node the root node.
ICodeNode rootNode = parseFactor(token);
token = currentToken();
TokenType tokenType = token.getType();
// Loop over multiplicative operators.
while (MULT_OPS.contains(tokenType)) {
// Create a new operator node and adopt the current tree
// as its first child.
ICodeNodeType nodeType = MULT_OPS_OPS_MAP.get(tokenType);
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 second child.
opNode.addChild(parseFactor(token));
// The operator node becomes the new root node.
rootNode = opNode;
token = currentToken();
tokenType = token.getType();
}
return rootNode;
}
public void parse(Token token) throws Exception {
token = synchronize(IDENTIFIER_SET);
// 遍历由分号分割的一系列变量申明
while (token.getType() == IDENTIFIER) {
// 解析每一个子表标识申明，比如 a,b,c : int
parseIdentifierSublist(token);
token = currentToken();
TokenType tokenType = token.getType();
// 一个定义由分号结束
if (tokenType == SEMICOLON) {
while (token.getType() == SEMICOLON) {
token = nextToken(); // consume the ;
}
} else if (NEXT_START_SET.contains(tokenType)) {
// 没有分号便开始下一个了。
errorHandler.flag(token, MISSING_SEMICOLON, this);
}
token = synchronize(IDENTIFIER_SET);
}
}
/**
* 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 {
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;
token = nextToken(); // consume the + or -
}
// Parse a term and make the root of its tree the root node.
ICodeNode rootNode = parseTerm(token);
// 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);
rootNode = negateNode;
}
token = currentToken();
tokenType = token.getType();
// Loop over additive operators.
while (ADD_OPS.contains(tokenType)) {
// Create a new operator node and adopt the current tree
// as its first child.
ICodeNodeType nodeType = ADD_OPS_OPS_MAP.get(tokenType);
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.
opNode.addChild(parseTerm(token));
// The operator node becomes the new root node.
rootNode = opNode;
token = currentToken();
tokenType = token.getType();
}
return rootNode;
}
/**
* 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);
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.
opNode.addChild(parseSimpleExpression(token));
// The operator node becomes the new root node.
rootNode = opNode;
}
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 make its node the root node.
ICodeNode rootNode = parseFactor(token);
token = currentToken();
TokenType tokenType = token.getType();
if (rootNode.getType() == ICodeNodeTypeImpl.SET
&& (tokenType == PascalTokenType.OR || tokenType == PascalTokenType.AND)) {
errorHandler.flag(token, INVALID_OPERATOR, this);
}
// Loop over multiplicative operators.
while (MULT_OPS.contains(tokenType)) {
// Create a new operator node and adopt the current tree
// as its first child.
ICodeNodeType nodeType = MULT_OPS_OPS_MAP.get(tokenType);
ICodeNode opNode = ICodeFactory.createICodeNode(nodeType);
opNode.addChild(rootNode);
switch ((ICodeNodeTypeImpl) opNode.getType()) {
case INTEGER_DIVIDE:
case FLOAT_DIVIDE:
if (rootNode.getType() == ICodeNodeTypeImpl.SET) {
errorHandler.flag(token, INVALID_OPERATOR, this);
}
}
token = nextToken(); // consume the operator
// Parse another factor. The operator node adopts
// the term's tree as its second child.
opNode.addChild(parseFactor(token));
// The operator node becomes the new root node.
rootNode = opNode;
token = currentToken();
tokenType = token.getType();
}
return rootNode;
}
/**
* Parse a set.
*
* @param token the initial token.
* @return the root of the generated parse subtree.
* @throws Exception if an error occurred.
*/
private ICodeNode parseSet(Token token) throws Exception {
ICodeNode rootNode = ICodeFactory.createICodeNode(SETS);
int tempInteger = 0;
token = nextToken(); // consume left bracket
while (token.getType() != RIGHT_BRACKET) {
if (token.getType() == INTEGER) {
tempInteger = (int) token.getValue();
rootNode.addChild(parseTerm(token));
token = currentToken();
} else if (token.getType() == IDENTIFIER) {
ICodeNode var = parseFactor(token);
rootNode.addChild(var);
token = currentToken();
}
if (token.getType() == COMMA) {
token = nextToken(); // consume next token
if (token.getType() == COMMA) {
errorHandler.flag(token, EXTRA_COMMA, this);
}
} else if (token.getType() == RIGHT_BRACKET) { // do nothing
} else if (token.getType() == SEMICOLON) {
errorHandler.flag(token, MISSING_CLOSE_SQUARE_BRACKET, this);
break;
} else if (token.getType() == DOT_DOT) {
token = nextToken(); // consume the integer.
// Create a STRING_CONSTANT node as the root node.
ICodeNode node = ICodeFactory.createICodeNode(SUBRANGE);
// denotes the maximum value of the range.
if (token.getType() != INTEGER) {
errorHandler.flag(token, MISSING_MAX_VAL_SUBRANGE, this);
} else {
int value = (int) token.getValue();
node.setAttribute(VALUE, value);
}
rootNode.addChild(node);
token = nextToken();
} else {
errorHandler.flag(token, MISSING_COMMA, this);
}
}
if (token.getType() != SEMICOLON) {
token = nextToken(); // consume right bracket
}
return rootNode;
}
/**
* 解析标识符子表及类型说明
*
* @param token the current token.
* @return 一个申明中的子表标识符列表
* @throws Exception
*/
protected ArrayList<SymTabEntry> parseIdentifierSublist(Token token) throws Exception {
ArrayList<SymTabEntry> sublist = new ArrayList<SymTabEntry>();
do {
token = synchronize(IDENTIFIER_START_SET);
SymTabEntry id = parseIdentifier(token);
if (id != null) {
sublist.add(id);
}
token = synchronize(COMMA_SET);
TokenType tokenType = token.getType();
// 找逗号
if (tokenType == COMMA) {
token = nextToken(); // 有逗号吞掉以便下一个
if (IDENTIFIER_FOLLOW_SET.contains(token.getType())) {
errorHandler.flag(token, MISSING_IDENTIFIER, this);
}
} else if (IDENTIFIER_START_SET.contains(tokenType)) {
errorHandler.flag(token, MISSING_COMMA, this);
}
} while (!IDENTIFIER_FOLLOW_SET.contains(token.getType()));
// 冒号后面的类型
TypeSpec type = parseTypeSpec(token);
// 将子表中的每个变量的类型设置上，比如a,b,c:int，先解析了a,b,c，然后解析了int类型
// 那么这儿就会给a,b,c设置上int类型
for (SymTabEntry variableId : sublist) {
variableId.setTypeSpec(type);
}
return sublist;
}
/**
* 解析变量申明里的类型
*
* @param token 当前token
* @return 类型说明
* @throws Exception
*/
protected TypeSpec parseTypeSpec(Token token) throws Exception {
// 同步在:处
token = synchronize(COLON_SET);
if (token.getType() == COLON) {
token = nextToken(); // 吞掉 :
} else {
errorHandler.flag(token, MISSING_COLON, this);
}
// 解析类型说明
TypeSpecificationParser typeSpecificationParser = new TypeSpecificationParser(this);
TypeSpec type = typeSpecificationParser.parse(token);
return type;
}
/**
* 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);
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);
ICodeNodeTypeImpl type = (ICodeNodeTypeImpl) opNode.getType();
if (type == LT || type == GT || type == IN_SET) {
if (rootNode.getType() == ICodeNodeTypeImpl.SET) {
errorHandler.flag(token, INVALID_OPERATOR, this);
}
}
Token previousToken = token;
token = nextToken(); // consume the operator
// Parse the second simple expression. The operator node adopts
// the simple expression's tree as its second child.
ICodeNode rightNode = parseSimpleExpression(token);
opNode.addChild(rightNode);
if (opNode.getType() == IN_SET && rightNode.getType() == INTEGER_CONSTANT) {
errorHandler.flag(previousToken, INVALID_OPERATOR, this);
}
// The operator node becomes the new root node.
rootNode = opNode;
}
return rootNode;
}
/**
* 解析标识符
*
* @param token
* @return 对应符号表项
* @throws Exception
*/
private SymTabEntry parseIdentifier(Token token) throws Exception {
SymTabEntry id = null;
if (token.getType() == IDENTIFIER) {
String name = token.getText().toLowerCase();
id = symTabStack.lookupLocal(name);
// 申明必须得没有，否则重定义了
if (id == null) {
id = symTabStack.enterLocal(name);
id.setDefinition(definition);
id.appendLineNumber(token.getLineNumber());
} else {
errorHandler.flag(token, IDENTIFIER_REDEFINED, this);
}
token = nextToken();
} else {
errorHandler.flag(token, MISSING_IDENTIFIER, this);
}
return id;
}
/**
* Parse a Triangle SingleDeclarationParser.
*
* <p>Single-Declaration ::= const Identifier ~ Expression | var Identifier : Type-Denoter | proc
* Identifier (Formal-Parameter-Sequence) ~ Single-Command | func Identifier
* (Formal-Parameter-Sequence) : Type-Denoter ~ Expression | Type Identifier ~ Type-Denoter
*
* <p>To be overridden by the specialized command parse subclasses.
*
* @param token the initial token.
* @return the root node of the generated parse tree.
* @throws Exception if an error occurred.
*/
public void parse(Token token) throws Exception {
SingleCommandParser singleCommand = null;
ExpressionParser expression = null;
FormalParameterSequenceParser formalParameterSequence = null;
TypeDenoterParser typeDenoter = null;
EnumSet<TriangleTokenType> syncSet = null;
TypeSpec identifierType = TrianglePredefined.undefinedType;
Token identifierToken = null;
ICode routineICode = null;
token = currentToken();
switch ((TriangleTokenType) token.getType()) {
case CONST:
identifierToken = nextToken();
syncSet = EnumSet.of(TILDE);
syncSet.addAll(ExpressionParser.FIRST_FOLLOW_SET);
synchronize(IDENTIFIER, MISSING_IDENTIFIER, syncSet);
syncSet.remove(TILDE);
token = synchronize(TILDE, MISSING_TILDE, syncSet);
expression = new ExpressionParser(this);
ICodeNode expressionNode = expression.parse(token);
SymTabEntry constantId = symTabStack.lookupLocal(identifierToken.getText().toLowerCase());
// Enter the new identifier into the symbol table
// but don't set how it's defined yet.
if (constantId == null) {
constantId = symTabStack.enterLocal(identifierToken.getText().toLowerCase());
constantId.setDefinition(DefinitionImpl.CONSTANT);
constantId.setAttribute(CONSTANT_VALUE, expressionNode);
constantId.appendLineNumber(identifierToken.getLineNumber());
constantId.setTypeSpec(expressionNode.getTypeSpec());
} else {
errorHandler.flag(identifierToken, IDENTIFIER_REDEFINED, this);
}
break;
case VAR:
identifierToken = nextToken();
syncSet = EnumSet.of(COLON);
syncSet.addAll(TypeDenoterParser.FIRST_FOLLOW_SET);
synchronize(IDENTIFIER, MISSING_IDENTIFIER, syncSet);
syncSet.remove(COLON);
token = synchronize(COLON, MISSING_COLON, syncSet);
typeDenoter = new TypeDenoterParser(this);
identifierType = typeDenoter.parse(token);
SymTabEntry variableId = symTabStack.lookupLocal(identifierToken.getText().toLowerCase());
// Enter the new identifier into the symbol table
// but don't set how it's defined yet.
if (variableId == null) {
variableId = symTabStack.enterLocal(identifierToken.getText().toLowerCase());
variableId.setDefinition(DefinitionImpl.VARIABLE);
variableId.appendLineNumber(identifierToken.getLineNumber());
variableId.setTypeSpec(identifierType);
} else {
errorHandler.flag(identifierToken, IDENTIFIER_REDEFINED, this);
}
break;
case PROC:
identifierToken = nextToken();
routineICode = ICodeFactory.createICode();
syncSet = EnumSet.of(LEFT_PAREN);
syncSet.addAll(FormalParameterSequenceParser.FIRST_FOLLOW_SET);
token = synchronize(IDENTIFIER, MISSING_IDENTIFIER, syncSet);
syncSet.remove(LEFT_PAREN);
token = synchronize(LEFT_PAREN, MISSING_LEFT_PAREN, syncSet);
SymTabEntry procId = symTabStack.lookupLocal(identifierToken.getText().toLowerCase());
// Enter the new identifier into the symbol table
// but don't set how it's defined yet.
if (procId == null) {
procId = symTabStack.enterLocal(identifierToken.getText().toLowerCase());
procId.setTypeSpec(TrianglePredefined.undefinedType);
procId.setDefinition(DefinitionImpl.PROCEDURE);
procId.appendLineNumber(identifierToken.getLineNumber());
procId.setAttribute(ROUTINE_SYMTAB, symTabStack.push());
procId.setAttribute(ROUTINE_ICODE, routineICode);
} else {
errorHandler.flag(identifierToken, IDENTIFIER_REDEFINED, this);
procId = null;
}
formalParameterSequence = new FormalParameterSequenceParser(this);
ArrayList<SymTabEntry> procParamList = formalParameterSequence.parse(token);
syncSet = EnumSet.of(TILDE);
syncSet.addAll(SingleCommandParser.FIRST_FOLLOW_SET);
token = synchronize(RIGHT_PAREN, MISSING_RIGHT_PAREN, syncSet);
syncSet.remove(TILDE);
token = synchronize(TILDE, MISSING_TILDE, syncSet);
singleCommand = new SingleCommandParser(this);
routineICode.setRoot(singleCommand.parse(token));
if (procId != null) {
procId.setAttribute(ROUTINE_PARMS, procParamList);
}
symTabStack.pop();
break;
case FUNC:
identifierToken = nextToken();
routineICode = ICodeFactory.createICode();
SymTabEntry funcId = symTabStack.lookupLocal(identifierToken.getText().toLowerCase());
// Enter the new identifier into the symbol table
// but don't set how it's defined yet.
if (funcId == null) {
funcId = symTabStack.enterLocal(identifierToken.getText().toLowerCase());
funcId.setDefinition(DefinitionImpl.FUNCTION);
funcId.appendLineNumber(identifierToken.getLineNumber());
funcId.setTypeSpec(TrianglePredefined.undefinedType);
funcId.setAttribute(ROUTINE_SYMTAB, symTabStack.push());
funcId.setAttribute(ROUTINE_ICODE, routineICode);
} else {
errorHandler.flag(identifierToken, IDENTIFIER_REDEFINED, this);
funcId = null;
}
syncSet = EnumSet.of(LEFT_PAREN);
syncSet.addAll(FormalParameterSequenceParser.FIRST_FOLLOW_SET);
token = synchronize(IDENTIFIER, MISSING_IDENTIFIER, syncSet);
syncSet.remove(LEFT_PAREN);
token = synchronize(LEFT_PAREN, MISSING_LEFT_PAREN, syncSet);
formalParameterSequence = new FormalParameterSequenceParser(this);
ArrayList<SymTabEntry> funcParamList = formalParameterSequence.parse(token);
syncSet = EnumSet.of(COLON);
syncSet.addAll(TypeDenoterParser.FIRST_FOLLOW_SET);
synchronize(RIGHT_PAREN, MISSING_RIGHT_PAREN, syncSet);
syncSet.remove(COLON);
token = synchronize(COLON, MISSING_COLON, syncSet);
Token typeToken = currentToken();
typeDenoter = new TypeDenoterParser(this);
TypeSpec funcType = typeDenoter.parse(token);
syncSet = ExpressionParser.FIRST_FOLLOW_SET.clone();
token = synchronize(TILDE, MISSING_TILDE, syncSet);
expression = new ExpressionParser(this);
routineICode.setRoot(expression.parse(token));
if (funcId != null) {
funcId.setTypeSpec(funcType);
funcId.setAttribute(ROUTINE_PARMS, funcParamList);
if (!routineICode.getRoot().getTypeSpec().equals(funcType)) {
errorHandler.flag(typeToken, RETURN_TYPE_MISMATCH, this);
}
}
symTabStack.pop();
break;
case TYPE:
identifierToken = nextToken();
syncSet = EnumSet.of(TILDE);
syncSet.addAll(TypeDenoterParser.FIRST_FOLLOW_SET);
synchronize(IDENTIFIER, MISSING_IDENTIFIER, syncSet);
syncSet.remove(TILDE);
token = synchronize(TILDE, MISSING_TILDE, syncSet);
typeDenoter = new TypeDenoterParser(this);
TypeSpec typeType = typeDenoter.parse(token);
SymTabEntry typeId = symTabStack.lookupLocal(identifierToken.getText().toLowerCase());
// Enter the new identifier into the symbol table
// but don't set how it's defined yet.
if (typeId == null) {
typeId = symTabStack.enterLocal(identifierToken.getText().toLowerCase());
typeId.setDefinition(DefinitionImpl.TYPE);
typeId.appendLineNumber(identifierToken.getLineNumber());
typeId.setTypeSpec(typeType);
} else {
errorHandler.flag(token, IDENTIFIER_REDEFINED, this);
}
break;
default:
errorHandler.flag(token, MISSING_DECLARATION, this);
break;
}
}
/**
* 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:
{
// Look up the identifier in the symbol table stack.
// Flag the identifier as undefined if it's not found.
String name = token.getText().toLowerCase();
SymTabEntry id = symTabStack.lookup(name);
if (id == null) {
errorHandler.flag(token, IDENTIFIER_UNDEFINED, this);
id = symTabStack.enterLocal(name);
}
rootNode = ICodeFactory.createICodeNode(VARIABLE);
rootNode.setAttribute(ID, id);
id.appendLineNumber(token.getLineNumber());
token = nextToken(); // consume the identifier
break;
}
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
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
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);
token = nextToken(); // consume the string
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.
rootNode.addChild(parseFactor(token));
break;
}
case LEFT_PAREN:
{
token = nextToken(); // consume the (
// Parse an expression and make its node the root node.
rootNode = parseExpression(token);
// Look for the matching ) token.
token = currentToken();
if (token.getType() == RIGHT_PAREN) {
token = nextToken(); // consume the )
} else {
errorHandler.flag(token, MISSING_RIGHT_PAREN, this);
}
break;
}
case LEFT_BRACKET:
{
rootNode = parseSet(token);
break;
}
default:
{
errorHandler.flag(token, UNEXPECTED_TOKEN, this);
break;
}
}
return rootNode;
}
/**
* Parse type definitions.
*
* @param token the initial token.
* @throws Exception if an error occurred.
*/
public void parse(Token token) throws Exception {
token = synchronize(IDENTIFIER_SET);
// Loop to parse a sequence of type definitions
// separated by semicolons.
while (token.getType() == IDENTIFIER) {
String name = token.getText().toLowerCase();
SymTabEntry typeId = symTabStack.lookupLocal(name);
// Enter the new identifier into the symbol table
// but don't set how it's defined yet.
if (typeId == null) {
typeId = symTabStack.enterLocal(name);
typeId.appendLineNumber(token.getLineNumber());
} else {
errorHandler.flag(token, IDENTIFIER_REDEFINED, this);
typeId = null;
}
token = nextToken(); // consume the identifier token
// Synchronize on the = token.
token = synchronize(EQUALS_SET);
if (token.getType() == EQUALS) {
token = nextToken(); // consume the =
} else {
errorHandler.flag(token, MISSING_EQUALS, this);
}
// Parse the type specification.
TypeSpecificationParser typeSpecificationParser = new TypeSpecificationParser(this);
TypeSpec type = typeSpecificationParser.parse(token);
// Set identifier to be a type and set its type specificationt.
if (typeId != null) {
typeId.setDefinition(TYPE);
}
// Cross-link the type identifier and the type specification.
if (type != null && typeId != null) {
if (type.getIdentifier() == null) {
type.setIdentifier(typeId);
}
typeId.setTypeSpec(type);
} else {
token = synchronize(FOLLOW_SET);
}
token = currentToken();
TokenType tokenType = token.getType();
// Look for one or more semicolons after a definition.
if (tokenType == SEMICOLON) {
while (token.getType() == SEMICOLON) {
token = nextToken(); // consume the ;
}
}
// If at the start of the next definition or declaration,
// then missing a semicolon.
else if (NEXT_START_SET.contains(tokenType)) {
errorHandler.flag(token, MISSING_SEMICOLON, this);
}
token = synchronize(IDENTIFIER_SET);
}
}
/**
* Parse a set.
*
* @param token the initial token.
* @return the root of the generated parse subtree.
* @throws Exception if an error occurred.
*/
private ICodeNode parseSet(Token token) throws Exception {
ICodeNode rootNode = ICodeFactory.createICodeNode(ICodeNodeTypeImpl.SET);
HashSet<Integer> values = new HashSet<>();
rootNode.setAttribute(VALUE, new HashSet<Integer>());
boolean isFinished = false;
while (token.getType() != RIGHT_BRACKET && token.getType() != ERROR && !isFinished) {
ICodeNode leftNode = parseSimpleExpression(token);
if (leftNode.getType() == INTEGER_CONSTANT
&& !values.add((Integer) leftNode.getAttribute(VALUE))) {
errorHandler.flag(token, NON_UNIQUE_MEMBERS, this);
}
token = currentToken();
switch ((PascalTokenType) token.getType()) {
case RIGHT_BRACKET:
rootNode.addChild(leftNode);
break;
case COMMA:
rootNode.addChild(leftNode);
token = nextToken(); // Consume the ,
if (token.getType() == COMMA) {
errorHandler.flag(token, EXTRA_COMMAS, this);
token = nextToken(); // Consume the extra ,
}
break;
case DOT_DOT:
token = nextToken(); // Consume the ..
if (token.getType() == COMMA) {
errorHandler.flag(token, INVALID_SUBRANGE, this);
token = nextToken(); // Consume the ,
rootNode.addChild(leftNode);
} else {
ICodeNode rightNode = parseSimpleExpression(token);
ICodeNode subrangeNode = ICodeFactory.createICodeNode(SUBRANGE);
subrangeNode.addChild(leftNode);
subrangeNode.addChild(rightNode);
rootNode.addChild(subrangeNode);
if (leftNode.getType() == INTEGER_CONSTANT && rightNode.getType() == INTEGER_CONSTANT) {
boolean duplicateFound = false;
Integer leftRange = (Integer) leftNode.getAttribute(VALUE) + 1;
Integer rightRange = (Integer) rightNode.getAttribute(VALUE);
while (leftRange <= rightRange) {
if (!values.add(leftRange++) && !duplicateFound) {
errorHandler.flag(token, NON_UNIQUE_MEMBERS, this);
duplicateFound = true;
}
}
}
token = currentToken();
if (token.getType() == COMMA) {
token = nextToken(); // Consume the ,
} else if (token.getType() != RIGHT_BRACKET) {
errorHandler.flag(token, MISSING_COMMA, this);
}
}
break;
case INTEGER:
errorHandler.flag(token, MISSING_COMMA, this);
break;
case SEMICOLON:
isFinished = true;
break;
default:
errorHandler.flag(token, UNEXPECTED_TOKEN, this);
break;
}
}
return rootNode;
}