@port-labs/jq-node-bindings 0.0.1

package/deps/jq/builtin.h

@@ -0,0 +1,10 @@
+#ifndef BUILTIN_H
+#define BUILTIN_H
+
+#include "jq.h"
+#include "bytecode.h"
+#include "compile.h"
+
+int builtins_bind(jq_state *, block*);
+
+#endif

package/deps/jq/bytecode.c

@@ -0,0 +1,161 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "bytecode.h"
+#include "jv_alloc.h"
+
+// flags, length
+#define NONE 0, 1
+#define CONSTANT OP_HAS_CONSTANT, 2
+#define VARIABLE (OP_HAS_VARIABLE | OP_HAS_BINDING), 3
+#define GLOBAL (OP_HAS_CONSTANT | OP_HAS_VARIABLE | OP_HAS_BINDING | OP_IS_CALL_PSEUDO), 4
+#define BRANCH OP_HAS_BRANCH, 2
+#define CFUNC (OP_HAS_CFUNC | OP_HAS_BINDING), 3
+#define UFUNC (OP_HAS_UFUNC | OP_HAS_BINDING | OP_IS_CALL_PSEUDO), 4
+#define DEFINITION (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
+#define CLOSURE_REF_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
+
+#define OP(name, imm, in, out) \
+  {name, #name, imm, in, out},
+
+static const struct opcode_description opcode_descriptions[] = {
+#include "opcode_list.h"
+};
+
+static const struct opcode_description invalid_opcode_description = {
+  -1, "#INVALID", 0, 0, 0, 0
+};
+
+
+const struct opcode_description* opcode_describe(opcode op) {
+  if ((int)op >= 0 && (int)op < NUM_OPCODES) {
+    return &opcode_descriptions[op];
+  } else {
+    return &invalid_opcode_description;
+  }
+}
+
+
+int bytecode_operation_length(uint16_t* codeptr) {
+  int length = opcode_describe(*codeptr)->length;
+  if (*codeptr == CALL_JQ || *codeptr == TAIL_CALL_JQ) {
+    length += codeptr[1] * 2;
+  }
+  return length;
+}
+
+static void dump_code(int indent, struct bytecode* bc) {
+  int pc = 0;
+  while (pc < bc->codelen) {
+    printf("%*s", indent, "");
+    dump_operation(bc, bc->code + pc);
+    printf("\n");
+    pc += bytecode_operation_length(bc->code + pc);
+  }
+}
+
+static void symbol_table_free(struct symbol_table* syms) {
+  jv_mem_free(syms->cfunctions);
+  jv_free(syms->cfunc_names);
+  jv_mem_free(syms);
+}
+
+void dump_disassembly(int indent, struct bytecode* bc) {
+  if (bc->nclosures > 0) {
+    printf("%*s[params: ", indent, "");
+    jv params = jv_object_get(jv_copy(bc->debuginfo), jv_string("params"));
+    for (int i=0; i<bc->nclosures; i++) {
+      if (i) printf(", ");
+      jv name = jv_array_get(jv_copy(params), i);
+      printf("%s", jv_string_value(name));
+      jv_free(name);
+    }
+    jv_free(params);
+    printf("]\n");
+  }
+  dump_code(indent, bc);
+  for (int i=0; i<bc->nsubfunctions; i++) {
+    struct bytecode* subfn = bc->subfunctions[i];
+    jv name = jv_object_get(jv_copy(subfn->debuginfo), jv_string("name"));
+    printf("%*s%s:%d:\n", indent, "", jv_string_value(name), i);
+    jv_free(name);
+    dump_disassembly(indent+2, subfn);
+  }
+}
+
+static struct bytecode* getlevel(struct bytecode* bc, int level) {
+  while (level > 0) {
+    bc = bc->parent;
+    level--;
+  }
+  return bc;
+}
+
+void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
+  int pc = codeptr - bc->code;
+  printf("%04d ", pc);
+  const struct opcode_description* op = opcode_describe(bc->code[pc++]);
+  printf("%s", op->name);
+  if (op->length > 1) {
+    uint16_t imm = bc->code[pc++];
+    if (op->op == CALL_JQ || op->op == TAIL_CALL_JQ) {
+      for (int i=0; i<imm+1; i++) {
+        uint16_t level = bc->code[pc++];
+        uint16_t idx = bc->code[pc++];
+        jv name;
+        if (idx & ARG_NEWCLOSURE) {
+          idx &= ~ARG_NEWCLOSURE;
+          name = jv_object_get(jv_copy(getlevel(bc,level)->subfunctions[idx]->debuginfo),
+                               jv_string("name"));
+        } else {
+          name = jv_array_get(jv_object_get(jv_copy(getlevel(bc,level)->debuginfo),
+                                            jv_string("params")), idx);
+        }
+        printf(" %s:%d",
+               jv_string_value(name),
+               idx);
+        jv_free(name);
+        if (level) {
+          printf("^%d", level);
+        }
+      }
+    } else if (op->op == CALL_BUILTIN) {
+      int func = bc->code[pc++];
+      jv name = jv_array_get(jv_copy(bc->globals->cfunc_names), func);
+      printf(" %s", jv_string_value(name));
+      jv_free(name);
+    } else if (op->flags & OP_HAS_BRANCH) {
+      printf(" %04d", pc + imm);
+    } else if (op->flags & OP_HAS_CONSTANT) {
+      printf(" ");
+      jv_dump(jv_array_get(jv_copy(bc->constants), imm), 0);
+    } else if (op->flags & OP_HAS_VARIABLE) {
+      uint16_t v = bc->code[pc++];
+      jv name = jv_array_get(jv_object_get(jv_copy(getlevel(bc,imm)->debuginfo), jv_string("locals")), v);
+      printf(" $%s:%d",
+             jv_string_value(name),
+             v);
+      jv_free(name);
+      if (imm) {
+        printf("^%d", imm);
+      }
+    } else {
+      printf(" %d", imm);
+    }
+  }
+}
+
+void bytecode_free(struct bytecode* bc) {
+  if (!bc)
+    return;
+  jv_mem_free(bc->code);
+  jv_free(bc->constants);
+  for (int i=0; i<bc->nsubfunctions; i++)
+    bytecode_free(bc->subfunctions[i]);
+  if (!bc->parent)
+    symbol_table_free(bc->globals);
+  jv_mem_free(bc->subfunctions);
+  jv_free(bc->debuginfo);
+  jv_mem_free(bc);
+}

