public CodeTypeReference GenerateDefinedTypeReferenceImpl(NativeDefinedType definedNt, ref string comment)
{
ThrowIfNull(definedNt);
comment += definedNt.Name;
return(new CodeTypeReference(definedNt.Name));
}
private void VerifyMembers(NativeDefinedType container, string name, params string[] args)
{
if (container.IsAnonymous)
{
Assert.True(string.IsNullOrEmpty(name));
}
else
{
Assert.Equal(name, container.Name);
}
int index = 0;
foreach (NativeMember cur in container.Members)
{
NativeDefinedType definedType = cur.NativeType as NativeDefinedType;
if (definedType != null && definedType.IsAnonymous)
{
Assert.True(string.IsNullOrEmpty(args[index]));
}
else
{
Assert.Equal(args[index], cur.NativeType.DisplayName);
}
Assert.Equal(args[index + 1], cur.Name);
index += 2;
}
}
/// <summary>
/// Generate the members of the container
/// </summary>
/// <param name="nt"></param>
/// <param name="ctd"></param>
/// <remarks></remarks>
private void GenerateContainerMembers(NativeDefinedType nt, CodeTypeDeclaration ctd)
{
ThrowIfNull(nt);
ThrowIfNull(ctd);
int bitVectorCount = 0;
for (int i = 0; i <= nt.Members.Count - 1; i++)
{
NativeMember member = nt.Members[i];
// Don't process unnamed container members
if (string.IsNullOrEmpty(member.Name))
{
continue;
}
if (IsBitVector(member.NativeType))
{
// Get the list of bitvectors that will fit into the next int
int bitCount = 0;
List <NativeMember> list = new List <NativeMember>();
NativeBitVector bitVector = null;
while ((i < nt.Members.Count && IsBitVector(nt.Members[i].NativeType, ref bitVector) && bitCount + bitVector.Size <= 32))
{
list.Add(nt.Members[i]);
i += 1;
}
i -= 1;
// Generate the int for the list of bit vectors
bitVectorCount += 1;
CodeMemberField cMember = GenerateContainerMember(new NativeMember("bitvector" + bitVectorCount, new NativeBuiltinType(BuiltinType.NativeInt32, true)), ctd);
cMember.Comments.Clear();
CodeComment comment = new CodeComment(string.Empty, true);
int offset = 0;
for (int j = 0; j <= list.Count - 1; j++)
{
if (j > 0)
{
comment.Text += Environment.NewLine;
}
IsBitVector(list[j].NativeType, ref bitVector);
comment.Text += list[j].Name + " : " + bitVector.Size;
GenerateBitVectorProperty(list[j], offset, ctd, cMember);
offset += bitVector.Size;
}
cMember.Comments.Add(new CodeCommentStatement(comment));
}
else
{
GenerateContainerMember(member, ctd);
}
}
}
public CodeTypeDeclarationCollection ConvertToCodeDom(NativeDefinedType definedNt, ErrorProvider ep)
{
NativeSymbolBag bag = new NativeSymbolBag(_storage);
bag.AddDefinedType(definedNt);
return(ConvertBagToCodeDom(bag, ep));
}
public string ConvertToPInvokeCode(NativeDefinedType definedNt)
{
ErrorProvider ep = new ErrorProvider();
CodeTypeDeclarationCollection col = ConvertToCodeDom(definedNt, ep);
return(ConvertCodeDomToPInvokeCodeImpl(col, ep));
}
/// <summary>
/// Run all of the marshaling hueristiscs on the type and it's members
/// </summary>
/// <param name="ctd"></param>
/// <remarks></remarks>
public void Process(CodeTypeDeclaration ctd)
{
// First check and see if it is a delegate type, if so run the delegate hueristics
CodeTypeDelegate ctdDel = ctd as CodeTypeDelegate;
if (ctdDel != null && ctdDel.UserData.Contains(TransformConstants.DefinedType))
{
ProcessDelegate(ctdDel);
return;
}
// Now run the hueristics over the actual members of the type
if (ctd.UserData.Contains(TransformConstants.DefinedType))
{
NativeDefinedType nt = ctd.UserData[TransformConstants.DefinedType] as NativeDefinedType;
if (nt != null)
{
switch (nt.Kind)
{
case NativeSymbolKind.StructType:
ProcessStruct(ctd);
break;
case NativeSymbolKind.UnionType:
RunPluginUnionMembers(ctd);
break;
case NativeSymbolKind.EnumType:
RunPluginEnumMembers(ctd);
break;
}
}
}
// Now process the methods on the type. First step is to convert all of them into
// best PInvoke signature. Then create wrapper methods for them
CodeTypeMemberCollection col = new CodeTypeMemberCollection(ctd.Members);
List <CodeMemberMethod> list = new List <CodeMemberMethod>();
foreach (CodeTypeMember mem in col)
{
// Look at procedures
CodeMemberMethod codeProc = mem as CodeMemberMethod;
if (codeProc != null && codeProc.UserData.Contains(TransformConstants.Procedure))
{
list.Add(codeProc);
}
}
foreach (CodeMemberMethod codeProc in list)
{
ProcessParameters(codeProc);
ProcessReturnType(codeProc);
}
foreach (CodeMemberMethod codeProc in list)
{
ProcessWrapperMethods(ctd, codeProc);
}
}
public void PerformRename(CodeTypeDeclarationCollection col)
{
if (col == null)
{
throw new ArgumentNullException("col");
}
Dictionary <string, string> map = new Dictionary <string, string>(StringComparer.Ordinal);
map.Add("tagPOINT", "Point");
CodeDomIterator it = new CodeDomIterator();
List <object> list = it.Iterate(col);
// Use the iterator so we make sure to reach nested types
foreach (CodeTypeDeclaration ctd in FindUnmodifiedTypes(list))
{
NativeDefinedType definedNt = GetDefined(ctd);
if (IsBadName(ctd.Name))
{
foreach (NativeTypeDef possible in FindTypeDefsTargeting(definedNt))
{
if (!IsBadName(possible.Name))
{
map[ctd.Name] = possible.Name;
}
}
}
}
SmartTypeRename(map, list);
ResetCustomExpressions(list);
}
public void SaveAndLoad6()
{
NativeFunctionPointer fptr = new NativeFunctionPointer("f1");
Assert.Equal(NativeCallingConvention.WinApi, fptr.CallingConvention);
fptr.CallingConvention = NativeCallingConvention.Pascal;
fptr.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
NativeProcedure proc = new NativeProcedure("p1");
Assert.Equal(NativeCallingConvention.WinApi, proc.CallingConvention);
proc.CallingConvention = NativeCallingConvention.CDeclaration;
proc.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
var ns = new BasicSymbolStorage();
ns.AddProcedure(proc);
ns.AddDefinedType(fptr);
NativeDefinedType temp = null;
NativeFunctionPointer retPtr = null;
Assert.True(ns.TryGetGlobalSymbol(fptr.Name, out temp));
retPtr = (NativeFunctionPointer)temp;
Assert.Equal(NativeCallingConvention.Pascal, retPtr.CallingConvention);
NativeProcedure retProc = null;
Assert.True(ns.TryGetGlobalSymbol(proc.Name, out retProc));
Assert.Equal(NativeCallingConvention.CDeclaration, retProc.CallingConvention);
}
public void FindOrLoad1()
{
var ns = new BasicSymbolStorage();
ns.AddDefinedType(new NativeStruct("s1"));
NativeSymbolBag bag = new NativeSymbolBag(ns);
NativeDefinedType s1 = null;
Assert.False(bag.Storage.TryGetGlobalSymbol("s1", out s1));
Assert.True(bag.TryGetGlobalSymbol("s1", out s1));
Assert.True(bag.TryGetGlobalSymbol("s1", out s1));
}
private void WriteDefined(NativeDefinedType nt)
{
Contract.Requires(nt.Kind == NativeSymbolKind.StructType || nt.Kind == NativeSymbolKind.UnionType);
_writer.WriteNameKind(nt.NameKind);
_writer.WriteString(nt.Name);
// Write out the members as a unit.
_writer.WriteInt32(nt.Members.Count);
foreach (var member in nt.Members)
{
_writer.WriteString(member.Name);
WriteTypeReference(member.NativeType);
}
}
public void ResolveLoad1()
{
var ns = new BasicSymbolStorage();
ns.AddDefinedType(new NativeStruct("s1"));
NativeSymbolBag bag = new NativeSymbolBag(ns);
bag.AddTypeDef(new NativeTypeDef("S1", "s1"));
Assert.True(bag.TryResolveSymbolsAndValues());
NativeDefinedType td = null;
Assert.True(bag.TryGetGlobalSymbol("s1", out td));
}
/// <summary>
/// Make sure that any NativeDefinedType referenced is in the bag. That way if we
/// have structures which point to other NativeDefinedType instances, they are automagically
/// put into the bag
/// </summary>
/// <param name="bag"></param>
/// <remarks></remarks>
private void ChaseReferencedDefinedTypes(NativeSymbolBag bag)
{
bag.TryResolveSymbolsAndValues();
foreach (NativeSymbol sym in bag.FindAllReachableNativeSymbols())
{
if (NativeSymbolCategory.Defined == sym.Category)
{
NativeDefinedType defined = null;
if (!bag.TryGetGlobalSymbol(sym.Name, out defined))
{
bag.AddDefinedType((NativeDefinedType)sym);
}
}
}
}
public void FuncPtr1()
{
NativeFunctionPointer fptr = new NativeFunctionPointer("f1");
fptr.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
fptr.Signature.Parameters.Add(new NativeParameter("f", new NativeBuiltinType(BuiltinType.NativeFloat)));
var ns = new BasicSymbolStorage();
ns.AddDefinedType(fptr);
NativeDefinedType retFptr = null;
Assert.True(ns.TryGetGlobalSymbol(fptr.Name, out retFptr));
Assert.Equal("char (*f1)(float f)", ((NativeFunctionPointer)retFptr).DisplayName);
}
private bool EqualsRecursive(NativeType left, NativeType right)
{
// Quick sanity check
if (!EqualsTopLevel(left, right))
{
return(false);
}
NativeSymbolIterator it = new NativeSymbolIterator();
Dictionary <string, NativeDefinedType> leftMap = new Dictionary <string, NativeDefinedType>();
Dictionary <string, NativeDefinedType> rightMap = new Dictionary <string, NativeDefinedType>();
foreach (NativeDefinedType nt in it.FindAllReachableDefinedTypes(left))
{
if (!leftMap.ContainsKey(nt.Name))
{
leftMap.Add(nt.Name, nt);
}
}
foreach (NativeDefinedType nt in it.FindAllReachableDefinedTypes(right))
{
if (!rightMap.ContainsKey(nt.Name))
{
rightMap.Add(nt.Name, nt);
}
}
if (leftMap.Count != rightMap.Count)
{
return(false);
}
foreach (NativeDefinedType leftDefined in leftMap.Values)
{
NativeDefinedType rightDefined = null;
if (!rightMap.TryGetValue(leftDefined.Name, out rightDefined) || !EqualsTopLevel(leftDefined, rightDefined))
{
return(false);
}
}
return(true);
}
private List <CodeTypeDeclaration> FindUnmodifiedTypes(List <object> col)
{
List <CodeTypeDeclaration> list = new List <CodeTypeDeclaration>();
// Use the iterator so we make sure to reach nested types
foreach (object obj in col)
{
CodeTypeDeclaration ctd = obj as CodeTypeDeclaration;
if (ctd != null)
{
NativeDefinedType definedNt = GetDefined(ctd);
if (definedNt != null && 0 == string.CompareOrdinal(definedNt.Name, ctd.Name))
{
list.Add(ctd);
}
}
}
return(list);
}
internal SyntaxNode GenerateDeclaration(NativeDefinedType decl)
{
switch (decl.Kind)
{
case NativeSymbolKind.StructType:
return(GenerateStruct((NativeStruct)decl));
case NativeSymbolKind.UnionType:
return(GenerateUnion((NativeUnion)decl));
case NativeSymbolKind.EnumType:
return(GenerateEnum((NativeEnum)decl));
case NativeSymbolKind.FunctionPointer:
return(GenerateFunctionPointer((NativeFunctionPointer)decl));
default:
throw Contract.InvalidEnum(decl.Kind);
}
}
public void SaveAndLoad1()
{
NativeStruct s1 = new NativeStruct("s1");
s1.Members.Add(new NativeMember("m1", new NativeBuiltinType(BuiltinType.NativeFloat)));
NativeStruct s2 = new NativeStruct("s2");
s2.Members.Add(new NativeMember("m1", s1));
var ns = new BasicSymbolStorage();
ns.AddDefinedType(s2);
NativeDefinedType rets2 = null;
Assert.True(ns.TryGetGlobalSymbol(s2.Name, out rets2));
Assert.NotNull(rets2);
Assert.True(NativeTypeEqualityComparer.AreEqualRecursive(s2, rets2));
Assert.True(NativeTypeEqualityComparer.AreEqualTopLevel(s2, rets2));
}
/// <summary>
/// Top level takes a very shallow look at the type. When it encounters a nested defined type, it will only compare the
/// name's. In that case NativeNamedType instances and NativeDefinedType instances will compare true if they match on name
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
/// <remarks></remarks>
private bool EqualsTopLevel(NativeType left, NativeType right)
{
left = DigThroughNamedType(left);
right = DigThroughNamedType(right);
if (left.Kind != right.Kind)
{
return(false);
}
if (!EqualsCore(left, right))
{
return(false);
}
// If this is a defined type then make sure the members compare
if (left.Category == NativeSymbolCategory.Defined)
{
NativeDefinedType leftDefined = (NativeDefinedType)left;
NativeDefinedType rightDefined = (NativeDefinedType)right;
if (leftDefined.Members.Count != rightDefined.Members.Count)
{
return(false);
}
for (int i = 0; i <= leftDefined.Members.Count - 1; i++)
{
NativeMember leftMember = leftDefined.Members[i];
NativeMember rightMember = rightDefined.Members[i];
if (0 != string.CompareOrdinal(leftMember.Name, rightMember.Name) || !EqualsCore(leftMember.NativeType, rightMember.NativeType))
{
return(false);
}
}
}
return(true);
}
private void VerifyReachable(NativeType nt, params string[] names)
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeDefinedType definedNt = nt as NativeDefinedType;
NativeTypeDef typedefNt = nt as NativeTypeDef;
if (definedNt != null)
{
bag.AddDefinedType((NativeDefinedType)nt);
}
else if (typedefNt != null)
{
bag.AddTypeDef((NativeTypeDef)nt);
}
else
{
throw new Exception("Not a searchable type");
}
VerifyReachable(bag, names);
}
public static void Main(string[] args)
{
NativeStorage ns = NativeStorage.LoadFromAssemblyPath;
NativeSymbolBag bag = new NativeSymbolBag(ns);
NativeProcedure ntProc = null;
bag.TryFindOrLoadProcedure("FindFirstFileW", ntProc);
bag.TryFindOrLoadProcedure("FindNextFileW", ntProc);
bag.TryFindOrLoadProcedure("FindClose", ntProc);
bag.TryFindOrLoadProcedure("GetSystemDirectoryW", ntProc);
bag.TryFindOrLoadProcedure("GetWindowTextW", ntProc);
bag.TryFindOrLoadProcedure("EnumWindows", ntProc);
bag.TryFindOrLoadProcedure("GetComputerNameW", ntProc);
bag.TryFindOrLoadProcedure("CreateWellKnownSid", ntProc);
bag.TryFindOrLoadProcedure("CopySid", ntProc);
bag.TryFindOrLoadProcedure("IsEqualSid", ntProc);
bag.TryFindOrLoadProcedure("SHGetFileInfoW", ntProc);
bag.TryFindOrLoadProcedure("GetEnvironmentVariableW", ntProc);
bag.TryFindOrLoadProcedure("atoi", ntProc);
NativeDefinedType ntDefined = null;
NativeTypeDef ntTypedef = null;
bag.TryFindOrLoadDefinedType("WNDPROC", ntDefined);
bag.TryFindOrLoadDefinedType("WNDENUMPROC", ntDefined);
bag.TryFindOrLoadDefinedType("COMSTAT", ntDefined);
bag.TryFindOrLoadDefinedType("_DCB", ntDefined);
bag.TryFindOrLoadDefinedType("_IMAGE_LINENUMBER", ntDefined);
BasicConverter convert = new BasicConverter(LanguageType.VisualBasic, ns);
string code = convert.ConvertToPInvokeCode(bag);
code = "' Generated File ... Re-Run PInvokeTestGen to regenerate this file" + Constants.vbCrLf + "Namespace Generated" + Constants.vbCrLf + code + Constants.vbCrLf + "End Namespace";
IO.File.WriteAllText(args(0), code);
}
public void Proc4()
{
NativeStruct s1 = new NativeStruct("s1");
s1.Members.Add(new NativeMember("m1", new NativeBuiltinType(BuiltinType.NativeByte)));
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = s1;
var ns = new BasicSymbolStorage();
ns.AddProcedure(p1);
NativeProcedure retp1 = null;
Assert.True(ns.TryGetGlobalSymbol(p1.Name, out retp1));
Assert.Equal(p1.DisplayName, retp1.DisplayName);
NativeDefinedType rets1 = null;
Assert.False(ns.TryGetGlobalSymbol(s1.Name, out rets1));
}
/// <summary>
/// Convert the defined type into a CodeTypeDeclaration
/// </summary>
/// <param name="nt"></param>
/// <returns></returns>
/// <remarks></remarks>
public CodeTypeDeclaration GenerateDeclaration(NativeDefinedType nt)
{
if (nt == null)
{
throw new ArgumentNullException("nt");
}
CodeTypeDeclaration ctd = default(CodeTypeDeclaration);
switch (nt.Kind)
{
case NativeSymbolKind.StructType:
ctd = GenerateStruct((NativeStruct)nt);
break;
case NativeSymbolKind.UnionType:
ctd = GenerateUnion((NativeUnion)nt);
break;
case NativeSymbolKind.EnumType:
ctd = GenerateEnum((NativeEnum)nt);
break;
case NativeSymbolKind.FunctionPointer:
ctd = GenerateDelegate((NativeFunctionPointer)nt);
break;
default:
Contract.ThrowInvalidEnumValue(nt.Kind);
return(null);
}
ThrowIfFalse(ctd.UserData.Contains(TransformConstants.DefinedType));
ctd.UserData[TransformConstants.Type] = nt;
return(ctd);
}
private bool EqualsDefinedCore(NativeDefinedType left, NativeDefinedType right)
{
if (left.IsAnonymous && right.IsAnonymous)
{
// don't compare names when both types are anonymous
}
else if (0 != string.CompareOrdinal(left.Name, right.Name))
{
return(false);
}
// If this is an enum, compare the values
if (left.Kind == NativeSymbolKind.EnumType)
{
NativeEnum leftEnum = (NativeEnum)left;
NativeEnum rightEnum = (NativeEnum)right;
if (rightEnum.Values.Count != leftEnum.Values.Count)
{
return(false);
}
for (int i = 0; i <= leftEnum.Values.Count - 1; i++)
{
NativeEnumValue e1 = leftEnum.Values[i];
NativeEnumValue e2 = rightEnum.Values[i];
if (0 != string.CompareOrdinal(e1.Name, e2.Name) || 0 != string.CompareOrdinal(e1.Value.Expression, e2.Value.Expression))
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Inspect the type name and determine if there is a better name for it
/// </summary>
/// <param name="definedNt"></param>
/// <remarks></remarks>
public void RunTypeNameHeuristics(NativeDefinedType definedNt)
{
ThrowIfNull(definedNt);
}
public NativeGlobalSymbol(NativeDefinedType definedType) : this(definedType.NativeName, definedType)
{
}
public static void AddDefinedType(this INativeSymbolStorage storage, NativeDefinedType definedType) => storage.Add(new NativeGlobalSymbol(definedType));
