diff --git a/src/runtime/c/README.md b/src/runtime/c/README.md index be9d8d347..011ba33a3 100644 --- a/src/runtime/c/README.md +++ b/src/runtime/c/README.md @@ -2,7 +2,9 @@ ## Requirements -Required system packages (Debian/Ubuntu): +### Debian/Ubuntu + +Required system packages (`apt install ...`): ``` autoconf automake @@ -11,6 +13,11 @@ make g++ ``` +### macOS + +- Install XCode from App Store +- Install XCode command line tools: `xcode-select --install` + ## Installation Installing the runtime (puts libraries in `/usr/local/lib`): diff --git a/src/runtime/javascript/README.md b/src/runtime/javascript/README.md index 164b0f6d8..a0c4052aa 100644 --- a/src/runtime/javascript/README.md +++ b/src/runtime/javascript/README.md @@ -30,3 +30,12 @@ npm run build ``` npm run test ``` + +## Known issues + +There is a known issue with random crashes with Node 14 and 16 on macOS. See here: +- https://github.com/nodejs/node/issues/32463 +- https://github.com/node-ffi-napi/node-ffi-napi/issues/97 +- https://github.com/node-ffi-napi/ref-napi/issues/47 + +It seems to work with Node 12 on macOS, as well as on other platforms. diff --git a/src/runtime/javascript/constants.ts b/src/runtime/javascript/constants.ts new file mode 100644 index 000000000..86d471f15 --- /dev/null +++ b/src/runtime/javascript/constants.ts @@ -0,0 +1,39 @@ +// Untested! +import os from 'os' + +export const BE: boolean = os.endianness() === 'BE' + +export let WORDSIZE_BITS: number +switch (process.arch) { + case 'arm': + case 'ia32': + case 'ppc': + case 's390': + case 'x32': + WORDSIZE_BITS = 32 + break + + case 'arm64': + case 'mips': + case 'mipsel': + case 'ppc64': + case 's390x': + case 'x64': + WORDSIZE_BITS = 64 + break + + default: + throw Error(`Unknown architecture: ${process.arch}`) +} + +export const WORDSIZE_BYTES = WORDSIZE_BITS / 8 + +export let LINT_BASE: bigint + +switch (WORDSIZE_BITS) { + case 64: LINT_BASE = BigInt('10000000000000000000'); break + case 32: LINT_BASE = BigInt('1000000000'); break + case 16: LINT_BASE = BigInt('10000'); break + case 8: LINT_BASE = BigInt('100'); break + default: throw Error(`Unsupported word size: ${WORDSIZE_BITS}`) +} diff --git a/src/runtime/javascript/expr.ts b/src/runtime/javascript/expr.ts index 5b6d7b90b..663c92ae9 100644 --- a/src/runtime/javascript/expr.ts +++ b/src/runtime/javascript/expr.ts @@ -1,7 +1,13 @@ export class Type { - hypos!: Hypo[] - name!: string - exprs!: Expr[] + hypos: Hypo[] + name: string + exprs: Expr[] + + constructor (hs: Hypo[], n: string, es: Expr[]) { + this.hypos = hs + this.name = n + this.exprs = es + } } export class Hypo { @@ -11,6 +17,7 @@ export class Hypo { } export class Expr { + // TODO overload constructor (n?: number) { if (n != null) { return new ExprLit(n) @@ -24,13 +31,32 @@ export class Expr { } export class ExprAbs extends Expr { + bind_type: boolean + name: string + body: Expr + constructor (bt: boolean, n: string, b: Expr) { + super() + this.bind_type = bt + this.name = n + this.body = b + } } + export class ExprApp extends Expr { + fun: Expr + arg: Expr + constructor (f: Expr, a: Expr) { + super() + this.fun = f + this.arg = a + } } + export class ExprLit extends Expr { lit: Literal + constructor (l: Literal | number | bigint | string) { super() if (l instanceof Literal) this.lit = l @@ -41,24 +67,57 @@ export class ExprLit extends Expr { return this.lit.toString() } } + export class ExprMeta extends Expr { + id: number + constructor (i: number) { + super() + this.id = i + } } + export class ExprFun extends Expr { + name: string + constructor (n: string) { + super() + this.name = n + } } + export class ExprVar extends Expr { + var: number + constructor (v: number) { + super() + this.var = v + } } + export class ExprTyped extends Expr { + expr: Expr + type: Type + constructor (e: Expr, t: Type) { + super() + this.expr = e + this.type = t + } } -export class ExprImplArg extends Expr { +export class ExprImplArg extends Expr { + expr: Expr + + constructor (e: Expr) { + super() + this.expr = e + } } export class Literal { val: number | bigint | string + constructor (v: number | bigint | string) { this.val = v } diff --git a/src/runtime/javascript/ffi.ts b/src/runtime/javascript/ffi.ts index 89df95197..b5190a547 100644 --- a/src/runtime/javascript/ffi.ts +++ b/src/runtime/javascript/ffi.ts @@ -1,7 +1,8 @@ /* eslint-disable @typescript-eslint/naming-convention */ import { Type, - // Hypo, + Hypo, + Expr, ExprAbs, ExprApp, ExprLit, @@ -12,8 +13,8 @@ import { ExprImplArg, Literal } from './expr' +import { BE, WORDSIZE_BITS, WORDSIZE_BYTES, LINT_BASE } from './constants' -import os from 'os' import ffi from 'ffi-napi' import ref, { Pointer } from 'ref-napi' import ref_struct from 'ref-struct-di' @@ -47,7 +48,7 @@ export const PgfTextPtr = ref.refType(PgfText) export const PgfItorPtr = ref.refType(ref.types.void) -const PgfType = ref.types.void // TODO +const PgfType = ref.refType(ref.types.Object) // TODO // const PgfTypePtr = ref.refType(PgfType) const PgfTypeHypo = ref.types.void // TODO @@ -159,17 +160,24 @@ export function PgfText_FromString (str: string): Pointer { const eabs = ffi.Callback(PgfExpr, [PgfUnmarshaller, ref.types.bool, PgfTextPtr, PgfExpr], function (self, btype: boolean, name: Pointer, body: Pointer): Pointer { - return 0 as any + const jsname = PgfText_AsString(name) + const obj = new ExprAbs(btype, jsname, body) // TODO check body + const buf = ref.alloc(ref.types.Object) as Pointer + ref.writeObject(buf, 0, obj) + return buf }) const eapp = ffi.Callback(PgfExpr, [PgfUnmarshaller, PgfExpr, PgfExpr], - function (self, fun: Pointer, arg: Pointer): Pointer { - return 0 as any + function (self, fun: Pointer, arg: Pointer): Pointer { + const obj = new ExprApp(fun, arg) // TODO check + const buf = ref.alloc(ref.types.Object) as Pointer + ref.writeObject(buf, 0, obj) + return buf }) const elit = ffi.Callback(PgfExpr, [PgfUnmarshaller, PgfLiteral], - function (self, lit: Pointer): Pointer { - const litObj = lit.deref() as Literal + function (self, lit: Pointer): Pointer { + const litObj = lit.deref() const obj = new ExprLit(litObj) const buf = ref.alloc(ref.types.Object) as Pointer ref.writeObject(buf, 0, obj) @@ -177,35 +185,46 @@ const elit = ffi.Callback(PgfExpr, [PgfUnmarshaller, PgfLiteral], }) const emeta = ffi.Callback(PgfExpr, [PgfUnmarshaller, PgfMetaId], - function (self, meta: Pointer): Pointer { - return 0 as any + function (self, meta: number): Pointer { + const obj = new ExprMeta(meta) + const buf = ref.alloc(ref.types.Object) as Pointer + ref.writeObject(buf, 0, obj) + return buf }) const efun = ffi.Callback(PgfExpr, [PgfUnmarshaller, PgfTextPtr], function (self, name: Pointer): Pointer { - return 0 as any + const jsname = PgfText_AsString(name) + const obj = new ExprFun(jsname) + const buf = ref.alloc(ref.types.Object) as Pointer + ref.writeObject(buf, 0, obj) + return buf }) const evar = ffi.Callback(PgfExpr, [PgfUnmarshaller, ref.types.int], function (self, index: number): Pointer { - return 0 as any + const obj = new ExprVar(index) + const buf = ref.alloc(ref.types.Object) as Pointer + ref.writeObject(buf, 0, obj) + return buf }) const etyped = ffi.Callback(PgfExpr, [PgfUnmarshaller, PgfExpr, PgfType], - function (self, expr: Pointer, type: Pointer): Pointer { - return 0 as any + function (self, expr: Pointer, type: Pointer): Pointer { + const obj = new ExprTyped(expr, type.deref()) // TODO check + const buf = ref.alloc(ref.types.Object) as Pointer + ref.writeObject(buf, 0, obj) + return buf }) const eimplarg = ffi.Callback(PgfExpr, [PgfUnmarshaller, PgfExpr], - function (self, expr: Pointer): Pointer { - return 0 as any + function (self, expr: Pointer): Pointer { + const obj = new ExprImplArg(expr) // TODO check + const buf = ref.alloc(ref.types.Object) as Pointer + ref.writeObject(buf, 0, obj) + return buf }) -// TODO get from platform/runtime -const WORDSIZE_BITS = 64 -const WORDSIZE_BYTES = WORDSIZE_BITS / 8 -const LINT_BASE = BigInt('10000000000000000000') - const lint = ffi.Callback(PgfLiteral, [PgfUnmarshaller, ref.types.size_t, ref.refType(ref.types.int)], function (self, size: number, val: Pointer): Pointer { let jsval: number | bigint = 0 @@ -219,7 +238,17 @@ const lint = ffi.Callback(PgfLiteral, [PgfUnmarshaller, ref.types.size_t, ref.re let thisval switch (WORDSIZE_BITS) { case 64: - thisval = BigInt((os.endianness() === 'LE') ? vals.readUInt64LE(n * WORDSIZE_BYTES) : vals.readUInt64BE(n * WORDSIZE_BYTES)) + thisval = BigInt(BE ? vals.readUInt64BE(n * WORDSIZE_BYTES) : vals.readUInt64LE(n * WORDSIZE_BYTES)) + break + case 32: + thisval = BigInt(BE ? vals.readUInt32BE(n * WORDSIZE_BYTES) : vals.readUInt32LE(n * WORDSIZE_BYTES)) + break + case 16: + thisval = BigInt(BE ? vals.readUInt16BE(n * WORDSIZE_BYTES) : vals.readUInt16LE(n * WORDSIZE_BYTES)) + break + case 8: + thisval = BigInt(vals.readUInt8(n * WORDSIZE_BYTES)) + break } if (thisval == null) { throw Error(`Unsupported word size: ${WORDSIZE_BITS}`) @@ -253,7 +282,14 @@ const lstr = ffi.Callback(PgfLiteral, [PgfUnmarshaller, PgfTextPtr], const dtyp = ffi.Callback(PgfType, [PgfUnmarshaller, ref.types.int, PgfTypeHypoPtr, PgfTextPtr, ref.types.int, ref.refType(PgfExpr)], function (self, n_hypos: number, hypos: Pointer, cat: Pointer, n_exprs: number, exprs: Pointer): Pointer { - return 0 as any + // TODO + const jshypos: Hypo[] = [] + const jsname = PgfText_AsString(cat) + const jsexprs: Expr[] = [] + const obj = new Type(jshypos, jsname, jsexprs) + const buf = ref.alloc(ref.types.Object) as Pointer + ref.writeObject(buf, 0, obj) + return buf }) const free_ref = ffi.Callback(ref.types.void, [PgfUnmarshaller, ref.refType(ref.types.Object)],