package/deps/jq/bytecode.h

@@ -0,0 +1,92 @@
+#ifndef BYTECODE_H
+#define BYTECODE_H
+#include <stdint.h>
+
+#include "jv.h"
+
+typedef enum {
+#define OP(name, imm, in, out) name,
+#include "opcode_list.h"
+#undef OP
+} opcode;
+
+enum {
+  NUM_OPCODES =
+#define OP(name, imm, in, out) +1
+#include "opcode_list.h"
+#undef OP
+};
+
+enum {
+  OP_HAS_CONSTANT = 2,
+  OP_HAS_VARIABLE = 4,
+  OP_HAS_BRANCH = 8,
+  OP_HAS_CFUNC = 32,
+  OP_HAS_UFUNC = 64,
+  OP_IS_CALL_PSEUDO = 128,
+  OP_HAS_BINDING = 1024,
+  // NOTE: Not actually part of any op -- a pseudo-op flag for special
+  //       handling of `break`.
+  OP_BIND_WILDCARD = 2048,
+};
+struct opcode_description {
+  opcode op;
+  const char* name;
+
+  int flags;
+
+  // length in 16-bit units
+  int length;
+
+  int stack_in, stack_out;
+};
+
+const struct opcode_description* opcode_describe(opcode op);
+
+
+#define MAX_CFUNCTION_ARGS 10
+typedef void (*cfunction_ptr)();
+struct cfunction {
+  cfunction_ptr fptr;
+  const char* name;
+  int nargs;
+};
+
+struct symbol_table {
+  struct cfunction* cfunctions;
+  int ncfunctions;
+  jv cfunc_names;
+};
+
+// The bytecode format matters in:
+//   execute.c  - interpreter
+//   compile.c  - compiler
+//   bytecode.c - disassembler
+
+#define ARG_NEWCLOSURE 0x1000
+
+struct bytecode {
+  uint16_t* code;
+  int codelen;
+
+  int nlocals;
+  int nclosures;
+
+  jv constants; // JSON array of constants
+  struct symbol_table* globals;
+
+  struct bytecode** subfunctions;
+  int nsubfunctions;
+
+  struct bytecode* parent;
+
+  jv debuginfo;
+};
+
+void dump_disassembly(int, struct bytecode* code);
+void dump_operation(struct bytecode* bc, uint16_t* op);
+
+int bytecode_operation_length(uint16_t* codeptr);
+void bytecode_free(struct bytecode* bc);
+
+#endif

