List of usage examples for org.antlr.v4.runtime CharStream getText
public String getText(Interval interval);
From source file:cloudlens.parser.ASTBuilder.java
License:Apache License
@Override public Void visitVarDecl(CloudLensParser.VarDeclContext ctx) { visitChildren(ctx);//from w w w .j ava 2s .c o m final int line = ctx.getStart().getLine(); final String ident = ctx.IDENT().getText(); final int a = ctx.start.getStartIndex(); final int b = ctx.stop.getStopIndex(); final Interval interval = new Interval(a, b); final CharStream source = ctx.start.getInputStream(); final String body = source.getText(interval); ctx.ast = new ASTDeclaration(fileName, line, ident, body); return null; }
From source file:cloudlens.parser.ASTBuilder.java
License:Apache License
@Override public Void visitBody(CloudLensParser.BodyContext ctx) { final int a = ctx.start.getStartIndex(); final int b = ctx.stop.getStopIndex(); // remove opening and closing {.} final Interval interval = new Interval(a + 1, b - 1); final CharStream source = ctx.start.getInputStream(); ctx.ast = source.getText(interval); return null;/*from ww w . jav a 2 s .co m*/ }
From source file:cloudlens.parser.ASTBuilder.java
License:Apache License
@Override public Void visitRegex(CloudLensParser.RegexContext ctx) { visitChildren(ctx);//w w w . ja va 2 s. co m final List<String> rg = new ArrayList<>(); if (ctx.IDENT() != null) { rg.add(ctx.IDENT().getText()); } else if (ctx.STRING() != null) { final int a = ctx.start.getStartIndex(); final int b = ctx.stop.getStopIndex(); // remove opening and closing "." final Interval interval = new Interval(a + 1, b - 1); final CharStream source = ctx.start.getInputStream(); final String r = source.getText(interval); rg.add("\"" + StringEscapeUtils.escapeEcmaScript(r) + "\""); } else if (ctx.regex() != null) { for (final RegexContext r : ctx.regex()) { rg.add(r.ast); } } ctx.ast = StringUtils.join(rg, "+"); return null; }
From source file:cloudlens.parser.ASTBuilder.java
License:Apache License
@Override public Void visitArgList(CloudLensParser.ArgListContext ctx) { final int a = ctx.start.getStartIndex(); final int b = ctx.stop.getStopIndex(); // remove opening and closing (.) final Interval interval = new Interval(a + 1, b - 1); final CharStream source = ctx.start.getInputStream(); ctx.ast = "[" + source.getText(interval) + "]"; return null;//from www .ja v a2s . co m }
From source file:cloudlens.parser.ASTBuilder.java
License:Apache License
@Override public Void visitUrl(CloudLensParser.UrlContext ctx) { final int a = ctx.start.getStartIndex(); final int b = ctx.stop.getStopIndex(); // remove opening and closing "." final Interval interval = new Interval(a + 1, b - 1); final CharStream source = ctx.start.getInputStream(); ctx.ast = source.getText(interval); return null;//from www . j a va 2 s . c om }
From source file:com.satisfyingstructures.J2S.J2SConvertBasicFor.java
License:Open Source License
public static void convert(ParserRuleContext ctx, J2SRewriter rewriter) { J2SConvertBasicFor converter = new J2SConvertBasicFor(rewriter); String couldNotConvertBecause = converter.convertBasicForStatementToForInLoopOrSayWhyNot(ctx); if (null != couldNotConvertBecause) { // Insert the original as a comment TerminalNode tnA = ctx.getToken(Java8Parser.FOR, 0), tnB = ctx.getToken(Java8Parser.RPAREN, 0); if (null != tnA && null != tnB) { CharStream cs = tnA.getSymbol().getInputStream(); String s = cs.getText(Interval.of(tnA.getSymbol().getStartIndex(), tnB.getSymbol().getStopIndex())); rewriter.insertComment(s, ctx, J2SRewriter.CommentWhere.beforeLineBreak); rewriter.insertComment(/*from w w w .java 2s . co m*/ "...not converted to a for-in expression because " + couldNotConvertBecause + ".", ctx, J2SRewriter.CommentWhere.beforeLineBreak); } converter.convertBasicForStatementToWhileLoop(ctx); } }
From source file:com.satisfyingstructures.J2S.J2SConvertBasicFor.java
License:Open Source License
private String convertBasicForStatementToForInLoopOrSayWhyNot(ParserRuleContext ctx) { int forRule = ctx.getRuleIndex(); if (forRule != Java8Parser.RULE_basicForStatement && forRule != Java8Parser.RULE_basicForStatementNoShortIf) return "statement kind is not as expected"; // not our expected parameter type // Get to know more about our for statement // 'for' '(' forInit? ';' expression? ';' forUpdate? ')' ( statement | statementNoShortIf ) Boolean noShortIf = forRule == Java8Parser.RULE_basicForStatementNoShortIf; Java8Parser.ForInitContext forInitCtx = ctx.getChild(Java8Parser.ForInitContext.class, 0); Java8Parser.ExpressionContext expressionCtx = ctx.getChild(Java8Parser.ExpressionContext.class, 0); Java8Parser.ForUpdateContext forUpdateCtx = ctx.getChild(Java8Parser.ForUpdateContext.class, 0); ParserRuleContext statementCtx = ctx.getChild( noShortIf ? Java8Parser.StatementNoShortIfContext.class : Java8Parser.StatementContext.class, 0); ParserRuleContext statementSubCtx = statementCtx.getChild(ParserRuleContext.class, 0); ParserRuleContext statementSubSubCtx = statementSubCtx.getChild(ParserRuleContext.class, 0); Boolean statementisEmpty = statementSubSubCtx.getRuleIndex() == Java8Parser.RULE_emptyStatement; /*//from w w w . jav a 2s .c o m 'for' '(' forInit? ';' expression? ';' forUpdate? ')' ( statement | statementNoShortIf ) Swift 3.0 has got rid of for(;;) statements for stong business cases such as... 'It is rarely used' 'not very Swift-like' 'The value of this construct is limited' ...and other total crap. We can convert simple equivalents of for ( i = startvalue ; i < endvalue ; i += step) to for i in start..<end or for i in start.stride(to: end by: step) To identify this we look for 1) have a forUpdate, which... a) operates on a single loop variable forUpdate().statementExpressionList().statementExpression().count()==1 b) incorporates increment or decrement by a constant step (++i,i++,i+=step,--i,i--,i-=step,) statementExpression rule is RULE_(assignment|preinc|postinc|predec|postdec) c) operates on the same variable tested in expression (compare - 2b) 2) have an expression, which... a) should be a simple comparison (<,<=,!=,>,>=, implicit non-zero) b) one side should be same as the loop var (compare - 1c) c) other side should not mutate within the loop - we can't tell this, too difficult 3) forInit a) must be i) empty(start with loop var existing value), or ii) simple init of a single loop var, or iii) simple declaration of a loop var */ // 1) Update statement. We need one... if (null == forUpdateCtx) return "it lacks an update statement"; // 1a) and it must operate on a single variable if (forUpdateCtx.statementExpressionList().getChildCount() != 1) return "there is more than one expression in the update statement"; // 1b) and it must be a simple increment or decrement Java8Parser.StatementExpressionContext updateStatementExpressionCtx = forUpdateCtx.statementExpressionList() .statementExpression(0); // statementExpression : assignment | preIncrementExpression | preDecrementExpression // | postIncrementExpression | postDecrementExpression // | methodInvocation | classInstanceCreationExpression ParserRuleContext updateExpressionCtx = updateStatementExpressionCtx.getChild(ParserRuleContext.class, 0); int updateExpressionRule = updateExpressionCtx.getRuleIndex(); boolean ascending_sequence; boolean open_interval; ParserRuleContext stepExpressionCtx = null; switch (updateExpressionRule) { // unaryExpression : preIncrementExpression | preDecrementExpression // | '+' unaryExpression | '-' unaryExpression // | unaryExpressionNotPlusMinus // preDecrementExpression : '--' unaryExpression // preIncrementExpression : '++' unaryExpression case Java8Parser.RULE_preDecrementExpression: ascending_sequence = false; break; case Java8Parser.RULE_preIncrementExpression: ascending_sequence = true; break; // postfixExpression : ( primary | expressionName ) ( '++' | '--')* // postIncrementExpression : postfixExpression '++' // postDecrementExpression : postfixExpression '--' case Java8Parser.RULE_postDecrementExpression: ascending_sequence = false; break; case Java8Parser.RULE_postIncrementExpression: ascending_sequence = true; break; // assignment : leftHandSide assignmentOperator expression // leftHandSide : expressionName | fieldAccess | arrayAccess case Java8Parser.RULE_assignment: if (null != updateStatementExpressionCtx.assignment().leftHandSide().arrayAccess()) return "cant convert a loop variable that is an array element"; TerminalNode node = updateStatementExpressionCtx.assignment().assignmentOperator() .getChild(TerminalNode.class, 0); switch (node.getSymbol().getType()) { case Java8Parser.ADD_ASSIGN: ascending_sequence = true; break; case Java8Parser.SUB_ASSIGN: ascending_sequence = false; break; case Java8Parser.ASSIGN: // possibilities too complex to warrant extracting simple a=a+1 cases default: return "potentially too complex to create a sequence from this update operation"; } stepExpressionCtx = updateStatementExpressionCtx.assignment().expression(); break; default: // methodInvocation | classInstanceCreationExpression return "the expression in the update statement is too complex"; } // In each of the cases that we have not rejected, the loop variable is in the first child rule context of the // update statement. Get the text of the variable, rather than analysing the graph any further, as the // possibilities are endless; all that we require is that the loop variable text matches that in the text // expression and the init expression. ParserRuleContext loopVariable_updated_Ctx = updateExpressionCtx.getChild(ParserRuleContext.class, 0); String loopVariableTxt = loopVariable_updated_Ctx.getText(); // we want original text // 2) Expression if (null == expressionCtx) return "it lacks a test expression"; // expression : lambdaExpression | assignmentExpression if (null != expressionCtx.lambdaExpression()) return "cannot convert a lambda expression"; // assignmentExpression : conditionalExpression | assignment if (null != expressionCtx.assignmentExpression().assignment()) return "cannot convert an assignment within the test expression"; // 2a) must be a simple relation: // Descend the chain of expression rule pass-through branches until we find the one that is significant, then // test to see if expression contains a terminal that is one of !=, <, <=, >, >=. ParserRuleContext testExpressionCtx = J2SGrammarUtils.descendToSignificantExpression(expressionCtx); int testExpressionRule = testExpressionCtx.getRuleIndex(); TerminalNode node = testExpressionCtx.getChild(TerminalNode.class, 0); int testOperatorType = null != node ? node.getSymbol().getType() : 0; switch (testOperatorType) { case Java8Parser.NOTEQUAL: open_interval = true; break; case Java8Parser.LE: open_interval = false; break; case Java8Parser.GE: open_interval = false; break; case Java8Parser.LT: // can occur in relational and shift expressions case Java8Parser.GT: // can occur in relational and shift expressions if (testExpressionRule == Java8Parser.RULE_relationalExpression) { open_interval = true; break; } default: return "can only convert test expressions that use !=, <, <=, > or >="; } // 2b) relation must be testing same var as changed in update expression // The loop variable could be on the left or the right of the comparison operator int i; ParserRuleContext loopVariable_tested_Ctx = null; for (i = 0; i < 2; i++) { loopVariable_tested_Ctx = testExpressionCtx.getChild(ParserRuleContext.class, i); if (null != loopVariable_tested_Ctx && loopVariableTxt.equals(loopVariable_tested_Ctx.getText())) break; // found matching loop variable loopVariable_tested_Ctx = null; } if (null == loopVariable_tested_Ctx || (i == 1 && testExpressionCtx.getChildCount() > 3)) return "the test expression must be testing the same variable as changed in update expression"; ParserRuleContext terminalValueCtx = testExpressionCtx.getChild(ParserRuleContext.class, i ^ 1); // 2c) the terminal value side should not mutate within the loop // - way too difficult for us to determine this // 3) Loop init expression. Must be either... ParserRuleContext initialValueCtx; if (null == forInitCtx) // a) empty { // Using the loop variable's existing value from outside the scope initialValueCtx = loopVariable_tested_Ctx; } else if (null != forInitCtx.statementExpressionList()) // b) a simple init of a single loop var { /* // Could not convert... // for (i = 0; i<10; i++) // ...to a for..in statement because can only work with an assignment expression for loop variable initialisation. i = 0; while i<10 {j += 1 i += 1; } */ if (forInitCtx.statementExpressionList().getChildCount() != 1) return "can only work with initialisation of a single loop variable"; Java8Parser.StatementExpressionContext initExpressionCtx = forInitCtx.statementExpressionList() .statementExpression(0); if (null == initExpressionCtx.assignment()) return "can only work with an assignment expression for loop variable initialisation"; if (!loopVariableTxt.equals(initExpressionCtx.assignment().leftHandSide().getText())) return "the initialised variable is different from the updated variable"; // different to the loop variable initialValueCtx = initExpressionCtx.assignment().expression(); } else if (null != forInitCtx.localVariableDeclaration()) // c) a simple decl of a single loop var { // localVariableDeclaration : variableModifier* unannType variableDeclaratorList Java8Parser.VariableDeclaratorListContext vdlc = forInitCtx.localVariableDeclaration() .variableDeclaratorList(); // variableDeclaratorList : variableDeclarator (',' variableDeclarator)* if (vdlc.getChildCount() != 1) return "can only work with declaration of a single loop variable"; Java8Parser.VariableDeclaratorContext vdc = vdlc.variableDeclarator(0); // variableDeclarator : variableDeclaratorId ('=' variableInitializer)? if (!loopVariableTxt.equals(vdc.getChild(0).getText())) return "the declared loop variable is be different from the updated variable"; initialValueCtx = vdc.variableInitializer(); if (null == initialValueCtx) return "there is no initialiser for the loop variable"; } else return "loop initialisation is in unexpected form"; // Now we have all the components we need String forInLoopText; // Use actual text with replacements String initialValueTxt = rewriter.getText(initialValueCtx); String terminalValueTxt = rewriter.getText(terminalValueCtx); // !!!: watch out... // if we use the actual text from the update expression, we can find that the pre/post-inc/dec has been // converted to the add/sub-assign form and because structure is lost when rewriting, the new form can // stick to the variable when we retrieve it. There's no easy solution for this (and any similar occurrences), // but we side step it by getting the text of loop variable from the test expression: loopVariableTxt = rewriter.getText(loopVariable_tested_Ctx); if (null != stepExpressionCtx || !ascending_sequence) { String stepExpressionText = stepExpressionCtx == null ? "-1" : ascending_sequence ? rewriter.getText(stepExpressionCtx) : "-(" + rewriter.getText(stepExpressionCtx) + ")"; forInLoopText = "for " + loopVariableTxt + " in " + loopVariableTxt + ".stride(from: " + initialValueTxt + (open_interval ? ", to: " : ", through: ") + terminalValueTxt + ", by: " + stepExpressionText + ")"; } else { forInLoopText = "for " + loopVariableTxt + " in " + initialValueTxt + (open_interval ? " ..< " : " ... ") + terminalValueTxt; } Token startToken = ctx.getToken(Java8Parser.FOR, 0).getSymbol(); Token endToken = ctx.getToken(Java8Parser.RPAREN, 0).getSymbol(); CharStream cs = startToken.getInputStream(); String originalExpressionTxt = cs.getText(Interval.of(startToken.getStartIndex(), endToken.getStopIndex())); rewriter.insertComment(originalExpressionTxt + " converted to", ctx, J2SRewriter.CommentWhere.beforeLineBreak); int startIndex = startToken.getTokenIndex(); int endIndex = endToken.getTokenIndex(); // Problem: (see notes in J2SRewriter.replaceAndAdjustWhitespace) Before converting to for-in, the loop will // also have had parentheses removed (and other transforms); rewriter may have coallesced some of the changes // so that the old end boundary no longer exists. (- a shortcoming of TokenStreamRewriter) // Workaround: test if endIndex is straddled by changed interval, and if so, extend our interval to the end of // the change. (Pretty horrendous to have to work around this here, but I don't yet see an easy way of fixing // the underlying problem or a generalised way of working around it.) Interval interval = rewriter.getChangedIntervalContaining(endIndex, endIndex); if (null != interval && interval.a <= endIndex && interval.b > endIndex) endIndex = interval.b; rewriter.replaceAndAdjustWhitespace(startIndex, endIndex, forInLoopText); return null; }
From source file:greycat.language.Model.java
License:Open Source License
private void internal_parse(CharStream in, Resolver resolver) { if (md == null) { try {/*ww w.java 2 s . com*/ md = MessageDigest.getInstance("SHA-1"); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } } if (in.size() == 0) { return; } String sha1 = convertToHex(md.digest(in.getText(new Interval(0, in.size())).getBytes())); if (alreadyLoaded.contains(sha1)) { return; } else { //circular dependency protection alreadyLoaded.add(sha1); } BufferedTokenStream tokens = new CommonTokenStream(new GreyCatModelLexer(in)); GreyCatModelParser parser = new GreyCatModelParser(tokens); GreyCatModelParser.ModelDclContext modelDclCtx = parser.modelDcl(); //first subImport modelDclCtx.importDcl().forEach(importDclContext -> { String subPath = cleanString(importDclContext.path); CharStream subStream = resolver.resolver(subPath); if (subStream == null) { throw new RuntimeException("Import not resolved " + subPath); } try { internal_parse(subStream, resolver); } catch (Exception e) { throw new RuntimeException("Parse Error while parsing " + subPath, e); } }); // constants for (GreyCatModelParser.ConstDclContext constDclCtx : modelDclCtx.constDcl()) { String const_name = constDclCtx.name.getText(); Constant c = constants.get(const_name); if (c == null) { c = new Constant(const_name); constants.put(const_name, c); } c.setType(constDclCtx.type.getText()); String value = null; if (constDclCtx.constValueDcl() != null) { if (constDclCtx.constValueDcl().simpleValueDcl() != null) { GreyCatModelParser.SimpleValueDclContext sVc = constDclCtx.constValueDcl().simpleValueDcl(); if (sVc.STRING() != null) { value = cleanString(sVc.STRING().getSymbol()); } else { value = constDclCtx.constValueDcl().simpleValueDcl().getText(); } } else if (constDclCtx.constValueDcl().taskValueDcl() != null) { GreyCatModelParser.TaskValueDclContext taskDcl = constDclCtx.constValueDcl().taskValueDcl(); value = taskDcl.getText(); } } c.setValue(value); } // classes for (GreyCatModelParser.ClassDclContext classDclCtx : modelDclCtx.classDcl()) { String classFqn = classDclCtx.name.getText(); Class newClass = getOrAddClass(classFqn); // parents if (classDclCtx.parentDcl() != null) { final Class parentClass = getOrAddClass(classDclCtx.parentDcl().IDENT().getText()); newClass.setParent(parentClass); } // annotations for (GreyCatModelParser.AnnotationDclContext annotationDcl : classDclCtx.annotationDcl()) { addAnnotation(newClass, annotationDcl); } // attributes for (GreyCatModelParser.AttributeDclContext attDcl : classDclCtx.attributeDcl()) { addAttribute(newClass, attDcl); } // relations for (GreyCatModelParser.RelationDclContext relDclCtx : classDclCtx.relationDcl()) { addRelation(newClass, relDclCtx); } // references for (GreyCatModelParser.ReferenceDclContext refDclCtx : classDclCtx.referenceDcl()) { addReference(newClass, refDclCtx); } // local indexes for (GreyCatModelParser.LocalIndexDclContext localIndexDclCtx : classDclCtx.localIndexDcl()) { addLocalIndex(newClass, localIndexDclCtx); } // local constants for (GreyCatModelParser.ConstDclContext constDclCtx : classDclCtx.constDcl()) { addLocalConstant(newClass, constDclCtx); } } // opposite management for (GreyCatModelParser.ClassDclContext classDclCtx : modelDclCtx.classDcl()) { String classFqn = classDclCtx.name.getText(); Class classType = classes.get(classFqn); // relations for (GreyCatModelParser.RelationDclContext relDclCtx : classDclCtx.relationDcl()) { linkOppositeRelations(classType, relDclCtx); } // references for (GreyCatModelParser.ReferenceDclContext refDclCtx : classDclCtx.referenceDcl()) { linkOppositeReferences(classType, refDclCtx); } // local indexes for (GreyCatModelParser.LocalIndexDclContext idxDclCtx : classDclCtx.localIndexDcl()) { linkOppositeLocalIndexes(classType, idxDclCtx); } } // global indexes for (GreyCatModelParser.GlobalIndexDclContext globalIdxDclContext : modelDclCtx.globalIndexDcl()) { final String name = globalIdxDclContext.name.getText(); final String type = globalIdxDclContext.type.getText(); final Index index = getOrAddGlobalIndex(name, type); final Class indexedClass = getOrAddClass(index.type()); for (TerminalNode idxDclIdent : globalIdxDclContext.indexAttributesDcl().IDENT()) { index.addAttributeRef(new AttributeRef(indexedClass.getOrCreateAttribute(idxDclIdent.getText()))); } } // custom types for (GreyCatModelParser.CustomTypeDclContext customTypeDclCtx : modelDclCtx.customTypeDcl()) { String customTypeName = customTypeDclCtx.name.getText(); final CustomType newCustomType = getOrAddCustomType(customTypeName); // parents if (customTypeDclCtx.parentDcl() != null) { final CustomType parentCustomType = getOrAddCustomType( customTypeDclCtx.parentDcl().IDENT().getText()); newCustomType.setParent(parentCustomType); } // attributes for (GreyCatModelParser.AttributeDclContext attDcl : customTypeDclCtx.attributeDcl()) { addAttribute(newCustomType, attDcl); } // // relations // for (GreyCatModelParser.RelationDclContext relDcl : customTypeDclCtx.relationDcl()) { // addRelation(newCustomType, relDcl); // } // // references // for (GreyCatModelParser.ReferenceDclContext refDcl : customTypeDclCtx.referenceDcl()) { // addReference(newCustomType, refDcl); // } // // local indexes // for (GreyCatModelParser.LocalIndexDclContext localIndexDcl : customTypeDclCtx.localIndexDcl()) { // addLocalIndex(newCustomType, localIndexDcl); // } // local constants for (GreyCatModelParser.ConstDclContext constDclCtx : customTypeDclCtx.constDcl()) { addLocalConstant(newCustomType, constDclCtx); } // // opposite management // for (GreyCatModelParser.CustomTypeDclContext typeDclCtx : modelDclCtx.customTypeDcl()) { // String typeFqn = typeDclCtx.name.getText(); // CustomType customType = customTypes.get(typeFqn); // // // relations // for (GreyCatModelParser.RelationDclContext relDclCtx : typeDclCtx.relationDcl()) { // linkOppositeRelations(customType, relDclCtx); // } // // references // for (GreyCatModelParser.ReferenceDclContext refDclCtx : typeDclCtx.referenceDcl()) { // linkOppositeReferences(customType, refDclCtx); // } // // local indexes // for (GreyCatModelParser.LocalIndexDclContext idxDclCtx : typeDclCtx.localIndexDcl()) { // linkOppositeLocalIndexes(customType, idxDclCtx); // } // } } }
From source file:nl.basjes.parse.useragent.utils.AntlrUtils.java
License:Apache License
public static String getSourceText(ParserRuleContext ctx) { if (ctx.start == null) { return null; // Invalid }/* ww w . j ava 2 s.c o m*/ if (ctx.stop == null) { return ctx.getText(); } int startIndex = ctx.start.getStartIndex(); int stopIndex = ctx.stop.getStopIndex(); if (stopIndex < startIndex) { return ctx.getText(); } CharStream inputStream = ctx.start.getInputStream(); return inputStream.getText(new Interval(startIndex, stopIndex)); }
From source file:org.apache.lucene.expressions.js.JavascriptErrorHandlingLexer.java
License:Apache License
/** * Ensures the ANTLR lexer will throw an exception after the first error * @param lnvae the lexer exception//from ww w . jav a 2 s .co m */ @Override public void recover(LexerNoViableAltException lnvae) { CharStream charStream = lnvae.getInputStream(); int startIndex = lnvae.getStartIndex(); String text = charStream.getText(Interval.of(startIndex, charStream.index())); ParseException parseException = new ParseException("unexpected character '" + getErrorDisplay(text) + "'" + " on line (" + _tokenStartLine + ") position (" + _tokenStartCharPositionInLine + ")", _tokenStartCharIndex); parseException.initCause(lnvae); throw new RuntimeException(parseException); }