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