package/deps/jq/compile-ios.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+
+# old values
+OLD_CFLAGS=$CFLAGS
+OLD_LDFLAGS=$LDFLAGS
+ORIG_PWD=`pwd`
+
+# For parallelism in make
+NJOBS="-j`sysctl -n hw.ncpu || echo 1`"
+
+
+# Get oniguruma
+rm -rf $PWD/build/ios onig-5.9.5
+echo "Downloading oniguruma 5.9.5"
+curl http://www.geocities.jp/kosako3/oniguruma/archive/onig-5.9.5.tar.gz | tar xz
+cd onig-5.9.5
+
+# So, we need to remake the configure scripts so that the arm64 architecture
+# exists in config.sub.  In order to keep autoreconf from failing, create
+# NEWS and ChangeLog.
+touch NEWS ChangeLog
+autoreconf -fi >/dev/null 2>&1
+
+
+
+
+CC=`xcrun -f clang`
+cd $ORIG_PWD
+
+autoreconf -fi
+for arch in i386 x86_64 armv7 armv7s arm64; do
+
+	# Some of the architectures are a bit different...
+	if [[ "$arch" = "i386" || "$arch" = "x86_64" ]]
+	then
+		SYSROOT=`xcrun -f --sdk iphonesimulator --show-sdk-path`
+	else
+		SYSROOT=`xcrun -f --sdk iphoneos --show-sdk-path`
+	fi
+	if [[ "$arch" = "arm64" ]]
+	then
+		HOST="aarch64-apple-darwin"
+	else
+		HOST="$arch-apple-darwin"
+	fi
+
+	CFLAGS="-arch $arch -miphoneos-version-min=6.0 -isysroot $SYSROOT $OLD_CFLAGS"
+	LDFLAGS="-arch $arch -miphoneos-version-min=6.0 -isysroot $SYSROOT $OLD_LDFLAGS"
+
+
+
+	# Build oniguruma for this architecture
+	cd onig-5.9.5
+	CC=$CC CFLAGS=$CFLAGS LDFLAGS=$LDFLAGS ./configure --disable-shared --enable-static --host=$HOST --prefix=$ORIG_PWD/build/ios/$arch
+	STATUS=$?
+	if [ $STATUS -ne 0 ]
+	then
+		echo "Failed to configure oniguruma for architecture $arch.  Check `pwd`/config.log for details."
+		cd $PWD
+		exit $STATUS
+	fi
+	make clean
+	make $NJBOS install
+	STATUS=$?
+	if [ $STATUS -ne 0 ]
+	then
+		echo "Failed to make oniguruma for architecture $arch."
+		cd $PWD
+		exit $STATUS
+	fi
+
+
+
+	# Build jq for this architecture
+	cd $ORIG_PWD
+	CC=$CC CFLAGS=$CFLAGS LDFLAGS=$LDFLAGS ./configure --disable-shared --enable-static -host=$HOST --prefix=$ORIG_PWD/build/ios/$arch --with-oniguruma=$ORIG_PWD/build/ios/$arch
+	STATUS=$?
+	if [ $STATUS -ne 0 ]
+	then
+		echo "Failed to configure jq for architecture $arch"
+		exit $STATUS
+	fi
+	make clean
+	make $NJOBS install
+	STATUS=$?
+	if [ $STATUS -ne 0 ]
+	then
+		echo "Failed to make jq for architecture $arch"
+		exit $STATUS
+	fi
+done
+
+
+# lipo together the different architectures into a universal 'fat' file
+lipo -create -output $ORIG_PWD/build/ios/libonig.a $ORIG_PWD/build/ios/{i386,x86_64,armv7,armv7s,arm64}/lib/libonig.a
+lipo -create -output $ORIG_PWD/build/ios/libjq.a $ORIG_PWD/build/ios/{i386,x86_64,armv7,armv7s,arm64}/lib/libjq.a
+
+# copy the products into the destination directory and clean up the single-architecture files.
+cp $ORIG_PWD/build/ios/i386/include/*.h $ORIG_PWD/build/ios/
+rm -rf $ORIG_PWD/build/ios/{i386,x86_64,armv7,armv7s,arm64}
+
+echo "Products are in $ORIG_PWD/build/ios"