node-ctypes 0.1.4 → 0.1.5

package/README.md

@@ -94,7 +94,10 @@ print(p.x, p.y)  # 10 20
 import { CDLL, c_int, Structure } from 'node-ctypes';
 
 // Traditional syntax (always available)
-const libc = new CDLL("libc.so.6");
+const libc = new CDLL("libc.so.6"); // Linux
+// const libc = new CDLL('msvcrt.dll');  // Windows
+// const libc = new CDLL('libc.dylib');  // macOS
+
 const abs = libc.func("abs", c_int, [c_int]);
 console.log(abs(-42));  // 42
 
@@ -142,7 +145,10 @@ const strlen = libc.func('strlen', c_size_t, [c_char_p]);
 console.log(strlen('Hello'));  // 5n (BigInt)
 
 // Load libm for math functions
-const libm = new CDLL('libm.so.6');
+const libm = new CDLL('libm.so.6'); // Linux
+// const libb = new CDLL('ucrtbase.dll'); // Windows
+// const libm = new CDLL('libm.dylib'); // macOS
+
 const sqrt = libm.func('sqrt', c_double, [c_double]);
 console.log(sqrt(16.0));  // 4.0
 ```
@@ -271,7 +277,7 @@ const pkt = new Packet({
     data: new Array(256).fill(0)
 });
 
-console.log(pkt.header);  // [1, 2, 3, 4, 5, 6, 7, 8]
+console.log(pkt.header.toString());  // [1, 2, 3, 4, 5, 6, 7, 8]
 ```
 
 ### Complex Nested Structures
@@ -332,6 +338,7 @@ console.log(img.pixels[1].color.value);  // -16711936 (0xFF00FF00 as signed)
 
 // Union nested in struct - direct property access!
 img.pixels[0].color.rgb.g = 128;  // Works correctly!
+console.log(img.pixels[0].color.rgb.g);  // 128
 ```
 
 ### Callbacks - JavaScript Functions in C
@@ -349,7 +356,7 @@ const compare = callback(
         const bVal = readValue(b, c_int32);
         return aVal - bVal;
     },
-    c_int,              // return type
+    c_int32,              // return type
     [c_void_p, c_void_p]  // argument types: two pointers
 );
 
@@ -388,16 +395,16 @@ const sprintf = libc.func('sprintf', c_int, [c_void_p, c_char_p]);
 const buffer = Buffer.alloc(256);
 
 // Pass extra arguments - automatically handled as variadic
-sprintf(buffer, create_string_buffer('Hello %s!'), create_string_buffer('World'));
+sprintf(buffer, 'Hello %s!', 'World');
 console.log(string_at(buffer));  // "Hello World!"
 
-sprintf(buffer, create_string_buffer('Number: %d'), 42);
+sprintf(buffer, 'Number: %d', 42);
 console.log(string_at(buffer));  // "Number: 42"
 
-sprintf(buffer, create_string_buffer('%s: %d + %d = %d'), create_string_buffer('Sum'), 10, 20, 30);
+sprintf(buffer, '%s: %d + %d = %d', 'Sum', 10, 20, 30);
 console.log(string_at(buffer));  // "Sum: 10 + 20 = 30"
 
-sprintf(buffer, create_string_buffer('Pi ≈ %.2f'), 3.14159);
+sprintf(buffer, 'Pi ≈ %.2f', 3.14159);
 console.log(string_at(buffer));  // "Pi ≈ 3.14"
 ```
 
