List of usage examples for org.antlr.v4.runtime Token getText
String getText();
From source file:com.github.jknack.handlebars.internal.TemplateBuilder.java
License:Apache License
@Override public BaseTemplate visitNewline(final NewlineContext ctx) { Token newline = ctx.NL().getSymbol(); if (newline.getChannel() == Token.HIDDEN_CHANNEL) { return null; }/*w ww . j a v a2s. c om*/ line.setLength(0); return new Text(newline.getText()).filename(source.filename()).position(newline.getLine(), newline.getCharPositionInLine()); }
From source file:com.github.jknack.handlebars.internal.WhiteSpaceControl.java
License:Apache License
/** * @param token The candidate token./* w w w .j a v a 2 s .com*/ * @return Text of the candidate token. */ private String text(final Token token) { return token.getText(); }
From source file:com.github.tamurashingo.dbutils3.parser.SQLParser.java
License:Open Source License
/** * analyse sql with named parameter and convert to parametarised SQL. * //from w w w. j a va2 s. c o m * @param sql sql string * @return converted sql string */ public String analyzeSQL(String sql) { SQLLexer l = new SQLLexer(new ANTLRInputStream(sql)); StringBuilder buf = new StringBuilder(); Token token = l.nextToken(); int prevType = SQLLexer.WS; while (token.getType() != SQLLexer.EOF) { switch (token.getType()) { case SQLLexer.NAMED_PARAM: keyNames.add(token.getText().substring(1)); buf.append("?"); break; case SQLLexer.WS: if (prevType != SQLLexer.WS) { buf.append(" "); } break; default: buf.append(token.getText()); } prevType = token.getType(); token = l.nextToken(); } this.analyzedSQL = buf.toString(); this.analyzed = true; return analyzedSQL; }
From source file:com.googlecode.sparkleg.IdentVisitor.java
License:Apache License
/** * * @param ctx//from ww w . j a va2 s.c o m * @return ST */ @Override public ST visitSelectClause(SparqlParser.SelectClauseContext ctx) { // selectClause : // SELECT (DISTINCT | REDUCED)? (selectVariables+ | ASTERISK) ST selectClause = g.getInstanceOf("selectClause"); for (ParseTree c : ctx.children) { if (c instanceof TerminalNode) { TerminalNode t = (TerminalNode) c; Token to = (Token) (t.getSymbol()); if (to.getType() == SparqlParser.ASTERISK) { selectClause.add("ASTERISK", to.getText()); } else if (to.getType() == SparqlParser.DISTINCT) { selectClause.add("attribute", to.getText().toUpperCase()); } else if (to.getType() == SparqlParser.REDUCED) { selectClause.add("attribute", to.getText().toUpperCase()); } } else if (c instanceof SparqlParser.SelectVariablesContext) { selectClause.add("selectVariables", visitSelectVariables((SparqlParser.SelectVariablesContext) c)); } } return selectClause; }
From source file:com.googlecode.sparkleg.IdentVisitor.java
License:Apache License
@Override public ST visitDescribeQuery(SparqlParser.DescribeQueryContext ctx) { // describeQuery // DESCRIBE (varOrIRI+ | ASTERISK) datasetClause* whereClause? solutionModifier ST describeQuery = g.getInstanceOf("describeQuery"); for (ParseTree c : ctx.children) { if (c instanceof TerminalNode) { TerminalNode t = (TerminalNode) c; Token to = (Token) (t.getSymbol()); if (to.getType() == SparqlParser.ASTERISK) { describeQuery.add("ASTERISK", to.getText()); }// ww w .jav a 2 s . c o m } else if (c instanceof SparqlParser.VarOrIRIContext) { describeQuery.add("varOrIRI", visitVarOrIRI((SparqlParser.VarOrIRIContext) c)); } else if (c instanceof SparqlParser.DatasetClauseContext) { describeQuery.add("datasetClause", visitDatasetClause((SparqlParser.DatasetClauseContext) c)); } else if (c instanceof SparqlParser.WhereClauseContext) { describeQuery.add("whereClause", visitWhereClause((SparqlParser.WhereClauseContext) c)); } else if (c instanceof SparqlParser.SolutionModifierContext) { describeQuery.add("solutionModifier", visitSolutionModifier((SparqlParser.SolutionModifierContext) c)); } } return describeQuery; }
From source file:com.huawei.streaming.cql.semanticanalyzer.parser.CQLErrorListener.java
License:Apache License
/** * ????????//w w w . j av a 2 s . c o m */ private String getOffendingSymbolWithHint(Recognizer<?, ?> recognizer, Object offendingSymbol) { Token token = (Token) offendingSymbol; String tokenText = token.getText(); if (tokenText.equals(SYMBOL_EOF)) { List<Token> allTokens = ((org.antlr.v4.runtime.CommonTokenStream) recognizer.getInputStream()) .getTokens(); int tokensCount = allTokens.size(); return (tokensCount < MIN_SIZE_FOR_TOKENS) ? "" : allTokens.get(tokensCount - MIN_SIZE_FOR_TOKENS).getText(); } return tokenText; }
From source file:com.huawei.streaming.cql.semanticanalyzer.parser.CQLErrorStrategy.java
License:Apache License
@NotNull private String getText(TokenStream tokens, Interval interval) { int start = interval.a; int stop = interval.b; if (start < 0 || stop < 0) return ""; if (stop >= tokens.size()) stop = tokens.size() - 1;// w w w . j av a2 s .c om StringBuilder buf = new StringBuilder(); for (int i = start; i <= stop; i++) { Token t = tokens.get(i); if (t.getType() == Token.EOF) break; buf.append(t.getText()); if (i != stop) { buf.append(" "); } } return buf.toString(); }
From source file:com.javasimple.parser.JavaClassTransformer.java
License:Open Source License
public static void parse(final JavaApplicationTransformer app, final String fileName) throws IOException { final ANTLRFileStream fileStream = new ANTLRFileStream(fileName); final JavaLexer lexer = new JavaLexer(fileStream); final CommonTokenStream tokenStream = new CommonTokenStream(lexer); final JavaParser parser = new JavaParser(tokenStream); final JavaBaseListener listener; final LinkedList<TypeReference> unresolvedTypeReferences = new LinkedList<TypeReference>(); listener = new JavaBaseListener() { // Handle JavaClass Declaration private String packageName; private List<String> imports; private Stack<Object> processStack; private int declaredElements = 0; private boolean processingBlock() { return !processStack.isEmpty() && processStack.peek() instanceof Boolean; }//from w w w . j ava 2s . co m @Override public void enterBlock(JavaParser.BlockContext ctx) { processStack.push(true); } @Override public void exitBlock(JavaParser.BlockContext ctx) { if (processStack.size() >= 2) { Object element = processStack.get(processStack.size() - 2); if (element instanceof StringBuilder) { // Process method/constructor source code Utils.convertirTexto(ctx.children, (StringBuilder) element); } } processStack.pop(); } @Override public void enterClassCreatorRest(JavaParser.ClassCreatorRestContext ctx) { processStack.push(true); } @Override public void exitClassCreatorRest(JavaParser.ClassCreatorRestContext ctx) { processStack.pop(); } // // @Override // public void enterMethodBody(JavaParser.MethodBodyContext ctx) { // classStack.push(true); // } // // @Override // public void exitMethodBody(JavaParser.MethodBodyContext ctx) { // classStack.pop(); // } // @Override public void enterConstructorBody(JavaParser.ConstructorBodyContext ctx) { if (processingBlock()) { return; } processStack.add(new StringBuilder()); } @Override public void enterMethodBody(JavaParser.MethodBodyContext ctx) { if (processingBlock()) { return; } processStack.push(new StringBuilder()); } @Override public void enterCompilationUnit(JavaParser.CompilationUnitContext ctx) { imports = new ArrayList<String>(); processStack = new Stack(); } @Override public void exitPackageDeclaration(JavaParser.PackageDeclarationContext ctx) { packageName = ctx.qualifiedName().getText(); } @Override public void exitImportDeclaration(JavaParser.ImportDeclarationContext ctx) { final String importText = ctx.getText(); // from 6 to discard 'import' // Until length-1 to discard ';' imports.add(importText.substring(6, importText.length() - 1)); } @Override public void enterInterfaceDeclaration(JavaParser.InterfaceDeclarationContext ctx) { if (processingBlock()) { return; } processStack.push(null); declaredElements++; } @Override public void enterClassDeclaration(JavaParser.ClassDeclarationContext ctx) { if (processingBlock()) { return; } processStack.push(null); declaredElements++; } @Override public void enterAnnotationTypeDeclaration(JavaParser.AnnotationTypeDeclarationContext ctx) { if (processingBlock()) { return; } processStack.push(null); } @Override public void enterEnumDeclaration(JavaParser.EnumDeclarationContext ctx) { if (processingBlock()) { return; } processStack.push(null); declaredElements++; } @Override public void exitInterfaceDeclaration(JavaParser.InterfaceDeclarationContext ctx) { if (processingBlock()) { return; } try { JavaInterface javaInterface; if (declaredElements == 1) { javaInterface = (JavaInterface) app.createJavaElement(SymbolType.Interface, packageName, ctx.Identifier().getText()); } else { javaInterface = (JavaInterface) JavasimpleFactory.eINSTANCE.createJavaInterface(); javaInterface.setName(ctx.Identifier().getText()); declaredElements--; } if (ctx.typeList() != null) { for (JavaParser.TypeContext typeContext : ctx.typeList().type()) { registerUnresolvedReference(javaInterface, SymbolType.Interface, JavasimplePackage.eINSTANCE.getJavaInterface_InheritedInterfaces(), typeContext); } } processClassOrInteface(javaInterface); } catch (Exception e) { e.printStackTrace(); } } @Override public void exitEnumDeclaration(JavaParser.EnumDeclarationContext ctx) { if (processingBlock()) { return; } try { JavaEnumeration javaEnumeration; if (declaredElements == 1) { javaEnumeration = (JavaEnumeration) app.createJavaElement(SymbolType.Enumeration, packageName, ctx.Identifier().getText()); declaredElements--; } else { javaEnumeration = (JavaEnumeration) JavasimpleFactory.eINSTANCE.createJavaEnumeration(); javaEnumeration.setName(ctx.Identifier().getText()); declaredElements--; } processClassOrInteface(javaEnumeration); } catch (Exception e) { e.printStackTrace(); } } @Override public void exitClassDeclaration(JavaParser.ClassDeclarationContext ctx) { if (processingBlock()) { return; } try { JavaClass javaClass; if (declaredElements == 1) { javaClass = (JavaClass) app.createJavaElement(SymbolType.Class, packageName, ctx.Identifier().getText()); } else { // System.out.println("Inner Class " + fileName + "--->" // + ctx.Identifier().getText()); javaClass = JavasimpleFactory.eINSTANCE.createJavaClass(); javaClass.setName(ctx.Identifier().getText()); javaClass.setPackageName(fileName); } declaredElements--; registerUnresolvedReference(javaClass, SymbolType.Class, JavasimplePackage.eINSTANCE.getJavaClass_SuperClass(), ctx.type()); if (ctx.typeList() != null) { for (JavaParser.TypeContext typeContext : ctx.typeList().type()) { registerUnresolvedReference(javaClass, SymbolType.Interface, JavasimplePackage.eINSTANCE.getJavaClass_Implements(), typeContext); } } processClassOrInteface(javaClass); } catch (Exception e) { e.printStackTrace(); } } @Override public void exitAnnotationTypeDeclaration(JavaParser.AnnotationTypeDeclarationContext ctx) { if (processingBlock()) { return; } try { AnnotationType aType = (AnnotationType) app.createJavaElement(SymbolType.AnnotationType, packageName, ctx.Identifier().getText()); processClassOrInteface(aType); } catch (Throwable e) { e.printStackTrace(); } } private void processClassOrInteface(ClassOrInterface element) { try { Object top; while (!processStack.isEmpty() && (top = processStack.pop()) != null) { if (top instanceof ClassConstructor) { if (element instanceof JavaClass) { ((JavaClass) element).getConstructors().add(0, (ClassConstructor) top); } else if (top instanceof JavaClass) { ((JavaEnumeration) element).getConstructors().add(0, (ClassConstructor) top); } } else if (top instanceof JavaInterface) { element.getInnerInterfaces().add(0, (JavaInterface) top); } else if (top instanceof JavaEnumeration) { element.getInnerEnumerations().add(0, (JavaEnumeration) top); } else if (top instanceof AnnotationType) { element.getInnerAnotationTypes().add(0, (AnnotationType) top); } else if (top instanceof JavaClass) { element.getInnerClasses().add(0, (JavaClass) top); } else if (top instanceof JavaField) { element.getFields().add(0, (JavaField) top); } else if (top instanceof JavaMethod) { element.getMethods().add(0, (JavaMethod) top); } else if (top instanceof EnumConstant) { ((JavaEnumeration) element).getConstans().add(0, (EnumConstant) top); } else if (top instanceof AnnotationMethod) { ((AnnotationType) element).getAnnotationsMethods().add(0, (AnnotationMethod) top); } else if (top instanceof Documentation) { ((Documentable) element).setDocumentation((Documentation) top); } else { throw new RuntimeException("UnProcess element in the stack :" + top); } } processModifiers(element); if (processStack.isEmpty()) { // System.out.println("End to ptocess: " + fileName); for (String importName : imports) { final JavaImport importV = JavasimpleFactory.eINSTANCE.createJavaImport(); importV.setName(importName); element.getImports().add(0, importV); } } processStack.push(element); // If is the main element register all subclases if (declaredElements == 0) { registerInnerElements(element); } } catch (Exception e) { System.out.println("----->" + fileName + "<------"); System.out.println(element.getName()); System.out.println(processStack); e.printStackTrace(); } } private void registerInnerElements(ClassOrInterface element) { registerElements(element.getInnerClasses()); registerElements(element.getInnerAnotationTypes()); registerElements(element.getInnerEnumerations()); registerElements(element.getInnerInterfaces()); } private void registerElements(List elements) { for (Object elementi : elements) { app.registerInnerElement(((ClassOrInterface) elementi).getQualifiedName(), elementi); registerInnerElements((ClassOrInterface) elementi); } } @Override public void exitEnumConstant(JavaParser.EnumConstantContext ctx) { if (processingBlock()) { return; } final EnumConstant enumConstant = JavasimpleFactory.eINSTANCE.createEnumConstant(); enumConstant.setName(ctx.Identifier().getText()); processModifiers(enumConstant); processStack.push(enumConstant); } @Override public void exitConstDeclaration(JavaParser.ConstDeclarationContext ctx) { if (processingBlock()) { return; } try { final ArrayList<String> fieldsNames = new ArrayList<String>(ctx.constantDeclarator().size()); final ArrayList<VariableInitializerContext> defaultValues = new ArrayList<VariableInitializerContext>( ctx.constantDeclarator().size()); final ArrayList<Boolean> arrayFlags = new ArrayList<Boolean>(ctx.constantDeclarator().size()); for (JavaParser.ConstantDeclaratorContext constantDeclaratorContext : ctx .constantDeclarator()) { fieldsNames.add(constantDeclaratorContext.Identifier().getText()); if (constantDeclaratorContext.variableInitializer() != null) { defaultValues.add(constantDeclaratorContext.variableInitializer()); } else { defaultValues.add(null); } if (constantDeclaratorContext.getText().split("=")[0].endsWith("[]")) { arrayFlags.add(true); } else { arrayFlags.add(false); } } processFieldDeclaration(ctx.type(), fieldsNames, defaultValues, arrayFlags); } catch (Exception e) { e.printStackTrace(); } } @Override public void exitAnnotationTypeElementRest(JavaParser.AnnotationTypeElementRestContext ctx) { if (processingBlock()) { return; } if (ctx.type() != null) { if (ctx.annotationMethodOrConstantRest() != null) { if (ctx.annotationMethodOrConstantRest().annotationMethodRest() != null) { final JavaParser.AnnotationMethodRestContext restContext = ctx .annotationMethodOrConstantRest().annotationMethodRest(); final AnnotationMethod method = JavasimpleFactory.eINSTANCE.createAnnotationMethod(); method.setName(restContext.Identifier().getText()); if (processStack.peek() instanceof AnnotationParam) { method.setDefaultValue((AnnotationParam) processStack.pop()); } // TODO: Check registerUnresolvedReference(method, SymbolType.Class, JavasimplePackage.eINSTANCE.getAnnotationMethod_Type(), ctx.type()); // method.setType(); method.setArray(isArray(ctx.type())); processModifiers(method); processStack.push(method); } else if (ctx.annotationMethodOrConstantRest().annotationConstantRest() != null) { JavaParser.AnnotationConstantRestContext restContext = ctx .annotationMethodOrConstantRest().annotationConstantRest(); processVariableDeclarators(ctx.type(), restContext.variableDeclarators()); } } } } @Override public void exitFieldDeclaration(JavaParser.FieldDeclarationContext ctx) { if (processingBlock()) { return; } processVariableDeclarators(ctx.type(), ctx.variableDeclarators()); } private void processVariableDeclarators(JavaParser.TypeContext typeContext, JavaParser.VariableDeclaratorsContext ctx) { try { final ArrayList<String> fieldsNames = new ArrayList<String>(ctx.variableDeclarator().size()); final ArrayList<VariableInitializerContext> defaultValues = new ArrayList<VariableInitializerContext>( ctx.variableDeclarator().size()); final ArrayList<Boolean> arrayFlags = new ArrayList<Boolean>(ctx.variableDeclarator().size()); for (JavaParser.VariableDeclaratorContext variableDeclaratorContext : ctx .variableDeclarator()) { fieldsNames.add(variableDeclaratorContext.variableDeclaratorId().Identifier().getText()); if (variableDeclaratorContext.variableInitializer() != null) { defaultValues.add(variableDeclaratorContext.variableInitializer()); } else { defaultValues.add(null); } if (variableDeclaratorContext.variableDeclaratorId().getText().endsWith("[]")) { arrayFlags.add(true); } else { arrayFlags.add(false); } } processFieldDeclaration(typeContext, fieldsNames, defaultValues, arrayFlags); } catch (Exception e) { e.printStackTrace(); } } private void processFieldDeclaration(final JavaParser.TypeContext typeContext, final List<String> fieldsNames, final List<VariableInitializerContext> defaultValues, final List<Boolean> arrayFlags) { try { // final com.javasimple.Type type = getType(typeContext); for (int i = 0; i < fieldsNames.size(); i++) { final String fieldName = fieldsNames.get(i); final VariableInitializerContext defaultValue = defaultValues.get(i); final boolean isArray = arrayFlags.get(i); final JavaField field = JavasimpleFactory.eINSTANCE.createJavaField(); registerUnresolvedReference(field, SymbolType.Class, JavasimplePackage.eINSTANCE.getJavaField_Type(), typeContext); // field.setType(type); field.setName(fieldName); if (defaultValue != null) { final String expression = app.handler.processFieldDefaultValueExpression(defaultValue); field.setDefaultValue(expression); } if (isArray(typeContext) || isArray) { field.setArray(true); } else { field.setArray(false); } // TODO: FIX IT It should apply to all the fields processModifiers(field); processStack.push(field); } } catch (Exception e) { e.printStackTrace(); } } @Override public void exitEveryRule(ParserRuleContext ctx) { if (ctx.getClass().equals(TypeDeclarationContext.class) || ctx.getClass().equals(ClassBodyDeclarationContext.class)) { int tokPos = ctx.getStart().getTokenIndex(); final List<Token> hiddenTokens = tokenStream.getHiddenTokensToLeft(tokPos); String doc = null; if (hiddenTokens != null) { for (int i = hiddenTokens.size() - 1; i > -1 && doc == null; i--) { final Token refTok = hiddenTokens.get(i); if (refTok != null) { doc = refTok.getText(); if (doc.startsWith("/**") == false) { doc = null; } } } } if (doc != null) { Documentation documentation = JavadocParser.parse(doc); Object obj = processStack.peek(); if (obj instanceof Documentable) { ((Documentable) obj).setDocumentation(documentation); } } } } @Override public void enterConstructorDeclaration(JavaParser.ConstructorDeclarationContext ctx) { super.enterConstructorDeclaration(ctx); // To change body of // generated methods, // choose Tools | // Templates. } @Override public void exitConstructorDeclaration(JavaParser.ConstructorDeclarationContext ctx) { if (processingBlock()) { return; } try { ClassConstructor classConstructor = JavasimpleFactory.eINSTANCE.createClassConstructor(); classConstructor.setName(ctx.Identifier().getText()); Object top; // Parameters while (processStack.isEmpty() == false && (top = processStack.pop()) != null) { if (top instanceof Parameter) { classConstructor.getParameters().add(0, (Parameter) top); } else if (top instanceof StringBuilder) { classConstructor.setSource(((StringBuilder) top).toString()); } } processModifiers(classConstructor); processStack.push(classConstructor); } catch (Exception e) { e.printStackTrace(); } } @Override public void exitInterfaceMethodDeclaration(JavaParser.InterfaceMethodDeclarationContext ctx) { if (processingBlock()) { return; } processMethod(ctx.Identifier().getText(), ctx.type(), null); } @Override public void exitMethodDeclaration(JavaParser.MethodDeclarationContext ctx) { if (processingBlock()) { return; } if (ctx.qualifiedNameList() != null) { processMethod(ctx.Identifier().getText(), ctx.type(), ctx.qualifiedNameList().qualifiedName()); } else { processMethod(ctx.Identifier().getText(), ctx.type(), null); } } private void processMethod(String identifier, JavaParser.TypeContext type, List<JavaParser.QualifiedNameContext> exceptions) { try { JavaMethod method = JavasimpleFactory.eINSTANCE.createJavaMethod(); method.setName(identifier); registerUnresolvedReference(method, SymbolType.Class, JavasimplePackage.eINSTANCE.getJavaMethod_ReturnType(), type); if (type != null) { method.setReturnArray(type.getText().endsWith("[]")); } // method.setReturnType(getType(type)); Object element = processStack.peek(); if (element instanceof StringBuilder) { method.setSource(((StringBuilder) element).toString()); processStack.pop(); } Object top; // Read parameters until find null while (processStack.isEmpty() == false && (top = processStack.pop()) != null) { if (top instanceof Parameter) { method.getParameters().add(0, (Parameter) top); } } processModifiers(method); if (exceptions != null) { for (JavaParser.QualifiedNameContext exception : exceptions) { registerUnresolvedReference(method, SymbolType.Class, JavasimplePackage.eINSTANCE.getJavaMethod_Exceptions(), exception.getText()); } } processStack.push(method); } catch (Exception e) { e.printStackTrace(); } } @Override public void enterFormalParameters(JavaParser.FormalParametersContext ctx) { if (processingBlock()) { return; } processStack.push(null); } @Override public void exitFormalParameter(JavaParser.FormalParameterContext ctx) { if (processingBlock()) { return; } Parameter param = JavasimpleFactory.eINSTANCE.createParameter(); param.setName(ctx.variableDeclaratorId().Identifier().getText()); registerUnresolvedReference(param, SymbolType.Class, JavasimplePackage.eINSTANCE.getParameter_Type(), ctx.type()); // param.setType(getType(ctx.type())); param.setArray(isArray(ctx.type())); processModifiers(param); processStack.push(param); } @Override public void exitLastFormalParameter(JavaParser.LastFormalParameterContext ctx) { if (processingBlock()) { return; } Parameter param = JavasimpleFactory.eINSTANCE.createParameter(); param.setName(ctx.variableDeclaratorId().Identifier().getText()); registerUnresolvedReference(param, SymbolType.Class, JavasimplePackage.eINSTANCE.getParameter_Type(), ctx.type()); // param.setType(getType(ctx.type())); param.setArray(isArray(ctx.type())); param.setVarArray(true); processModifiers(param); processStack.push(param); } // @Override // public void // enterElementValuePair(JavaParser.ElementValuePairContext ctx) { // classStack.push(null); // } @Override public void enterElementValueArrayInitializer(JavaParser.ElementValueArrayInitializerContext ctx) { if (processingBlock()) { return; } processStack.push(null); } @Override public void exitElementValue(JavaParser.ElementValueContext ctx) { if (processingBlock()) {/* ctx.getText() */ return; } try { AnnotationParam param = null; if (ctx.expression() != null) { AnnotationParamValueExpression expression = JavasimpleFactory.eINSTANCE .createAnnotationParamValueExpression(); final String valueExpression = app.handler .processAnnotationValueExpresion(ctx.expression()); expression.setValue(valueExpression); param = expression; } else if (ctx.annotation() != null) { AnnotationParamValueAnnotation expression = JavasimpleFactory.eINSTANCE .createAnnotationParamValueAnnotation(); expression.setAnnotation((Annotation) processStack.pop()); param = expression; } else if (ctx.elementValueArrayInitializer() != null) { AnnotationParamValueArray expression = JavasimpleFactory.eINSTANCE .createAnnotationParamValueArray(); Object top; while ((top = processStack.pop()) != null) { if (top instanceof Annotation) { AnnotationParamValueAnnotation arrayElement = JavasimpleFactory.eINSTANCE .createAnnotationParamValueAnnotation(); arrayElement.setAnnotation((Annotation) top); expression.getValues().add(0, arrayElement); } else { try { expression.getValues().add(0, (AnnotationParam) top); } catch (Exception ex) { ex.printStackTrace(); } } } param = expression; } processStack.push(param); } catch (Exception e) { e.printStackTrace(); } } @Override public void exitElementValuePair(JavaParser.ElementValuePairContext ctx) { if (processingBlock()) { return; } final AnnotationParam param = (AnnotationParam) processStack.peek(); if (ctx.Identifier() != null) { if (param == null) { throw new RuntimeException(); } param.setKey(ctx.Identifier().getText()); } } @Override public void enterAnnotation(JavaParser.AnnotationContext ctx) { if (processingBlock()) { return; } processStack.push(null); } @Override public void exitAnnotation(JavaParser.AnnotationContext ctx) { if (processingBlock()) { return; } try { // final String annotationPackageName = getPackage(imports, // ctx.annotationName().qualifiedName().getText()); // AnnotationType aType = (AnnotationType) // app.getOrCreateReferencedJavaElement(SymbolType.AnnotationType, // packageName, annotationPackageName, // ctx.annotationName().qualifiedName().getText()); Annotation an = JavasimpleFactory.eINSTANCE.createAnnotation(); registerUnresolvedReference(an, SymbolType.AnnotationType, JavasimplePackage.eINSTANCE.getAnnotation_AnnotationType(), ctx.annotationName().qualifiedName().getText()); // an.setAnnotationType(aType); Object top; while (!processStack.isEmpty() && (top = processStack.pop()) != null) { AnnotationParam param = (AnnotationParam) top; if (param.getKey() == null) { an.setValue(param); } else { an.getParameters().add(0, param); } } processStack.push(an); } catch (Exception e) { e.printStackTrace(); } } /** * Generic method to put in the stack the modifiers * * @param ctx */ @Override public void exitModifier(JavaParser.ModifierContext ctx) { if (processingBlock()) { return; } if (ctx.classOrInterfaceModifier() == null) { processStack.push(Modifier.getByName(ctx.getText())); } } /** * Put in the stack the modifiers of a class or interface * * @param ctx */ @Override public void exitClassOrInterfaceModifier(JavaParser.ClassOrInterfaceModifierContext ctx) { if (processingBlock()) { return; } /** * The ClassOrInterfaceContext include the annotation we only * add when is not an annotation */ if (ctx.annotation() == null) { processStack.push(Modifier.getByName(ctx.getText())); } } /** * Put in the stack the modifiers of a variable AKA final * * @param ctx */ @Override public void exitVariableModifier(JavaParser.VariableModifierContext ctx) { if (processingBlock()) { return; } if (ctx.annotation() == null) { processStack.push(Modifier.getByName(ctx.getText())); } } /** * Search in the stack for all the modifiers * * @param se */ private void processModifiers(StructuralElement se) { String a; Object top; try { while (!processStack.isEmpty() && (processStack.peek() instanceof Modifier || processStack.peek() instanceof Annotation)) { top = processStack.pop(); if (top instanceof Annotation) { se.getAnnotations().add(0, (Annotation) top); } else if (top instanceof Modifier) { se.getModifiers().add(0, (Modifier) top); } } } catch (Exception e) { System.out.println("----->" + fileName + "<------"); System.out.println(((NamedElement) se).getName()); System.out.println(processStack); e.printStackTrace(); } } private void registerUnresolvedReference(EObject javaElement, SymbolType symbolType, EReference feature, JavaParser.TypeContext type) { if (type != null) { unresolvedTypeReferences .add(new TypeReference(javaElement, symbolType, feature, packageName, imports, type)); } } private void registerUnresolvedReference(EObject javaElement, SymbolType symbolType, EReference feature, String qualifiedName) { if (qualifiedName != null) { unresolvedTypeReferences.add(new TypeReference(javaElement, symbolType, feature, packageName, imports, qualifiedName)); } } private boolean isArray(final JavaParser.TypeContext typeContext) { if (typeContext == null) { return false; } else { return typeContext.getText().endsWith("[]"); } } }; // parser.addParseListener(listener); // parser.addErrorListener(new ConsoleErrorListener()); ParseTreeWalker walker = new ParseTreeWalker(); ParseTree pTree = parser.compilationUnit(); walker.walk(listener, pTree); app.registerUnresolvedReferences(unresolvedTypeReferences); // lexer.getInputStream(). }
From source file:com.khubla.jvmbasic.jvmbasicc.function.impl.token.FLOATToken.java
License:Open Source License
@Override public boolean execute(GenerationContext generationContext) throws Exception { try {/*from w w w . ja va2 s . co m*/ /* * num */ final Token token = (Token) generationContext.getParseTree().getPayload(); final String num = token.getText(); /* * check for decimal */ if (-1 != num.indexOf('.')) { /* * push the double */ final double value = Double.parseDouble(num); RTLHelper.push(generationContext, value); } else { /* * push the int */ final int value = Integer.parseInt(num); RTLHelper.push(generationContext, value); } return true; } catch (final Exception e) { throw new Exception("Exception in execute", e); } }
From source file:com.khubla.jvmbasic.jvmbasicc.function.impl.token.LETTERSToken.java
License:Open Source License
@Override public boolean execute(GenerationContext generationContext) throws Exception { try {// w w w . j a va 2 s . co m /* * push the letter */ final Token token = (Token) generationContext.getParseTree().getPayload(); String letter = token.getText(); /* * is there a suffix like "$" or "%" on this letters? */ if (generationContext.getParseTree().getChildCount() == 1) { letter += generationContext.getChildValue(0); } /* * push onto value stack */ RTLHelper.push(generationContext, letter); return true; } catch (final Exception e) { throw new Exception("Exception in execute", e); } }