forked from geffzhang/JavaToCSharp
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathJavaToCSharpConverter.cs
More file actions
123 lines (96 loc) · 4.56 KB
/
Copy pathJavaToCSharpConverter.cs
File metadata and controls
123 lines (96 loc) · 4.56 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using com.github.javaparser;
using com.github.javaparser.ast;
using com.github.javaparser.ast.body;
using JavaToCSharp.Declarations;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace JavaToCSharp
{
public static class JavaToCSharpConverter
{
public static string ConvertText(string javaText, JavaConversionOptions options = null)
{
options ??= new JavaConversionOptions();
options.ConversionStateChanged(ConversionState.Starting);
var context = new ConversionContext(options);
var textBytes = Encoding.UTF8.GetBytes(javaText ?? string.Empty);
using var memoryStream = new MemoryStream(textBytes);
using var wrapper = new ikvm.io.InputStreamWrapper(memoryStream);
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 (string 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() ?? "MyApp";
foreach (var packageReplacement in options.PackageReplacements)
{
packageName = packageReplacement.Replace(packageName);
}
packageName = TypeHelper.Capitalize(packageName);
namespaceSyntax = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(packageName))
.WithJavaComments(package);
}
foreach (var type in types)
{
if (type is ClassOrInterfaceDeclaration classOrIntType)
{
if (classOrIntType.isInterface())
{
var interfaceSyntax = ClassOrInterfaceDeclarationVisitor.VisitInterfaceDeclaration(context, classOrIntType, false);
if (namespaceSyntax != null)
namespaceSyntax = namespaceSyntax.AddMembers(interfaceSyntax);
else
rootMembers.Add(interfaceSyntax);
}
else
{
var classSyntax = ClassOrInterfaceDeclarationVisitor.VisitClassDeclaration(context, classOrIntType, false);
if (namespaceSyntax != null)
namespaceSyntax = namespaceSyntax.AddMembers(classSyntax);
else
rootMembers.Add(classSyntax);
}
}
}
if (namespaceSyntax != null)
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();
root = root.WithJavaComments(parsed, "\r\n");
var postConversionSanitizer = new SanitizingSyntaxRewriter();
var sanitizedRoot = postConversionSanitizer.VisitCompilationUnit(root);
var tree = SyntaxFactory.SyntaxTree(sanitizedRoot);
options.ConversionStateChanged(ConversionState.Done);
return tree.GetText().ToString();
}
}
}