static void Main(string[] args)
{
var fileName = args[0];
var stream = new AntlrInputStream(File.ReadAllText(fileName));
var lexer = new JavaLexer(stream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new JavaParser(tokenStream);
var classContext = parser.class_definition();
var methodContext = classContext.method();
var program = new IRVisitor().Visit(methodContext.body());
Console.WriteLine("IR:");
Console.WriteLine(string.Join("\n", program.Select(x => " " + x.ToString())));
Console.WriteLine();
var blocks = BasicBlockCreator.Create(program);
Console.WriteLine("Basic Blocks:");
var graphViz = BasicBlockCreator.DumpGraphViz(blocks);
Console.WriteLine(graphViz);
var definitions = DFA.GetReachingDefinitions(blocks.Last());
Console.WriteLine("Reaching definitions: " + string.Join(", ", definitions));
}
public static IEnumerable <ClassInfo> OuterClassInfosFromSource(string source, string filePath)
{
try
{
char[] codeArray = source.ToCharArray();
AntlrInputStream inputStream = new AntlrInputStream(codeArray, codeArray.Length);
JavaLexer lexer = new JavaLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(commonTokenStream);
parser.RemoveErrorListeners();
parser.AddErrorListener(new ErrorListener()); // add ours
// a compilation unit is the highest level container -> start there
// do not call parser.compilationUnit() more than once
CompilationUnitListener compilationUnitListener = new CompilationUnitListener(filePath);
parser.compilationUnit().EnterRule(compilationUnitListener);
return(compilationUnitListener.OuterClassInfos);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(new List <ClassInfo>());
}
public void Load(string path)
{
var tokens = new CommonTokenStream(GetLexer(path));
var parser = new JavaParser(tokens);
parser.enableErrorMessageCollection(true);
var tree = parser.JavaSource().Tree;
var nodes = new CommonTreeNodeStream(tree);
var xs = new JavaTreeParser(nodes);
xs.enableErrorMessageCollection(true);
var rootNode = xs.JavaSource();
if (!parser.hasErrors() && !xs.hasErrors())
{
}
else
{
foreach (var message in parser.getMessages())
{
Console.WriteLine(message);
}
foreach (var message in xs.getMessages())
{
Console.WriteLine(message);
}
throw new NotImplementedException();
}
}
public static bool TryGetLineStatements(string text, int lineNumber, out IList<IParseTree> statementTrees, out IList<IToken> tokens)
{
Contract.Requires<ArgumentNullException>(text != null, "text");
Contract.Requires<ArgumentOutOfRangeException>(lineNumber >= 0);
try
{
AntlrInputStream input = new AntlrInputStream(text);
JavaLexer lexer = new JavaLexer(new JavaUnicodeStreamV4(input));
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokenStream);
parser.Interpreter.PredictionMode = PredictionMode.Sll;
parser.BuildParseTree = true;
JavaParser.CompilationUnitContext result = parser.compilationUnit();
statementTrees = null;
tokens = tokenStream.GetTokens();
AssociatedTreeListener listener = new AssociatedTreeListener(lineNumber, tokens);
ParseTreeWalker.Default.Walk(listener, result);
statementTrees = listener.StatementTrees;
return true;
}
catch (Exception e)
{
if (ErrorHandler.IsCriticalException(e))
throw;
statementTrees = null;
tokens = null;
return false;
}
}
/// <summary>
/// Creates a collection of entities from a collection go IFiles.
/// </summary>
/// <returns>The entities.</returns>
/// <param name="files">Files.</param>
public static EntityCollection MakeEntities(IEnumerable <IFile> files)
{
EntityCollection entities = new EntityCollection();
ParallelOptions parallelOptions = new ParallelOptions
{
MaxDegreeOfParallelism = 8
};
switch (CheckProjectType(files))
{
case ProjectType.CSharp:
CsParser csParser = new CsParser();
Parallel.ForEach(files.Where(x => Path.GetExtension(x.Path) == ".cs"), parallelOptions, item => {
entities.Add(csParser.Parse(item), item.Date.DateTime, item.Revisions);
});
break;
case ProjectType.Unicon:
IcnParser icnParser = new IcnParser();
Parallel.ForEach(files.Where(x => Path.GetExtension(x.Path) == ".icn"), parallelOptions, item => {
entities.Add(icnParser.Parse(item), item.Date.DateTime, item.Revisions);
});
break;
case ProjectType.Java:
JavaParser javaParser = new JavaParser();
Parallel.ForEach(files.Where(x => Path.GetExtension(x.Path) == ".java"), parallelOptions, item => {
entities.Add(javaParser.Parse(item), item.Date.DateTime, item.Revisions);
});
break;
}
return(entities);
}
static void Main(string[] args)
{
if (args.Length > 0)
{
var visitor = new JavaTreeVisitor(args[0]);
var package = new List <string>();
if (args.Length > 1)
{
foreach (var path in args.Skip(1))
{
package.AddRange(Directory.GetFiles(path, "*.java", SearchOption.AllDirectories));
}
}
else
{
var landResultsFile = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\LanD Workspace\last_batch_parsing_report.txt";
if (File.Exists(landResultsFile))
{
package.AddRange(Directory.GetFiles(
File.ReadAllLines(landResultsFile)[1],
"*.java", SearchOption.AllDirectories));
}
else
{
Console.WriteLine("Не указаны каталоги для парсинга");
return;
}
}
var totalTime = new TimeSpan();
foreach (var filename in package)
{
var inputStream = new AntlrInputStream(File.ReadAllText(filename));
var lexer = new JavaLexer(inputStream);
var parser = new JavaParser(new CommonTokenStream(lexer));
/// Запускаем парсинг
var startTime = DateTime.Now;
var context = parser.compilationUnit();
totalTime += DateTime.Now - startTime;
visitor.SetFile(filename);
context.Accept(visitor);
}
visitor.CloseOutputs();
Console.WriteLine($"methods: {visitor.MethodCounter}");
Console.WriteLine($"classes: {visitor.ClassInterfaceCounter}");
Console.WriteLine($"enums: {visitor.EnumCounter}");
Console.WriteLine($"fields: {visitor.FieldCounter}");
Console.WriteLine($"field declarations: {visitor.FieldDeclarationCounter}");
Console.WriteLine(totalTime.ToString(@"hh\:mm\:ss\:ff"));
}
}
public static AstParserRuleReturnScope <CommonTree, IToken> JavaSource(this JavaParser parser)
{
var type = parser.GetType();
var methodInfos = type.GetMethod("javaSource", BindingFlags.NonPublic | BindingFlags.Instance);
var method = methodInfos;
return((AstParserRuleReturnScope <CommonTree, IToken>)method.Invoke(parser, new object[0]));
}
static void Main(string[] args)
{
string in_filename = @"..\..\NOD.java";
string out_filename = @"..\..\NOD.class";
AntlrInputStream inputStream = new AntlrFileStream(in_filename);
var javaLexer = new JavaLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(javaLexer);
var javaParser = new JavaParser(commonTokenStream);
var visitor = new JavaVisitor(new StackFrame());
visitor.Visit(javaParser.compileUnit());
var stackFrame = visitor.StackFrame;
var initInd = stackFrame.GetOrAddMethodref("<init>", "()V", "java/lang/Object");
var methods = new List <MethodInfo>();
var initMethod = new MethodInfo(MethodAccessFlags.ACC_PUBLIC,
stackFrame.GetOrAddString("<init>"),
stackFrame.GetOrAddString("()V"));
var initCodeInstructions = new List <byte>();
initCodeInstructions.Add(0x2A);
initCodeInstructions.Add(0xB7);
initCodeInstructions.AddRange(Utils.WriteUShort(initInd));
initCodeInstructions.Add(0xB1);
var initCodeAttribute = new CodeAttributeParser(1, 1, initCodeInstructions);
var initData = initCodeAttribute.BuildData();
initMethod.AttributesCount = 1;
initMethod.Attributes = new AttributeDescription[1] {
new AttributeDescription(stackFrame.GetOrAddString("Code"), (uint)initData.Length, initData)
};
methods.Add(initMethod);
var mainMethod = new MethodInfo(MethodAccessFlags.ACC_PUBLIC | MethodAccessFlags.ACC_STATIC,
stackFrame.GetOrAddString("main"),
stackFrame.GetOrAddString("([Ljava/lang/String;)V"));
var mainCodeAttribute = new CodeAttributeParser(stackFrame.maxStackSize,
stackFrame.maxLocalsSize, stackFrame.BuildInstructions());
var mainData = mainCodeAttribute.BuildData();
mainMethod.AttributesCount = 1;
mainMethod.Attributes = new AttributeDescription[1] {
new AttributeDescription(stackFrame.GetOrAddString("Code"), (uint)mainData.Length, mainData)
};
methods.Add(mainMethod);
var classFile = ClassFile.CreateClassFile(0, 52, ClassAccessFlags.ACC_PUBLIC | ClassAccessFlags.ACC_SUPER,
stackFrame.thisClass, stackFrame.constantPool, methods);
classFile.SuperClass = stackFrame.GetOrAddClass("java/lang/Object");
File.WriteAllBytes(out_filename, classFile.BuildClassFile());
}
public static string ConvertStatement(string java)
{
var statement = JavaParser.parseStatement(java);
var options = new JavaConversionOptions();
var context = new ConversionContext(options);
var statementSyntax = StatementVisitor.VisitStatement(context, statement);
var tree = CSharpSyntaxTree.Create(statementSyntax);
return(tree.GetText().ToString());
}
public void Test()
{
var inputStream = new AntlrInputStream("public /*aa*/ class Klass { }");
var javaLexer = new JavaLexer(inputStream);
var commonTokenStream = new CommonTokenStream(javaLexer);
var javaParser = new JavaParser(commonTokenStream);
var context = javaParser.compilationUnit();
var visitor = new CstBuilderForAntlr4(javaParser);
visitor.Visit(context);
Console.WriteLine(visitor.FinishParsing().ToXml());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static void main(String[] args) throws Exception
public static void Main(string[] args)
{
Thread.Sleep(10000);
ANTLRFileStream input = new ANTLRFileStream(args[0]);
JavaLexer lexer = new JavaLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokens);
JavaParser.CompilationUnitContext tree = parser.compilationUnit();
// System.out.println(tree.toStringTree(parser));
Thread.Sleep(10000);
}
private static string ConvertStatement(string java)
{
var declaration = JavaParser.parseBodyDeclaration(java);
var options = new JavaConversionOptions();
var context = new ConversionContext(options);
var arrayCreationExpression = (ArrayCreationExpr)((Node)((MethodDeclaration)declaration.getChildrenNodes().get(1)).getBody().getStmts().get(0)).getChildrenNodes().get(0);
var expressionSyntax = ExpressionVisitor.VisitExpression(context, arrayCreationExpression).NormalizeWhitespace();
var tree = CSharpSyntaxTree.Create(expressionSyntax);
return(tree.GetText().ToString());
}
public Program ParseFromString(string sourceCode)
{
var symbolSolver = new JavaSymbolSolver(new ReflectionTypeSolver());
CompilationUnit x = JavaParser.parse(new ByteArrayInputStream(sourceCode.getBytes(StandardCharsets.UTF_8)));
symbolSolver.inject(x);
if (x.getTypes().size() != 1)
{
throw new ArgumentException("Exactly one top-level type is expected");
}
Node rootClassNode = x.getTypes().get(0);
if (!(rootClassNode is ClassOrInterfaceDeclaration rootClass && !rootClass.isInterface() && !rootClass.isAbstract() && rootClass.isPublic()))
{
throw new ArgumentException("Top-level type should be a public non-abstract class");
}
KernelBase kernel = new StandardKernel();
kernel.Bind <IVariablesStorage>().To <VariablesStorage>().InSingletonScope();
PartialFunctionCombiningMissingBindingResolver <TypeParsingTag> .LoadAllTaggedFunctions(kernel);
PartialFunctionCombiningMissingBindingResolver <TypeParsingTag> .AddToKernel(kernel);
PartialFunctionCombiningMissingBindingResolver <NodeParsingTag> .LoadAllTaggedFunctions(kernel);
PartialFunctionCombiningMissingBindingResolver <NodeParsingTag> .AddToKernel(kernel);
var parseStatement = kernel.Get <TaggedFunction <PartialFunctionCombined <NodeParsingTag>, Statement, IStatement> >();
IStatement mainStatement = null;
foreach (MethodDeclaration method in rootClass.getMethods().toArray())
{
if (!IsMethodMain(method))
{
throw new ArgumentException("Expected only main() method");
}
mainStatement = parseStatement.Apply((Statement)method.getBody().get());
if (mainStatement == null)
{
throw new ArgumentException($"Unable to parse main() method statement: {method.getBody().get()}");
}
}
if (mainStatement == null)
{
throw new ArgumentException("main() not found");
}
return(new Program(mainStatement));
}
public override void EnterStatement(JavaParser.StatementContext context)
{
if (context.ASSERT() != null
|| context.RETURN() != null
|| context.THROW() != null
|| context.BREAK() != null
|| context.CONTINUE() != null
|| (context.SEMI() != null && context.ChildCount == 1)
|| context.statementExpression() != null)
{
if (IsInCurrentContext(context))
_statementTrees.Add(context);
}
}
private void ParseJava(string input)
{
AntlrInputStream stream = new AntlrInputStream(input);
ITokenSource lexer = new JavaLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokens);
parser.BuildParseTree = true;
JavaParser.CompilationUnitContext tree = parser.compilationUnit();
if (tree != null)
{
var builder = new TreeBuilder(parser, tree, treeModel);
builder.Build();
}
}
static void TestDefinitions(string resourceName, IEnumerable <int> expected)
{
var resourceStream = typeof(Tests).Assembly.GetManifestResourceStream($"pt_dfa.tests.{resourceName}");
var stream = new AntlrInputStream(resourceStream);
var lexer = new JavaLexer(stream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new JavaParser(tokenStream);
var classContext = parser.class_definition();
var methodContext = classContext.method();
var ir = methodContext.Accept(new IRVisitor());
var blocks = BasicBlockCreator.Create(ir);
var definitions = DFA.GetReachingDefinitions(blocks.Last());
Assert.IsTrue(definitions.SequenceEqual(expected));
}
public string Transpile(string javaCode)
{
var stream = new AntlrInputStream(javaCode);
var lexer = new JavaLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new JavaParser(tokens);
parser.BuildParseTree = true;
var styleKitVisitor = new StyleKitVisitor(tokens)
{
Namespace = Namespace
};
styleKitVisitor.Visit(parser.compilationUnit());
return(styleKitVisitor.GetResult());
}
public override void Parse(FileInfo file)
{
Lexer lexer = new JavaLexer(CharStreams.fromPath(file.FullName));
CommonTokenStream tokens = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokens);
ParserRuleContext context = parser.compilationUnit();
var children = context.children;
foreach (IParseTree child in children)
{
this.ParseNode(child);
}
}
static void Main(string[] args)
{
int i = 0;
bool build_tree = true;
for (; i < args.Length; ++i)
{
switch (args[i])
{
case "-notree":
build_tree = false;
break;
}
}
var input = File.OpenText(args[i - 1]);
var str = new AntlrInputStream(input);
var lexer = new JavaLexer(str);
var tokens = new CommonTokenStream(lexer);
var parser = new JavaParser(tokens);
var listener = new ErrorListener <IToken>(parser, lexer, tokens);
parser.AddErrorListener(listener);
parser.BuildParseTree = build_tree;
var start = DateTime.Now;
var tree = parser.compilationUnit();
if (listener.had_error)
{
System.Console.WriteLine("error in parse.");
}
else
{
System.Console.WriteLine("parse completed.");
}
var end = DateTime.Now;
System.Console.WriteLine(tokens.OutputTokens());
if (tree != null)
{
System.Console.WriteLine(tree.OutputTree(tokens));
}
System.Console.WriteLine(end - start);
}
public static string ConvertMethodDeclaration(string java)
{
var javaClassDeclaration = @"
class A
{
" + java + @"
}";
var declaration = JavaParser.parseBodyDeclaration(javaClassDeclaration);
var options = new JavaConversionOptions();
var context = new ConversionContext(options);
var classDeclaration = SyntaxFactory.ClassDeclaration("A");
var statementSyntax = BodyDeclarationVisitor.VisitBodyDeclarationForClass(context,
classDeclaration, (BodyDeclaration)declaration.getChildrenNodes().get(0))
.NormalizeWhitespace();
var tree = CSharpSyntaxTree.Create(statementSyntax);
return(tree.GetText().ToString());
}
public void Parse(string file, IProject project)
{
AntlrFileStream filestream = new AntlrFileStream(file);
JavaLexer lexer = new JavaLexer(filestream);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokenStream);
var startingPonit = parser.compilationUnit();
OrchestratingListener genericListener = new OrchestratingListener(project);
genericListener.ParseInfoUpdate += (string info) => NotifyParseInfoUpdated?.Invoke(info);
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(genericListener, startingPonit);
}
public void ParseJava() {
var inputStream = new AntlrInputStream(@"
import javax.swing.*;
public class Hello extends JFrame {
Hello() {
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
pack();
}
public static void main(String[] args) {
new Hello().setVisible(true);
}
}");
var lexer = new JavaLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new JavaParser(commonTokenStream);
var visitor = new CstBuilderForAntlr4(parser);
visitor.Visit(parser.compilationUnit());
Console.WriteLine(visitor.FinishParsing());
}
static void Main(string[] args)
{
StreamReader sr = new StreamReader("W:/Spring2021/Senior proj/JavaCXGamesMode/JavaCSharp/JavaCSharp/Test.txt");
string input = sr.ReadToEnd();
AntlrInputStream inputStream = new AntlrInputStream(input);
ICharStream stream = inputStream;
JavaLexer lexer = new JavaLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokens);
IParseTree tree = parser.compilationUnit();
//TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
//Console.WriteLine(parser.ToString());
//Console.WriteLine(tree.ToStringTree(parser));
JavaVisitor visitor = new JavaVisitor();
visitor.Visit(tree);
Console.ReadLine();
}
static void Main(string[] args)
{
List <string> options = new List <string>();
List <string> arguments = new List <string>();
string ast_output_file = null;
CommandLine.Parser.Default.ParseArguments <Options>(args)
.WithParsed <Options>(o =>
{
arguments = o.JavaFiles.ToList();
ast_output_file = o.AstOutFile;
})
.WithNotParsed(a =>
{
System.Console.Error.WriteLine(a);
});
Runtime.Redirect r = new Runtime.Redirect(ast_output_file);
foreach (var file_name in arguments)
{
var code_as_string = File.ReadAllText(file_name);
var input = new AntlrInputStream(code_as_string);
var lexer = new JavaLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new JavaParser(tokens);
var listener = new ErrorListener <IToken>();
parser.AddErrorListener(listener);
JavaParser.CompilationUnitContext tree = parser.compilationUnit();
if (listener.had_error)
{
return;
}
var sb = new StringBuilder();
var ser = new Runtime.AstHelpers();
ser.ParenthesizedAST(sb, file_name, tree, tokens);
System.Console.WriteLine(sb.ToString());
}
r.Dispose();
}
// Here's where we do the real work...
public static void ParseJavaFile(string f)
{
try
{
// Create a scanner that reads from the input stream passed to us
lexer = new JavaLexer(new ANTLRFileStream(f));
CommonTokenStream tokens = new CommonTokenStream();
tokens.TokenSource = lexer;
// Create a parser that reads from the scanner
JavaParser parser = new JavaParser(tokens);
// start parsing at the compilationUnit rule
parser.compilationUnit();
}
catch (Exception e)
{
Console.Error.WriteLine("[ERROR}");
Console.Error.WriteLine("parser exception: " + e);
Console.Error.WriteLine(e.StackTrace); // so we can get stack trace
}
}
// Here's where we do the real work...
public static void ParseJavaFile(string f)
{
try
{
// Create a scanner that reads from the input stream passed to us
lexer = new JavaLexer(new ANTLRFileStream(f));
CommonTokenStream tokens = new CommonTokenStream();
tokens.TokenSource = lexer;
// Create a parser that reads from the scanner
JavaParser parser = new JavaParser(tokens);
// start parsing at the compilationUnit rule
parser.compilationUnit();
}
catch (Exception e)
{
Console.Error.WriteLine("[ERROR}");
Console.Error.WriteLine("parser exception: " + e);
Console.Error.WriteLine(e.StackTrace); // so we can get stack trace
}
}
public void ParseJava()
{
var inputStream = new AntlrInputStream(@"
import javax.swing.*;
public class Hello extends JFrame {
Hello() {
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
pack();
}
public static void main(String[] args) {
new Hello().setVisible(true);
}
}");
var lexer = new JavaLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new JavaParser(commonTokenStream);
var visitor = new CstBuilderForAntlr4(parser);
visitor.Visit(parser.compilationUnit());
Console.WriteLine(visitor.FinishParsing());
}
public static bool TryGetLineStatements(string text, int lineNumber, out IList <IParseTree> statementTrees, out IList <IToken> tokens)
{
Contract.Requires <ArgumentNullException>(text != null, "text");
Contract.Requires <ArgumentOutOfRangeException>(lineNumber >= 0);
try
{
AntlrInputStream input = new AntlrInputStream(text);
JavaLexer lexer = new JavaLexer(new JavaUnicodeStreamV4(input));
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokenStream);
parser.Interpreter.PredictionMode = PredictionMode.Sll;
parser.BuildParseTree = true;
JavaParser.CompilationUnitContext result = parser.compilationUnit();
statementTrees = null;
tokens = tokenStream.GetTokens();
AssociatedTreeListener listener = new AssociatedTreeListener(lineNumber, tokens);
ParseTreeWalker.Default.Walk(listener, result);
statementTrees = listener.StatementTrees;
return(true);
}
catch (Exception e)
{
if (ErrorHandler.IsCriticalException(e))
{
throw;
}
statementTrees = null;
tokens = null;
return(false);
}
}
private bool TryGetAssociatedTree(out IParseTree associatedTree, out IList<IToken> tokens)
{
try
{
string sourcePath = _location.GetSourcePath();
if (!File.Exists(sourcePath))
{
associatedTree = null;
tokens = null;
return false;
}
string text = File.ReadAllText(sourcePath);
AntlrInputStream input = new AntlrInputStream(text);
JavaLexer lexer = new JavaLexer(new JavaUnicodeStreamV4(input));
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokenStream);
parser.Interpreter.PredictionMode = PredictionMode.Sll;
parser.BuildParseTree = true;
JavaParser.CompilationUnitContext result = parser.compilationUnit();
associatedTree = null;
tokens = tokenStream.GetTokens();
AssociatedTreeListener listener = new AssociatedTreeListener(_location, tokens);
ParseTreeWalker.Default.Walk(listener, result);
List<IParseTree> potentialTrees = listener.AssociatedTree;
if (potentialTrees.Count == 1)
{
associatedTree = potentialTrees[0];
}
else if (potentialTrees.Count > 1)
{
byte[] bytecode = _location.GetMethod().GetBytecodes();
DisassembledMethod disassembledMethod = BytecodeDisassembler.Disassemble(bytecode);
var constantPool = _location.GetDeclaringType().GetConstantPool();
ReadOnlyCollection<ExceptionTableEntry> exceptionTable;
try
{
exceptionTable = _location.GetMethod().GetExceptionTable();
}
catch (DebuggerException)
{
exceptionTable = new ReadOnlyCollection<ExceptionTableEntry>(new ExceptionTableEntry[0]);
}
ImmutableList<int?> evaluationStackDepths = BytecodeDisassembler.GetEvaluationStackDepths(disassembledMethod, constantPool, exceptionTable);
ReadOnlyCollection<ILocation> locations = _location.GetMethod().GetLineLocations();
// find all bytecode offsets with evaluation stack depth 0 on the current line
List<int> relevantOffsets = new List<int>();
for (int i = 0; i < locations.Count; i++)
{
if (locations[i].GetLineNumber() != _location.GetLineNumber())
continue;
long offsetLimit = i < locations.Count - 1 ? locations[i + 1].GetCodeIndex() : bytecode.Length;
// start with the instruction for this bytecode offset
for (int j = GetInstructionAtOffset(disassembledMethod, locations[i].GetCodeIndex());
j >= 0 && j < disassembledMethod.Instructions.Count && disassembledMethod.Instructions[j].Offset < offsetLimit;
j++)
{
if (evaluationStackDepths[j] == 0)
{
// ignore unconditional branches
if (disassembledMethod.Instructions[j].OpCode.FlowControl == JavaFlowControl.Branch)
continue;
relevantOffsets.Add(disassembledMethod.Instructions[j].Offset);
}
}
}
if (relevantOffsets.Count == potentialTrees.Count)
{
// heuristic: assume they appear in the same order as the source code on this line
int treeIndex = relevantOffsets.IndexOf((int)_location.GetCodeIndex());
if (treeIndex >= 0)
associatedTree = potentialTrees[treeIndex];
}
}
if (associatedTree == null)
{
tokens = null;
return false;
}
return true;
}
catch (Exception e)
{
if (ErrorHandler.IsCriticalException(e))
throw;
associatedTree = null;
tokens = null;
return false;
}
}
private void setStatValues()
{
if (File.Exists(filepath))
{
Stream inputStream = Console.OpenStandardInput();
ANTLRFileStream input = new ANTLRFileStream(filepath);
JavaLexer lexer = new JavaLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokens);
parser.compilationUnit();
//assign parser variables to actual variables
String textRead = File.ReadAllText(filepath);
totalChars = textRead.Length;
className = parser.className;
packageName = parser.packageName;
totalKeywords = parser.totalKeywords;
totalUdis = parser.totalUdis - parser.UdisToRemove;
totalConstants = parser.totalConstants;
totalSpecialChars = parser.totalSpecialChars;
totalWhiteSpace = lexer.totalWhiteSpace;
uniqueKeywords = parser.uniqueKeywordSet.Count;
uniqueUdis = parser.uniqueUdiSet.Count;
uniqueConstants = parser.uniqueConstantsSet.Count;
uniqueSpecialChars = parser.uniqueSpecialCharSet.Count;
//calculated values
percentWhiteSpace = (float)totalWhiteSpace / totalChars * 100;
int commentChars = 0;
for (int k = 0; k < lexer.commentsSet.Count; k++)
{
String com = lexer.commentsSet.ElementAt(k).ToString();
commentChars += com.Length;
Console.WriteLine("Comment Block Size: " + com.Length);
Console.WriteLine("Comment Block Contents\n" + com);
Console.WriteLine("---------Comment Block End ------------");
}
totalCommentChars = commentChars;
percentCommentChars = (float)totalCommentChars / totalChars * 100;
//FOR TESTING
Console.WriteLine("Package Name: " + parser.packageName);
Console.WriteLine("Class Name: " + parser.className);
Console.WriteLine("Total Keywords: " + parser.totalKeywords);
Console.WriteLine("Total UDIs: " + (parser.totalUdis - parser.UdisToRemove));
Console.WriteLine("Total Constants: " + parser.totalConstants);
Console.WriteLine("Total Special Chars: " + parser.totalSpecialChars);
Console.WriteLine("Total White Space: " + lexer.totalWhiteSpace);
Console.WriteLine("Unique Keywords size: " + parser.uniqueKeywordSet.Count);
Console.WriteLine("****** Unique Keyword Contents *********");
for (int i = 0; i < parser.uniqueKeywordSet.Count; i++)
{
Console.WriteLine(parser.uniqueKeywordSet.ElementAt(i));
}
Console.WriteLine("Unique UDI size: " + (parser.uniqueUdiSet.Count - parser.udisToRemoveSet.Count));
Console.WriteLine("****** Unique UDIS Contents *********");
for (int i = 0; i < parser.uniqueUdiSet.Count; i++)
{
Console.WriteLine(parser.uniqueUdiSet.ElementAt(i));
}
Console.WriteLine("Unique Constant size: " + parser.uniqueConstantsSet.Count);
Console.WriteLine("****** Unique Constants Contents *********");
for (int i = 0; i < parser.uniqueConstantsSet.Count; i++)
{
Console.WriteLine(parser.uniqueConstantsSet.ElementAt(i));
}
Console.WriteLine("Unique Special Chars size: " + parser.uniqueSpecialCharSet.Count);
Console.WriteLine("******* Unique Special Char Contents ********");
for (int j = 0; j < parser.uniqueSpecialCharSet.Count; j++)
{
Console.WriteLine(parser.uniqueSpecialCharSet.ElementAt(j));
}
Console.WriteLine("Comments Size: " + lexer.commentsSet.Count);
Console.WriteLine("*********** Comments Contents ************");
for (int j = 0; j < lexer.commentsSet.Count; j++)
{
Console.WriteLine(lexer.commentsSet.ElementAt(j));
}
Console.WriteLine("ALL UDIS FOUND");
for (int k = 0; k < parser.everyUdi.Count; k++)
{
Console.WriteLine(parser.everyUdi.ElementAt(k));
}
}
}
public static void Main(String[] args)
{
bool print_tree = false;
bool perf = false;
bool print_tokens = false;
int file_index = 0;
if (args.Length == 0)
{
System.Console.WriteLine("Antlr Java parser.");
return;
}
else
{
for (int i = 0; i < args.Length; ++i)
{
if (args[i] == "-t")
{
print_tree = true;
}
else if (args[i] == "-p")
{
perf = true;
}
else if (args[i] == "-i")
{
print_tokens = true;
}
else
{
file_index = i;
}
}
}
int exceptions = 0;
var errorListener = new ErrorListener <IToken>();
IParseTree tree = null;
CommonTokenStream tokens = null;
var start = DateTime.Now;
try
{
var input = File.OpenText(args[file_index]);
var str = new AntlrInputStream(input);
JavaLexer lexer = new JavaLexer(str);
tokens = new CommonTokenStream(lexer);
var parser = new JavaParser(tokens);
parser.RemoveErrorListeners();
parser.AddErrorListener(errorListener);
tree = parser.compilationUnit();
}
catch (Exception e)
{
exceptions++;
}
System.Console.WriteLine("errors " + errorListener.num_errors + " exceptions " + exceptions);
var end = DateTime.Now;
if (perf)
{
System.Console.WriteLine(end - start);
}
if (print_tokens && tokens != null)
{
foreach (var token in tokens.GetTokens())
{
System.Console.WriteLine("Token " + token.TokenIndex + " " + token.Type + " " + Output.PerformEscapes(token.Text));
}
}
if (print_tree && tree != null)
{
System.Console.WriteLine(tree.OutputTree(tokens));
}
}
public static string ConvertText(string javaText, JavaConversionOptions options = null)
{
if (options == null)
{
options = new JavaConversionOptions();
}
options.ConversionStateChanged(ConversionState.Starting);
var context = new ConversionContext(options);
var textBytes = Encoding.UTF8.GetBytes(javaText ?? string.Empty);
using (var stringreader = new MemoryStream(textBytes))
using (var wrapper = new ikvm.io.InputStreamWrapper(stringreader))
{
options.ConversionStateChanged(ConversionState.ParsingJavaAST);
var parsed = JavaParser.parse(wrapper);
options.ConversionStateChanged(ConversionState.BuildingCSharpAST);
var types = parsed.getTypes().ToList <TypeDeclaration>();
var imports = parsed.getImports().ToList <ImportDeclaration>();
var package = parsed.getPackage();
var usings = new List <UsingDirectiveSyntax>();
//foreach (var import in imports)
//{
// var usingSyntax = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(import.getName().toString()));
// usings.Add(usingSyntax);
//}
if (options.IncludeUsings)
{
foreach (var ns in options.Usings.Where(x => !string.IsNullOrWhiteSpace(x)))
{
var usingSyntax = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(ns));
usings.Add(usingSyntax);
}
}
var rootMembers = new List <MemberDeclarationSyntax>();
NamespaceDeclarationSyntax namespaceSyntax = null;
if (options.IncludeNamespace)
{
string packageName = package.getName().toString();
foreach (var packageReplacement in options.PackageReplacements)
{
packageName = packageReplacement.Replace(packageName);
}
packageName = TypeHelper.Capitalize(packageName);
namespaceSyntax = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(packageName));
}
foreach (var type in types)
{
if (type is ClassOrInterfaceDeclaration)
{
var classOrIntType = type as ClassOrInterfaceDeclaration;
if (classOrIntType.isInterface())
{
var interfaceSyntax = VisitInterfaceDeclaration(context, classOrIntType, false);
if (options.IncludeNamespace)
{
namespaceSyntax = namespaceSyntax.AddMembers(interfaceSyntax);
}
else
{
rootMembers.Add(interfaceSyntax);
}
}
else
{
var classSyntax = VisitClassDeclaration(context, classOrIntType, false);
if (options.IncludeNamespace)
{
namespaceSyntax = namespaceSyntax.AddMembers(classSyntax);
}
else
{
rootMembers.Add(classSyntax);
}
}
}
}
if (options.IncludeNamespace)
{
rootMembers.Add(namespaceSyntax);
}
var root = SyntaxFactory.CompilationUnit(
externs: new SyntaxList <ExternAliasDirectiveSyntax>(),
usings: SyntaxFactory.List(usings.ToArray()),
attributeLists: new SyntaxList <AttributeListSyntax>(),
members: SyntaxFactory.List <MemberDeclarationSyntax>(rootMembers))
.NormalizeWhitespace();
var tree = SyntaxFactory.SyntaxTree(root);
options.ConversionStateChanged(ConversionState.Done);
return(tree.GetText().ToString());
}
}
private void ConstructProject()
{
#region OsgiProject
status = Status.Working;
Debug.Log("Starting OSGi-Project construction!");
JSONObject tmp = jsonObj.GetField("name");
Assert.IsNotNull(tmp, "Projectname could not be found!");
currentProject = new OsgiProject(tmp.str);
#endregion
#region Bundle,Fragments,Compilation Units
tmp = jsonObj.GetField("bundles");
Assert.IsNotNull(tmp, "Project does not contain any Bundles!");
List <JSONObject> jsonBundleList = tmp.list;
List <JSONObject> jsonPackageList = jsonObj.GetField("packages").list;
long maxLOC = 0;
foreach (JSONObject jsonBundle in jsonBundleList)
{
string name = jsonBundle.GetField("name").str;
string symbName = jsonBundle.GetField("symbolicName").str;
Bundle currentBundle = new Bundle(name, symbName, currentProject);
//Create Fragments
tmp = jsonBundle.GetField("packageFragments");
if (tmp != null)
{
List <JSONObject> fragList = tmp.list;
foreach (JSONObject frag in fragList)
{
JSONObject jsonPkg = frag.GetField("package");
int pkgIdx = resolvePackageReferenceIdx(jsonPkg);
string fragName = jsonPackageList[pkgIdx].GetField("qualifiedName").str;
Package currentFragment = new Package(currentBundle, fragName);
//Create Compilation Units
if (frag.GetField("compilationUnits") != null)
{
List <JSONObject> jsonCompUnits = frag.GetField("compilationUnits").list;
foreach (JSONObject jsonCU in jsonCompUnits)
{
JSONObject tlt = jsonCU.GetField("topLevelType");
string tempStr = tlt.GetField("eClass").str;
tempStr = tempStr.Replace(redundantString_A, "");
type type = JavaParser.getTypeFromString(tempStr);
tempStr = tlt.GetField("visibility").str;
tempStr = tempStr.Replace(redundantString_A, "");
modifier mod = JavaParser.getModifierFromString(tempStr);
long loc = jsonCU.GetField("LOC").i;
if (loc > maxLOC)
{
maxLOC = loc;
}
CompilationUnit compUnit = new CompilationUnit(tlt.GetField("name").str, type, mod, loc, currentFragment);
//TODO: Add support for additional information about a compilation unit(Methods, references to others)
currentFragment.addCompilationUnit(compUnit);
}
}
currentBundle.addPackage(currentFragment);
}
}
currentProject.addBundle(currentBundle);
}
GlobalVar.maximumLOCinProject = maxLOC;
#endregion
#region Services
List <Bundle> bundles = currentProject.getBundles();
tmp = jsonObj.GetField("services");
if (tmp != null)
{
List <JSONObject> serviceJsonList = tmp.list;
foreach (JSONObject jsonService in serviceJsonList)
{
string serviceName = jsonService.GetField("interfaceName").str;
tmp = jsonService.GetField("interface");
CompilationUnit serviceCU = null;
if (tmp != null)
{
Vector3 cuIdx = resolveCompilationUnitRef(tmp);
serviceCU = bundles[(int)cuIdx.x].getPackages()[(int)cuIdx.y].getCompilationUnits()[(int)cuIdx.z];
serviceCU.setServiceDeclaration(true);
}
Service service = new Service(serviceName, serviceCU);
currentProject.addService(service);
}
}
#endregion
#region Resolve import/export + construct ServiceComponents + build dependency graph
int i = 0;
BidirectionalGraph <GraphVertex, GraphEdge> dependencyGraph = currentProject.getDependencyGraph();
foreach (JSONObject jsonBundle in jsonBundleList)
{
//Resolve Exports for Bundle
tmp = jsonBundle.GetField("exports");
if (tmp != null)
{
List <Vector2> exportList = resolvePckgFragmentRefList(tmp.list);
foreach (Vector2 indexVec in exportList)
{
Package resolvedFragment = bundles[(int)indexVec.x].getPackages()[(int)indexVec.y];
resolvedFragment.setExport(true);
bundles[i].addExportedPackage(resolvedFragment);
}
}
//Resolve Imports for Bundle
tmp = jsonBundle.GetField("imports");
if (tmp != null)
{
List <Vector2> importList = resolvePckgFragmentRefList(tmp.list);
foreach (Vector2 indexVec in importList)
{
Package resolvedFragment = bundles[(int)indexVec.x].getPackages()[(int)indexVec.y];
// Ignore self Import redundancy
if (string.Compare(bundles[i].getName(), resolvedFragment.getBundle().getName()) != 0)
{
bundles[i].addImportedPackage(resolvedFragment);
//Package dependency
//Check if Vertices already in Graph
List <GraphVertex> allVertices = dependencyGraph.Vertices.ToList();
GraphVertex vert1 = allVertices.Find(v => (string.Equals(v.getName(), bundles[i].getName())));
GraphVertex vert2 = allVertices.Find(v => (string.Equals(v.getName(), bundles[(int)indexVec.x].getName())));
if (vert1 == null)
{
vert1 = new GraphVertex(bundles[i].getName());
}
if (vert2 == null)
{
vert2 = new GraphVertex(bundles[(int)indexVec.x].getName());
}
dependencyGraph.AddVertex(vert1);
dependencyGraph.AddVertex(vert2);
GraphEdge edge;
bool edgePresent = dependencyGraph.TryGetEdge(vert1, vert2, out edge);
if (edgePresent && dependencyGraph.AllowParallelEdges)
{
edge.incrementWeight(1f);
}
else
{
edge = new GraphEdge(vert1, vert2);
dependencyGraph.AddEdge(edge);
}
GraphEdge opposingEdge;
float bidirectionalEdgeWeight = edge.getWeight();
bool oppEdgePresent = dependencyGraph.TryGetEdge(vert2, vert1, out opposingEdge);
if (oppEdgePresent)
{
bidirectionalEdgeWeight += opposingEdge.getWeight();
}
if (bidirectionalEdgeWeight > currentProject.getMaxImportCount())
{
currentProject.setMaxImportCount((int)bidirectionalEdgeWeight);
}
}
else
{
Debug.Log("Spotted import redundancy in: " + bundles[i].getName());
}
}
}
//Construct and resolve ServiceComponents
List <Service> serviceList = currentProject.getServices();
tmp = jsonBundle.GetField("components");
if (tmp != null)
{
foreach (JSONObject jsonComponent in tmp.list)
{
string scName = jsonComponent.GetField("name").str;
Vector3 implIdx = resolveCompilationUnitRef(jsonComponent.GetField("implementation"));
CompilationUnit resolvedCu = bundles[(int)implIdx.x].getPackages()[(int)implIdx.y].getCompilationUnits()[(int)implIdx.z];
resolvedCu.setServiceComponentImpl(true);
ServiceComponent sc = new ServiceComponent(scName, resolvedCu);
tmp = jsonComponent.GetField("providedServices");
if (tmp != null)
{
List <int> serviceRefs = resolveServiceReferenceIdxList(tmp);
foreach (int s in serviceRefs)
{
sc.addProvidedService(serviceList[s]);
serviceList[s].addImplementingComponent(sc);
}
}
tmp = jsonComponent.GetField("referencedServices");
if (tmp != null)
{
List <int> serviceRefs = resolveServiceReferenceIdxList(tmp);
foreach (int s in serviceRefs)
{
sc.addReferencedService(serviceList[s]);
serviceList[s].addReferencingComponent(sc);
}
}
bundles[i].addServiceComponent(sc);
}
}
i++;
}
#endregion
Debug.Log("Max Import-count: " + currentProject.getMaxImportCount());
status = Status.Finished;
Debug.Log("Finished OSGi-Project construction!");
cb();
}
public override void EnterParExpression(JavaParser.ParExpressionContext context)
{
if (context.expression() == null)
return;
if (IsInCurrentContext(context.expression()))
{
_statementTrees.Add(context.expression());
}
}
public override void EnterEnhancedForControl(JavaParser.EnhancedForControlContext context)
{
if (IsInCurrentContext(context))
{
_statementTrees.Add(context);
}
}
public override void EnterLocalVariableDeclarationStatement(JavaParser.LocalVariableDeclarationStatementContext context)
{
if (IsInCurrentContext(context))
{
_statementTrees.Add(context);
}
}
public override void EnterExpression(JavaParser.ExpressionContext context)
{
if (context.Parent is JavaParser.ForControlContext)
{
if (IsInCurrentContext(context))
{
_statementTrees.Add(context);
}
}
}
private bool TryGetAssociatedTree(out IParseTree associatedTree, out IList <IToken> tokens)
{
try
{
string sourcePath = _location.GetSourcePath();
if (!File.Exists(sourcePath))
{
associatedTree = null;
tokens = null;
return(false);
}
string text = File.ReadAllText(sourcePath);
AntlrInputStream input = new AntlrInputStream(text);
JavaLexer lexer = new JavaLexer(new JavaUnicodeStreamV4(input));
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokenStream);
parser.Interpreter.PredictionMode = PredictionMode.Sll;
parser.BuildParseTree = true;
JavaParser.CompilationUnitContext result = parser.compilationUnit();
associatedTree = null;
tokens = tokenStream.GetTokens();
AssociatedTreeListener listener = new AssociatedTreeListener(_location, tokens);
ParseTreeWalker.Default.Walk(listener, result);
List <IParseTree> potentialTrees = listener.AssociatedTree;
if (potentialTrees.Count == 1)
{
associatedTree = potentialTrees[0];
}
else if (potentialTrees.Count > 1)
{
byte[] bytecode = _location.GetMethod().GetBytecodes();
DisassembledMethod disassembledMethod = BytecodeDisassembler.Disassemble(bytecode);
var constantPool = _location.GetDeclaringType().GetConstantPool();
var exceptionTable = _location.GetMethod().GetExceptionTable();
ImmutableList <int?> evaluationStackDepths = BytecodeDisassembler.GetEvaluationStackDepths(disassembledMethod, constantPool, exceptionTable);
ReadOnlyCollection <ILocation> locations = _location.GetMethod().GetLineLocations();
// find all bytecode offsets with evaluation stack depth 0 on the current line
List <int> relevantOffsets = new List <int>();
for (int i = 0; i < locations.Count; i++)
{
if (locations[i].GetLineNumber() != _location.GetLineNumber())
{
continue;
}
long offsetLimit = i < locations.Count - 1 ? locations[i + 1].GetCodeIndex() : bytecode.Length;
// start with the instruction for this bytecode offset
for (int j = GetInstructionAtOffset(disassembledMethod, locations[i].GetCodeIndex());
j >= 0 && j < disassembledMethod.Instructions.Count && disassembledMethod.Instructions[j].Offset < offsetLimit;
j++)
{
if (evaluationStackDepths[j] == 0)
{
// ignore unconditional branches
if (disassembledMethod.Instructions[j].OpCode.FlowControl == JavaFlowControl.Branch)
{
continue;
}
relevantOffsets.Add(disassembledMethod.Instructions[j].Offset);
}
}
}
if (relevantOffsets.Count == potentialTrees.Count)
{
// heuristic: assume they appear in the same order as the source code on this line
int treeIndex = relevantOffsets.IndexOf((int)_location.GetCodeIndex());
if (treeIndex >= 0)
{
associatedTree = potentialTrees[treeIndex];
}
}
}
if (associatedTree == null)
{
tokens = null;
return(false);
}
return(true);
}
catch (Exception e)
{
if (ErrorHandler.IsCriticalException(e))
{
throw;
}
associatedTree = null;
tokens = null;
return(false);
}
}
public Java()
{
parser = new JavaParser();
executableCode = string.Empty;
}
public override void EnterForUpdate(JavaParser.ForUpdateContext context)
{
if (IsInCurrentContext(context))
{
_associatedTrees.Add(context);
}
}
/**
* Parses a piece of Java code that matches a certain grammar rule.
*
* @param pSource The Java source that should get parsed.
* @param pCodeFragmentType The code fragment type defining the grammar
* rule that should be used to parse the code
* fragment.
* @param pErrorMessages If this argument is not <code>null</code> error
* messages emited by the parser will be added to
* this list. Otherwise these error messages will be
* written to <code>System.err</code>.
*
* @return An object of type <code>JSOParser.ParserResult</code>
* containing the root node representing a Java code fragment and
* the token stream containing the tokens of the parsed source.
*
* @
* if parsing the code fragment or creating the AST failes.
* @throws RecognitionException
*
* __TEST__ All parsable code fragments still untested for parser failure.
*/
private ParserResult parse(
ANTLRStringStream pSource, CodeFragmentType pCodeFragmentType,
List<String> pErrorMessages)
{
ParserResult result = new ParserResult();
bool isMessageCollectingEnabled = pErrorMessages != null;
mLexer.CharStream = pSource;
mLexer.EnableErrorMessageCollection(isMessageCollectingEnabled);
TokenRewriteStream tokenRewriteStream =
new TokenRewriteStream(mLexer);
if (mParser != null) {
mParser.TokenStream = tokenRewriteStream;
} else {
mParser = new JavaParser(tokenRewriteStream);
mParser.TreeAdaptor = mAST2JSOMTreeAdaptor;
}
mParser.EnableErrorMessageCollection(isMessageCollectingEnabled);
AST2JSOMTree tree = null;
if (pCodeFragmentType == CodeFragmentType.ANNOTATION) {
tree = (AST2JSOMTree) mParser.annotation().Tree;
} else if (pCodeFragmentType == CodeFragmentType.ASSERT_STATEMENT) {
tree = (AST2JSOMTree) mParser.assertStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.BREAK_STATEMENT) {
tree = (AST2JSOMTree) mParser.breakStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.CLASS_EXTENDS_CLAUSE) {
tree = (AST2JSOMTree) mParser.classExtendsClause().Tree;
} else if ( pCodeFragmentType
== CodeFragmentType.COMPLEX_TYPE_IDENTIFIER) {
tree = (AST2JSOMTree) mParser.typeIdent().Tree;
} else if (pCodeFragmentType == CodeFragmentType.CONTINUE_STATEMENT) {
tree = (AST2JSOMTree) mParser.continueStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.DO_WHILE_STATEMENT) {
tree = (AST2JSOMTree) mParser.doWhileStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.ENUM_CONSTANT) {
tree = (AST2JSOMTree) mParser.enumConstant().Tree;
} else if (pCodeFragmentType == CodeFragmentType.EXPRESSION) {
tree = (AST2JSOMTree) mParser.expression().Tree;
} else if (pCodeFragmentType == CodeFragmentType.EXPRESSION_STATEMENT) {
tree = (AST2JSOMTree) mParser.expressionStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.FOR_STATEMENT) {
tree = (AST2JSOMTree) mParser.forStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.FOREACH_STATEMENT) {
tree = (AST2JSOMTree) mParser.forEachStatement().Tree;
} else if ( pCodeFragmentType
== CodeFragmentType.FORMAL_PARAMETER_LIST) {
tree = (AST2JSOMTree) mParser.formalParameterList().Tree;
} else if ( pCodeFragmentType
== CodeFragmentType.GENERIC_TYPE_ARGUMENT_LIST) {
tree = (AST2JSOMTree) mParser.genericTypeArgumentList().Tree;
} else if ( pCodeFragmentType
== CodeFragmentType.GENERIC_TYPE_PARAMETER_LIST) {
tree = (AST2JSOMTree) mParser.genericTypeParameterList().Tree;
} else if (pCodeFragmentType == CodeFragmentType.IF_STATEMENT) {
tree = (AST2JSOMTree) mParser.ifStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.IMPLEMENTS_CLAUSE) {
tree = (AST2JSOMTree) mParser.implementsClause().Tree;
} else if (pCodeFragmentType == CodeFragmentType.IMPORT_DECLARATION) {
tree = (AST2JSOMTree) mParser.importDeclaration().Tree;
} else if ( pCodeFragmentType
== CodeFragmentType.INTERFACE_EXTENDS_CLAUSE) {
tree = (AST2JSOMTree) mParser.interfaceExtendsClause().Tree;
} else if (pCodeFragmentType == CodeFragmentType.JAVA_SOURCE) {
tree = (AST2JSOMTree) mParser.javaSource().Tree;
} else if (pCodeFragmentType == CodeFragmentType.LABELED_STATEMENT) {
tree = (AST2JSOMTree) mParser.labeledStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.LOCAL_VARIABLE_DECLARATION) {
tree = (AST2JSOMTree) mParser.localVariableDeclaration().Tree;
} else if (pCodeFragmentType == CodeFragmentType.MODIFIER_LIST) {
tree = (AST2JSOMTree) mParser.modifierList().Tree;
} else if (pCodeFragmentType == CodeFragmentType.PRIMITIVE_TYPE) {
tree = (AST2JSOMTree) mParser.primitiveType().Tree;
} else if (pCodeFragmentType == CodeFragmentType.QUALIFIED_IDENTIFIER) {
tree = (AST2JSOMTree) mParser.qualifiedIdentifier().Tree;
} else if (pCodeFragmentType == CodeFragmentType.RETURN_STATEMENT) {
tree = (AST2JSOMTree) mParser.returnStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.STATEMENT) {
tree = (AST2JSOMTree) mParser.statement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.STATEMENT_BLOCK) {
tree = (AST2JSOMTree) mParser.block().Tree;
} else if (pCodeFragmentType == CodeFragmentType.STATEMENT_BLOCK_ELEMENT) {
tree = (AST2JSOMTree) mParser.blockStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.SWITCH_CASE_LABEL) {
tree = (AST2JSOMTree) mParser.switchCaseLabel().Tree;
} else if (pCodeFragmentType == CodeFragmentType.SWITCH_DEFAULT_LABEL) {
tree = (AST2JSOMTree) mParser.switchDefaultLabel().Tree;
} else if (pCodeFragmentType == CodeFragmentType.SWITCH_STATEMENT) {
tree = (AST2JSOMTree) mParser.switchStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.SYNCHRONIZED_STATEMENT) {
tree = (AST2JSOMTree) mParser.synchronizedStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.THROW_STATEMENT) {
tree = (AST2JSOMTree) mParser.throwStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.THROWS_CLAUSE) {
tree = (AST2JSOMTree) mParser.throwsClause().Tree;
} else if (pCodeFragmentType == CodeFragmentType.TRY_STATEMENT) {
tree = (AST2JSOMTree) mParser.tryStatement().Tree;
} else if (pCodeFragmentType == CodeFragmentType.TRY_STATEMENT_CATCH_CLAUSE) {
tree = (AST2JSOMTree) mParser.catchClause().Tree;
} else if (pCodeFragmentType == CodeFragmentType.TYPE) {
tree = (AST2JSOMTree) mParser.type().Tree;
} else if (pCodeFragmentType == CodeFragmentType.TYPE_DECLARATION) {
tree = (AST2JSOMTree) mParser.typeDeclaration().Tree;
} else if (pCodeFragmentType == CodeFragmentType.VARIABLE_DECLARATOR_IDENTIFIER) {
// Simply use the grammar rule for local variables.
tree = (AST2JSOMTree) mParser.variableDeclaratorId().Tree;
} else if (pCodeFragmentType == CodeFragmentType.VARIABLE_INITIALIZER) {
tree = (AST2JSOMTree) mParser.variableInitializer().Tree;
} else if (pCodeFragmentType == CodeFragmentType.WHILE_STATEMENT) {
tree = (AST2JSOMTree) mParser.whileStatement().Tree;
} else if (pCodeFragmentType != null) {
throw new JSourceUnmarshallerException(
UnmarshallerMessages
.getUnsupportedCodeFragmentTypeMessage(
pCodeFragmentType));
} else {
// TODO Internationalize the message.
throw new JSourceUnmarshallerException(
"The argument stating the code fragment type mustn't be " +
"'null'");
}
// On parser errors the generated parser may return something
// undefined rather than 'null'.
if (!mParser.HasErrors()) {
// TODO It seems that the JSourceObjectizer uses the parser result
// instead of the tree parser result. CHECK THIS!
CommonTreeNodeStream treeNodes =
new CommonTreeNodeStream(mAST2JSOMTreeAdaptor, tree);
treeNodes.TokenStream = tokenRewriteStream;
if (mTreeParser != null) {
mTreeParser.Reset();
mTreeParser.SetTreeNodeStream(treeNodes);
} else {
mTreeParser = new JavaTreeParser(treeNodes);
}
mTreeParser.EnableErrorMessageCollection(
isMessageCollectingEnabled);
if (pCodeFragmentType == CodeFragmentType.ANNOTATION) {
mTreeParser.annotation();
} else if ( pCodeFragmentType
== CodeFragmentType.COMPLEX_TYPE_IDENTIFIER) {
mTreeParser.typeIdent();
} else if (pCodeFragmentType == CodeFragmentType.ENUM_CONSTANT) {
mTreeParser.enumConstant();
} else if (pCodeFragmentType == CodeFragmentType.EXPRESSION) {
mTreeParser.expression();
} else if ( pCodeFragmentType
== CodeFragmentType.CLASS_EXTENDS_CLAUSE
|| pCodeFragmentType
== CodeFragmentType.INTERFACE_EXTENDS_CLAUSE) {
mTreeParser.extendsClause();
} else if ( pCodeFragmentType
== CodeFragmentType.FORMAL_PARAMETER_LIST) {
mTreeParser.formalParameterList();
} else if ( pCodeFragmentType
== CodeFragmentType.GENERIC_TYPE_ARGUMENT_LIST) {
mTreeParser.genericTypeArgumentList();
} else if ( pCodeFragmentType
== CodeFragmentType.GENERIC_TYPE_PARAMETER_LIST) {
mTreeParser.genericTypeParameterList();
} else if ( pCodeFragmentType
== CodeFragmentType.IMPLEMENTS_CLAUSE) {
mTreeParser.implementsClause();
} else if ( pCodeFragmentType
== CodeFragmentType.IMPORT_DECLARATION) {
mTreeParser.importDeclaration();
} else if (pCodeFragmentType == CodeFragmentType.JAVA_SOURCE) {
mTreeParser.javaSource();
} else if (pCodeFragmentType == CodeFragmentType.LOCAL_VARIABLE_DECLARATION) {
mTreeParser.localVariableDeclaration();
} else if (pCodeFragmentType == CodeFragmentType.MODIFIER_LIST) {
mTreeParser.modifierList();
} else if (pCodeFragmentType == CodeFragmentType.PRIMITIVE_TYPE) {
mTreeParser.primitiveType();
} else if ( pCodeFragmentType
== CodeFragmentType.QUALIFIED_IDENTIFIER) {
mTreeParser.qualifiedIdentifier();
} else if ( pCodeFragmentType == CodeFragmentType.STATEMENT
|| pCodeFragmentType == CodeFragmentType.ASSERT_STATEMENT
|| pCodeFragmentType == CodeFragmentType.BREAK_STATEMENT
|| pCodeFragmentType == CodeFragmentType.CONTINUE_STATEMENT
|| pCodeFragmentType == CodeFragmentType.DO_WHILE_STATEMENT
|| pCodeFragmentType == CodeFragmentType.EXPRESSION_STATEMENT
|| pCodeFragmentType == CodeFragmentType.FOR_STATEMENT
|| pCodeFragmentType == CodeFragmentType.FOREACH_STATEMENT
|| pCodeFragmentType == CodeFragmentType.IF_STATEMENT
|| pCodeFragmentType == CodeFragmentType.LABELED_STATEMENT
|| pCodeFragmentType == CodeFragmentType.RETURN_STATEMENT
|| pCodeFragmentType == CodeFragmentType.SWITCH_STATEMENT
|| pCodeFragmentType == CodeFragmentType.SYNCHRONIZED_STATEMENT
|| pCodeFragmentType == CodeFragmentType.THROW_STATEMENT
|| pCodeFragmentType == CodeFragmentType.TRY_STATEMENT
|| pCodeFragmentType == CodeFragmentType.WHILE_STATEMENT) {
mTreeParser.statement();
} else if (pCodeFragmentType == CodeFragmentType.SWITCH_CASE_LABEL) {
mTreeParser.switchCaseLabel();
} else if (pCodeFragmentType == CodeFragmentType.SWITCH_DEFAULT_LABEL) {
mTreeParser.switchDefaultLabel();
} else if (pCodeFragmentType == CodeFragmentType.STATEMENT_BLOCK) {
mTreeParser.block();
} else if (pCodeFragmentType == CodeFragmentType.STATEMENT_BLOCK_ELEMENT) {
mTreeParser.blockStatement();
} else if (pCodeFragmentType == CodeFragmentType.THROWS_CLAUSE) {
mTreeParser.throwsClause();
} else if (pCodeFragmentType == CodeFragmentType.TRY_STATEMENT_CATCH_CLAUSE) {
mTreeParser.catchClause();
} else if (pCodeFragmentType == CodeFragmentType.TYPE) {
mTreeParser.type();
} else if (pCodeFragmentType == CodeFragmentType.TYPE_DECLARATION) {
mTreeParser.typeDeclaration();
} else if (pCodeFragmentType == CodeFragmentType.VARIABLE_DECLARATOR_IDENTIFIER) {
mTreeParser.variableDeclaratorId();
} else if (pCodeFragmentType == CodeFragmentType.VARIABLE_INITIALIZER) {
mTreeParser.variableInitializer();
} else if (pCodeFragmentType != null) {
throw new JSourceUnmarshallerException(
UnmarshallerMessages
.getUnsupportedCodeFragmentTypeMessage(
pCodeFragmentType));
} else {
// TODO Internationalize the message.
throw new JSourceUnmarshallerException(
"The argument stating the code fragment type mustn't be " +
"'null'");
}
result.mLineCount = mLexer.Line;
result.mTokenRewriteStream = tokenRewriteStream;
result.mTree = tree;
}
return result;
}
public void Test() {
var inputStream = new AntlrInputStream("public /*aa*/ class Klass { }");
var javaLexer = new JavaLexer(inputStream);
var commonTokenStream = new CommonTokenStream(javaLexer);
var javaParser = new JavaParser(commonTokenStream);
var context = javaParser.compilationUnit();
var visitor = new CstBuilderForAntlr4(javaParser);
visitor.Visit(context);
Console.WriteLine(visitor.FinishParsing().ToXml());
}
public override void EnterForInit(JavaParser.ForInitContext context)
{
if (IsInCurrentContext(context))
{
_statementTrees.Add(context);
}
}
