Use ref-array to construct array argument

In an attempt to clarify the problem with #3.

package.json

@@ -7,11 +7,13 @@
   },
   "dependencies": {
     "ffi": "^2.2.0",
-    "ref": "^1.3.4"
+    "ref": "^1.3.4",
+    "ref-array": "^1.2.0"
   },
   "devDependencies": {
     "@types/ffi": "^0.0.19",
     "@types/node": "^7.0.5",
-    "@types/ref": "^0.0.28"
+    "@types/ref": "^0.0.28",
+    "@types/ref-array": "^0.0.28"
   }
 }

src/llvmc.ts

@@ -8,6 +8,7 @@
 
 import * as ffi from 'ffi';
 import * as ref from 'ref';
+import * as ArrayType from 'ref-array'
 import * as Struct from 'ref-struct';
 
 // Some useful types.
@@ -20,6 +21,12 @@ let voidp = ref.refType(ref.types.void);  // Pointer to an opaque LLVM value.
 let voidpp = ref.refType(voidp);  // void**, used for arrays and out-parameters.
 let void_ = ref.types.void;
 
+/**
+ * A constructor for arrays of pointers. Use this as `new PointerArray(N)` to
+ * create an array of length N.
+ */
+export const PointerArray = ArrayType(ref.refType(ref.types.void));
+
 // some structs
 // http://llvm.org/docs/doxygen/html/structLLVMOpInfoSymbol1.html
 var LLVMOpInfoSymbol1 = Struct({
@@ -250,7 +257,7 @@ export const LLVM = ffi.Library('libLLVM', {
 
   // Function types.
   // http://llvm.org/docs/doxygen/html/group__LLVMCCoreTypeFunction.html
-  'LLVMFunctionType':           [voidp, [voidp, voidpp, 'uint', 'bool']],
+  'LLVMFunctionType':           [voidp, [voidp, PointerArray, 'uint', 'bool']],
   'LLVMIsFunctionVarArg':       ['bool', [voidp]],                                      
   'LLVMGetReturnType':          [voidp, [voidp]],
   'LLVMCountParamTypes':        ['uint', [voidp]],

src/wrapped.ts

@@ -7,7 +7,7 @@
  * TypeScript class instead of an opaque pointer from the API.
  */
 
-import { LLVM } from './llvmc';
+import { LLVM, PointerArray } from './llvmc';
 
 /**
  * A base class for our wrapper classes that abstract an `LLVM*Ref` type.
@@ -237,11 +237,15 @@ export class Type extends Ref {
  */
 export class FunctionType extends Ref {
   static create(ret: Type, params: Type[], isVarArg = false) {
-    // TODO parameter types ignored currently. We need to transform the
-    // JavaScript array into a C array of pointers, and then set the length
-    // parameter to its length (instead of just 0).
-    //let paramtypes = new Buffer(params.length);
-    let paramtypes = Buffer.from(params.map(t => t.ref));
+    // Construct an array containing the parameter references.
+    let paramtypes = new PointerArray(params.length);
+    let i = 0;
+    for (let param of params) {
+      paramtypes[i] = param.ref;
+      ++i;
+    }
+
+    // Construct the function type.
     let ftref = LLVM.LLVMFunctionType(ret.ref, paramtypes, params.length, isVarArg);
     return new FunctionType(ftref);
   }