(#354) VoidPtr, FuncPtr

ForNeVeR · Feb 17, 2023 · 7c73251 · 7c73251
1 parent 8ed11c6
commit 7c73251
Show file tree

Hide file tree

Showing 5 changed files with 18 additions and 14 deletions.
diff --git a/Cesium.Runtime.Tests/PtrTests.cs b/Cesium.Runtime.Tests/PtrTests.cs
@@ -3,14 +3,18 @@ namespace Cesium.Runtime.Tests;
 public unsafe class PtrTests
 {
     [Fact]
-    public void CPtrTests()
+    public void VoidPtrTests()
     {
-        CPtr v = (void*)0x1234;
+        VoidPtr v = (void*)0x1234;
         Assert.Equal(0x1234L, (long)v.AsPtr());
         Assert.Equal(0x1234L, (long)v.AsPtr<byte>());
 
-        Assert.Equal(sizeof(long), sizeof(CPtr));
+        Assert.Equal(sizeof(long), sizeof(VoidPtr));
+    }
 
+    [Fact]
+    public void CPtrTests()
+    {
         CPtr<int> t = (int*)0x2345;
         Assert.Equal(0x2345L, (long)t.AsPtr());
         Assert.Equal((IntPtr)0x2345, t.AsIntPtr());
@@ -20,10 +24,10 @@ public void CPtrTests()
     }
 
     [Fact]
-    public void FPtrTests()
+    public void FuncPtrTests()
     {
-        var a = new FPtr<Action>((void*)0x1234);
+        var a = new FuncPtr<Action>((void*)0x1234);
         Assert.Equal(0x1234L, (long)a.AsPtr());
-        Assert.Equal(sizeof(long), sizeof(FPtr<Action>));
+        Assert.Equal(sizeof(long), sizeof(FuncPtr<Action>));
     }
 }
diff --git a/Cesium.Runtime/FPtr.cs → Cesium.Runtime/FuncPtr.cs b/Cesium.Runtime/FPtr.cs → Cesium.Runtime/FuncPtr.cs
@@ -1,11 +1,11 @@
 namespace Cesium.Runtime;
 
 /// <summary>A class encapsulating a C function pointer.</summary>
-public readonly unsafe struct FPtr<TDelegate> where TDelegate : Delegate // TODO: Think about vararg and empty parameter list encoding.
+public readonly unsafe struct FuncPtr<TDelegate> where TDelegate : Delegate // TODO: Think about vararg and empty parameter list encoding.
 {
     private readonly long _value;
 
-    public FPtr(void* ptr)
+    public FuncPtr(void* ptr)
     {
         _value = (long)ptr;
     }

diff --git a/Cesium.Runtime/StdIoFunctions.cs b/Cesium.Runtime/StdIoFunctions.cs
@@ -19,7 +19,7 @@ public static void PutS(CPtr<byte> str)
         }
     }
 
-    public static int PrintF(CPtr<byte> str, CPtr varargs)
+    public static int PrintF(CPtr<byte> str, VoidPtr varargs)
     {
         var formatString = RuntimeHelpers.Unmarshal(str.AsPtr());
         if (formatString == null)

diff --git a/Cesium.Runtime/CPtr.cs → Cesium.Runtime/VoidPtr.cs b/Cesium.Runtime/CPtr.cs → Cesium.Runtime/VoidPtr.cs
@@ -1,16 +1,16 @@
 namespace Cesium.Runtime;
 
 /// <summary>A class encapsulating an opaque pointer (aka <code>void*</code> in C).</summary>
-public readonly unsafe struct CPtr
+public readonly unsafe struct VoidPtr
 {
     private readonly long _value;
 
-    private CPtr(long value)
+    private VoidPtr(long value)
     {
         _value = value;
     }
 
-    public static implicit operator CPtr(void* ptr) => new((long)ptr);
+    public static implicit operator VoidPtr(void* ptr) => new((long)ptr);
     public void* AsPtr() => (void*)_value;
     public TResult* AsPtr<TResult>() where TResult : unmanaged => (TResult*)_value;
     public IntPtr AsIntPtr() => (IntPtr)AsPtr();

diff --git a/docs/type-system.md b/docs/type-system.md
@@ -33,8 +33,8 @@ The **wide** architecture set supports mapping to raw pointers as well, but also
 
 | C type                                                 | CLI Type                 |
 |--------------------------------------------------------|--------------------------|
-| `void*`                                                | `Cesium.Runtime.CPtr`    |
-| Function pointer                                       | `Cesium.Runtime.FPtr`    |
+| `void*`                                                | `Cesium.Runtime.VoidPtr` |
+| Function pointer                                       | `Cesium.Runtime.FuncPtr` |
 | `T*` (where `T` is not `void` and not a function type) | `Cesium.Runtime.CPtr<T>` |
 
 Note that function and function pointer signatures still use raw pointers even in the **wide** architecture set, because this has no effect on memory requirement and alignment, and thus type safety is preferred by default.