@@ -713,8 +720,8 @@ Base class for Python-like union definitions. Subclasses should define `static _
 | **Arrays** | `c_int * 5` | `array(c_int, 5)` |
 | **Bit fields** | `("flags", c_uint, 3)` | `bitfield(c_uint32, 3)` |
 | **Callbacks** | `CFUNCTYPE(c_int, c_int)` | `callback(fn, c_int, [c_int])` |
-| **Strings** | `c_char_p(b"hello")` | `create_string_buffer("hello")` |
-| **Pointers** | `POINTER(c_int)` | `c_void_p` or `"pointer"` |
+| **Strings** | `c_char_p(b"hello")` | `create_string_buffer("hello")`<br>**or**<br>`c_char_p(b"hello")` |
+| **Pointers** | `POINTER(c_int)` | `c_void_p` |
 | **Variadic** | `sprintf(buf, b"%d", 42)` | `sprintf(buf, fmt, 42)` (auto) |
 | **Sizeof** | `sizeof(c_int)` | `sizeof(c_int)` |
 

package/lib/index.js

@@ -454,8 +454,23 @@ function cstring(str) {
  * @returns {Buffer} Buffer con stringa wide
  */
 function wstring(str) {
-  // Converti stringa JS a UTF-16LE (che è come wchar_t su Windows)
-  const buf = Buffer.from(str + "\0", "utf16le");
+  // Crea un buffer contenente la stringa wide null-terminata
+  // Su Windows wchar_t è 2 bytes (UTF-16LE), su Unix è 4 bytes (UTF-32LE)
+  const wcharSize = native.WCHAR_SIZE;
+  if (wcharSize === 2) {
+    return Buffer.from(str + "\0", "utf16le");
+  }
+
+  // Costruisci manualmente UTF-32LE
+  const codePoints = [];
+  for (const ch of str) {
+    codePoints.push(ch.codePointAt(0));
+  }
+  const buf = Buffer.alloc((codePoints.length + 1) * 4);
+  for (let i = 0; i < codePoints.length; i++) {
+    buf.writeUInt32LE(codePoints[i], i * 4);
+  }
+  // terminatore 0 già inizializzato
   return buf;
 }
 
@@ -825,12 +840,28 @@ function union(fields) {
     let size, alignment;
     let fieldDef = { name, type, offset: 0 };
 
-    // Nested struct
+    // Nested struct (object form)
     if (_isStruct(type)) {
       size = type.size;
       alignment = type.alignment;
       fieldDef.isNested = true;
     }
+    // Struct class (declarata come `class X extends Structure`)
+    else if (typeof type === "function" && type.prototype instanceof Structure) {
+      const nested = type._structDef || type._buildStruct();
+      size = nested.size;
+      alignment = nested.alignment;
+      fieldDef.type = nested;
+      fieldDef.isNested = true;
+    }
+    // Union class (declarata come `class X extends Union`)
+    else if (typeof type === "function" && type.prototype instanceof Union) {
+      const nested = type._unionDef || type._buildUnion();
+      size = nested.size;
+      alignment = nested.alignment;
+      fieldDef.type = nested;
+      fieldDef.isNested = true;
+    }
     // Array type
     else if (_isArrayType(type)) {
       size = type.getSize();
@@ -1520,24 +1551,31 @@ class Union extends Structure {
  * console.log(arr[2]);  // 42
  */
 function array(elementType, count) {
-  // Validate elementType is a SimpleCData class
-  if (!(typeof elementType === "function" && elementType._isSimpleCData)) {
-    throw new TypeError("array elementType must be a SimpleCData class (e.g., c_int32, c_uint8)");
+  // Validate elementType: accept SimpleCData classes, Structure/Union classes,
+  // or native CType-like objects.
+  const isSimple = typeof elementType === "function" && elementType._isSimpleCData;
+  const isStruct = typeof elementType === "function" && (elementType.prototype instanceof Structure || elementType.prototype instanceof Union);
+  const isNativeTypeObj = typeof elementType === "object" && elementType !== null && (typeof elementType.getSize === "function" || elementType.size !== undefined);
+  if (!isSimple && !isStruct && !isNativeTypeObj) {
+    throw new TypeError("array elementType must be a SimpleCData class or a Structure/Union class");
   }
 
-  const elementSize = elementType._size;
+  const elementSize = sizeof(elementType);
   let nativeArray;
-  if (typeof elementType === "object") {
+  if (isNativeTypeObj) {
     nativeArray = new ArrayType(elementType, count);
   } else {
-    // For strings, create a mock
+    // Provide a small JS-side shim implementing the minimal ArrayType API
     nativeArray = {
       getSize: () => count * elementSize,
       getLength: () => count,
-      getAlignment: () => elementSize, // Approximation
+      getAlignment: () => elementSize,
       create: (values) => {
-        // Already handled in JS
-        throw new Error("Should not be called");
+        // JS create is implemented below; this should not be invoked by JS code
+        const size = count * elementSize;
+        const buffer = alloc(size);
+        buffer.fill(0);
+        return buffer;
       },
     };
   }
@@ -1567,7 +1605,13 @@ function array(elementType, count) {
         if (prop === Symbol.iterator) {
           return function* () {
             for (let i = 0; i < count; i++) {
-              yield elementType._reader(target, i * elementSize);
+              const off = i * elementSize;
+              // If elementType is a struct/union class, return an instance bound to the slice
+              if (typeof elementType === "function" && (elementType.prototype instanceof Structure || elementType.prototype instanceof Union)) {
+                yield new elementType(target.subarray(off, off + elementSize));
+              } else {
+                yield readValue(target, elementType, off);
+              }
             }
           };
         }
@@ -1585,7 +1629,11 @@ function array(elementType, count) {
         const index = Number(prop);
         if (Number.isInteger(index) && !isNaN(index)) {
           if (index >= 0 && index < count) {
-            return readValue(target, elementType, index * elementSize);
+            const off = index * elementSize;
+            if (typeof elementType === "function" && (elementType.prototype instanceof Structure || elementType.prototype instanceof Union)) {
+              return new elementType(target.subarray(off, off + elementSize));
+            }
+            return readValue(target, elementType, off);
           }
           // Indice numerico fuori bounds -> undefined (comportamento JavaScript)
           return undefined;
@@ -2066,6 +2114,66 @@ function struct(fields, options = {}) {
         maxAlignment = alignment;
       }
     }
+    // Caso 2a: Struct class (declarata come `class X extends Structure`)
+    else if (typeof type === "function" && type.prototype instanceof Structure) {
+      // Reset bit field state
+      currentBitFieldBase = null;
+      currentBitOffset = 0;
+
+      const nestedStruct = type._structDef || type._buildStruct();
+      const size = nestedStruct.size;
+      const alignment = packed ? 1 : nestedStruct.alignment;
+
+      // Applica padding per allineamento
+      if (!packed && totalSize % alignment !== 0) {
+        totalSize += alignment - (totalSize % alignment);
+      }
+
+      fieldDef = {
+        name,
+        type: nestedStruct,
+        offset: totalSize,
+        size,
+        alignment,
+        isNested: true,
+      };
+
+      totalSize += size;
+
+      if (alignment > maxAlignment) {
+        maxAlignment = alignment;
+      }
+    }
+    // Caso 2b: Union class (declarata come `class X extends Union`)
+    else if (typeof type === "function" && type.prototype instanceof Union) {
+      // Reset bit field state
+      currentBitFieldBase = null;
+      currentBitOffset = 0;
+
+      const nestedUnion = type._unionDef || type._buildUnion();
+      const size = nestedUnion.size;
+      const alignment = packed ? 1 : nestedUnion.alignment;
+
+      // Applica padding per allineamento
+      if (!packed && totalSize % alignment !== 0) {
+        totalSize += alignment - (totalSize % alignment);
+      }
+
+      fieldDef = {
+        name,
+        type: nestedUnion,
+        offset: totalSize,
+        size,
+        alignment,
+        isNested: true,
+      };
+
+      totalSize += size;
+
+      if (alignment > maxAlignment) {
+        maxAlignment = alignment;
+      }
+    }
     // Caso 2: Nested struct
     else if (_isStruct(type)) {
       // Reset bit field state
@@ -2875,7 +2983,10 @@ class c_int32 extends SimpleCData {
   static _size = 4;
   static _type = "int32";
   static _reader = (buf, off) => buf.readInt32LE(off);
-  static _writer = (buf, off, val) => buf.writeInt32LE(val, off);
+  static _writer = (buf, off, val) => {
+    const v = Number(val) | 0; // coerce to signed 32-bit
+    return buf.writeInt32LE(v, off);
+  };
 }
 
 class c_int64 extends SimpleCData {
@@ -2989,7 +3100,11 @@ class c_wchar extends SimpleCData {
 class c_void_p extends SimpleCData {
   static _size = native.POINTER_SIZE;
   static _type = "pointer";
-  static _reader = (buf, off) => (native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off)));
+  static _reader = (buf, off) => {
+    const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
+    if (!ptr) return null;
+    return ptr;
+  };
   static _writer = (buf, off, val) => {
     // Accept Buffers (pointer to memory) and struct proxies with _buffer
     if (Buffer.isBuffer(val)) {
@@ -3020,7 +3135,11 @@ class c_void_p extends SimpleCData {
 class c_size_t extends SimpleCData {
   static _size = native.POINTER_SIZE;
   static _type = "size_t";
-  static _reader = (buf, off) => (native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off)));
+  static _reader = (buf, off) => {
+    const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
+    if (!ptr) return null;
+    return ptr;
+  };
   static _writer = (buf, off, val) => {
     const v = typeof val === "bigint" ? val : BigInt(val || 0);
     if (native.POINTER_SIZE === 8) {
@@ -3058,8 +3177,15 @@ class c_ulong extends SimpleCData {
 class c_char_p extends SimpleCData {
   static _size = native.POINTER_SIZE;
   static _type = "char_p";
-  static _reader = (buf, off) => (native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off)));
+  static _reader = (buf, off) => {
+    const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
+    if (!ptr) return null;
+    return readCString(ptr);
+  };
   static _writer = (buf, off, val) => {
+    if (typeof val === "string") {
+      val = cstring(val);
+    }
     if (Buffer.isBuffer(val)) {
       const addr = addressOf(val);
       const v = typeof addr === "bigint" ? addr : BigInt(addr || 0);
@@ -3082,8 +3208,15 @@ class c_char_p extends SimpleCData {
 class c_wchar_p extends SimpleCData {
   static _size = native.POINTER_SIZE;
   static _type = "wchar_p";
-  static _reader = (buf, off) => (native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off)));
+  static _reader = (buf, off) => {
+    const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
+    if (!ptr) return null;
+    return readWString(ptr);
+  };
   static _writer = (buf, off, val) => {
+    if (typeof val === "string") {
+      val = wstring(val);
+    }
     if (Buffer.isBuffer(val)) {
       const addr = addressOf(val);
       const v = typeof addr === "bigint" ? addr : BigInt(addr || 0);

package/package.json

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