void ParseClass(Definition.ClassDef def)
{
if (def.IsDefinedBySWIG)
{
return;
}
if (def.IsDefinedDefault)
{
return;
}
foreach (var field in def.Fields)
{
var semanticModel = compilation.GetSemanticModel(field.Internal.SyntaxTree);
var v = field.Internal.Declaration.Variables[0];
if (v.Initializer != null && v.Initializer.Value != null)
{
field.Initializer = ParseExpression(v.Initializer.Value, semanticModel);
}
}
foreach (var prop in def.Properties)
{
var semanticModel = compilation.GetSemanticModel(prop.Internal.SyntaxTree);
if (prop.Getter != null && prop.Getter.Internal.Body != null)
{
prop.Getter.Body = ParseStatement(prop.Getter.Internal.Body, semanticModel);
}
if (prop.Setter != null)
{
prop.Setter.Body = ParseStatement(prop.Setter.Internal.Body, semanticModel);
}
}
foreach (var method in def.Methods)
{
var semanticModel = compilation.GetSemanticModel(method.Internal.SyntaxTree);
if (method.Internal.Body == null)
{
continue;
}
var statement = ParseStatement(method.Internal.Body, semanticModel) as BlockStatement;
method.Body = statement.Statements.ToList();
var declaredSymbol = semanticModel.GetDeclaredSymbol(method.Internal);
var xml = declaredSymbol?.GetDocumentationCommentXml();
method.Summary = SummaryComment.Parse(xml);
}
foreach (var cst in def.Constructors)
{
if (cst.Internal == null)
{
continue;
}
var semanticModel = compilation.GetSemanticModel(cst.Internal.SyntaxTree);
if (cst.Internal.Body == null)
{
continue;
}
if (cst.Initializer != null)
{
foreach (var arg in cst.Initializer.Internal.ArgumentList.Arguments)
{
cst.Initializer.Arguments.Add(ParseExpression(arg.Expression, semanticModel));
}
}
var statement = ParseStatement(cst.Internal.Body, semanticModel) as BlockStatement;
cst.Body = statement.Statements.ToList();
}
foreach (var dst in def.Destructors)
{
if (dst.Internal == null)
{
continue;
}
var semanticModel = compilation.GetSemanticModel(dst.Internal.SyntaxTree);
if (dst.Internal.Body == null)
{
continue;
}
var statement = ParseStatement(dst.Internal.Body, semanticModel) as BlockStatement;
dst.Body = statement.Statements.ToList();
}
}
private void OutputClass(Definition.ClassDef cs)
{
Summary(cs.Summary);
MakeIndent();
List <Definition.TypeSpecifier> bases = new List <Definition.TypeSpecifier>();
List <Definition.TypeSpecifier> interfaces = new List <Definition.TypeSpecifier>();
foreach (var b in cs.BaseTypes)
{
var simple = b as Definition.SimpleType;
var gene = b as Definition.GenericType;
if (simple != null)
{
if (simple.TypeKind == Definition.SimpleTypeKind.Interface || simple.TypeKind == Definition.SimpleTypeKind.Other)
{
interfaces.Add(b);
}
else
{
bases.Add(b);
}
}
else if (gene != null)
{
if (gene.OuterType.TypeKind == Definition.SimpleTypeKind.Interface || gene.OuterType.TypeKind == Definition.SimpleTypeKind.Other)
{
interfaces.Add(b);
}
else
{
bases.Add(b);
}
}
}
Func <string> extends = () =>
{
if (bases.Count == 0)
{
return(string.Empty);
}
return("extends " + string.Join(",", GetTypeSpecifier(bases[0])));
};
Func <string> implements = () =>
{
if (interfaces.Count == 0)
{
return(string.Empty);
}
return("implements " + string.Join(",", interfaces.Select(_ => GetTypeSpecifier(_))));
};
Func <string> generics = () =>
{
return(GetGenericsTypeParameters(cs.TypeParameters));
};
List <string> strs_1 = new List <string>();
strs_1.Add(GetAccessLevel(cs.AccessLevel));
strs_1.Add(cs.IsAbstract ? "abstract" : "");
strs_1.Add("class");
strs_1.Add(cs.Name);
List <string> strs_2 = new List <string>();
strs_2.Add(string.Join(" ", strs_1.Where(_ => !string.IsNullOrEmpty(_)).ToArray()) + generics());
strs_2.Add(extends());
strs_2.Add(implements());
var strs_2_ = string.Join(" ", strs_2.Where(_ => !string.IsNullOrEmpty(_)).ToArray());
WriteLine(strs_2_);
WriteLine("{{");
IndentDepth++;
Res.Append(cs.UserCode);
foreach (var f in cs.Fields)
{
OutputField(f);
}
foreach (var p in cs.Properties)
{
OutputProperty(p);
}
foreach (var m in cs.Methods)
{
OutputMethod(m);
}
if (cs.Constructors != null)
{
foreach (var c in cs.Constructors)
{
OutputConstructor(cs.Name, c);
}
}
if (cs.Destructors != null)
{
foreach (var d in cs.Destructors)
{
WriteLine("@Override");
WriteLine("protected void finalize() throws Throwable {{");
IndentDepth++;
if (cs.BaseTypes != null && cs.BaseTypes.Count > 0)
{
WriteLine("try {{ super.finalize(); }} finally {{");
IndentDepth++;
}
foreach (var s in d.Body)
{
OutputStatement(s);
}
if (cs.BaseTypes != null)
{
IndentDepth--;
WriteLine("}}");
}
IndentDepth--;
WriteLine("}}");
}
}
IndentDepth--;
WriteLine("}}");
}
