node-ctypes 1.7.0 → 1.8.0

package/lib/index.js

@@ -208,6 +208,15 @@ function sizeof(type) {
 }
 
 function alignment(type) {
+  // Instance of Structure/Union — use _structDef/_unionDef (Python: alignment(instance) works)
+  if (type instanceof Structure || type instanceof Union) {
+    const def = type._structDef || type._unionDef;
+    return def ? def.alignment : 1;
+  }
+  // SimpleCData instance — delegate to class (Python: alignment(c_int32(42)) works)
+  if (typeof type === "object" && type !== null && type.constructor && type.constructor._isSimpleCData) {
+    return alignment(type.constructor);
+  }
   // Structure/Union class
   if (typeof type === "function" && (type.prototype instanceof Structure || type.prototype instanceof Union)) {
     const def = type._structDef || type._unionDef || type._buildStruct?.() || type._buildUnion?.();
@@ -242,7 +251,7 @@ function byref(obj) {
 }
 
 function cast(ptr, targetType) {
-  return _cast(ptr, targetType, readValue, sizeof, ptrToBuffer);
+  return _cast(ptr, targetType, readValue, sizeof, ptrToBuffer, native);
 }
 
 function ptrToBuffer(address, size) {

package/lib/memory/operations.js

@@ -119,6 +119,12 @@ export function readValue(ptr, type, offset = 0, sizeof, ptrToBuffer, Structure,
     return def.toObject(tempBuf);
   }
 
+  // Struct/Union def object (has _isStructType and toObject)
+  if (typeof type === "object" && type !== null && type._isStructType && typeof type.toObject === "function") {
+    const tempBuf = ptr.subarray(offset, offset + type.size);
+    return type.toObject(tempBuf);
+  }
+
   throw new TypeError(`readValue: unsupported type ${type}`);
 }
 
@@ -211,6 +217,19 @@ export function writeValue(ptr, type, value, offset = 0, sizeof, Structure, Unio
     return def.size;
   }
 
+  // Struct/Union def object (has _isStructType and set/fromObject)
+  if (typeof type === "object" && type !== null && type._isStructType && typeof type.set === "function") {
+    const tempBuf = ptr.subarray(offset, offset + type.size);
+    if (Buffer.isBuffer(value)) {
+      value.copy(tempBuf, 0, 0, type.size);
+    } else if (typeof value === "object" && value !== null) {
+      for (const [k, v] of Object.entries(value)) {
+        type.set(tempBuf, k, v);
+      }
+    }
+    return type.size;
+  }
+
   throw new TypeError(`writeValue: unsupported type ${type}`);
 }
 

package/lib/memory/pointer.js

@@ -53,6 +53,10 @@
  * ```
  */
 export function addressOf(ptr, alloc, native) {
+  // If it's an object with _buffer (SimpleCData, Structure, Union, array proxy), use its buffer
+  if (!Buffer.isBuffer(ptr) && ptr && ptr._buffer && Buffer.isBuffer(ptr._buffer)) {
+    ptr = ptr._buffer;
+  }
   if (Buffer.isBuffer(ptr)) {
     // Get the buffer's memory address
     const tempBuf = alloc(native.POINTER_SIZE);
@@ -164,7 +168,7 @@ export function byref(obj) {
  * console.log(header.contents); // { magic: 23117, version: 1 }
  * ```
  */
-export function cast(ptr, targetType, readValue, sizeof, ptrToBuffer) {
+export function cast(ptr, targetType, readValue, sizeof, ptrToBuffer, native) {
   // Validate inputs
   if (!ptr) {
     throw new TypeError("cast() requires a non-null pointer");
@@ -173,9 +177,42 @@ export function cast(ptr, targetType, readValue, sizeof, ptrToBuffer) {
     throw new TypeError("cast() requires a target type");
   }
 
-  // PointerTypeDef — return a PointerInstance via fromAddress()
-  // Python equivalent: cast(c_void_p(addr), POINTER(MyStruct))
+  // PointerTypeDef — return a PointerInstance via fromAddress() or fromBuffer()
+  // Python equivalent: cast(c_void_p(addr), POINTER(c_int32)) — read stored address
+  // Python equivalent: cast(arr, POINTER(c_int32))  — pointer to arr's memory
+  // Python equivalent: cast(p, POINTER(c_double))   — pointer to same memory as p
   if (typeof targetType === "object" && targetType._pointerTo !== undefined) {
+    // PointerInstance — use its address/buffer (Python: cast(p, POINTER(OtherType)))
+    if (ptr && typeof ptr === "object" && typeof ptr.address === "bigint") {
+      if (ptr._buffer) {
+        return targetType.fromBuffer(ptr._buffer);
+      }
+      return targetType.fromAddress(ptr.address);
+    }
+
+    // ctypes object with _buffer — distinguish data objects from pointer-value objects
+    // Note: array proxies are Buffer.isBuffer()==true but also have ._buffer, so don't exclude Buffers
+    if (ptr && typeof ptr === "object" && ptr._buffer && Buffer.isBuffer(ptr._buffer)) {
+      // SimpleCData storing a pointer/address value (c_void_p, c_char_p, etc.)
+      // → read the stored address value from the buffer
+      if (ptr.constructor && ptr.constructor._isSimpleCData && ptr.constructor._type === native.CType.POINTER) {
+        // This is a pointer-valued SimpleCData — read address from buffer
+        const buf = ptr._buffer;
+        let addr;
+        if (buf.length >= 8) {
+          addr = buf.readBigUInt64LE(0);
+        } else if (buf.length >= 4) {
+          addr = BigInt(buf.readUInt32LE(0));
+        } else {
+          throw new TypeError("cast(): buffer too small to contain a pointer");
+        }
+        return targetType.fromAddress(addr);
+      }
+      // Array, Structure, Union — pointer to their data buffer
+      // Python: cast(arr, POINTER(c_int32)) points to arr's memory
+      return targetType.fromBuffer(ptr._buffer);
+    }
+
     let addr;
     if (typeof ptr === "bigint") {
       addr = ptr;
@@ -190,18 +227,8 @@ export function cast(ptr, targetType, readValue, sizeof, ptrToBuffer) {
       } else {
         throw new TypeError("cast(): buffer too small to contain a pointer");
       }
-    } else if (ptr && ptr._buffer) {
-      // SimpleCData instance (e.g., c_void_p)
-      const buf = ptr._buffer;
-      if (buf.length >= 8) {
-        addr = buf.readBigUInt64LE(0);
-      } else if (buf.length >= 4) {
-        addr = BigInt(buf.readUInt32LE(0));
-      } else {
-        throw new TypeError("cast(): buffer too small to contain a pointer");
-      }
     } else {
-      throw new TypeError("cast(): ptr must be a BigInt, number, Buffer, or ctypes instance");
+      throw new TypeError("cast(): ptr must be a BigInt, number, Buffer, ctypes instance, or PointerInstance");
     }
     return targetType.fromAddress(addr);
   }
@@ -320,7 +347,7 @@ export function ptrToBuffer(address, size, native) {
  */
 export function POINTER(baseType, sizeof, alloc, readValue, writeValue, c_void_p, native) {
   const baseSize = typeof baseType === "object" ? baseType.size : sizeof(baseType);
-  const typeName = typeof baseType === "object" ? "struct" : baseType._type || "unknown";
+  const typeName = typeof baseType === "object" ? "struct" : baseType._type || baseType.name || "unknown";
 
   /**
    * Helper to get buffer's memory address using native writeValue
@@ -591,13 +618,16 @@ export function pointer(obj, POINTER_fn, sizeof, alloc, readValue, writeValue, c
   } else if (obj && obj._buffer) {
     // Structure/Union instance or SimpleCData with _buffer
     targetBuffer = obj._buffer;
-    // Get the base type - use constructor for SimpleCData, _structDef for structures
+    // Get the base type for POINTER creation
     if (obj.constructor && obj.constructor._type) {
-      // SimpleCData instance - use the class itself
+      // SimpleCData instance - use the class itself (c_int32, c_double, etc.)
       baseType = obj.constructor;
+    } else if (obj._structDef) {
+      // Structure/Union instance - use the struct def object
+      // (obj.constructor is a bound function from Proxy, so we use _structDef directly)
+      baseType = obj._structDef;
     } else {
-      // Structure/Union instance
-      baseType = obj._structDef || obj.__structDef || c_void_p;
+      baseType = c_void_p;
     }
   } else {
     throw new TypeError("pointer() argument must be a ctypes instance or Buffer");

package/lib/structures/helpers/union.js

@@ -320,6 +320,12 @@ export function union(fields, sizeof, alloc, readValue, writeValue, _isStruct, _
         return field.type.wrap(buf.subarray(field.offset, field.offset + field.size));
       }
 
+      // POINTER() field — return PointerInstance
+      if (field.isPointer) {
+        const addr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(field.offset) : BigInt(buf.readUInt32LE(field.offset));
+        return field.type.fromAddress(addr);
+      }
+
       // Tipo base
       return readValue(buf, field.type, field.offset);
     },
@@ -376,6 +382,28 @@ export function union(fields, sizeof, alloc, readValue, writeValue, _isStruct, _
         return;
       }
 
+      // POINTER() field — write address
+      if (field.isPointer) {
+        let addr;
+        if (typeof value === "bigint") {
+          addr = value;
+        } else if (typeof value === "number") {
+          addr = BigInt(value);
+        } else if (value && typeof value.address === "bigint") {
+          addr = value.address;
+        } else if (Buffer.isBuffer(value)) {
+          addr = native.POINTER_SIZE === 8 ? value.readBigUInt64LE(0) : BigInt(value.readUInt32LE(0));
+        } else {
+          addr = 0n;
+        }
+        if (native.POINTER_SIZE === 8) {
+          buf.writeBigUInt64LE(addr, field.offset);
+        } else {
+          buf.writeUInt32LE(Number(addr), field.offset);
+        }
+        return;
+      }
+
       // Tipo base
       writeValue(buf, field.type, value, field.offset);
     },
@@ -429,6 +457,9 @@ export function union(fields, sizeof, alloc, readValue, writeValue, _isStruct, _
             } else if (field.isArray) {
               const wrapped = field.type.wrap(buf.subarray(0, field.size));
               return [...wrapped];
+            } else if (field.isPointer) {
+              const addr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(0) : BigInt(buf.readUInt32LE(0));
+              return field.type.fromAddress(addr);
             } else {
               return readValue(buf, field.type, 0);
             }
@@ -436,6 +467,24 @@ export function union(fields, sizeof, alloc, readValue, writeValue, _isStruct, _
           set(value) {
             if (field.isBitField) {
               _writeBitField(buf, 0, field.type, field.bitOffset, field.bitSize, value, sizeof);
+            } else if (field.isPointer) {
+              let addr;
+              if (typeof value === "bigint") {
+                addr = value;
+              } else if (typeof value === "number") {
+                addr = BigInt(value);
+              } else if (value && typeof value.address === "bigint") {
+                addr = value.address;
+              } else if (Buffer.isBuffer(value)) {
+                addr = native.POINTER_SIZE === 8 ? value.readBigUInt64LE(0) : BigInt(value.readUInt32LE(0));
+              } else {
+                addr = 0n;
+              }
+              if (native.POINTER_SIZE === 8) {
+                buf.writeBigUInt64LE(addr, 0);
+              } else {
+                buf.writeUInt32LE(Number(addr), 0);
+              }
             } else {
               writeValue(buf, field.type, value, 0);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-ctypes",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Python ctypes-like FFI for Node.js using libffi",
   "author": "Damiano Mazzella",
   "license": "MIT",