public override bool VisitTypedefDecl(TypedefDecl typedef)
{
TypeMap typeMap;
if (TypeMapDatabase.FindTypeMap(typedef, out typeMap))
{
if (typeMap.IsIgnored)
Ignore();
return false;
}
return base.VisitTypedefDecl(typedef);
}
public override bool VisitTypedefDecl(TypedefDecl typedef)
{
Type type = typedef.Type.Desugar();
List<TypedefDecl> typedefDecls;
if (TypeDefsPerType.ContainsKey(type))
typedefDecls = TypeDefsPerType[type];
else
TypeDefsPerType.Add(type, typedefDecls = new List<TypedefDecl>());
if (!typedefDecls.Contains(typedef))
typedefDecls.Add(typedef);
return base.VisitTypedefDecl(typedef);
}
public override bool VisitTypedefDecl(TypedefDecl typedef)
{
var @class = typedef.Namespace.FindClass(typedef.Name);
// Clang will walk the typedef'd tag decl and the typedef decl,
// so we ignore the class and process just the typedef.
if (@class != null)
typedef.ExplicityIgnored = true;
if (typedef.Type == null)
typedef.ExplicityIgnored = true;
return base.VisitTypedefDecl(typedef);
}
public override bool VisitMethodDecl(Method method)
{
if (!base.VisitMethodDecl(method) || !method.IsVirtual || method.Ignore)
return false;
var @params = method.GatherInternalParams(Driver.Options.IsItaniumLikeAbi, true).ToList();
var delegateName = GenerateDelegateSignature(@params, method.ReturnType);
var @delegate = new TypedefDecl
{
Name = delegateName,
QualifiedType = new QualifiedType(
new PointerType(
new QualifiedType(
new FunctionType
{
CallingConvention = method.CallingConvention,
IsDependent = method.IsDependent,
Parameters = @params,
ReturnType = method.ReturnType
}))),
Namespace = namespaceDelegates
};
var delegateString = @delegate.Visit(TypePrinter).Type;
var existingDelegate = GetExistingDelegate(delegateString);
if (existingDelegate != null)
{
Driver.Delegates.Add(method, existingDelegate);
return true;
}
existingDelegate = new DelegateDefinition(Driver.Options.OutputNamespace, delegateString);
Driver.Delegates.Add(method, existingDelegate);
foreach (var library in Driver.Options.Libraries)
libsDelegates[library].Add(delegateString, existingDelegate);
namespaceDelegates.Declarations.Add(@delegate);
return true;
}
public bool GenerateTypedef(TypedefDecl typedef)
{
if (!typedef.IsGenerated)
return false;
FunctionType function;
if (typedef.Type.IsPointerTo(out function))
{
PushBlock(CLIBlockKind.Typedef, typedef);
GenerateDeclarationCommon(typedef);
var insideClass = typedef.Namespace is Class;
var attributedType = typedef.Type.GetPointee() as AttributedType;
if (attributedType != null)
{
var equivalentFunctionType = attributedType.Equivalent.Type as FunctionType;
var callingConvention = equivalentFunctionType.CallingConvention.ToInteropCallConv();
if (callingConvention != System.Runtime.InteropServices.CallingConvention.Winapi)
{
WriteLine("[{0}({1}::{2})] ",
"System::Runtime::InteropServices::UnmanagedFunctionPointer",
"System::Runtime::InteropServices::CallingConvention",
callingConvention);
}
}
WriteLine("{0}{1};",
!insideClass ? "public " : "",
string.Format(TypePrinter.VisitDelegate(function),
typedef.Name));
PopBlock(NewLineKind.BeforeNextBlock);
return true;
}
return false;
}
public virtual bool VisitTypedefDecl(TypedefDecl typedef)
{
return(VisitTypedefNameDecl(typedef));
}
void SymbolDecl.IVisitor.Visit(TypedefDecl decl)
{
EntryDecl(decl);
}
public override bool VisitTypedefDecl(TypedefDecl typedef)
{
if (!base.VisitTypedefDecl(typedef))
return false;
if (typedef.TranslationUnit.IsSystemHeader)
typedef.ExplicitlyIgnore();
return true;
}
public static TypedefDecl __CreateInstance(TypedefDecl.Internal native)
{
return new TypedefDecl(native);
}
private static void* __CopyValue(TypedefDecl.__Internal native)
{
var ret = Marshal.AllocHGlobal(136);
global::CppSharp.Parser.AST.TypedefDecl.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
return ret.ToPointer();
}
public override bool VisitTypedefDecl(TypedefDecl typedef)
{
if (!Targets.HasFlag(RenameTargets.Delegate))
return false;
return base.VisitTypedefDecl(typedef);
}
public string VisitTypedefDecl(TypedefDecl typedef)
{
return(VisitDeclaration(typedef));
}
public string VisitTypedefDecl(TypedefDecl typedef)
{
throw new NotImplementedException();
}
public virtual TypePrinterResult VisitTypedefDecl(TypedefDecl typedef)
{
return(VisitDeclaration(typedef));
}
public virtual bool VisitTypedefDecl(TypedefDecl typedef)
{
throw new NotImplementedException();
}
private TypedefDecl(TypedefDecl.Internal native)
: this(__CopyValue(native))
{
__ownsNativeInstance = true;
}
static SymbolDecl[] ParseSymbolInternal(string[] tokens, ref int index)
{
if (CppParser.Token(tokens, ref index, "public") || CppParser.Token(tokens, ref index, "protected") || CppParser.Token(tokens, ref index, "private"))
{
index--;
return(null);
}
TemplateDecl templateDecl = null;
if (CppParser.Token(tokens, ref index, "template"))
{
templateDecl = new TemplateDecl
{
TypeParameters = new List <TypeParameterDecl>(),
Specialization = new List <TypeDecl>(),
};
CppParser.EnsureToken(tokens, ref index, "<");
if (!CppParser.Token(tokens, ref index, ">"))
{
while (true)
{
string token = null;
CppParser.SkipUntilInTemplate(tokens, ref index, out token, ",", ">", "=");
index -= 2;
templateDecl.TypeParameters.Add(new TypeParameterDecl
{
Name = CppParser.EnsureId(tokens, ref index),
});
index++;
if (token == "=")
{
CppParser.SkipUntilInTemplate(tokens, ref index, out token, ",", ">");
}
if (token == ">")
{
break;
}
}
}
}
if (CppParser.Token(tokens, ref index, "friend"))
{
int oldIndex = index - 1;
string token = null;
CppParser.SkipUntil(tokens, ref index, out token, ";", "{");
if (token == ";")
{
return(null);
}
else
{
index = oldIndex;
tokens[index] = "static";
}
}
if (CppParser.Token(tokens, ref index, "namespace"))
{
if (templateDecl != null)
{
throw new ArgumentException("Failed to parse.");
}
var decl = new NamespaceDecl();
decl.Name = CppParser.EnsureId(tokens, ref index);
CppParser.EnsureToken(tokens, ref index, "{");
ParseSymbols(tokens, ref index, decl);
CppParser.EnsureToken(tokens, ref index, "}");
return(new SymbolDecl[] { decl });
}
else if (CppParser.Token(tokens, ref index, "using"))
{
if (CppParser.Token(tokens, ref index, "namespace"))
{
if (templateDecl != null)
{
throw new ArgumentException("Failed to parse.");
}
var decl = new UsingNamespaceDecl();
decl.Path = new List <string>();
decl.Path.Add(CppParser.EnsureId(tokens, ref index));
while (!CppParser.Token(tokens, ref index, ";"))
{
CppParser.EnsureToken(tokens, ref index, ":");
CppParser.EnsureToken(tokens, ref index, ":");
decl.Path.Add(CppParser.EnsureId(tokens, ref index));
}
return(new SymbolDecl[] { decl });
}
else
{
string name = null;
if (CppParser.Id(tokens, ref index, out name))
{
if (templateDecl != null)
{
if (CppParser.Token(tokens, ref index, "<"))
{
while (true)
{
templateDecl.Specialization.Add(CppTypeParser.EnsureTypeWithoutNameInTemplate(tokens, ref index));
if (CppParser.Token(tokens, ref index, ">"))
{
break;
}
CppParser.EnsureToken(tokens, ref index, ",");
}
}
}
if (CppParser.Token(tokens, ref index, "="))
{
SymbolDecl decl = new TypedefDecl
{
Name = name,
Type = CppTypeParser.EnsureTypeWithoutName(tokens, ref index),
};
CppParser.EnsureToken(tokens, ref index, ";");
if (templateDecl != null)
{
templateDecl.Element = decl;
decl = templateDecl;
}
return(new SymbolDecl[] { decl });
}
}
if (templateDecl != null)
{
throw new ArgumentException("Failed to parse.");
}
CppParser.SkipUntil(tokens, ref index, ";");
}
}
else if (CppParser.Token(tokens, ref index, "typedef"))
{
if (templateDecl != null)
{
throw new ArgumentException("Failed to parse.");
}
string name = null;
var type = CppTypeParser.EnsureTypeWithName(tokens, ref index, out name);
CppParser.EnsureToken(tokens, ref index, ";");
var decl = new TypedefDecl();
decl.Name = name;
decl.Type = type;
return(new SymbolDecl[] { decl });
}
else if (CppParser.Token(tokens, ref index, "enum"))
{
if (templateDecl != null)
{
throw new ArgumentException("Failed to parse.");
}
bool enumClass = CppParser.Token(tokens, ref index, "class");
string name = CppParser.EnsureId(tokens, ref index);
if (CppParser.Token(tokens, ref index, ":"))
{
CppTypeParser.EnsureTypeWithoutName(tokens, ref index);
}
if (!CppParser.Token(tokens, ref index, ";"))
{
CppParser.EnsureToken(tokens, ref index, "{");
var decl = new EnumDecl
{
Name = name,
EnumClass = enumClass,
Children = new List <SymbolDecl>(),
};
while (true)
{
if (CppParser.Token(tokens, ref index, "}"))
{
break;
}
string document = null;
while (index < tokens.Length && tokens[index].Length >= 3 && tokens[index].StartsWith("///"))
{
var line = tokens[index];
if (document == null)
{
document = "";
}
document += line.StartsWith("/// ") || line.StartsWith("///\t")
? line.Substring(4)
: line.Substring(3);
document += "\r\n";
index++;
}
decl.Children.Add(new EnumItemDecl
{
Name = CppParser.EnsureId(tokens, ref index),
Document = document,
});
string token = null;
CppParser.SkipUntil(tokens, ref index, out token, ",", "}");
if (token == "}")
{
break;
}
}
if (CppParser.Id(tokens, ref index, out name))
{
var varDecl = new VarDecl
{
Static = false,
Name = name,
Type = new RefTypeDecl
{
Name = decl.Name,
},
};
CppParser.EnsureToken(tokens, ref index, ";");
return(new SymbolDecl[] { decl, varDecl });
}
else
{
CppParser.EnsureToken(tokens, ref index, ";");
return(new SymbolDecl[] { decl });
}
}
}
else if (CppParser.Token(tokens, ref index, "struct") || CppParser.Token(tokens, ref index, "class") || CppParser.Token(tokens, ref index, "union"))
{
if (CppParser.Token(tokens, ref index, "{"))
{
if (tokens[index - 2] == "class")
{
throw new ArgumentException("Failed to parse.");
}
var decl = new GroupedFieldDecl
{
Grouping = tokens[index - 2] == "struct" ? Grouping.Struct : Grouping.Union,
};
ParseSymbols(tokens, ref index, decl);
CppParser.EnsureToken(tokens, ref index, "}");
CppParser.EnsureToken(tokens, ref index, ";");
return(new SymbolDecl[] { decl });
}
else
{
string name = CppParser.EnsureId(tokens, ref index);
if (!CppParser.Token(tokens, ref index, ";"))
{
var classDecl = new ClassDecl
{
ClassType =
tokens[index - 2] == "struct" ? ClassType.Struct :
tokens[index - 2] == "class" ? ClassType.Class :
ClassType.Union,
BaseTypes = new List <BaseTypeDecl>(),
Name = name,
};
if (templateDecl != null)
{
if (CppParser.Token(tokens, ref index, "<"))
{
if (!CppParser.Token(tokens, ref index, ">"))
{
while (true)
{
int oldIndex = index;
templateDecl.Specialization.Add(CppTypeParser.EnsureTypeWithoutNameInTemplate(tokens, ref index));
if (CppParser.Token(tokens, ref index, ">"))
{
break;
}
CppParser.EnsureToken(tokens, ref index, ",");
}
}
}
}
CppParser.Token(tokens, ref index, "abstract");
if (CppParser.Token(tokens, ref index, ":"))
{
while (true)
{
Access access = classDecl.ClassType == ClassType.Class ? Access.Private : Access.Public;
CppParser.Token(tokens, ref index, "virtual");
if (CppParser.Token(tokens, ref index, "private"))
{
access = Access.Private;
}
else if (CppParser.Token(tokens, ref index, "protected"))
{
access = Access.Protected;
}
else if (CppParser.Token(tokens, ref index, "public"))
{
access = Access.Public;
}
CppParser.Token(tokens, ref index, "virtual");
classDecl.BaseTypes.Add(new BaseTypeDecl
{
Access = access,
Type = CppTypeParser.EnsureTypeWithoutName(tokens, ref index),
});
if (!CppParser.Token(tokens, ref index, ","))
{
break;
}
}
}
CppParser.EnsureToken(tokens, ref index, "{");
while (true)
{
if (CppParser.Token(tokens, ref index, "}"))
{
break;
}
Access access = classDecl.ClassType == ClassType.Class ? Access.Private : Access.Public;
if (CppParser.Token(tokens, ref index, "private"))
{
access = Access.Private;
CppParser.EnsureToken(tokens, ref index, ":");
}
else if (CppParser.Token(tokens, ref index, "protected"))
{
access = Access.Protected;
CppParser.EnsureToken(tokens, ref index, ":");
}
else if (CppParser.Token(tokens, ref index, "public"))
{
access = Access.Public;
CppParser.EnsureToken(tokens, ref index, ":");
}
ParseSymbols(tokens, ref index, classDecl, access);
}
SymbolDecl decl = classDecl;
if (templateDecl != null)
{
templateDecl.Element = decl;
decl = templateDecl;
}
if (CppParser.Id(tokens, ref index, out name))
{
var varDecl = new VarDecl
{
Static = false,
Name = name,
Type = new RefTypeDecl
{
Name = classDecl.Name,
},
};
CppParser.EnsureToken(tokens, ref index, ";");
return(new SymbolDecl[] { decl, varDecl });
}
else
{
CppParser.EnsureToken(tokens, ref index, ";");
return(new SymbolDecl[] { decl });
}
}
}
}
else if (!CppParser.Token(tokens, ref index, ";"))
{
Function function = Function.Function;
{
int oldIndex = index;
string name = null;
if (CppParser.Id(tokens, ref index, out name))
{
if (CppParser.Token(tokens, ref index, "("))
{
CppParser.SkipUntil(tokens, ref index, ")");
if (CppParser.Token(tokens, ref index, ";") || CppParser.Token(tokens, ref index, "=") || CppParser.Token(tokens, ref index, ":") || CppParser.Token(tokens, ref index, "{"))
{
function = Function.Constructor;
}
}
index = oldIndex;
}
else if (CppParser.Token(tokens, ref index, "~"))
{
function = Function.Destructor;
}
}
if (function == Function.Function)
{
Virtual virtualFunction = Virtual.Normal;
CppParser.Token(tokens, ref index, "extern");
CppParser.Token(tokens, ref index, "mutable");
if (CppParser.Token(tokens, ref index, "virtual"))
{
virtualFunction = Virtual.Virtual;
}
else if (CppParser.Token(tokens, ref index, "static"))
{
virtualFunction = Virtual.Static;
}
CppParser.Token(tokens, ref index, "inline");
CppParser.Token(tokens, ref index, "__forceinline");
if (CppParser.Token(tokens, ref index, "operator"))
{
TypeDecl returnType = null;
{
int oldIndex = index;
CppParser.SkipUntilInTemplate(tokens, ref index, "(");
int modify = --index;
tokens[modify] = "$";
index = oldIndex;
returnType = CppTypeParser.EnsureTypeWithoutName(tokens, ref index);
if (index != modify)
{
throw new ArgumentException("Failed to parse.");
}
tokens[modify] = "(";
}
var decl = new FuncDecl
{
Virtual = Virtual.Normal,
Name = "operator",
Function = function,
};
TypeDecl functionType = null;
Action <TypeDecl> continuation = null;
CallingConvention callingConvention = CallingConvention.Default;
CppTypeParser.ParseTypeContinueAfterName(tokens, ref index, ref callingConvention, out functionType, out continuation);
continuation(returnType);
decl.Type = functionType;
if (!CppParser.Token(tokens, ref index, ";"))
{
CppParser.EnsureToken(tokens, ref index, "{");
CppParser.SkipUntil(tokens, ref index, "}");
}
if (templateDecl != null)
{
templateDecl.Element = decl;
return(new SymbolDecl[] { templateDecl });
}
else
{
return(new SymbolDecl[] { decl });
}
}
else
{
string name = null;
TypeDecl type = null;
if (CppTypeParser.ParseType(tokens, ref index, out type, out name))
{
if (name == null)
{
throw new ArgumentException("Failed to parse.");
}
if (type is FunctionTypeDecl)
{
if (CppParser.Token(tokens, ref index, "="))
{
if (CppParser.Token(tokens, ref index, "0"))
{
virtualFunction = Virtual.Abstract;
}
else
{
CppParser.EnsureToken(tokens, ref index, "default", "delete");
}
}
var decl = new FuncDecl
{
Virtual = virtualFunction,
Name = name,
Type = type,
Function = Function.Function,
};
{
var funcType = (FunctionTypeDecl)type;
var returnType = funcType.ReturnType as RefTypeDecl;
if (returnType != null && returnType.Name == "auto")
{
if (CppParser.Token(tokens, ref index, "-"))
{
CppParser.EnsureToken(tokens, ref index, ">");
TypeDecl newReturnType = CppTypeParser.EnsureTypeWithoutName(tokens, ref index);
funcType.ReturnType = newReturnType;
}
}
if (!CppParser.Token(tokens, ref index, ";"))
{
CppParser.EnsureToken(tokens, ref index, "{");
CppParser.SkipUntil(tokens, ref index, "}");
}
}
if (templateDecl != null)
{
templateDecl.Element = decl;
return(new SymbolDecl[] { templateDecl });
}
else
{
return(new SymbolDecl[] { decl });
}
}
else
{
if (virtualFunction != Virtual.Normal && virtualFunction != Virtual.Static)
{
throw new ArgumentException("Failed to parse.");
}
if (CppParser.Token(tokens, ref index, "="))
{
CppParser.SkipUntil(tokens, ref index, ";");
}
else if (CppParser.Token(tokens, ref index, "{"))
{
CppParser.SkipUntil(tokens, ref index, "}");
}
else
{
CppParser.EnsureToken(tokens, ref index, ";");
}
if (!(type is ClassMemberTypeDecl))
{
var decl = new VarDecl
{
Static = virtualFunction == Virtual.Static,
Name = name,
Type = type,
};
return(new SymbolDecl[] { decl });
}
}
}
}
}
else
{
var decl = new FuncDecl
{
Virtual = Virtual.Normal,
Name = (function == Function.Constructor ? "" : "~") + CppParser.EnsureId(tokens, ref index),
Function = function,
};
TypeDecl functionType = null;
Action <TypeDecl> continuation = null;
CallingConvention callingConvention = CallingConvention.Default;
CppTypeParser.ParseTypeContinueAfterName(tokens, ref index, ref callingConvention, out functionType, out continuation);
continuation(new RefTypeDecl
{
Name = "void"
});
decl.Type = functionType;
if (CppParser.Token(tokens, ref index, "="))
{
CppParser.EnsureToken(tokens, ref index, "default", "delete");
}
if (!CppParser.Token(tokens, ref index, ";"))
{
if (CppParser.Token(tokens, ref index, ":"))
{
do
{
CppTypeParser.EnsureMiniType(tokens, ref index);
if (CppParser.Token(tokens, ref index, "("))
{
CppParser.SkipUntil(tokens, ref index, ")");
}
else if (CppParser.Token(tokens, ref index, "{"))
{
CppParser.SkipUntil(tokens, ref index, "}");
}
else
{
throw new ArgumentException("Failed to parse.");
}
}while (CppParser.Token(tokens, ref index, ","));
}
CppParser.EnsureToken(tokens, ref index, "{");
CppParser.SkipUntil(tokens, ref index, "}");
}
if (templateDecl != null)
{
templateDecl.Element = decl;
return(new SymbolDecl[] { templateDecl });
}
else
{
return(new SymbolDecl[] { decl });
}
}
}
return(null);
}
internal TypedefDecl(TypedefDecl.Internal native)
: this(&native)
{
}
public bool VisitTypedefDecl(TypedefDecl typedef)
{
return(false);
}
private TypedefDecl(TypedefDecl.Internal native, bool skipVTables = false)
: this(__CopyValue(native), skipVTables)
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
private static bool Match(TypedefDecl t, string delegateName, Module module)
{
return(t.Name == delegateName &&
(module == t.TranslationUnit.Module ||
module.Dependencies.Contains(t.TranslationUnit.Module)));
}
private TypedefDecl(TypedefDecl.Internal native)
: this(__CopyValue(native))
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
public override bool VisitTypedefDecl(TypedefDecl typedef)
{
throw new NotImplementedException();
}
public override TypePrinterResult VisitTypedefDecl(TypedefDecl typedef)
{
return(VisitDeclaration(typedef));
}
void SymbolDecl.IVisitor.Visit(TypedefDecl decl)
{
Fix(decl);
Execute(decl.Type);
}
public bool VisitTypedefDecl(TypedefDecl typedef)
{
throw new System.NotImplementedException();
}
public string VisitTypedefDecl(TypedefDecl typedef)
{
return(typedef.Name);
}
public override bool VisitTypedefDecl(TypedefDecl typedef)
{
throw new NotImplementedException();
}
public virtual TypePrinterResult VisitTypedefDecl(TypedefDecl typedef)
{
throw new NotImplementedException();
}
/// <summary>
/// Generates a new typedef for the given type if necessary and returns the new type.
/// </summary>
/// <param name="namespace">The namespace the typedef will be added to.</param>
/// <param name="type">The type to check.</param>
/// <returns>The new type.</returns>
private QualifiedType CheckType(DeclarationContext @namespace, QualifiedType type)
{
if (type.Type.IsDependent)
return type;
var pointerType = type.Type as PointerType;
if (pointerType == null)
return type;
var functionType = pointerType.Pointee as FunctionType;
if (functionType == null)
return type;
List<Typedef> typedefs;
if (!allTypedefs.TryGetValue(@namespace.QualifiedName, out typedefs))
{
typedefs = new List<Typedef>();
allTypedefs.Add(@namespace.QualifiedName, typedefs);
}
var typedef = FindMatchingTypedef(typedefs, functionType);
if (typedef == null)
{
for (int i = 0; i < functionType.Parameters.Count; i++)
{
functionType.Parameters[i].Name = string.Format("_{0}", i);
}
typedef = new TypedefDecl
{
Access = AccessSpecifier.Public,
Name = string.Format("__AnonymousDelegate{0}", typedefs.Count),
Namespace = @namespace,
QualifiedType = type,
IsSynthetized = true
};
typedefs.Add(new Typedef
{
Context = @namespace,
Declaration = typedef
});
}
var typedefType = new TypedefType
{
Declaration = typedef
};
return new QualifiedType(typedefType);
}
public override TypePrinterResult VisitTypedefDecl(TypedefDecl typedef)
{
return(GetName(typedef));
}
public override bool VisitMethodDecl(Method method)
{
if (!base.VisitMethodDecl(method) || !method.IsVirtual || method.Ignore)
return false;
var @params = method.GatherInternalParams(Context.ParserOptions.IsItaniumLikeAbi, true).ToList();
var delegateName = GenerateDelegateSignature(@params, method.ReturnType);
var module = method.TranslationUnit.Module;
Namespace namespaceDelegates;
if (namespacesDelegates.ContainsKey(module))
{
namespaceDelegates = namespacesDelegates[module];
}
else
{
namespaceDelegates = new Namespace
{
Name = DelegatesNamespace,
Namespace = module.Units.Last()
};
namespacesDelegates.Add(module, namespaceDelegates);
}
var @delegate = new TypedefDecl
{
Name = delegateName,
QualifiedType = new QualifiedType(
new PointerType(
new QualifiedType(
new FunctionType
{
CallingConvention = method.CallingConvention,
IsDependent = method.IsDependent,
Parameters = @params,
ReturnType = method.ReturnType
}))),
Namespace = namespaceDelegates,
IsSynthetized = true
};
Generator.CurrentOutputNamespace = module.OutputNamespace;
var delegateString = @delegate.Visit(TypePrinter).Type;
var existingDelegate = GetExistingDelegate(
method.TranslationUnit.Module.Libraries, delegateString);
if (existingDelegate != null)
{
Context.Delegates.Add(method, existingDelegate);
return true;
}
existingDelegate = new DelegateDefinition(module.OutputNamespace, delegateString);
Context.Delegates.Add(method, existingDelegate);
foreach (var library in module.Libraries)
libsDelegates[library].Add(delegateString, existingDelegate);
namespaceDelegates.Declarations.Add(@delegate);
return true;
}
public override bool VisitMethodDecl(Method method)
{
if (!base.VisitMethodDecl(method) || !method.IsVirtual || method.Ignore)
{
return(false);
}
var @params = method.GatherInternalParams(Context.ParserOptions.IsItaniumLikeAbi, true).ToList();
var delegateName = GenerateDelegateSignature(@params, method.ReturnType);
var module = method.TranslationUnit.Module;
Namespace namespaceDelegates;
if (namespacesDelegates.ContainsKey(module))
{
namespaceDelegates = namespacesDelegates[module];
}
else
{
Namespace parent = null;
if (string.IsNullOrEmpty(module.OutputNamespace))
{
var group = module.Units.SelectMany(u => u.Declarations).OfType <Namespace>(
).GroupBy(d => d.Name).Where(g => g.Any(d => d.HasDeclarations)).ToList();
if (group.Count == 1)
{
parent = group.Last().Last();
}
}
if (parent == null)
{
parent = module.Units.Last();
}
namespaceDelegates = new Namespace
{
Name = DelegatesNamespace,
Namespace = parent
};
namespacesDelegates.Add(module, namespaceDelegates);
}
var @delegate = new TypedefDecl
{
Name = delegateName,
QualifiedType = new QualifiedType(
new PointerType(
new QualifiedType(
new FunctionType
{
CallingConvention = method.CallingConvention,
IsDependent = method.IsDependent,
Parameters = @params,
ReturnType = method.ReturnType
}))),
Namespace = namespaceDelegates,
IsSynthetized = true,
Access = AccessSpecifier.Private
};
var delegateString = @delegate.Visit(TypePrinter).Type;
var existingDelegate = GetExistingDelegate(
method.TranslationUnit.Module, delegateString);
if (existingDelegate != null)
{
Context.Delegates.Add(method, existingDelegate);
return(true);
}
existingDelegate = new DelegateDefinition(module.OutputNamespace, delegateString);
Context.Delegates.Add(method, existingDelegate);
libsDelegates[module].Add(delegateString, existingDelegate);
namespaceDelegates.Declarations.Add(@delegate);
return(true);
}
internal TypedefDecl(TypedefDecl.Internal native)
: this(__CopyValue(native))
{
}
public CSharpTypePrinterResult VisitTypedefDecl(TypedefDecl typedef)
{
return(GetNestedQualifiedName(typedef));
}
internal TypedefDecl(TypedefDecl.Internal* native)
: this(new global::System.IntPtr(native))
{
}
public override bool VisitTypedefDecl(TypedefDecl typedef)
{
return(true);
}
public override bool VisitTypedefDecl(TypedefDecl typedef)
{
if (!VisitDeclaration(typedef))
return false;
string msg;
if (HasInvalidType(typedef.Type, out msg))
{
typedef.ExplicitlyIgnore();
Log.Debug("Typedef '{0}' was ignored due to {1} type",
typedef.Name, msg);
return false;
}
return true;
}
public override bool VisitMethodDecl(Method method)
{
if (!base.VisitMethodDecl(method) || !method.IsVirtual || method.Ignore)
{
return(false);
}
var @params = method.GatherInternalParams(Context.ParserOptions.IsItaniumLikeAbi, true).ToList();
var delegateName = GenerateDelegateSignature(@params, method.ReturnType);
var module = method.TranslationUnit.Module;
Namespace namespaceDelegates;
if (namespacesDelegates.ContainsKey(module))
{
namespaceDelegates = namespacesDelegates[module];
}
else
{
namespaceDelegates = new Namespace
{
Name = DelegatesNamespace,
Namespace = module.Units.Last()
};
namespacesDelegates.Add(module, namespaceDelegates);
}
var @delegate = new TypedefDecl
{
Name = delegateName,
QualifiedType = new QualifiedType(
new PointerType(
new QualifiedType(
new FunctionType
{
CallingConvention = method.CallingConvention,
IsDependent = method.IsDependent,
Parameters = @params,
ReturnType = method.ReturnType
}))),
Namespace = namespaceDelegates,
IsSynthetized = true
};
Generator.CurrentOutputNamespace = module.OutputNamespace;
var delegateString = @delegate.Visit(TypePrinter).Type;
var existingDelegate = GetExistingDelegate(
method.TranslationUnit.Module.Libraries, delegateString);
if (existingDelegate != null)
{
Context.Delegates.Add(method, existingDelegate);
return(true);
}
existingDelegate = new DelegateDefinition(module.OutputNamespace, delegateString);
Context.Delegates.Add(method, existingDelegate);
foreach (var library in module.Libraries)
{
libsDelegates[library].Add(delegateString, existingDelegate);
}
namespaceDelegates.Declarations.Add(@delegate);
return(true);
}
public static TypedefDecl __CreateInstance(TypedefDecl.Internal native, bool skipVTables = false)
{
return new TypedefDecl(native, skipVTables);
}
public abstract TRet VisitTypedef(TypedefDecl decl);
protected TypedefDecl(TypedefDecl.Internal* native, bool skipVTables = false)
: base((CppSharp.Parser.AST.Declaration.Internal*) null)
{
__PointerAdjustment = 0;
if (native == null)
return;
__Instance = new global::System.IntPtr(native);
}
public virtual TRet Visit(Parser.AST.Declaration decl)
{
switch (decl.Kind)
{
case DeclarationKind.TranslationUnit:
{
var _decl = new TranslationUnit(decl.__Instance);
return(VisitTranslationUnit(_decl));
}
case DeclarationKind.Namespace:
{
var _decl = new Namespace(decl.__Instance);
return(VisitNamespace(_decl));
}
case DeclarationKind.Typedef:
{
var _decl = new TypedefDecl(decl.__Instance);
return(VisitTypedef(_decl));
}
case DeclarationKind.Parameter:
{
var _decl = new Parameter(decl.__Instance);
return(VisitParameter(_decl));
}
case DeclarationKind.Function:
{
var _decl = new Function(decl.__Instance);
return(VisitFunction(_decl));
}
case DeclarationKind.Method:
{
var _decl = new Method(decl.__Instance);
return(VisitMethod(_decl));
}
case DeclarationKind.Enumeration:
{
var _decl = new Enumeration(decl.__Instance);
return(VisitEnumeration(_decl));
}
case DeclarationKind.EnumerationItem:
{
var _decl = new Enumeration.Item(decl.__Instance);
return(VisitEnumerationItem(_decl));
}
case DeclarationKind.Variable:
{
var _decl = new Variable(decl.__Instance);
return(VisitVariable(_decl));
}
case DeclarationKind.Field:
{
var _decl = new Field(decl.__Instance);
return(VisitField(_decl));
}
case DeclarationKind.AccessSpecifier:
{
var _decl = new AccessSpecifierDecl(decl.__Instance);
return(VisitAccessSpecifier(_decl));
}
case DeclarationKind.Class:
{
var _decl = new Class(decl.__Instance);
return(VisitClass(_decl));
}
case DeclarationKind.ClassTemplate:
{
var _decl = new ClassTemplate(decl.__Instance);
return(VisitClassTemplate(_decl));
}
case DeclarationKind.ClassTemplateSpecialization:
{
var _decl = new ClassTemplateSpecialization(decl.__Instance);
return(VisitClassTemplateSpecialization(_decl));
}
case DeclarationKind.ClassTemplatePartialSpecialization:
{
var _decl = new ClassTemplatePartialSpecialization(decl.__Instance);
return(VisitClassTemplatePartialSpecialization(_decl));
}
case DeclarationKind.FunctionTemplate:
{
var _decl = new FunctionTemplate(decl.__Instance);
return(VisitFunctionTemplate(_decl));
}
case DeclarationKind.MacroDefinition:
{
var _decl = new MacroDefinition(decl.__Instance);
return(VisitMacroDefinition(_decl));
}
case DeclarationKind.MacroExpansion:
{
var _decl = new MacroExpansion(decl.__Instance);
return(VisitMacroExpansion(_decl));
}
}
throw new ArgumentOutOfRangeException();
}
private static TypedefDecl.Internal* __CopyValue(TypedefDecl.Internal native)
{
var ret = Marshal.AllocHGlobal(184);
CppSharp.Parser.AST.TypedefDecl.Internal.cctor_2(ret, new global::System.IntPtr(&native));
return (TypedefDecl.Internal*) ret;
}
private Class AddInternalImplementation(Class @class)
{
var internalImpl = GetInternalImpl(@class);
var abstractMethods = GetRelevantAbstractMethods(@class);
foreach (var abstractMethod in abstractMethods)
{
var method = new Method(abstractMethod) { Namespace = internalImpl };
internalImpl.Methods.Add(method);
var @delegate = new TypedefDecl
{
Name = ASTHelpers.GetDelegateName(abstractMethod),
QualifiedType = abstractMethod.GetFunctionType(),
IgnoreFlags = abstractMethod.IgnoreFlags,
Namespace = internalImpl,
Access = AccessSpecifier.Private
};
internalImpl.Typedefs.Add(@delegate);
}
internalImpl.Layout = new ClassLayout(@class.Layout);
FillVTable(@class, abstractMethods, internalImpl);
foreach (var method in internalImpl.Methods)
{
method.IsPure = false;
method.IsOverride = true;
method.IsSynthetized = true;
}
return internalImpl;
}
protected TypedefDecl(TypedefDecl.Internal* native, bool isInternalImpl = false)
: base((CppSharp.Parser.AST.Declaration.Internal*) native)
{
}
public bool GenerateTypedef(TypedefDecl typedef)
{
if (typedef.Ignore)
return false;
FunctionType function;
if (typedef.Type.IsPointerTo(out function))
{
PushBlock(CLIBlockKind.Typedef, typedef);
GenerateDeclarationCommon(typedef);
var insideClass = typedef.Namespace is Class;
WriteLine("{0}{1};",
!insideClass ? "public " : "",
string.Format(TypePrinter.VisitDelegate(function),
typedef.Name));
PopBlock(NewLineKind.BeforeNextBlock);
return true;
}
return false;
}