Merging the Extensions and Wrappers folders

dotnet · Nov 23, 2019 · 163326a · 163326a
1 parent 0c1f271
commit 163326a
Show file tree

Hide file tree

Showing 156 changed files with 496 additions and 732 deletions.
diff --git a/sources/LLVMSharp/Extensions/LLVMMemoryBufferRef.cs b/sources/LLVMSharp/Extensions/LLVMMemoryBufferRef.cs
diff --git a/sources/LLVMSharp/Extensions/LLVMTargetLibraryInfoRef.cs b/sources/LLVMSharp/Extensions/LLVMTargetLibraryInfoRef.cs
diff --git a/sources/LLVMSharp/Extensions/LLVMTargetMachineRef.cs b/sources/LLVMSharp/Extensions/LLVMTargetMachineRef.cs
diff --git a/.../LLVMSharp/Extensions/LLVMAttributeRef.cs → ...rp/Interop.Extensions/LLVMAttributeRef.cs b/.../LLVMSharp/Extensions/LLVMAttributeRef.cs → ...rp/Interop.Extensions/LLVMAttributeRef.cs
@@ -4,8 +4,25 @@
 
 namespace LLVMSharp
 {
-    public partial struct LLVMAttributeRef : IEquatable<LLVMAttributeRef>
+    public unsafe partial struct LLVMAttributeRef : IEquatable<LLVMAttributeRef>
     {
+        public LLVMAttributeRef(IntPtr pointer)
+        {
+            Pointer = pointer;
+        }
+
+        public IntPtr Pointer;
+
+        public static implicit operator LLVMAttributeRef(LLVMOpaqueAttributeRef* value)
+        {
+            return new LLVMAttributeRef((IntPtr)value);
+        }
+
+        public static implicit operator LLVMOpaqueAttributeRef*(LLVMAttributeRef value)
+        {
+            return (LLVMOpaqueAttributeRef*)value.Pointer;
+        }
+
         public static bool operator ==(LLVMAttributeRef left, LLVMAttributeRef right) => left.Equals(right);
 
         public static bool operator !=(LLVMAttributeRef left, LLVMAttributeRef right) => !(left == right);

diff --git a/...LLVMSharp/Extensions/LLVMBasicBlockRef.cs → ...p/Interop.Extensions/LLVMBasicBlockRef.cs b/...LLVMSharp/Extensions/LLVMBasicBlockRef.cs → ...p/Interop.Extensions/LLVMBasicBlockRef.cs
@@ -6,6 +6,33 @@ namespace LLVMSharp
 {
     public unsafe partial struct LLVMBasicBlockRef : IEquatable<LLVMBasicBlockRef>
     {
+        public LLVMBasicBlockRef(IntPtr pointer)
+        {
+            Pointer = pointer;
+        }
+
+        public IntPtr Pointer;
+
+        public static explicit operator LLVMBasicBlockRef(LLVMOpaqueValue* value)
+        {
+            return new LLVMBasicBlockRef((IntPtr)value);
+        }
+
+        public static implicit operator LLVMBasicBlockRef(LLVMOpaqueBasicBlock* value)
+        {
+            return new LLVMBasicBlockRef((IntPtr)value);
+        }
+
+        public static implicit operator LLVMOpaqueBasicBlock*(LLVMBasicBlockRef value)
+        {
+            return (LLVMOpaqueBasicBlock*)value.Pointer;
+        }
+
+        public static implicit operator LLVMOpaqueValue*(LLVMBasicBlockRef value)
+        {
+            return (LLVMOpaqueValue*)value.Pointer;
+        }
+
         public LLVMValueRef FirstInstruction => (Pointer != IntPtr.Zero) ? LLVM.GetFirstInstruction(this) : default;
 
         public LLVMValueRef LastInstruction => (Pointer != IntPtr.Zero) ? LLVM.GetLastInstruction(this) : default;
@@ -22,18 +49,18 @@ public unsafe partial struct LLVMBasicBlockRef : IEquatable<LLVMBasicBlockRef>
 
         public static bool operator !=(LLVMBasicBlockRef left, LLVMBasicBlockRef right) => !(left == right);
 
-        public override bool Equals(object obj) => obj is LLVMBasicBlockRef other && Equals(other);
-
-        public bool Equals(LLVMBasicBlockRef other) => Pointer == other.Pointer;
-
-        public override int GetHashCode() => Pointer.GetHashCode();
-
         public LLVMValueRef AsValue() => LLVM.BasicBlockAsValue(this);
 
         public void Delete() => LLVM.DeleteBasicBlock(this);
 
         public void Dump() => LLVM.DumpValue(this);
 
+        public override bool Equals(object obj) => obj is LLVMBasicBlockRef other && Equals(other);
+
+        public bool Equals(LLVMBasicBlockRef other) => Pointer == other.Pointer;
+
+        public override int GetHashCode() => Pointer.GetHashCode();
+
         public LLVMBasicBlockRef InsertBasicBlock(string Name)
         {
             using (var marshaledName = new MarshaledString(Name))

diff --git a/...es/LLVMSharp/Extensions/LLVMBuilderRef.cs → ...harp/Interop.Extensions/LLVMBuilderRef.cs b/...es/LLVMSharp/Extensions/LLVMBuilderRef.cs → ...harp/Interop.Extensions/LLVMBuilderRef.cs
@@ -6,32 +6,34 @@ namespace LLVMSharp
 {
     public unsafe partial struct LLVMBuilderRef : IDisposable, IEquatable<LLVMBuilderRef>
     {
-        public LLVMValueRef CurrentDebugLocation
+        public LLVMBuilderRef(IntPtr pointer)
         {
-            get => (Pointer != IntPtr.Zero) ? LLVM.GetCurrentDebugLocation(this) : default;
-            set => LLVM.SetCurrentDebugLocation(this, value);
+            Pointer = pointer;
         }
 
-        public LLVMBasicBlockRef InsertBlock => (Pointer != IntPtr.Zero) ? LLVM.GetInsertBlock(this) : default;
+        public IntPtr Pointer;
 
-        public static bool operator ==(LLVMBuilderRef left, LLVMBuilderRef right) => left.Equals(right);
+        public static implicit operator LLVMBuilderRef(LLVMOpaqueBuilder* Builder)
+        {
+            return new LLVMBuilderRef((IntPtr)Builder);
+        }
 
-        public static bool operator !=(LLVMBuilderRef left, LLVMBuilderRef right) => !(left == right);
+        public static implicit operator LLVMOpaqueBuilder*(LLVMBuilderRef Builder)
+        {
+            return (LLVMOpaqueBuilder*)Builder.Pointer;
+        }
 
-        public void Dispose()
+        public LLVMValueRef CurrentDebugLocation
         {
-            if (Pointer != IntPtr.Zero)
-            {
-                LLVM.DisposeBuilder(this);
-                Pointer = IntPtr.Zero;
-            }
+            get => (Pointer != IntPtr.Zero) ? LLVM.GetCurrentDebugLocation(this) : default;
+            set => LLVM.SetCurrentDebugLocation(this, value);
         }
 
-        public override bool Equals(object obj) => obj is LLVMBuilderRef other && Equals(other);
+        public LLVMBasicBlockRef InsertBlock => (Pointer != IntPtr.Zero) ? LLVM.GetInsertBlock(this) : default;
 
-        public bool Equals(LLVMBuilderRef other) => Pointer == other.Pointer;
+        public static bool operator ==(LLVMBuilderRef left, LLVMBuilderRef right) => left.Equals(right);
 
-        public override int GetHashCode() => Pointer.GetHashCode();
+        public static bool operator !=(LLVMBuilderRef left, LLVMBuilderRef right) => !(left == right);
 
         public LLVMValueRef BuildAdd(LLVMValueRef LHS, LLVMValueRef RHS, string Name = "")
         {
@@ -120,10 +122,10 @@ public LLVMValueRef BuildBitCast(LLVMValueRef Val, LLVMTypeRef DestTy, string Na
         public LLVMValueRef BuildCall(LLVMValueRef Fn, LLVMValueRef[] Args, string Name = "")
         {
             fixed (LLVMValueRef* pArgs = Args)
-            using (var marshaledName = new MarshaledString(Name))
-            {
-                return LLVM.BuildCall(this, Fn, (LLVMOpaqueValue**)pArgs, (uint)Args?.Length, marshaledName);
-            }
+                using (var marshaledName = new MarshaledString(Name))
+                {
+                    return LLVM.BuildCall(this, Fn, (LLVMOpaqueValue**)pArgs, (uint)Args?.Length, marshaledName);
+                }
         }
 
         public LLVMValueRef BuildCast(LLVMOpcode Op, LLVMValueRef Val, LLVMTypeRef DestTy, string Name = "")
@@ -692,9 +694,22 @@ public LLVMValueRef BuildZExtOrBitCast(LLVMValueRef Val, LLVMTypeRef DestTy, str
                 return LLVM.BuildZExtOrBitCast(this, Val, DestTy, marshaledName);
             }
         }
+        public void ClearInsertionPosition() => LLVM.ClearInsertionPosition(this);
 
+        public void Dispose()
+        {
+            if (Pointer != IntPtr.Zero)
+            {
+                LLVM.DisposeBuilder(this);
+                Pointer = IntPtr.Zero;
+            }
+        }
 
-        public void ClearInsertionPosition() => LLVM.ClearInsertionPosition(this);
+        public override bool Equals(object obj) => obj is LLVMBuilderRef other && Equals(other);
+
+        public bool Equals(LLVMBuilderRef other) => Pointer == other.Pointer;
+
+        public override int GetHashCode() => Pointer.GetHashCode();
 
         public void Insert(LLVMValueRef Instr) => LLVM.InsertIntoBuilder(this, Instr);
 

diff --git a/sources/LLVMSharp/Wrappers/LLVMComdatRef.cs → ...Sharp/Interop.Extensions/LLVMComdatRef.cs b/sources/LLVMSharp/Wrappers/LLVMComdatRef.cs → ...Sharp/Interop.Extensions/LLVMComdatRef.cs
diff --git a/...es/LLVMSharp/Extensions/LLVMContextRef.cs → ...harp/Interop.Extensions/LLVMContextRef.cs b/...es/LLVMSharp/Extensions/LLVMContextRef.cs → ...harp/Interop.Extensions/LLVMContextRef.cs
@@ -7,6 +7,23 @@ namespace LLVMSharp
 {
     public unsafe partial struct LLVMContextRef : IDisposable, IEquatable<LLVMContextRef>
     {
+        public LLVMContextRef(IntPtr pointer)
+        {
+            Pointer = pointer;
+        }
+
+        public IntPtr Pointer;
+
+        public static implicit operator LLVMContextRef(LLVMOpaqueContext* value)
+        {
+            return new LLVMContextRef((IntPtr)value);
+        }
+
+        public static implicit operator LLVMOpaqueContext*(LLVMContextRef value)
+        {
+            return (LLVMOpaqueContext*)value.Pointer;
+        }
+
         public static LLVMContextRef Global => LLVM.GetGlobalContext();
 
         public LLVMTypeRef DoubleType => (Pointer != IntPtr.Zero) ? LLVM.DoubleTypeInContext(this) : default;

diff --git a/...es/LLVMSharp/Wrappers/LLVMDIBuilderRef.cs → ...rp/Interop.Extensions/LLVMDIBuilderRef.cs b/...es/LLVMSharp/Wrappers/LLVMDIBuilderRef.cs → ...rp/Interop.Extensions/LLVMDIBuilderRef.cs
diff --git a/...Sharp/Extensions/LLVMDiagnosticInfoRef.cs → ...terop.Extensions/LLVMDiagnosticInfoRef.cs b/...Sharp/Extensions/LLVMDiagnosticInfoRef.cs → ...terop.Extensions/LLVMDiagnosticInfoRef.cs
@@ -4,8 +4,25 @@
 
 namespace LLVMSharp
 {
-    public partial struct LLVMDiagnosticInfoRef : IEquatable<LLVMDiagnosticInfoRef>
+    public unsafe partial struct LLVMDiagnosticInfoRef : IEquatable<LLVMDiagnosticInfoRef>
     {
+        public LLVMDiagnosticInfoRef(IntPtr pointer)
+        {
+            Pointer = pointer;
+        }
+
+        public IntPtr Pointer;
+
+        public static implicit operator LLVMDiagnosticInfoRef(LLVMOpaqueDiagnosticInfo* value)
+        {
+            return new LLVMDiagnosticInfoRef((IntPtr)value);
+        }
+
+        public static implicit operator LLVMOpaqueDiagnosticInfo*(LLVMDiagnosticInfoRef value)
+        {
+            return (LLVMOpaqueDiagnosticInfo*)value.Pointer;
+        }
+
         public static bool operator ==(LLVMDiagnosticInfoRef left, LLVMDiagnosticInfoRef right) => left.Equals(right);
 
         public static bool operator !=(LLVMDiagnosticInfoRef left, LLVMDiagnosticInfoRef right) => !(left == right);

diff --git a/...MSharp/Extensions/LLVMDisasmContextRef.cs → ...nterop.Extensions/LLVMDisasmContextRef.cs b/...MSharp/Extensions/LLVMDisasmContextRef.cs → ...nterop.Extensions/LLVMDisasmContextRef.cs
@@ -4,8 +4,25 @@
 
 namespace LLVMSharp
 {
-    public partial struct LLVMDisasmContextRef : IEquatable<LLVMDisasmContextRef>
+    public unsafe partial struct LLVMDisasmContextRef : IEquatable<LLVMDisasmContextRef>
     {
+        public LLVMDisasmContextRef(IntPtr pointer)
+        {
+            Pointer = pointer;
+        }
+
+        public IntPtr Pointer;
+
+        public static explicit operator LLVMDisasmContextRef(void* value)
+        {
+            return new LLVMDisasmContextRef((IntPtr)value);
+        }
+
+        public static implicit operator void*(LLVMDisasmContextRef value)
+        {
+            return (void*)value.Pointer;
+        }
+
         public static bool operator ==(LLVMDisasmContextRef left, LLVMDisasmContextRef right) => left.Pointer == right.Pointer;
 
         public static bool operator !=(LLVMDisasmContextRef left, LLVMDisasmContextRef right) => !(left == right);

diff --git a/sources/LLVMSharp/Wrappers/LLVMErrorRef.cs → ...MSharp/Interop.Extensions/LLVMErrorRef.cs b/sources/LLVMSharp/Wrappers/LLVMErrorRef.cs → ...MSharp/Interop.Extensions/LLVMErrorRef.cs
diff --git a/...ces/LLVMSharp/Wrappers/LLVMErrorTypeId.cs → ...arp/Interop.Extensions/LLVMErrorTypeId.cs b/...ces/LLVMSharp/Wrappers/LLVMErrorTypeId.cs → ...arp/Interop.Extensions/LLVMErrorTypeId.cs
diff --git a/...harp/Extensions/LLVMExecutionEngineRef.cs → ...erop.Extensions/LLVMExecutionEngineRef.cs b/...harp/Extensions/LLVMExecutionEngineRef.cs → ...erop.Extensions/LLVMExecutionEngineRef.cs
@@ -7,6 +7,23 @@ namespace LLVMSharp
 {
     public unsafe partial struct LLVMExecutionEngineRef : IDisposable, IEquatable<LLVMExecutionEngineRef>
     {
+        public LLVMExecutionEngineRef(IntPtr pointer)
+        {
+            Pointer = pointer;
+        }
+
+        public IntPtr Pointer;
+
+        public static implicit operator LLVMExecutionEngineRef(LLVMOpaqueExecutionEngine* value)
+        {
+            return new LLVMExecutionEngineRef((IntPtr)value);
+        }
+
+        public static implicit operator LLVMOpaqueExecutionEngine*(LLVMExecutionEngineRef value)
+        {
+            return (LLVMOpaqueExecutionEngine*)value.Pointer;
+        }
+
         public LLVMTargetDataRef TargetData => (Pointer != IntPtr.Zero) ? LLVM.GetExecutionEngineTargetData(this) : default;
 
         public LLVMTargetMachineRef TargetMachine => (Pointer != IntPtr.Zero) ? LLVM.GetExecutionEngineTargetMachine(this) : default;
@@ -17,12 +34,6 @@ public unsafe partial struct LLVMExecutionEngineRef : IDisposable, IEquatable<LL
 
         public void AddGlobalMapping(LLVMValueRef Global, IntPtr Addr) => LLVM.AddGlobalMapping(this, Global, (void*)Addr);
 
-        public override bool Equals(object obj) => obj is LLVMExecutionEngineRef other && Equals(other);
-
-        public bool Equals(LLVMExecutionEngineRef other) => Pointer == other.Pointer;
-
-        public override int GetHashCode() => Pointer.GetHashCode();
-
         public void AddModule(LLVMModuleRef M) => LLVM.AddModule(this, M);
 
         public void Dispose()
@@ -34,6 +45,10 @@ public void Dispose()
             }
         }
 
+        public override bool Equals(object obj) => obj is LLVMExecutionEngineRef other && Equals(other);
+
+        public bool Equals(LLVMExecutionEngineRef other) => Pointer == other.Pointer;
+
         public LLVMValueRef FindFunction(string Name)
         {
             if (!TryFindFunction(Name, out var Fn))
@@ -62,6 +77,8 @@ public ulong GetGlobalValueAddress(string Name)
             }
         }
 
+        public override int GetHashCode() => Pointer.GetHashCode();
+
         public IntPtr GetPointerToGlobal(LLVMValueRef Global) => (IntPtr)LLVM.GetPointerToGlobal(this, Global);
 
         public TDelegate GetPointerToGlobal<TDelegate>(LLVMValueRef Global)

diff --git a/...VMSharp/Extensions/LLVMGenericValueRef.cs → ...Interop.Extensions/LLVMGenericValueRef.cs b/...VMSharp/Extensions/LLVMGenericValueRef.cs → ...Interop.Extensions/LLVMGenericValueRef.cs
@@ -6,6 +6,23 @@ namespace LLVMSharp
 {
     public unsafe partial struct LLVMGenericValueRef : IEquatable<LLVMGenericValueRef>
     {
+        public LLVMGenericValueRef(IntPtr pointer)
+        {
+            Pointer = pointer;
+        }
+
+        public IntPtr Pointer;
+
+        public static implicit operator LLVMGenericValueRef(LLVMOpaqueGenericValue* GenericValue)
+        {
+            return new LLVMGenericValueRef((IntPtr)GenericValue);
+        }
+
+        public static implicit operator LLVMOpaqueGenericValue*(LLVMGenericValueRef GenericValue)
+        {
+            return (LLVMOpaqueGenericValue*)GenericValue.Pointer;
+        }
+
         public static bool operator ==(LLVMGenericValueRef left, LLVMGenericValueRef right) => left.Pointer == right.Pointer;
 
         public static bool operator !=(LLVMGenericValueRef left, LLVMGenericValueRef right) => !(left == right);

diff --git a/...Sharp/Wrappers/LLVMJITEventListenerRef.cs → ...rop.Extensions/LLVMJITEventListenerRef.cs b/...Sharp/Wrappers/LLVMJITEventListenerRef.cs → ...rop.Extensions/LLVMJITEventListenerRef.cs
diff --git a/...rp/Extensions/LLVMMCJITCompilerOptions.cs → ...op.Extensions/LLVMMCJITCompilerOptions.cs b/...rp/Extensions/LLVMMCJITCompilerOptions.cs → ...op.Extensions/LLVMMCJITCompilerOptions.cs