use of org.antlr.v4.runtime.Lexer in project ihmc-pub-sub by ihmcrobotics.
the class IDLGenerator method execute.
/**
* Generate java classes from an IDL file
*
* @param idlFile IDL file to parse
* @param packageName Target package (IDL Module gets added to this)
* @param targetDirectory Directory to save the generated files in. The whole package structure is generated in this directory
* @throws IOException
*/
public static void execute(File idlFile, String packageName, File targetDirectory, List<File> includePath) throws IOException {
String idlFilename = idlFile.getAbsolutePath();
Field field;
try {
field = TemplateManager.class.getDeclaredField("m_loaderDirectories");
field.setAccessible(true);
field.set(null, "us/ihmc/idl/templates");
} catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
throw new RuntimeException("API changed, fixme", e);
}
String onlyFileName = Util.getIDLFileNameOnly(idlFilename);
IDLContext context = new IDLContext(onlyFileName, idlFilename, new ArrayList<>());
context.setPackage(packageName);
TypeCode.javapackage = context.isIsPackageEmpty() ? "" : (context.getPackage() + ".");
// Create default @default annotation.
AnnotationDeclaration defaultAnnotation = context.createAnnotationDeclaration("defaultValue", null);
defaultAnnotation.addMember(new AnnotationMember("value", new PrimitiveTypeCode(TypeCode.KIND_STRING), ""));
// Create default @Key annotation.
AnnotationDeclaration keyann = context.createAnnotationDeclaration("Key", null);
keyann.addMember(new AnnotationMember("value", new PrimitiveTypeCode(TypeCode.KIND_BOOLEAN), "true"));
// Create default @Topic annotation.
AnnotationDeclaration topicann = context.createAnnotationDeclaration("Topic", null);
topicann.addMember(new AnnotationMember("value", new PrimitiveTypeCode(TypeCode.KIND_BOOLEAN), "true"));
AnnotationDeclaration abstractann = context.createAnnotationDeclaration("Abstract", null);
abstractann.addMember(new AnnotationMember("type", new PrimitiveTypeCode(TypeCode.KIND_STRING), "java.lang.Object"));
abstractann.addMember(new AnnotationMember("impl", new PrimitiveTypeCode(TypeCode.KIND_STRING), ""));
AnnotationDeclaration typecode = context.createAnnotationDeclaration("TypeCode", null);
typecode.addMember(new AnnotationMember("type", new PrimitiveTypeCode(TypeCode.KIND_BOOLEAN), "INVALID_TYPE_CODE"));
// Create template manager
TemplateManager tmanager = new TemplateManager("FastCdrCommon:Common");
// Create main template
TemplateGroup maintemplates = tmanager.createTemplateGroup("main");
maintemplates.setAttribute("ctx", context);
if (idlFile.exists()) {
Reader reader = createPreProcessedInputStream(idlFile, includePath);
ANTLRInputStream input = new ANTLRInputStream(reader);
IDLLexer lexer = new IDLLexer(input);
lexer.setContext(context);
CommonTokenStream tokens = new CommonTokenStream(lexer);
// printTokenStream(tokens);
IDLParser parser = new IDLParser(tokens);
// Pass the filename without the extension
parser.specification(context, tmanager, maintemplates);
File packageDir = new File(targetDirectory, context.getPackageDir());
if (packageDir.isDirectory() || packageDir.mkdirs()) {
TypesGenerator gen = new TypesGenerator(tmanager, true);
if (!gen.generate(context, packageDir.getPath() + "/", context.getPackage(), null)) {
throw new IOException("Cannot create Java files");
}
} else {
throw new IOException("Cannot create output dir " + packageDir);
}
} else {
throw new IOException("The File " + idlFilename + " was not found.");
}
}
use of org.antlr.v4.runtime.Lexer in project titan.EclipsePlug-ins by eclipse.
the class ASN1Analyzer method parse.
@Override
public void parse(final IFile file, final String code) throws FileNotFoundException {
Reader reader = null;
if (code != null) {
reader = new StringReader(code);
} else if (file != null) {
try {
reader = new BufferedReader(new InputStreamReader(file.getContents(), file.getCharset()));
} catch (Exception e) {
ErrorReporter.logExceptionStackTrace("Could not get the contents of `" + file.getName() + "'", e);
return;
}
} else {
return;
}
final CharStream charStream = new UnbufferedCharStream(reader);
final Asn1Lexer lexer = new Asn1Lexer(charStream);
lexer.setTokenFactory(new TokenWithIndexAndSubTokensFactory(true));
lexer.setActualFile(file);
lexerListener = new ASN1Listener();
// remove ConsoleErrorListener
lexer.removeErrorListeners();
lexer.addErrorListener(lexerListener);
final ModuleLevelTokenStreamTracker tracker = new ModuleLevelTokenStreamTracker(lexer);
tracker.discard(Asn1Lexer.WS);
tracker.discard(Asn1Lexer.MULTILINECOMMENT);
tracker.discard(Asn1Lexer.SINGLELINECOMMENT);
tracker.setActualFile(file);
final Asn1Parser parser = new Asn1Parser(tracker);
parser.setProject(file.getProject());
parser.setActualFile(file);
parser.setBuildParseTree(false);
parserListener = new ASN1Listener(parser);
// remove ConsoleErrorListener
parser.removeErrorListeners();
parser.addErrorListener(parserListener);
parser.pr_ASN1ModuleDefinition();
actualAsn1Module = parser.getModule();
warnings = parser.getWarnings();
unsupportedConstructs = parser.getUnsupportedConstructs();
try {
reader.close();
} catch (IOException e) {
}
}
use of org.antlr.v4.runtime.Lexer in project titan.EclipsePlug-ins by eclipse.
the class TTCN3ReferenceAnalyzer method parse.
/**
* @return the parsed reference or null if the text can not form a reference
*/
public Reference parse(final IFile file, final String code, final boolean reportErrors, final int aLine, final int aOffset) {
Reference reference = null;
Reader reader = new StringReader(code);
CharStream charStream = new UnbufferedCharStream(reader);
Ttcn3Lexer lexer = new Ttcn3Lexer(charStream);
lexer.setTokenFactory(new CommonTokenFactory(true));
lexer.initRootInterval(code.length());
lexer.removeErrorListeners();
final CommonTokenStream tokenStream = new CommonTokenStream(lexer);
Ttcn3Parser parser = new Ttcn3Parser(tokenStream);
ParserUtilities.setBuildParseTree(parser);
lexer.setActualFile(file);
parser.setActualFile(file);
parser.setProject(file.getProject());
parser.setLine(aLine);
parser.setOffset(aOffset);
parser.removeErrorListeners();
final Pr_UnifiedReferenceParserContext root = parser.pr_UnifiedReferenceParser();
ParserUtilities.logParseTree(root, parser);
reference = root.reference;
return reference;
}
use of org.antlr.v4.runtime.Lexer in project titan.EclipsePlug-ins by eclipse.
the class TTCN3ReparseUpdater method startsWithFollow.
/**
* Checks if the first TTCN-3 lexical token in the substring, that covers the possibly changed interval of the document belongs to a given list of
* expected tokens or not.
*
* @param followSet the possible tokens that can follow the element before the suspected
*
* @return true if the first lexical token is part of the followset, false otherwise
*/
public boolean startsWithFollow(final List<Integer> followSet) {
if (followSet == null || followSet.isEmpty()) {
return false;
}
if (code == null) {
return false;
}
int line = getLineOfOffset(code, modificationStartOffset);
int column = getPositionInLine(code, modificationStartOffset);
String substring;
if (code.length() <= modificationEndOffset + shift) {
substring = code.substring(modificationStartOffset);
} else {
substring = code.substring(modificationStartOffset, modificationEndOffset + shift);
}
Reader reader = new StringReader(substring);
CharStream charStream = new UnbufferedCharStream(reader);
Ttcn3Lexer lexer = new Ttcn3Lexer(charStream);
lexer.setTokenFactory(new CommonTokenFactory(true));
lexer.setLine(line + 1);
lexer.setCharPositionInLine(column);
lexer.initRootInterval(modificationEndOffset - modificationStartOffset + 1);
Token token = lexer.nextToken();
if (token == null) {
return false;
}
return followSet.contains(token.getType());
}
use of org.antlr.v4.runtime.Lexer in project titan.EclipsePlug-ins by eclipse.
the class TTCN3ReparseUpdater method parse.
public int parse(final ITTCN3ReparseBase userDefined) {
if (modificationStartOffset == modificationEndOffset + shift) {
return 0;
}
// double wideparsing = System.nanoTime();
mErrors = null;
warnings = null;
Iterator<TITANMarker> iterator = unsupportedConstructs.iterator();
while (iterator.hasNext()) {
TITANMarker marker = iterator.next();
if ((marker.getOffset() > modificationStartOffset && marker.getOffset() <= modificationEndOffset) || (marker.getEndOffset() > modificationStartOffset && marker.getEndOffset() <= modificationEndOffset)) {
iterator.remove();
}
}
MarkerHandler.markAllOnTheFlyMarkersForRemoval(file, modificationStartOffset, modificationEndOffset + shift);
if (code == null) {
return Integer.MAX_VALUE;
}
int line = getLineOfOffset(code, modificationStartOffset);
String substring;
if (code.length() <= modificationEndOffset + shift) {
substring = code.substring(modificationStartOffset);
} else {
substring = code.substring(modificationStartOffset, modificationEndOffset + shift);
}
Reader reader = new StringReader(substring);
CharStream charStream = new UnbufferedCharStream(reader);
Ttcn3Lexer lexer = new Ttcn3Lexer(charStream);
lexer.setTokenFactory(new CommonTokenFactory(true));
lexer.initRootInterval(modificationEndOffset - modificationStartOffset + 1);
// lexer and parser listener
TitanListener parserListener = new TitanListener();
// remove ConsoleErrorListener
lexer.removeErrorListeners();
lexer.addErrorListener(parserListener);
// 1. Previously it was UnbufferedTokenStream(lexer), but it was changed to BufferedTokenStream, because UnbufferedTokenStream seems to be unusable. It is an ANTLR 4 bug.
// Read this: https://groups.google.com/forum/#!topic/antlr-discussion/gsAu-6d3pKU
// pr_PatternChunk[StringBuilder builder, boolean[] uni]:
// $builder.append($v.text); <-- exception is thrown here: java.lang.UnsupportedOperationException: interval 85..85 not in token buffer window: 86..341
// 2. Changed from BufferedTokenStream to CommonTokenStream, otherwise tokens with "-> channel(HIDDEN)" are not filtered out in lexer.
final CommonTokenStream tokenStream = new CommonTokenStream(lexer);
Ttcn3Reparser parser = new Ttcn3Reparser(tokenStream);
ParserUtilities.setBuildParseTree(parser);
lexer.setActualFile(file);
parser.setActualFile(file);
parser.setProject(file.getProject());
parser.setOffset(modificationStartOffset);
parser.setLine(line + 1);
// remove ConsoleErrorListener
parser.removeErrorListeners();
parser.addErrorListener(parserListener);
userDefined.reparse(parser);
mErrors = parserListener.getErrorsStored();
warnings = parser.getWarnings();
unsupportedConstructs.addAll(parser.getUnsupportedConstructs());
int result = measureIntervallDamage();
if (!parser.isErrorListEmpty()) {
++result;
}
return result;
}
Aggregations