public TokenRangeElement(Grammar g, Token t1, Token t2, int autoGenType) { super(g, t1, autoGenType); begin = grammar.tokenManager.getTokenSymbol(t1.getText()).getTokenType(); beginText = t1.getText(); end = grammar.tokenManager.getTokenSymbol(t2.getText()).getTokenType(); endText = t2.getText(); line = t1.getLine(); }
// $ANTLR start arrayIdSet // ECL.g:41:1: arrayIdSet returns [java.util.Set<Long> idSet] : (id1= DIGIT ) ( ',' id2= DIGIT )* // ; public final java.util.Set<Long> arrayIdSet() throws RecognitionException { java.util.Set<Long> idSet = null; Token id1 = null; Token id2 = null; idSet = new java.util.HashSet<Long>(); try { // ECL.g:45:2: ( (id1= DIGIT ) ( ',' id2= DIGIT )* ) // ECL.g:45:4: (id1= DIGIT ) ( ',' id2= DIGIT )* { // ECL.g:45:4: (id1= DIGIT ) // ECL.g:45:5: id1= DIGIT { id1 = (Token) input.LT(1); match(input, DIGIT, FOLLOW_DIGIT_in_arrayIdSet154); idSet.add(new Long(id1.getText())); } // ECL.g:47:5: ( ',' id2= DIGIT )* loop7: do { int alt7 = 2; int LA7_0 = input.LA(1); if ((LA7_0 == 14)) { alt7 = 1; } switch (alt7) { case 1: // ECL.g:47:6: ',' id2= DIGIT { match(input, 14, FOLLOW_14_in_arrayIdSet158); id2 = (Token) input.LT(1); match(input, DIGIT, FOLLOW_DIGIT_in_arrayIdSet162); idSet.add(new Long(id2.getText())); } break; default: break loop7; } } while (true); } } catch (RecognitionException re) { reportError(re); recover(input, re); } finally { } return idSet; }
/** Make name and alias for target. Replace any previous def of name */ public CompiledST defineTemplateAlias(Token aliasT, Token targetT) { String alias = aliasT.getText(); String target = targetT.getText(); CompiledST targetCode = rawGetTemplate(target); if (targetCode == null) { errMgr.compileTimeError(ErrorType.ALIAS_TARGET_UNDEFINED, null, aliasT, alias, target); return null; } templates.put(alias, targetCode); return targetCode; }
/** Create singleton template for use with dictionary values */ public ST createSingleton(Token templateToken) { String template; if (templateToken.getType() == GroupParser.BIGSTRING) { template = Misc.strip(templateToken.getText(), 2); } else { template = Misc.strip(templateToken.getText(), 1); } CompiledST impl = compile(getFileName(), null, null, template, templateToken); ST st = createStringTemplateInternally(impl); st.groupThatCreatedThisInstance = this; st.impl.hasFormalArgs = false; st.impl.name = ST.UNKNOWN_NAME; st.impl.defineImplicitlyDefinedTemplates(this); return st; }
private SymTabEntry parseRoutineName(Token token, String dummyName) throws Exception { SymTabEntry routineId = null; // Parse the routine name identifier. if (token.getType() == IDENTIFIER) { String routineName = token.getText().toLowerCase(); routineId = symTabStack.lookupLocal(routineName); // Not already defined locally: Enter into the local symbol table. if (routineId == null) { routineId = symTabStack.enterLocal(routineName); routineId.appendLineNumber(token.getLineNumber()); } // If already defined, it should be a forward definition. else { routineId = null; errorHandler.flag(token, IDENTIFIER_REDEFINED, this); } token = nextToken(); // consume routine name identifier } else { errorHandler.flag(token, MISSING_IDENTIFIER, this); } // If necessary, create a dummy routine name symbol table entry. if (routineId == null) { routineId = symTabStack.enterLocal(dummyName); } return routineId; }
// $ANTLR start "color" // D:\\Pamela\\Quinto semestre\\Computación Gráfica\\RayTracer\\RayTracer.g:112:1: color : // TYPE_COLOR ; public final RayTracerParser.color_return color() throws RecognitionException { RayTracerParser.color_return retval = new RayTracerParser.color_return(); retval.start = input.LT(1); Token TYPE_COLOR5 = null; try { // D:\\Pamela\\Quinto semestre\\Computación Gráfica\\RayTracer\\RayTracer.g:112:7: ( // TYPE_COLOR ) // D:\\Pamela\\Quinto semestre\\Computación Gráfica\\RayTracer\\RayTracer.g:112:9: TYPE_COLOR { TYPE_COLOR5 = (Token) match(input, TYPE_COLOR, FOLLOW_TYPE_COLOR_in_color265); color += (TYPE_COLOR5 != null ? TYPE_COLOR5.getText() : null); double[] color1 = new double[3]; if (color.equals("Yellow")) { color1[0] = 1.0; color1[1] = 1.0; color1[2] = 0.0; } else if (color.equals("Blue")) { color1[0] = 0.0; color1[1] = 0.0; color1[2] = 1.0; } else if (color.equals("Red")) { color1[0] = 1.0; color1[1] = 0.0; color1[2] = 0.0; } else if (color.equals("Green")) { color1[0] = 0.0; color1[1] = 1.0; color1[2] = 0.0; } else if (color.equals("White")) { color1[0] = 1.0; color1[1] = 1.0; color1[2] = 1.0; } color = ""; switch (typeObject) { case 4: ligths.add(color1); break; case 5: for (int i = 0; i < 3; i++) { ambientLight[i] = color1[i]; } break; default: break; } } retval.stop = input.LT(-1); } catch (RecognitionException re) { reportError(re); recover(input, re); } finally { } return retval; }
/** * Get an integer option. Given the name of the option find its associated integer value. If the * associated value is not an integer or is not in the table, then throw an exception of type * NumberFormatException. * * @param key The name of the option * @return The value associated with the key. */ public int getIntegerOption(String key) throws NumberFormatException { Token t = (Token) options.get(key); if (t == null || t.getType() != ANTLRTokenTypes.INT) { throw new NumberFormatException(); } else { return Integer.parseInt(t.getText()); } }
public static void main(String[] args) throws Exception { ANTLRFileStream input = new ANTLRFileStream(args[0]); WigLexer lexer = new WigLexer(input); Token token; while ((token = lexer.nextToken()) != Token.EOF_TOKEN) { System.out.println("Token: " + token.getText() + "(" + token.getType() + ")"); } }
@Override protected final void logLoadError(Token ident) { logLoadErrorImpl( ident.getLineNo(), ident.getColumnNo(), MSG_CLASS_INFO, JavadocTagInfo.THROWS.getText(), ident.getText()); }
protected VarNode varNode() throws JmoException { Token t = buf.findValid(); checkType(t, null); String name = t.getText(); if (validMethodName(name)) { buf.takeToken(); return new VarNode(t.getPosition(), name); } throw new ParseException("invalid varNode " + t, t.getPosition()); }
// $ANTLR start rangeIdSet // ECL.g:51:1: rangeIdSet returns [java.util.Set<Long> idSet] : id1= DIGIT '.' '.' id2= DIGIT ; public final java.util.Set<Long> rangeIdSet() throws RecognitionException { java.util.Set<Long> idSet = null; Token id1 = null; Token id2 = null; idSet = new java.util.HashSet<Long>(); Long start = 0L; Long end = 0L; try { // ECL.g:56:3: (id1= DIGIT '.' '.' id2= DIGIT ) // ECL.g:56:6: id1= DIGIT '.' '.' id2= DIGIT { id1 = (Token) input.LT(1); match(input, DIGIT, FOLLOW_DIGIT_in_rangeIdSet184); start = new Long(id1.getText()); match(input, 15, FOLLOW_15_in_rangeIdSet187); match(input, 15, FOLLOW_15_in_rangeIdSet189); id2 = (Token) input.LT(1); match(input, DIGIT, FOLLOW_DIGIT_in_rangeIdSet193); end = new Long(id2.getText()); if (end < start) { Long temp = end; end = start; start = temp; } for (Long id = start; id <= end; id++) { idSet.add(id); } } } catch (RecognitionException re) { reportError(re); recover(input, re); } finally { } return idSet; }
/** * Checks a set of tags for matching throws. * * @param tags the tags to check * @param throwsList the throws to check * @param reportExpectedTags whether we should report if do not find expected tag */ private void checkThrowsTags( List<JavadocTag> tags, List<ExceptionInfo> throwsList, boolean reportExpectedTags) { // Loop over the tags, checking to see they exist in the throws. // The foundThrows used for performance only final Set<String> foundThrows = Sets.newHashSet(); final ListIterator<JavadocTag> tagIt = tags.listIterator(); while (tagIt.hasNext()) { final JavadocTag tag = tagIt.next(); if (!tag.isThrowsTag()) { continue; } tagIt.remove(); // Loop looking for matching throw final String documentedEx = tag.getFirstArg(); final Token token = new Token(tag.getFirstArg(), tag.getLineNo(), tag.getColumnNo()); final AbstractClassInfo documentedCI = createClassInfo(token, getCurrentClassName()); final boolean found = foundThrows.contains(documentedEx) || isInThrows(throwsList, documentedCI, foundThrows); // Handle extra JavadocTag. if (!found) { boolean reqd = true; if (allowUndeclaredRTE) { reqd = !isUnchecked(documentedCI.getClazz()); } if (reqd && validateThrows) { log( tag.getLineNo(), tag.getColumnNo(), MSG_UNUSED_TAG, JavadocTagInfo.THROWS.getText(), tag.getFirstArg()); } } } // Now dump out all throws without tags :- unless // the user has chosen to suppress these problems if (!allowMissingThrowsTags && reportExpectedTags) { for (ExceptionInfo ei : throwsList) { if (!ei.isFound()) { final Token fi = ei.getName(); log( fi.getLineNo(), fi.getColumnNo(), MSG_EXCPECTED_TAG, JavadocTagInfo.THROWS.getText(), fi.getText()); } } } }
private String collectToEnd() { StringBuilder sb = new StringBuilder(); buf.findValid(); do { Token t = buf.getToken(0); if (t == null) break; sb.append(t.getText()); } while (buf.takeToken() != null); return sb.toString(); }
public String toString(int start, int stop) { if (start < 0 || stop < 0) return null; if (p == -1) setup(); if (stop >= tokens.size()) stop = tokens.size() - 1; StringBuffer buf = new StringBuffer(); for (int i = start; i <= stop; i++) { Token t = tokens.get(i); if (t.getType() == Token.EOF) break; buf.append(t.getText()); } return buf.toString(); }
/** * Gets the text without the comments. For example for the string <code>{ // it's a comment</code> * this method will return "{ ". * * @param aStart start of the text. * @param anEnd end of the text. * @return String for the line without comments (if exists). */ public synchronized String getUncommentedText(int aStart, int anEnd) { readLock(); StringBuilder result = new StringBuilder(); Iterator<Token> iter = getTokens(aStart, anEnd); while (iter.hasNext()) { Token t = iter.next(); if (!TokenType.isComment(t)) { result.append(t.getText(this)); } } readUnlock(); return result.toString(); }
/** * How should a token be displayed in an error message? The default is to display just the text, * but during development you might want to have a lot of information spit out. Override in that * case to use t.toString() (which, for CommonToken, dumps everything about the token). This is * better than forcing you to override a method in your token objects because you don't have to go * modify your lexer so that it creates a new Java type. */ public String getTokenErrorDisplay(Token t) { String s = t.getText(); if (s == null) { if (t.getType() == Token.EOF) { s = "<EOF>"; } else { s = "<" + t.getType() + ">"; } } s = s.replaceAll("\n", "\\\\n"); s = s.replaceAll("\r", "\\\\r"); s = s.replaceAll("\t", "\\\\t"); return "'" + s + "'"; }
public Instance pipe(Instance carrier) { TokenSequence ts = (TokenSequence) carrier.getData(); for (int i = 0; i < ts.size(); i++) { Token t = ts.get(i); String s = t.getText(); if (distinguishBorders) s = startBorderChar + s + endBorderChar; int slen = s.length(); for (int j = 0; j < gramSizes.length; j++) { int size = gramSizes[j]; for (int k = 0; k < (slen - size) + 1; k++) t.setFeatureValue((prefix + s.substring(k, k + size)).intern(), 1.0); } } return carrier; }
/** * Checks the validity of the logic behind the tokens and then creates a valid ADS by calling * createADS on the valid tokens list. * * @param theTokens A valid and mathematically correct array of tokens. * @return Expression that abstracts the initial, mathematically correct input. */ public Expression createADS(Token[] theTokens) { // operations stack Stack<Token> operations = new Stack<Token>(); // operands stack Stack<Expression> operand = new Stack<Expression>(); for (int i = 0; i < theTokens.length; i++) { if (theTokens[i].getType() == Token.Type.PLUS || theTokens[i].getType() == Token.Type.MULTIPLY || theTokens[i].getType() == Token.Type.OPEN_PAREN) // push operations and open paren on operations stack operations.push(theTokens[i]); else if (theTokens[i].getType() == Token.Type.NUMBER) // push number on operands stack operand.push(new Number(theTokens[i].getText())); else if (theTokens[i].getType() == Token.Type.VARIABLE) { Variable k = new Variable(theTokens[i].getText()); // push variable on operands stack operand.push(k); System.out.println("In Parser: " + k.value); } // whenever a closed paren is seen, pop the elements between this paren and the previous open // one if (theTokens[i].getText() == ")") { // if the previous one is open, there is nothing in between if (i > 0 && operations.peek().getText() == "(") { operations.pop(); } // if the previous element pushed is a number or variable, it is the case for (3) or (x) else if (i > 1 && operations.peek().getText() == "(" && (theTokens[i - 1].getType() == Token.Type.NUMBER || theTokens[i - 1].getType() == Token.Type.VARIABLE)) { operations.pop(); } // This is the case for a complete expression such as (4*x) or (4+x) else { Expression right = operand.pop(); Expression left = operand.pop(); Token op = operations.pop(); operations.pop(); if (op.getText() == "+") operand.push(new Add(left, right)); else operand.push(new Multiply(left, right)); } } } // returns the complete expression return operand.pop(); }
public void syntaxError( Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) { CommonTokenStream tokens = (CommonTokenStream) recognizer.getInputStream(); String input = tokens.getTokenSource().getInputStream().toString(); Token token = (Token) offendingSymbol; String[] lines = StringUtils.splitPreserveAllTokens(input, '\n'); String errorLine = lines[line - 1]; String simpleMessage = "syntax error at or near \"" + token.getText() + "\""; throw new LangParserException(token, line, charPositionInLine, simpleMessage, errorLine); }
public Instance pipe(Instance carrier) { TokenSequence ts = (TokenSequence) carrier.getData(); for (int i = 0; i < ts.size(); i++) { Token t = ts.get(i); String s = t.getText(); if (distinguishBorders) s = startBorderChar + s + endBorderChar; int slen = s.length(); for (int j = 0; j < gramSizes.length; j++) { int size = gramSizes[j]; for (int k = 0; k < slen - size; k++) t.setFeatureValue( s.substring(k, k + size), 1.0); // original was substring(k, size), changed by Fuchun } } return carrier; }
public String toString(String programName, int start, int end) { List rewrites = (List) programs.get(programName); // ensure start/end are in range if (end > tokens.size() - 1) end = tokens.size() - 1; if (start < 0) start = 0; if (rewrites == null || rewrites.size() == 0) { return toOriginalString(start, end); // no instructions to execute } StringBuffer buf = new StringBuffer(); // First, optimize instruction stream Map indexToOp = reduceToSingleOperationPerIndex(rewrites); // Walk buffer, executing instructions and emitting tokens int i = start; while (i <= end && i < tokens.size()) { RewriteOperation op = (RewriteOperation) indexToOp.get(new Integer(i)); indexToOp.remove(new Integer(i)); // remove so any left have index size-1 Token t = (Token) tokens.get(i); if (op == null) { // no operation at that index, just dump token if (t.getType() != Token.EOF) buf.append(t.getText()); i++; // move to next token } else { i = op.execute(buf); // execute operation and skip } } // include stuff after end if it's last index in buffer // So, if they did an insertAfter(lastValidIndex, "foo"), include // foo if end==lastValidIndex. if (end == tokens.size() - 1) { // Scan any remaining operations after last token // should be included (they will be inserts). Iterator it = indexToOp.values().iterator(); while (it.hasNext()) { RewriteOperation op = (RewriteOperation) it.next(); if (op.index >= tokens.size() - 1) buf.append(op.text); } } return buf.toString(); }
@NotNull @Override public Pair<Token<T>, State> parse(@NotNull List<Token<T>> tokens, @NotNull State state) throws ParserException { final int pos = state.getPos(); if (pos >= tokens.size()) { throw new ParserException("No tokens left", state); } final Token<T> token = tokens.get(pos); if (token.getType().equals(myType) && (myText == null || token.getText().equals(myText))) { final int newPos = pos + 1; final State newState = new State(state, newPos, Math.max(newPos, state.getMax())); return Pair.create(token, newState); } final String expected = myText != null ? String.format("Token(<%s>, \"%s\")", myType, myText) : String.format("Token(<%s>)", myType); throw new ParserException(String.format("Expected %s, found %s", expected, token), state); }
private String readUntil(TokenType... stopTypes) { StringBuilder sb = new StringBuilder(); while (true) { Token t = buf.getToken(0); if (t == null) { break; } boolean shouldStop = false; for (TokenType type : stopTypes) { if (t.getType() == type) { shouldStop = true; } } if (shouldStop) { break; } buf.takeToken(); sb.append(t.getText()); } return sb.toString(); }
// $ANTLR start "lengthScheme" // C:\\data\\eclipse_workspace\\clea\\grammars\\pointertarget\\URIFragmentIdentifierPlainText.g:185:1: lengthScheme returns [Integer length] : 'length=' INT ; public final Integer lengthScheme() throws RecognitionException { Integer length = null; Token INT11 = null; try { // C:\\data\\eclipse_workspace\\clea\\grammars\\pointertarget\\URIFragmentIdentifierPlainText.g:186:2: ( 'length=' INT ) // C:\\data\\eclipse_workspace\\clea\\grammars\\pointertarget\\URIFragmentIdentifierPlainText.g:186:4: 'length=' INT { match(input, 15, FOLLOW_15_in_lengthScheme369); INT11 = (Token) match(input, INT, FOLLOW_INT_in_lengthScheme371); length = Integer.valueOf((INT11 != null ? INT11.getText() : null)); } } catch (RecognitionException e) { throw e; } finally { // do for sure before leaving } return length; }
// $ANTLR start "md5Scheme" // C:\\data\\eclipse_workspace\\clea\\grammars\\pointertarget\\URIFragmentIdentifierPlainText.g:193:1: md5Scheme returns [String md5] : 'md5=' MD5VALUE ; public final String md5Scheme() throws RecognitionException { String md5 = null; Token MD5VALUE12 = null; try { // C:\\data\\eclipse_workspace\\clea\\grammars\\pointertarget\\URIFragmentIdentifierPlainText.g:194:2: ( 'md5=' MD5VALUE ) // C:\\data\\eclipse_workspace\\clea\\grammars\\pointertarget\\URIFragmentIdentifierPlainText.g:194:4: 'md5=' MD5VALUE { match(input, 16, FOLLOW_16_in_md5Scheme397); MD5VALUE12 = (Token) match(input, MD5VALUE, FOLLOW_MD5VALUE_in_md5Scheme399); md5 = (MD5VALUE12 != null ? MD5VALUE12.getText() : null); } } catch (RecognitionException e) { throw e; } finally { // do for sure before leaving } return md5; }
/** * 解析标识符 * * @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; }
public CompiledST defineRegion( String enclosingTemplateName, Token regionT, String template, Token templateToken) { String name = regionT.getText(); template = Misc.trimOneStartingNewline(template); template = Misc.trimOneTrailingNewline(template); CompiledST code = compile(getFileName(), enclosingTemplateName, null, template, templateToken); String mangled = getMangledRegionName(enclosingTemplateName, name); if (lookupTemplate(mangled) == null) { errMgr.compileTimeError( ErrorType.NO_SUCH_REGION, templateToken, regionT, enclosingTemplateName, name); return new CompiledST(); } code.name = mangled; code.isRegion = true; code.regionDefType = ST.RegionType.EXPLICIT; code.templateDefStartToken = regionT; rawDefineTemplate(mangled, code, regionT); code.defineArgDefaultValueTemplates(this); code.defineImplicitlyDefinedTemplates(this); return code; }
private static String location(Token t) { if (t == Token.EOF) return "the last line"; else return "\"" + t.getText() + "\" at line " + t.getLineNumber(); }
/** * 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; }