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 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());
}
}