public static void WriteInstanceConstructor(OutputWriter writer, ConstructorDeclarationSyntax method,
List <string> otherInits)
{
writer.WriteLine();
var accessmodifiers = "";
var isInterface = method.Parent is InterfaceDeclarationSyntax;
if (method.Modifiers.Any(SyntaxKind.PublicKeyword) || method.Modifiers.Any(SyntaxKind.InternalKeyword) ||
method.Modifiers.Any(SyntaxKind.ProtectedKeyword) || method.Modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
{
accessmodifiers += ("public ");
}
// Reflection cannot work with this, cant get address or set value
//if (method.Modifiers.Any(SyntaxKind.PrivateKeyword))
// accessmodifiers += ("private ");
if (method.Modifiers.Any(SyntaxKind.StaticKeyword))
{
accessmodifiers += ("static ");
}
var constructorName = "this";
if (Context.Instance.Type.TypeKind == TypeKind.Struct) // Struct
{
constructorName = " void __init";
}
writer.WriteLine(accessmodifiers + constructorName + WriteMethod.GetParameterListAsString(method.ParameterList.Parameters));
if (isInterface || method.Modifiers.Any(SyntaxKind.AbstractKeyword))
{
writer.Write(" = 0;\r\n");
return;
}
//if (!returnsVoid)
// writer.Write(" =");
// writer.Write("\r\n");
writer.OpenBrace();
if (otherInits != null) //We need to write the static initializers before anything else
{
foreach (var statement in otherInits)
{
var nodeString = statement;
if (nodeString != null)
{
writer.WriteLine(nodeString);
}
}
}
if (method.Initializer != null)
{
//writer.Write(":");
Core.Write(writer, method.Initializer);
writer.Write(";");
writer.WriteLine(); //";\r\n");
}
if (method.Body != null)
{
foreach (var statement in method.Body.Statements)
{
Core.Write(writer, statement);
}
TriviaProcessor.ProcessTrivias(writer, method.Body.DescendantTrivia());
}
writer.CloseBrace();
}
private static void WriteOneDelegate(OutputWriter outputWriter, Context.DelegateSyntaxAndSymbol first, bool fileExists)
{
Context.Instance.Namespace = first.Symbol.ContainingNamespace.FullName();
Context.Instance.Type = first.Symbol;
TypeProcessor.ClearUsedTypes();
var mynamespace = Context.Instance.Type.ContainingNamespace.FullName().RemoveFromEndOfString(".Namespace");
// + "." + TypeState.Instance.TypeName;
var myUsingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(mynamespace));
var SystemUsingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System"));
// Required as certain functions like boxing are in this namespace
Context.Instance.UsingDeclarations =
first.Syntax.Parent.DescendantNodes().OfType <UsingDirectiveSyntax>().ToArray()
.Union(new[]
{
myUsingDirective, SystemUsingDirective
}).ToArray();
OutputWriter writer = null;
using (
writer =
outputWriter == null
? new OutputWriter(Context.Instance.Namespace, Context.Instance.TypeName)
: new TempWriter())
{
if (outputWriter != null)
{
writer.WriteLine();
writer.Indent = outputWriter.Indent + 2;
writer.WriteIndent();
}
writer.FileExists = fileExists;
WriteBcl.Go(writer);
WriteStandardIncludes.Go(writer);
//Look for generic arguments
{
List <TypeParameterSyntax> genericArgs = new List <TypeParameterSyntax>();
if (first.Syntax.TypeParameterList != null)
{
genericArgs = first.Syntax.TypeParameterList.Parameters.ToList();
}
var name = WriteType.TypeName(Context.Instance.Type, false); //Context.Instance.TypeName;
if (genericArgs.Count > 0)
{
name = "template " + name;
name += ("(");
name += (string.Join(" , ", genericArgs.Select(o => o)));
name += (")");
writer.WriteLine(name);
writer.OpenBrace();
writer.WriteLine("alias __Delegate!(" + TypeProcessor.ConvertType(first.Syntax.ReturnType) + " delegate" +
WriteMethod.GetParameterListAsString(first.Syntax.ParameterList.Parameters) + ") " +
WriteType.TypeName(Context.Instance.Type, false) + ";");
writer.CloseBrace();
}
else
{
//Non-generic
writer.WriteLine("alias __Delegate!(" + TypeProcessor.ConvertType(first.Syntax.ReturnType) + " delegate" +
WriteMethod.GetParameterListAsString(first.Syntax.ParameterList.Parameters) + ") " +
WriteType.TypeName(Context.Instance.Type, false) + ";");
}
}
if (outputWriter != null)
{
outputWriter.WriteLine(writer.ToString());
}
}
}
public static void Go(OutputWriter writer, OperatorDeclarationSyntax method)
{
var methodSymbol = (IMethodSymbol)TypeProcessor.GetDeclaredSymbol(method);
var actualMethodName = OverloadResolver.MethodName(methodSymbol);
writer.Write("\n");
var returnType = "";
if (method.ReturnType.ToString() == "void")
{
returnType = ("void ");
}
else
{
returnType = TypeProcessor.ConvertType(method.ReturnType) + " ";
// writer.Write(returnType);
}
var methodName = "";
if (BinaryOperators.ContainsKey(actualMethodName))
{
methodName = "opBinary";
var typeSymbolParam0 = TypeProcessor.GetTypeInfo(method.ParameterList.Parameters[0].Type);
var typeSymbolParent = (methodSymbol.ContainingType);
if (typeSymbolParam0.Type != typeSymbolParent)
{
methodName += "Right";
}
}
if (UnaryOperators.ContainsKey(actualMethodName))
{
methodName = "opUnary";
}
if (EqualsOperators.ContainsKey(actualMethodName))
{
methodName = "opEquals";
}
if (CmpOperators.ContainsKey(actualMethodName))
{
methodName = "opCmp";
}
if (AssignOperators.ContainsKey(actualMethodName))
{
methodName = "opAssign";
}
if (AssignOpOperators.ContainsKey(actualMethodName))
{
methodName = "opOpAssign"; // need to remove = from the name
}
var paramType = method.ParameterList.Parameters[0];
if (method.ParameterList.Parameters.Count == 2)
{
if (methodName.EndsWith("Right"))
{
paramType = method.ParameterList.Parameters[0];
}
else
{
paramType = method.ParameterList.Parameters[1];
}
}
var token = method.OperatorToken.Text;
var methodBody = "";
var temp = new TempWriter();
foreach (var statement in method.Body.Statements)
{
Core.Write(temp, statement);
}
TriviaProcessor.ProcessTrivias(temp, method.Body.DescendantTrivia());
methodBody = temp.ToString();
if (methodName == "opOpAssign")
{
token = token.Substring(0, 1);
}
//We are going to have to rewrite this bit later ... for now all overloads are called directly
/* if (methodName == "opBinary")
* {
*
* writer.WriteLine("public final " + returnType + " " + methodName +
* String.Format(
* " (string _op) ({0} other)\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\treturn {1}(this,other); \r\n\t}}\r\n\r\n",
* TypeProcessor.ConvertType(paramType.Type), actualMethodName, token));
*
* //Add Assignment operator if it doesn't exist
* if (!methodSymbol.ContainingType.GetMembers(AssignOpOperators.FirstOrDefault(k => k.Value == token + "=").Key).Any())
* {
* writer.WriteLine("public final " + returnType + " opOpAssign" +
* String.Format(
* " (string _op) ({0} other)\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\treturn {1}(this,other); \r\n\t}}\r\n\r\n",
* TypeProcessor.ConvertType(paramType.Type), actualMethodName, token));
* }
* }
* else if (methodName == "opUnary")//TODO unary operators are mostly going to be direct methodCalls
* {
*
* writer.WriteLine("public final " + returnType + " " + methodName +
* String.Format(
* " (string _op) ()\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\treturn {1}(this); \r\n\t}}\r\n\r\n",
* TypeProcessor.ConvertType(paramType.Type), actualMethodName, token));
* // writer.WriteLine ("public final ref " + returnType + " " + methodName +
* // String.Format (
* // " (string _op) ()\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\t{3}\r\n\t}}\r\n\r\n",
* //TypeProcessor.ConvertType (paramType.Type), actualMethodName, token, methodBody.Replace(method.ParameterList.Parameters[0].Identifier.ValueText,"this")));
* }
* else
* {
* writer.WriteLine("public final " + returnType + " " + methodName +
* String.Format(
* " (string _op) ({0} other)\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\treturn {1}(this); \r\n\t}}\r\n\r\n",
* TypeProcessor.ConvertType(paramType.Type), actualMethodName, token));
* }*/
var @params = method.ParameterList.Parameters;
writer.WriteLine("public static " + returnType + " " + actualMethodName + WriteMethod.GetParameterListAsString(method.ParameterList.Parameters));
writer.OpenBrace();
if (method.Body != null)
{
foreach (var statement in method.Body.Statements)
{
Core.Write(writer, statement);
}
TriviaProcessor.ProcessTrivias(writer, method.Body.DescendantTrivia());
}
writer.CloseBrace();
}
private static void Factory(OutputWriter writer, SyntaxNode node, bool isConst)
{
if (node is ConstructorInitializerSyntax)
{
WriteConstructorInitializer.Go(writer, node.As <ConstructorInitializerSyntax>());
}
else if (node is CheckedExpressionSyntax)
{
WriteChecked.Go(writer, node.As <CheckedExpressionSyntax>());
}
else if (node is CheckedStatementSyntax)
{
WriteChecked.Go(writer, node.As <CheckedStatementSyntax>());
}
else if (node is UnsafeStatementSyntax)
{
WriteUnsafeStatement.Go(writer, node.As <UnsafeStatementSyntax>());
}
else if (node is InitializerExpressionSyntax)
{
WriteInitializer.Go(writer, node.As <InitializerExpressionSyntax>());
}
else if (node is GotoStatementSyntax)
{
WriteGoto.Go(writer, node.As <GotoStatementSyntax>());
}
else if (node is CaseSwitchLabelSyntax)
{
WriteLabel.Go(writer, node.As <CaseSwitchLabelSyntax>());
}
else if (node is LabeledStatementSyntax)
{
WriteLabel.Go(writer, node.As <LabeledStatementSyntax>());
}
else if (node is OperatorDeclarationSyntax)
{
WriteOperatorDeclaration.Go(writer, node.As <OperatorDeclarationSyntax>());
}
else if (node is MethodDeclarationSyntax)
{
WriteMethod.Go(writer, node.As <MethodDeclarationSyntax>());
}
else if (node is PropertyDeclarationSyntax)
{
WriteProperty.Go(writer, node.As <PropertyDeclarationSyntax>());
}
else if (node is EventDeclarationSyntax)
{
WriteEvent.Go(writer, node.As <EventDeclarationSyntax>());
}
else if (node is FieldDeclarationSyntax)
{
WriteField.Go(writer, node.As <FieldDeclarationSyntax>());
}
else if (node is EventFieldDeclarationSyntax)
{
WriteField.Go(writer, node.As <EventFieldDeclarationSyntax>());
}
else if (node is ConstructorDeclarationSyntax)
{
WriteConstructorBody.Go(writer, node.As <ConstructorDeclarationSyntax>());
}
else if (node is ExpressionStatementSyntax)
{
WriteStatement(writer, node.As <ExpressionStatementSyntax>());
}
else if (node is FixedStatementSyntax)
{
WriteFixedStatement(writer, node.As <FixedStatementSyntax>());
}
else if (node is LocalDeclarationStatementSyntax)
{
WriteLocalDeclaration.Go(writer, node.As <LocalDeclarationStatementSyntax>());
}
else if (node is VariableDeclarationSyntax)
{
WriteVariableDeclaration.Go(writer, node.As <VariableDeclarationSyntax>());
}
else if (node is BlockSyntax)
{
WriteBlock(writer, node.As <BlockSyntax>());
}
else if (node is InvocationExpressionSyntax)
{
WriteInvocationExpression.Go(writer, node.As <InvocationExpressionSyntax>());
}
else if (node is LiteralExpressionSyntax)
{
WriteLiteralExpression.Go(writer, node.As <LiteralExpressionSyntax>(), isConst);
}
else if (node is IdentifierNameSyntax)
{
WriteIdentifierName.Go(writer, node.As <IdentifierNameSyntax>());
}
else if (node is ImplicitArrayCreationExpressionSyntax)
{
WriteArrayCreationExpression.Go(writer, node.As <ImplicitArrayCreationExpressionSyntax>());
}
else if (node is ArrayCreationExpressionSyntax)
{
WriteArrayCreationExpression.Go(writer, node.As <ArrayCreationExpressionSyntax>());
}
else if (node is MemberAccessExpressionSyntax)
{
WriteMemberAccessExpression.Go(writer, node.As <MemberAccessExpressionSyntax>());
}
else if (node is ParenthesizedLambdaExpressionSyntax)
{
WriteLambdaExpression.Go(writer, node.As <ParenthesizedLambdaExpressionSyntax>());
}
else if (node is SimpleLambdaExpressionSyntax)
{
WriteLambdaExpression.Go(writer, node.As <SimpleLambdaExpressionSyntax>());
}
else if (node is AnonymousMethodExpressionSyntax)
{
WriteLambdaExpression.Go(writer, node.As <AnonymousMethodExpressionSyntax>());
}
else if (node is ReturnStatementSyntax)
{
WriteReturnStatement.Go(writer, node.As <ReturnStatementSyntax>());
}
else if (node is ObjectCreationExpressionSyntax)
{
WriteObjectCreationExpression.Go(writer, node.As <ObjectCreationExpressionSyntax>());
}
else if (node is ElementAccessExpressionSyntax)
{
WriteElementAccessExpression.Go(writer, node.As <ElementAccessExpressionSyntax>());
}
else if (node is ForEachStatementSyntax)
{
WriteForEachStatement.Go(writer, node.As <ForEachStatementSyntax>());
}
else if (node is IfStatementSyntax)
{
WriteIfStatement.Go(writer, node.As <IfStatementSyntax>());
}
else if (node is BinaryExpressionSyntax)
{
WriteBinaryExpression.Go(writer, node.As <BinaryExpressionSyntax>());
}
else if (node is AssignmentExpressionSyntax)
{
WriteAssignmentExpression.Go(writer, node.As <AssignmentExpressionSyntax>());
}
else if (node is ConditionalExpressionSyntax)
{
WriteConditionalExpression.Go(writer, node.As <ConditionalExpressionSyntax>());
}
else if (node is BaseExpressionSyntax)
{
WriteBaseExpression.Go(writer, node.As <BaseExpressionSyntax>());
}
else if (node is ThisExpressionSyntax)
{
WriteThisExpression.Go(writer, node.As <ThisExpressionSyntax>());
}
else if (node is CastExpressionSyntax)
{
WriteCastExpression.Go(writer, node.As <CastExpressionSyntax>());
}
else if (node is ThrowStatementSyntax)
{
WriteThrowStatement.Go(writer, node.As <ThrowStatementSyntax>());
}
else if (node is EqualsValueClauseSyntax)
{
WriteEqualsValueClause.Go(writer, node.As <EqualsValueClauseSyntax>());
}
else if (node is ForStatementSyntax)
{
WriteForStatement.Go(writer, node.As <ForStatementSyntax>());
}
else if (node is WhileStatementSyntax)
{
WriteWhileStatement.Go(writer, node.As <WhileStatementSyntax>());
}
else if (node is BreakStatementSyntax)
{
WriteBreakStatement.Go(writer, node.As <BreakStatementSyntax>());
}
else if (node is ContinueStatementSyntax)
{
WriteContinueStatement.Go(writer, node.As <ContinueStatementSyntax>());
}
else if (node is DoStatementSyntax)
{
WriteDoStatement.Go(writer, node.As <DoStatementSyntax>());
}
else if (node is SwitchStatementSyntax)
{
WriteSwitchStatement.Go(writer, node.As <SwitchStatementSyntax>());
}
else if (node is TryStatementSyntax)
{
WriteTryStatement.Go(writer, node.As <TryStatementSyntax>());
}
else if (node is UsingStatementSyntax)
{
WriteUsingStatement.Go(writer, node.As <UsingStatementSyntax>());
}
else if (node is ParenthesizedExpressionSyntax)
{
WriteParenthesizedExpression.Go(writer, node.As <ParenthesizedExpressionSyntax>());
}
else if (node is LockStatementSyntax)
{
WriteLockStatement.Go(writer, node.As <LockStatementSyntax>());
}
else if (node is TypeOfExpressionSyntax)
{
WriteTypeOfExpression.Go(writer, node.As <TypeOfExpressionSyntax>());
}
else if (node is AnonymousObjectCreationExpressionSyntax)
{
WriteAnonymousObjectCreationExpression.Go(writer, node.As <AnonymousObjectCreationExpressionSyntax>());
}
else if (node is EmptyStatementSyntax)
{
return; //ignore empty statements
}
else if (node is DelegateDeclarationSyntax)
{
return; //don't write delegates - TypeProcessor converts them to function types directly
}
else if (node is DefaultExpressionSyntax)
{
WriteDefaultExpression.Go(writer, node.As <DefaultExpressionSyntax>());
}
else if (node is GenericNameSyntax)
{
WriteGenericName.Go(writer, node.As <GenericNameSyntax>());
}
else if (node is ConversionOperatorDeclarationSyntax)
{
WriteConversionOperatorDeclaration.Go(writer, node.As <ConversionOperatorDeclarationSyntax>());
}
else if (node is PrefixUnaryExpressionSyntax)
{
WriteUnaryExpression.WritePrefix(writer, node.As <PrefixUnaryExpressionSyntax>());
}
else if (node is PostfixUnaryExpressionSyntax)
{
WriteUnaryExpression.WritePostfix(writer, node.As <PostfixUnaryExpressionSyntax>());
}
else if (node is SizeOfExpressionSyntax)
{
WriteSizeOfExpression.Go(writer, node.As <SizeOfExpressionSyntax>());
}
else if (node is DestructorDeclarationSyntax)
{
WriteDestructorBody.WriteDestructor(writer, node.As <DestructorDeclarationSyntax>());
}
else if (node is IndexerDeclarationSyntax)
{
WriteIndexer.Go(writer, node.As <IndexerDeclarationSyntax>());
}
else if (node is StackAllocArrayCreationExpressionSyntax)
{
WriteStackArrayCreation.Go(writer, node.As <StackAllocArrayCreationExpressionSyntax>());
}
// writer.Write(node.ToFullString() + "//TODO: StackAlloc not supported yet");
else if (node is YieldStatementSyntax)
{
WriteYieldStatement.Go(writer, node.As <YieldStatementSyntax>());
}
else
{
throw new NotImplementedException(node.GetType().Name + " is not supported. " + Utility.Descriptor(node));
}
}
public static void Go(OutputWriter writer, BasePropertyDeclarationSyntax property, bool isProxy = false)
{
writer.WriteLine();
//TODO, doesnt ref make things slower ?, though it makes proprties behave as in c#
var isInterface = property.Parent is InterfaceDeclarationSyntax;
var getter =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.GetKeyword);
var setter =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.SetKeyword);
var isYield = getter != null && getter.DescendantNodes().OfType <YieldStatementSyntax>().Any();
var isStatic = property.Modifiers.Any(k => k.IsKind(SyntaxKind.StaticKeyword));
ITypeSymbol iface;
ISymbol[] proxies;
var name = MemberUtilities.GetMethodName(property, ref isInterface, out iface, out proxies);
var modifiers = property.Modifiers;
var propertySymbol = (IPropertySymbol)TypeProcessor.GetDeclaredSymbol(property);
var type = propertySymbol.Type;
var acccessmodifiers = MemberUtilities.GetAccessModifiers(property, isInterface || propertySymbol.IsAbstract);
var typeString = TypeProcessor.ConvertType(type);
var hasGetter = getter != null;
var getterHasBody = hasGetter && getter.Body != null;
var hasSetter = setter != null;
var setterHasBody = hasSetter && setter.Body != null;
var indexerDeclarationSyntax = property as IndexerDeclarationSyntax;
var isindexer = indexerDeclarationSyntax != null;
string getterbody = null;
if (getterHasBody)
{
getterbody = Core.WriteBlock(getter.Body, false, writer.Indent + 2);
if (!isProxy && isYield)
{
var namedTypeSymbol = propertySymbol.Type as INamedTypeSymbol;
if (namedTypeSymbol != null)
{
// var iteratortype = namedTypeSymbol.TypeArguments[0];
// getterbody=String.Format("return new __IteratorBlock!({0})(delegate(__IteratorBlock!({0}) __iter){{ {1} }});",
// TypeProcessor.ConvertType(iteratortype),getterbody);
var className = propertySymbol.GetYieldClassName() + (
(((INamedTypeSymbol)propertySymbol.Type).TypeArguments.Any() && ((INamedTypeSymbol)propertySymbol.Type).TypeArguments[0].TypeKind == TypeKind.TypeParameter) ? "__G" : "");
// writer.WriteLine(accessString + returnTypeString + methodSignatureString + @params2 + constraints);
//writer.OpenBrace();
if (!propertySymbol.IsStatic)
{
getterbody = writer.WriteIndentToString() + ("return new " + className + "(this);");
}
else
{
getterbody = writer.WriteIndentToString() + ("return new " + className + "();");
}
}
}
}
string setterbody = null;
if (setterHasBody)
{
setterbody = Core.WriteString(setter.Body, false, writer.Indent + 2);
if (isindexer)
{
setterbody += writer.WriteIndentToString() + "return value;";
}
else
{
if (hasGetter)
{
setterbody += writer.WriteIndentToString() + "return " + name + ";";
}
}
}
if (getter == null && setter == null)
{
throw new Exception("Property must have either a get or a set");
}
string isOverride;
var fieldName = WriteAutoFieldName(writer, name, modifiers, isInterface, hasGetter, getterHasBody,
hasSetter, setterHasBody, typeString, out isOverride, (property is IndexerDeclarationSyntax));
BracketedParameterListSyntax @params = null;
if (indexerDeclarationSyntax != null)
{
@params = indexerDeclarationSyntax.ParameterList;
}
string parameters = null;
if (@params != null)
{
parameters = WriteMethod.GetParameterListAsString(@params.Parameters, iface: proxies == null ? iface : null, writebraces: false);
}
WriteGetter(writer, isProxy, hasGetter, acccessmodifiers, typeString, name, proxies == null ? iface : null, getterHasBody, modifiers, isInterface, fieldName, getterbody, parameters, indexerDeclarationSyntax != null);
WriteSetter(writer, isProxy, hasSetter, acccessmodifiers, name, typeString, proxies == null ? iface : null, isOverride, setterHasBody, modifiers, isInterface, fieldName, setterbody, parameters, isindexer, hasGetter);
// if (!isindexer && !isInterface) //TODO: Find a better solution
// {
// var fieldacccessmodifiers = acccessmodifiers.Replace ("abstract", "").Replace ("virtual","").Replace("override","");
//
// writer.WriteLine(fieldacccessmodifiers + "__Property!(" + typeString + ")" + name + ";");
// if (isStatic)
// {
// var staticWriter = new TempWriter ();
//
// staticWriter.WriteLine (name + String.Format (" = __Property!(" + typeString + ")(__ToDelegate(&set{0}), __ToDelegate(&get{0}));", name));
// Context.Instance.StaticInits.Add (staticWriter.ToString ());
// }
// else
// {
// var instanceWriter = new TempWriter ();
//
// instanceWriter.WriteLine (name + String.Format (" = __Property!(" + typeString + ")((&set{0}), (&get{0}));", name));
// Context.Instance.InstanceInits.Add (instanceWriter.ToString ());
// }
// }
if (proxies != null)
{
foreach (var proxy in proxies)
{
if (indexerDeclarationSyntax == null)
{
setterbody = writer.WriteIndentToString() + name + "=" + "value" + ";";
getterbody = writer.WriteIndentToString() + "return " + name + ";";
}
else
{
string parameters2 = "";
if (@params != null)
{
parameters2 = WriteMethod.GetParameterListAsString(@params.Parameters, iface: null, includeTypes: false, writebraces: false);
// parameters2 = WriteMethod.GetParameterListAsString(@params.Parameters, iface: proxies == null ? iface : null, writebraces: false);
}
setterbody = writer.WriteIndentToString() + "return opIndexAssign(value," + parameters2 + ");";// + "=" + "value" + ";";
getterbody = writer.WriteIndentToString() + "return opIndex(" + parameters2 + ");";
}
parameters = null;
if (@params != null)
{
parameters = WriteMethod.GetParameterListAsString(@params.Parameters, iface: proxy.ContainingType, writebraces: false);
}
WriteGetter(writer, isProxy, hasGetter, acccessmodifiers, typeString, name, proxy.ContainingType, getterHasBody, modifiers, isInterface, fieldName, getterbody, parameters, isindexer);
WriteSetter(writer, isProxy, hasSetter, acccessmodifiers, name, typeString, proxy.ContainingType, isOverride, setterHasBody, modifiers, isInterface, fieldName, setterbody, parameters, isindexer, hasGetter);
}
}
}
public static void WriteInstanceConstructor(OutputWriter writer, ConstructorDeclarationSyntax method)
{
var methodSymbol = (IMethodSymbol)TypeProcessor.GetDeclaredSymbol(method);
var methodName = OverloadResolver.MethodName(methodSymbol);
// var methodType = Program.GetModel(method).GetTypeInfo(method);
//TODO: Improve partial class / method support
if (method.Modifiers.Any(SyntaxKind.PartialKeyword) && method.Body == null)
{
//We only want to render out one of the two partial methods. If there's another, skip this one.
if (Context.Instance.Partials.SelectMany(o => o.Syntax.As <ClassDeclarationSyntax>().Members)
.OfType <ConstructorDeclarationSyntax>()
.Except(method).Any(o => o.Identifier.ValueText == method.Identifier.ValueText))
{
return;
}
}
// if (method.Identifier.ValueText == "GetEnumerator")
// return; //TODO: Support enumerator methods
writer.WriteLine();
// writer.WriteIndent();
var accessmodifiers = "";
var isInterface = method.Parent is InterfaceDeclarationSyntax;
if (method.Modifiers.Any(SyntaxKind.PublicKeyword) || method.Modifiers.Any(SyntaxKind.InternalKeyword) ||
method.Modifiers.Any(SyntaxKind.ProtectedKeyword) || method.Modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
{
accessmodifiers += ("public ");
}
if (method.Modifiers.Any(SyntaxKind.PrivateKeyword))
{
accessmodifiers += ("private ");
}
if (ShouldUseOverrideKeyword(method, methodSymbol))
{
accessmodifiers += ("override ");
}
//D does not use the virtual keyword
// if (method.Modifiers.Any(SyntaxKind.VirtualKeyword) || isInterface)
// writer.Write("virtual ");
//Need to improve performance by labling non virtual methods with "final" ... but we have to check the original definition of the method
if (method.Modifiers.Any(SyntaxKind.StaticKeyword))
{
accessmodifiers += ("static ");
}
if (isInterface)
{
// writer.IsInterface = true;
}
//Constructors in d dont have return types
// writer.Write("void ");
// writer.HeaderWriter.Write("void ");
// writer.Write("this");
// writer.Write("(");
// var firstParam = true;
// foreach (var parameter in method.ParameterList.Parameters)
// {
// bool isRef = parameter.Modifiers.Any(SyntaxKind.OutKeyword) ||
// parameter.Modifiers.Any(SyntaxKind.RefKeyword);
//
// if (firstParam)
// firstParam = false;
// else
// {
// writer.Write(", ");
// }
//
//
// var localSymbol = TypeProcessor.GetTypeInfo(parameter.Type);
// var ptr = (localSymbol.Type != null && !localSymbol.Type.IsValueType) ? "" : "";
//
// if (!isRef)
// {
// var s = TypeProcessor.ConvertType(parameter.Type) + " " + ptr;
// writer.Write(s);
// }
// else
// {
//
//
//
// var s = " ref " + TypeProcessor.ConvertType(parameter.Type) + " "; // Refs in D are simple
//
// writer.Write(s);
//
// Program.RefOutSymbols.TryAdd(TypeProcessor.GetDeclaredSymbol(parameter), null);
// }
//
// writer.Write(WriteIdentifierName.TransformIdentifier(parameter.Identifier.ValueText));
//
// if (parameter.Default != null)
// {
// writer.Write(" = ");
// Core.Write(writer, parameter.Default.Value);
// }
// }
//
// writer.Write(")");
writer.WriteLine(accessmodifiers + "this" + WriteMethod.GetParameterListAsString(method.ParameterList));
if (isInterface || method.Modifiers.Any(SyntaxKind.AbstractKeyword))
{
writer.Write(" = 0;\r\n");
return;
}
//if (!returnsVoid)
// writer.Write(" =");
// writer.Write("\r\n");
writer.OpenBrace();
if (method.Initializer != null)
{
//writer.Write(":");
Core.Write(writer, method.Initializer);
writer.Write(";");
writer.WriteLine(); //";\r\n");
}
if (method.Body != null)
{
foreach (var statement in method.Body.Statements)
{
Core.Write(writer, statement);
}
TriviaProcessor.ProcessTrivias(writer, method.Body.DescendantTrivia());
}
writer.CloseBrace();
}
private static void WriteOutBoxed(OutputWriter writer, List <ITypeSymbol> genericArgs, List <ITypeSymbol> bases)
{
//Implement Boxed!T
if (Context.Instance.Type.TypeKind == TypeKind.Struct)
{
writer.WriteLine();
var typeName = TypeProcessor.ConvertType(Context.Instance.Type); /*TypeName(Context.Instance.Type, false) +
* (Context.Instance.Type.IsGenericType && genericArgs.Any()
* ? ("!(" + string.Join(" , ", genericArgs.Select(o => o)) + ")")
* : "");*/
var baseString = "";
foreach (var baseType in bases.OrderBy(o => o.TypeKind == TypeKind.Interface ? 1 : 0))
{
baseString += (" ,");
baseString += (TypeProcessor.ConvertType(baseType, false));
}
writer.WriteLine("public static class __Boxed_" + " " +
//(genericArgs.Any() ? ("( " + (string.Join(" , ", genericArgs.Select(o => o)) + " )")) : "") +//Internal boxed should not be generic
": Boxed!(" + typeName + ")" + baseString);
writer.OpenBrace();
writer.WriteLine("import std.traits;");
var members = new List <ISymbol>();
foreach (var baseType in bases.Where(o => o.TypeKind == TypeKind.Interface))
{
members.AddRange(Utility.GetAllMembers(baseType));
}
// foreach (var baseType in bases.Where(o => o.TypeKind == TypeKind.Interface))
//{
var ifacemembers = members.DistinctBy(k => k);//Utility.GetAllMembers(Context.Instance.Type);
foreach (var member in ifacemembers)
{
var findImplementationForInterfaceMember = Context.Instance.Type.FindImplementationForInterfaceMember(member);
if (findImplementationForInterfaceMember == null)
{
continue;
}
var ifacemethod =
findImplementationForInterfaceMember
.DeclaringSyntaxReferences.First()
.GetSyntax();
var syntax = ifacemethod as MethodDeclarationSyntax;
if (syntax != null)
{
WriteMethod.WriteIt(writer, syntax);
}
var property = ifacemethod as PropertyDeclarationSyntax;
if (property != null)
{
WriteProperty.Go(writer, property, true);
}
}
// {
// writer.WriteLine("public override String ToString()");
// writer.OpenBrace();
// writer.WriteLine("return __Value.ToString();", Program.GetGenericMetadataName(Context.Instance.Type));
// writer.CloseBrace();
// }
//}
//This is required to be able to create an instance at runtime / reflection
// this()
// {
// super(SimpleStruct.init);
// }
writer.WriteLine();
writer.WriteLine("this()");
writer.OpenBrace();
writer.WriteLine("super({0}.init);", typeName); //TODO fix this for another TypeNew that calls the valuetype constructor only
writer.CloseBrace();
// if (Context.Instance.Type.GetMembers("ToString").Any()) // Use better matching ?
{
// writer.WriteLine ();
writer.WriteLine("public override String ToString()");
writer.OpenBrace();
writer.WriteLine("return __Value.ToString();");
writer.CloseBrace();
}
writer.WriteLine();
writer.WriteLine("this(ref " + typeName + " value)");
writer.OpenBrace();
writer.WriteLine("super(value);");
writer.CloseBrace();
writer.WriteLine();
writer.WriteLine("U opCast(U)()");
writer.WriteLine("if(is(U:{0}))", typeName);
writer.OpenBrace();
writer.WriteLine("return __Value;");
writer.CloseBrace();
writer.WriteLine();
writer.WriteLine("U opCast(U)()");
writer.WriteLine("if(!is(U:{0}))", typeName);
writer.OpenBrace();
writer.WriteLine("return this;");
writer.CloseBrace();
writer.WriteLine();
writer.WriteLine("auto opDispatch(string op, Args...)(Args args)");
writer.OpenBrace();
writer.WriteLine("enum name = op;");
writer.WriteLine("return __traits(getMember, __Value, name)(args);");
writer.CloseBrace();
writer.WriteLine();
writer.WriteLine("public override Type GetType()");
writer.OpenBrace();
writer.WriteLine("return __Value.GetType();");
writer.CloseBrace();
writer.CloseBrace();
}
}
public static void Go()
{
var partials = Context.Instance.Partials;
var first = partials.First();
Context.Instance.Namespace = first.Symbol.ContainingNamespace.FullName();
Context.Instance.Type = first.Symbol;
TypeProcessor.ClearUsedTypes();
var mynamespace = Context.Instance.Type.ContainingNamespace.FullName().RemoveFromEndOfString(".Namespace");
// + "." + TypeState.Instance.TypeName;
Console.WriteLine("Writing out type: " + Context.Instance.Namespace + "." + Context.Instance.TypeName);
if ((Context.Instance.Namespace + "." + Context.Instance.TypeName) ==
"Mono.Security.X509.Namespace.X509Chain")
{
}
var myUsingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(mynamespace));
var SystemUsingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System"));
// Required as certain functions like boxing are in this namespace
var namespaces = first.Syntax.Parent.DescendantNodes().OfType <UsingDirectiveSyntax>().ToArray();
var usingStatements = first.Syntax.Parent.DescendantNodes().OfType <UsingStatementSyntax>().ToArray();
Context.Instance.UsingDeclarations = namespaces
.Union(new[]
{
myUsingDirective, SystemUsingDirective
}).ToArray();
var objectType =
TypeProcessor.GetSemanticModel(partials.First().Syntax)
.Compilation.GetTypeByMetadataName("System.Object");
using (var writer = new OutputWriter(Context.Instance.Namespace, Context.Instance.TypeName))
{
var bases = partials
.Select(o => o.Syntax.BaseList)
.Where(o => o != null)
.SelectMany(o => o.Types)
.Select(o => TypeProcessor.GetTypeInfo(o.Type).ConvertedType)
.Distinct()
.ToList();
// var interfaces = bases.Where(o => o.TypeKind == TypeKind.Interface).ToList();
if (!bases.Any((j => j.TypeKind != TypeKind.Interface)) &&
!(first.Symbol.TypeKind == TypeKind.Interface || first.Symbol.TypeKind == TypeKind.Struct))
{
//TODO: fix structs using mixins / alias this
bases.Add(objectType);
}
// WriteStandardIncludes.Go(writer);
// writer.WriteLine(String.Format("#include \"{0}\"", TypeState.Instance.TypeName + ".h"));
WriteBcl.Go(writer);
//TypeState.Instance.DerivesFromObject = bases.Count == interfaces.Count;
var @namespace = first.Symbol.ContainingNamespace.FullName();
//Module name = namespace + "." + typename;
WriteStandardIncludes.Go(writer);
// var namespaces = @namespace.Split(new string[] { "." }, StringSplitOptions.None);
//
// if (@namespace.Length > 0)
// {
// foreach (var ns in namespaces)
// {
// writer.WriteLine("namespace " + ns + "\r\n{");
// writer.WriteLine("namespace " + ns + "\r\n{");
// }
//
// }
//TODO: Fix enum support
if (first.Syntax is EnumDeclarationSyntax)
{
WriteEnum.Go(writer,
Context.Instance.Partials.Select(o => o.Syntax)
.Cast <EnumDeclarationSyntax>()
.SelectMany(o => o.Members)
.Where(o => !Program.DoNotWrite.ContainsKey(o)));
return;
}
Context.Instance.AllMembers =
partials.Select(o => o.Syntax)
.Cast <TypeDeclarationSyntax>()
.SelectMany(o => o.Members)
.Where(o => !Program.DoNotWrite.ContainsKey(o))
.ToList();
var allMembersToWrite = Context.Instance.AllMembers
.Where(member => !(member is TypeDeclarationSyntax) &&
!(member is EnumDeclarationSyntax) &&
!(member is DelegateDeclarationSyntax) &&
!(member is ConstructorDeclarationSyntax))
.ToList();
var instanceCtors = Context.Instance.AllMembers.OfType <ConstructorDeclarationSyntax>()
.Where(o => !o.Modifiers.Any(SyntaxKind.StaticKeyword))
.ToList();
var staticCtors = Context.Instance.AllMembers.OfType <ConstructorDeclarationSyntax>()
.Where(o => (o.Modifiers.Any(SyntaxKind.StaticKeyword)))
.ToList();
//TODO: Add support for overloading constructing
// if (instanceCtors.Count > 1)
// throw new Exception(
// "Overloaded constructors are not supported. Consider changing all but one to static Create methods " +
// Utility.Descriptor(first.Syntax));
// var ctorOpt = instanceCtors.SingleOrDefault();
//TODO: Handle interfaces by
/*
* class Interface
* {
* public:
* virtual ~Interface() { }
* virtual void test() = 0; // Functions, must all be virtual
* }
*/
var membersToWrite = allMembersToWrite.ToList();
//.Where(o => IsStatic(o) == staticMembers).ToList();
// if (membersToWrite.Count == 0 && (partials.Any(o => o.Syntax.Modifiers.Any(SyntaxKind.StaticKeyword))))
// continue;
// if (staticMembers)
// writer.Write("object ");
// else if (first.Syntax.Kind == SyntaxKind.InterfaceDeclaration)
// writer.Write("trait ");
// else
// {
// if (partials.Any(o => o.Syntax.Modifiers.Any(SyntaxKind.AbstractKeyword)))
// writer.Write("abstract ");
// }
// writer.Write(TypeState.Instance.TypeName);
if (first.Syntax is TypeDeclarationSyntax)
{
//Look for generic arguments
var genericArgs = partials
.Select(o => o.Syntax)
.Cast <TypeDeclarationSyntax>()
.Where(o => o.TypeParameterList != null)
.SelectMany(o => o.TypeParameterList.Parameters)
.ToList();
if (Context.Instance.Type.TypeKind == TypeKind.Class)
{
writer.Write("class ");
}
else if (Context.Instance.Type.TypeKind == TypeKind.Interface)
{
writer.Write("interface ");
}
else if (Context.Instance.Type.TypeKind == TypeKind.Struct)
{
writer.Write("struct ");
// writer.Write (" class "); // Allows inheritance ... but too many issues, will look at this when it gets relevant
}
else
{
throw new Exception("don't know how to write type: " + Context.Instance.Type.TypeKind);
}
//writer.Write (((TypeState.Instance.Type.TypeKind== TypeKind.Interface)?" interface ": ) );
writer.Write(Context.Instance.TypeName);
if (genericArgs.Count > 0)
{
writer.Write("( ");
writer.Write(string.Join(" , ", genericArgs.Select(o => o)));
writer.Write(" )");
}
bool firstBase = true;
if (Context.Instance.Type.TypeKind != TypeKind.Struct)
{
foreach (var baseType in bases.OrderBy(o => o.TypeKind == TypeKind.Interface ? 1 : 0))
{
writer.Write(firstBase ? " : " : " ,");
writer.Write(TypeProcessor.ConvertType(baseType));
// if (firstBase && ctorOpt != null && ctorOpt.Initializer != null &&
// ctorOpt.Initializer.ArgumentList.Arguments.Count > 0)
// {
// writer.Write("(");
// bool firstArg = true;
// foreach (var init in ctorOpt.Initializer.ArgumentList.Arguments)
// {
// if (firstArg)
// firstArg = false;
// else
// writer.Write(", ");
//
// Core.Write(writer, init.Expression);
// }
// writer.Write(")");
// }
firstBase = false;
}
}
}
writer.WriteLine();
writer.OpenBrace();
var fields = membersToWrite.OfType <FieldDeclarationSyntax>().ToList();
var nonFields = membersToWrite.Except(fields); // also static fields should be separately dealt with
var structLayout = first.Syntax.GetAttribute(Context.StructLayout);
if (structLayout != null)
{
LayoutKind value = LayoutKind.Auto;
if (
structLayout.ArgumentList.Arguments.Any(
k => k.NameEquals != null && k.NameEquals.Name.ToFullString().Trim() == "Value"))
{
value =
(LayoutKind)
Enum.Parse(typeof(LayoutKind),
structLayout.ArgumentList.Arguments.FirstOrDefault(
k => k.NameEquals != null && k.NameEquals.Name.ToFullString().Trim() == "Value")
.Expression.ToFullString()
.SubstringAfterLast('.'));
//structLayout.ArgumentList.Arguments.Where (k => k.Expression is MemberAccessExpressionSyntax).FirstOrDefault(k=>(k.Expression as MemberAccessExpressionSyntax).Name.ToFullString() == "Value");
}
//structLayout.ArgumentList.Arguments.Where (k => k.Expression is MemberAccessExpressionSyntax).FirstOrDefault(k=>(k.Expression as MemberAccessExpressionSyntax).Name.ToFullString() == "Value");
else if (structLayout.ArgumentList.Arguments.Count > 0 &&
structLayout.ArgumentList.Arguments[0].NameEquals == null)
{
value =
(LayoutKind)
Enum.Parse(typeof(LayoutKind),
structLayout.ArgumentList.Arguments[0].Expression.ToFullString()
.SubstringAfterLast('.'));
}
int pack = -1;
int size = -1;
CharSet charset = CharSet.Auto;
// if (structLayout.ArgumentList.Arguments.Count > 1)
{
try
{
if (
structLayout.ArgumentList.Arguments.Any(
k => k.NameEquals != null && k.NameEquals.Name.ToFullString().Trim() == "CharSet"))
{
charset =
(CharSet)
Enum.Parse(typeof(CharSet),
structLayout.ArgumentList.Arguments.FirstOrDefault(
k =>
k.NameEquals != null &&
k.NameEquals.Name.ToFullString().Trim() == "CharSet")
.Expression.ToFullString()
.SubstringAfterLast('.'));
//structLayout.ArgumentList.Arguments.Where (k => k.Expression is MemberAccessExpressionSyntax).FirstOrDefault(k=>(k.Expression as MemberAccessExpressionSyntax).Name.ToFullString() == "Value");
}
//structLayout.ArgumentList.Arguments.Where (k => k.Expression is MemberAccessExpressionSyntax).FirstOrDefault(k=>(k.Expression as MemberAccessExpressionSyntax).Name.ToFullString() == "Value");
else if (structLayout.ArgumentList.Arguments.Count > 1 &&
structLayout.ArgumentList.Arguments[1].NameEquals == null)
{
charset =
(CharSet)
Enum.Parse(typeof(CharSet),
structLayout.ArgumentList.Arguments[1].Expression.ToFullString()
.SubstringAfterLast('.'));
}
}
catch (Exception ex)
{
}
try
{
if (
structLayout.ArgumentList.Arguments.Any(
k => k.NameEquals != null && k.NameEquals.Name.ToFullString().Trim() == "Pack"))
{
pack =
int.Parse(
structLayout.ArgumentList.Arguments.FirstOrDefault(
k =>
k.NameEquals != null &&
k.NameEquals.Name.ToFullString().Trim() == "Pack")
.Expression.ToFullString());
}
//structLayout.ArgumentList.Arguments.Where (k => k.Expression is MemberAccessExpressionSyntax).FirstOrDefault(k=>(k.Expression as MemberAccessExpressionSyntax).Name.ToFullString() == "Value");
else if (structLayout.ArgumentList.Arguments.Count > 2 &&
structLayout.ArgumentList.Arguments[2].NameEquals == null)
{
pack = int.Parse(structLayout.ArgumentList.Arguments[2].Expression.ToFullString());
}
}
catch (Exception ex)
{
}
try
{
if (
structLayout.ArgumentList.Arguments.Any(
k => k.NameEquals != null && k.NameEquals.Name.ToFullString().Trim() == "Size"))
{
size =
int.Parse(
structLayout.ArgumentList.Arguments.FirstOrDefault(
k => k.NameColon != null && k.NameColon.ToFullString().Trim() == "Size")
.Expression.ToFullString());
}
//structLayout.ArgumentList.Arguments.Where (k => k.Expression is MemberAccessExpressionSyntax).FirstOrDefault(k=>(k.Expression as MemberAccessExpressionSyntax).Name.ToFullString() == "Value");
else if (structLayout.ArgumentList.Arguments.Count > 3 &&
structLayout.ArgumentList.Arguments[3].NameEquals == null)
{
size = int.Parse(structLayout.ArgumentList.Arguments[3].Expression.ToFullString());
}
}
catch (Exception ex)
{
}
// size = int.Parse (structLayout.ArgumentList.Arguments [3].Expression.ToFullString ());
}
// var pack = structLayout.ArgumentList.Arguments.FirstOrDefault (k => k.NameColon.Name.ToFullString() == "Pack");
// var charset = structLayout.ArgumentList.Arguments.FirstOrDefault (k => k.NameColon.Name.ToFullString() == "CharSet");
// var size = structLayout.ArgumentList.Arguments.FirstOrDefault (k => k.NameColon.Name.ToFullString() == "Size");
if (value == LayoutKind.Explicit)
{
var fieldGroups =
fields.GroupBy(f => f.GetAttribute(Context.FieldOffset).ArgumentList.Arguments[0].ToString())
.OrderBy(k => k.Key);
writer.Indent++;
foreach (var group in fieldGroups)
{
writer.WriteLine("//FieldOffset(" + @group.Key + ")");
writer.WriteLine("union {");
foreach (var member in group)
{
Core.Write(writer, member);
}
writer.WriteLine("}");
}
// foreach (var member in fields)
// {
// // writer.WriteLine();
// Core.Write (writer, member);
// }
}
else if (value == LayoutKind.Sequential)
{
fields = SortFields(fields);
writer.Indent++;
foreach (var member in fields)
{
if (pack != -1)
{
writer.WriteLine("align (" + pack + "): //Pack = " + pack);
}
// writer.WriteLine();
Core.Write(writer, member);
}
}
else
{
//Looks like C# aligns to 1 by default ... don't know about D...
fields = SortFields(fields);
writer.Indent++;
foreach (var member in fields)
{
pack = 1;
writer.WriteLine("align (" + pack + "): //Pack = " + pack + "C# default");
// writer.WriteLine();
Core.Write(writer, member);
}
}
}
else
{
//Looks like C# aligns to 1 by default ... don't know about D...
fields = SortFields(fields);
writer.Indent++;
foreach (var member in fields)
{
var pack = 1;
writer.WriteLine("align (" + pack + "): //Pack = " + pack + "C# default");
// writer.WriteLine();
Core.Write(writer, member);
}
}
foreach (var member in nonFields)
{
// writer.WriteLine();
Core.Write(writer, member);
}
foreach (var constructor in instanceCtors)
{
// writer.WriteLine();
Core.Write(writer, constructor);
}
if (staticCtors.Count == 0)
{
if (Context.Instance.StaticInits.Count > 0)
{
var constructor = SyntaxFactory.ConstructorDeclaration(Context.Instance.TypeName);
constructor =
constructor.WithModifiers(
SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.StaticKeyword)));
WriteConstructorBody.WriteStaticConstructor(writer, constructor, Context.Instance.StaticInits);
staticCtors.Add(constructor);
}
}
else
{
var isFirst = true;
foreach (ConstructorDeclarationSyntax constructor in staticCtors)
{
if (isFirst)
{
WriteConstructorBody.WriteStaticConstructor(writer, constructor,
Context.Instance.StaticInits);
}
else
{
WriteConstructorBody.Go(writer, constructor);
}
isFirst = false;
}
}
var dllImports = Context.Instance.DllImports;
// This should only be written once ... I guess we have to put the detection logic in Program.cs
if (Context.Instance.EntryMethod != null)
{
if (dllImports.Count > 0)
{
writer.WriteLine();
writer.WriteLine(String.Format("static void * __DllImportMap[{0}];", dllImports.Count));
writer.WriteLine("static void __SetupDllImports()");
writer.OpenBrace();
for (int index = 0; index < dllImports.Count; index++)
{
var dllImport = dllImports[index];
writer.WriteLine(String.Format("__DllImportMap[{0}] = LoadNativeLibrary(cast(string){1});",
index, dllImport.ArgumentList.Arguments.FirstOrDefault(k => k.Expression != null)));
}
writer.CloseBrace();
writer.WriteLine();
writer.WriteLine("static void __FreeDllImports()");
writer.OpenBrace();
writer.WriteLine(String.Format(@"for(int i=0;i<{0};i++)", dllImports.Count));
writer.OpenBrace();
writer.WriteLine("if(__DllImportMap[i]!=null)");
writer.WriteLine("\tFreeNativeLibrary(__DllImportMap[i]);");
writer.CloseBrace();
writer.CloseBrace();
// if (hModule != null)
// {
// ::FreeLibrary(hModule);
// }
}
}
writer.Indent--;
writer.CloseBrace();
//Implement Boxed!Interface
if (Context.Instance.Type.TypeKind == TypeKind.Struct)
{
writer.WriteLine();
var typeName = Context.Instance.TypeName;
writer.Write("public class __Boxed_" + typeName + " : Boxed!(" + typeName + ")");
foreach (var baseType in bases.OrderBy(o => o.TypeKind == TypeKind.Interface ? 1 : 0))
{
writer.Write(" ,");
writer.Write(TypeProcessor.ConvertType(baseType, false));
}
writer.OpenBrace();
//FIXME:This is giving issues, we will just generate them here
// writer.WriteLine ("import Irio.Utilities;");
writer.WriteLine("import std.traits;");
foreach (var baseType in bases.Where(o => o.TypeKind == TypeKind.Interface))
{
//FIXME:This is giving issues, we will just generate them here
// writer.WriteLine ("mixin(__ImplementInterface!({0}, Value));",TypeProcessor.ConvertType(baseType,false));
var ifacemembers = baseType.GetMembers();
foreach (var member in ifacemembers)
{
var ifacemethod =
Context.Instance.Type.FindImplementationForInterfaceMember(member)
.DeclaringSyntaxReferences.First()
.GetSyntax();
// .Where(member => !(member is TypeDeclarationSyntax)
// && !(member is EnumDeclarationSyntax)
// && !(member is DelegateDeclarationSyntax) && !(member is ConstructorDeclarationSyntax))
// .ToList();
// writer.WriteLine();
// Core.Write(writer, member);
if (ifacemethod is MethodDeclarationSyntax)
{
WriteMethod.WriteIt(writer, (MethodDeclarationSyntax)ifacemethod);
}
else if (ifacemethod is PropertyDeclarationSyntax)
{
WriteProperty.Go(writer, (PropertyDeclarationSyntax)ifacemethod, true);
}
}
}
//This is required to be able to create an instance at runtime / reflection
// this()
// {
// super(SimpleStruct.init);
// }
writer.WriteLine();
writer.WriteLine("this()");
writer.OpenBrace();
writer.WriteLine("super({0}.init);", typeName);
writer.CloseBrace();
if (Context.Instance.Type.GetMembers("ToString").Count() >= 1) // Use better matching ?
{
// writer.WriteLine ();
writer.WriteLine("override String ToString()");
writer.OpenBrace();
writer.WriteLine("return Value.ToString();");
writer.CloseBrace();
}
writer.WriteLine();
writer.WriteLine("this(ref " + typeName + " value)");
writer.OpenBrace();
writer.WriteLine("super(value);");
writer.CloseBrace();
writer.WriteLine();
writer.WriteLine("U opCast(U)()");
writer.WriteLine("if(is(U:{0}))", typeName);
writer.OpenBrace();
writer.WriteLine("return Value;");
writer.CloseBrace();
writer.WriteLine();
writer.WriteLine("U opCast(U)()");
writer.WriteLine("if(!is(U:{0}))", typeName);
writer.OpenBrace();
writer.WriteLine("return this;");
writer.CloseBrace();
writer.WriteLine();
writer.WriteLine("auto opDispatch(string op, Args...)(Args args)");
writer.OpenBrace();
writer.WriteLine("enum name = op;");
writer.WriteLine("return __traits(getMember, Value, name)(args);");
writer.CloseBrace();
writer.CloseBrace();
}
if (Context.Instance.EntryMethod != null)
{
//TODO: DllImports should be centralized
//
writer.WriteLine();
writer.WriteLine("void main(string[] args)");
writer.OpenBrace();
if (dllImports.Count > 0)
{
writer.WriteLine(Context.Instance.TypeName + ".__SetupDllImports();");
}
writer.WriteLine(Context.Instance.EntryMethod);
if (dllImports.Count > 0)
{
writer.WriteLine(Context.Instance.TypeName + ".__FreeDllImports();");
}
writer.CloseBrace();
}
// var mySpecializations = Program.AllGenericSpecializations.Where (t => t.OriginalDefinition == TypeState.Instance.Type);
//
//
// foreach (var specialization in mySpecializations) {
//
// var specializationText = ("template class " + specialization.GetFullNameD (false) + " (" +
// (string.Join (" , ",
// specialization.TypeArguments.Select (
// o =>
// TypeProcessor.ConvertType (o) +
// ((o.IsValueType ||
// o.TypeKind == TypeKind.TypeParameter)
// ? ""
// : "*"))) +
// ");"));
// writer.Write (specializationText);
// }
// if (@namespace.Length > 0)
// {
// foreach (var ns in namespaces)
// {
// writer.WriteLine("\n\n}");
// writer.WriteLine("\n\n}");
// }
// }
}
}
/*
* template Action(T) {
* alias void delegate(T obj) Action;
* }
*
*/
public static void Go()
{
var partials = Context.Instance.DelegatePartials;
var first = partials.First();
Context.Instance.Namespace = first.Symbol.ContainingNamespace.FullName();
Context.Instance.Type = first.Symbol;
TypeProcessor.ClearUsedTypes();
var mynamespace = Context.Instance.Type.ContainingNamespace.FullName().RemoveFromEndOfString(".Namespace");
// + "." + TypeState.Instance.TypeName;
var myUsingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(mynamespace));
var SystemUsingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System"));
// Required as certain functions like boxing are in this namespace
Context.Instance.UsingDeclarations =
first.Syntax.Parent.DescendantNodes().OfType <UsingDirectiveSyntax>().ToArray()
.Union(new[]
{
myUsingDirective, SystemUsingDirective
}).ToArray();
using (var writer = new OutputWriter(Context.Instance.Namespace, Context.Instance.TypeName))
{
var objectType =
TypeProcessor.GetSemanticModel(partials.First().Syntax)
.Compilation.GetTypeByMetadataName("System.Object");
WriteBcl.Go(writer);
var @namespace = first.Symbol.ContainingNamespace.FullName();
WriteStandardIncludes.Go(writer);
//Look for generic arguments
//Look for generic arguments
var genericArgs = partials.Select(o => o.Syntax)
.Where(o => o.TypeParameterList != null)
.SelectMany(o => o.TypeParameterList.Parameters)
.ToList();
var name = Context.Instance.TypeName;
if (genericArgs.Count > 0)
{
name = "template " + name;
name += ("( ");
name += (string.Join(" , ", genericArgs.Select(o => o)));
name += (" )");
writer.Write(name);
writer.Write("\r\n");
writer.OpenBrace();
writer.Indent++;
writer.Write("alias Delegate!(" + TypeProcessor.ConvertType(first.Syntax.ReturnType) + " delegate" +
WriteMethod.GetParameterListAsString(first.Syntax.ParameterList));
writer.Write(") " + Context.Instance.TypeName + ";");
writer.Indent--;
writer.Write("\r\n");
writer.CloseBrace();
}
else
{
//Non-generic
writer.Write("alias Delegate!(" + TypeProcessor.ConvertType(first.Syntax.ReturnType) + " delegate" +
WriteMethod.GetParameterListAsString(first.Syntax.ParameterList));
writer.Write(") " + Context.Instance.TypeName + ";");
}
}
}
