@port-labs/jq-node-bindings 0.0.1

package/deps/jq/compile.h

@@ -0,0 +1,101 @@
+#ifndef COMPILE_H
+#define COMPILE_H
+#include <stdint.h>
+#include "jv.h"
+#include "bytecode.h"
+#include "locfile.h"
+
+struct inst;
+typedef struct inst inst;
+
+
+typedef struct block {
+  inst* first;
+  inst* last;
+} block;
+
+block gen_location(location, struct locfile*, block);
+
+block gen_noop();
+int block_is_noop(block b);
+block gen_op_simple(opcode op);
+block gen_const(jv constant);
+block gen_const_global(jv constant, const char *name);
+int block_is_const(block b);
+int block_is_const_inf(block b);
+jv_kind block_const_kind(block b);
+jv block_const(block b);
+block gen_op_target(opcode op, block target);
+block gen_op_unbound(opcode op, const char* name);
+block gen_op_bound(opcode op, block binder);
+block gen_op_var_fresh(opcode op, const char* name);
+
+block gen_module(block metadata);
+jv block_module_meta(block b);
+block gen_import(const char* name, block metadata, const char *as, int is_data);
+block gen_function(const char* name, block formals, block body);
+block gen_param_regular(const char* name);
+block gen_param(const char* name);
+block gen_lambda(block body);
+block gen_call(const char* name, block body);
+block gen_subexp(block a);
+block gen_both(block a, block b);
+block gen_const_object(block expr);
+block gen_collect(block expr);
+block gen_reduce(block source, block matcher, block init, block body);
+block gen_foreach(block source, block matcher, block init, block update, block extract);
+block gen_definedor(block a, block b);
+block gen_condbranch(block iftrue, block iffalse);
+block gen_and(block a, block b);
+block gen_or(block a, block b);
+
+block gen_var_binding(block var, const char* name, block body);
+block gen_array_matcher(block left, block curr);
+block gen_object_matcher(block name, block curr);
+block gen_destructure(block var, block matcher, block body);
+
+block gen_cond(block cond, block iftrue, block iffalse);
+block gen_try_handler(block handler);
+block gen_try(block exp, block handler);
+block gen_label(const char *label, block exp);
+
+block gen_cbinding(const struct cfunction* functions, int nfunctions, block b);
+
+void block_append(block* b, block b2);
+block block_join(block a, block b);
+int block_has_only_binders_and_imports(block, int bindflags);
+int block_has_only_binders(block, int bindflags);
+int block_has_main(block);
+int block_is_funcdef(block b);
+int block_is_single(block b);
+block block_bind(block binder, block body, int bindflags);
+block block_bind_library(block binder, block body, int bindflags, const char* libname);
+block block_bind_referenced(block binder, block body, int bindflags);
+block block_drop_unreferenced(block body);
+
+jv block_take_imports(block* body);
+
+int block_compile(block, struct bytecode**, struct locfile*);
+
+void block_free(block);
+
+
+
+// Here's some horrible preprocessor gunk so that code
+// sequences can be contructed as BLOCK(block1, block2, block3)
+
+#define BLOCK_1(b1) (b1)
+#define BLOCK_2(b1,b2) (block_join((b1),(b2)))
+#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3)))
+#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4)))
+#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5)))
+#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6)))
+#define BLOCK_7(b1,b2,b3,b4,b5,b6,b7) (block_join(BLOCK_6(b1,b2,b3,b4,b5,b6),(b7)))
+#define BLOCK_8(b1,b2,b3,b4,b5,b6,b7,b8) (block_join(BLOCK_7(b1,b2,b3,b4,b5,b6,b7),(b8)))
+
+#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
+#define BLOCK(...) \
+  BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__)
+
+
+#endif

package/deps/jq/config/m4/check-math-func.m4

@@ -0,0 +1,4 @@
+dnl AC_FIND_FUNC(func, arguments)
+AC_DEFUN([AC_CHECK_MATH_FUNC], [
+  AC_FIND_FUNC_NO_LIBS([$1], [m], [#include <math.h>], [$2])
+])

package/deps/jq/config/m4/find-func-no-libs.m4

@@ -0,0 +1,8 @@
+dnl Shamelessly stolen from Heimdal
+dnl
+dnl Look for function in any of the specified libraries
+dnl
+
+dnl AC_FIND_FUNC_NO_LIBS(func, libraries, includes, arguments, extra libs, extra args)
+AC_DEFUN([AC_FIND_FUNC_NO_LIBS], [
+AC_FIND_FUNC_NO_LIBS2([$1], ["" $2], [$3], [$4], [$5], [$6])])

package/deps/jq/config/m4/find-func-no-libs2.m4

@@ -0,0 +1,62 @@
+dnl Shamelessly stolen from Heimdal
+dnl
+dnl Look for function in any of the specified libraries
+dnl
+
+dnl AC_FIND_FUNC_NO_LIBS2(func, libraries, includes, arguments, extra libs, extra args)
+AC_DEFUN([AC_FIND_FUNC_NO_LIBS2], [
+
+AC_MSG_CHECKING([for $1])
+AC_CACHE_VAL(ac_cv_funclib_$1,
+[
+if eval "test \"\$ac_cv_func_$1\" != yes" ; then
+	ac_save_LIBS="$LIBS"
+	for ac_lib in $2; do
+		case "$ac_lib" in
+		"") ;;
+		yes) ac_lib="" ;;
+		no) continue ;;
+		-l*) ;;
+		*) ac_lib="-l$ac_lib" ;;
+		esac
+		LIBS="$6 $ac_lib $5 $ac_save_LIBS"
+		AC_LINK_IFELSE([AC_LANG_PROGRAM([[$3]],[[$1($4)]])],[eval "if test -n \"$ac_lib\";then ac_cv_funclib_$1=$ac_lib; else ac_cv_funclib_$1=yes; fi";break])
+	done
+	eval "ac_cv_funclib_$1=\${ac_cv_funclib_$1-no}"
+	LIBS="$ac_save_LIBS"
+fi
+])
+
+eval "ac_res=\$ac_cv_funclib_$1"
+
+if false; then
+	AC_CHECK_FUNCS($1)
+dnl	AC_CHECK_LIBS($2, foo)
+fi
+# $1
+eval "ac_tr_func=HAVE_[]upcase($1)"
+eval "ac_tr_lib=HAVE_LIB[]upcase($ac_res | sed -e 's/-l//')"
+eval "LIB_$1=$ac_res"
+
+case "$ac_res" in
+	yes)
+	eval "ac_cv_func_$1=yes"
+	eval "LIB_$1="
+	AC_DEFINE_UNQUOTED($ac_tr_func)
+	AC_MSG_RESULT([yes])
+	;;
+	no)
+	eval "ac_cv_func_$1=no"
+	eval "LIB_$1="
+	AC_MSG_RESULT([no])
+	;;
+	*)
+	eval "ac_cv_func_$1=yes"
+	eval "ac_cv_lib_`echo "$ac_res" | sed 's/-l//'`=yes"
+	AC_DEFINE_UNQUOTED($ac_tr_func)
+	AC_DEFINE_UNQUOTED($ac_tr_lib)
+	AC_MSG_RESULT([yes, in $ac_res])
+	;;
+esac
+AC_SUBST(LIB_$1)
+])

package/deps/jq/config/m4/find-func.m4

@@ -0,0 +1,9 @@
+dnl Shamelessly stolen from Heimdal
+dnl
+dnl AC_FIND_FUNC(func, libraries, includes, arguments)
+AC_DEFUN([AC_FIND_FUNC], [
+AC_FIND_FUNC_NO_LIBS([$1], [$2], [$3], [$4])
+if test -n "$LIB_$1"; then
+	LIBS="$LIB_$1 $LIBS"
+fi
+])

package/deps/jq/config/m4/misc.m4

@@ -0,0 +1,3 @@
+
+dnl Shamelessly stolen from Heimdal
+AC_DEFUN([upcase],[`echo $1 | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ`])dnl

package/deps/jq/configure.ac

@@ -0,0 +1,221 @@
+m4_define([jq_version], m4_esyscmd_s([git describe --tags --dirty --match 'jq-*'|sed 's/^jq-//']))
+
+AC_INIT([jq], [jq_version], [https://github.com/stedolan/jq/issues],
+             [jq], [https://stedolan.github.io/jq])
+
+m4_include([m4/ax_compare_version.m4])
+m4_include([m4/ax_prog_bison_version.m4])
+
+dnl Created autoconf implementation thompson@dtosolutions, 26NOV12
+AC_PREREQ([2.64])
+AC_CONFIG_AUX_DIR([config])
+AM_INIT_AUTOMAKE([1.11.2 parallel-tests foreign -Wall])
+AM_SILENT_RULES([yes])
+AM_PROG_AR
+AM_MAINTAINER_MODE([enable])
+AC_PROG_CC
+AC_PROG_CC_STDC
+AC_PROG_CPP_WERROR
+AC_PROG_YACC
+AC_OBJEXT
+AC_EXEEXT
+LT_INIT([shared static win32-dll])
+AM_PROG_CC_C_O
+
+
+dnl couldn't use AM_PROG_LEX as it doesn't support header files like the
+dnl AC_PROG_YACC macros...
+
+dnl check bison version
+
+if test "$USE_MAINTAINER_MODE" = yes; then
+  if test "$YACC" != "bison -y"; then
+    AC_MSG_CHECKING([bison version])
+    AC_MSG_RESULT([not bison])
+  else
+    AX_PROG_BISON_VERSION([3],
+      [],
+      [AC_MSG_ERROR([You need bison version 3.0 or greater, or use --disable-maintainer-mode.])])
+  fi
+
+  AC_PROG_LEX
+  if test "x$LEX" != xflex; then
+    LEX="$SHELL $missing_dir/missing flex"
+  fi
+fi
+
+
+##########################################################################
+# check for ONIGURUMA library
+##########################################################################
+
+AC_ARG_WITH([oniguruma],
+    [AS_HELP_STRING([--with-oniguruma=prefix],
+        [try this for a non-standard install prefix of the oniguruma library])],
+    [ONIGURUMAPATHSET=1],
+    [ONIGURUMAPATHSET=0])
+
+if test $ONIGURUMAPATHSET = 1; then
+  CFLAGS="$CFLAGS -I${with_oniguruma}/include"
+  LDFLAGS="$LDFLAGS -L${with_oniguruma}/lib"
+fi
+
+# check for ONIGURUMA library
+HAVE_ONIGURUMA=0
+AC_CHECK_HEADER("oniguruma.h",
+    AC_CHECK_LIB([onig],[onig_version],[LIBS="$LIBS -lonig"; HAVE_ONIGURUMA=1;]))
+
+# handle check results
+if test $HAVE_ONIGURUMA != 1; then
+    AC_MSG_NOTICE([Oniguruma was not found.])
+    AC_MSG_NOTICE([ Try setting the location using '--with-oniguruma=PREFIX' ])
+else
+    AC_DEFINE([HAVE_ONIGURUMA],1,[Define to 1 if Oniguruma is installed])
+fi
+
+
+dnl Check for valgrind
+AC_CHECK_PROGS(valgrind_cmd, valgrind)
+if test "x$valgrind_cmd" = "x" ; then
+    AC_MSG_WARN([valgrind is required to test jq.])
+fi
+AC_CHECK_FUNCS(memmem)
+AC_CHECK_FUNCS(mkstemp)
+
+
+dnl Running tests with Valgrind is slow. It is faster to iterate on
+dnl code without Valgrind until tests pass, then enable Valgrind and
+dnl fix leaks.
+AC_ARG_ENABLE([valgrind],
+   AC_HELP_STRING([--disable-valgrind], [do not run tests under Valgrind]))
+
+dnl Code coverage
+AC_ARG_ENABLE([gcov],
+   AC_HELP_STRING([--enable-gcov], [enable gcov code coverage tool]))
+
+dnl Don't attempt to build docs if there's no Ruby lying around
+AC_ARG_ENABLE([docs],
+   AC_HELP_STRING([--disable-docs], [don't build docs]))
+
+dnl Don't attempt to build the error injection object (if there is no LD_PRELOAD support)
+AC_ARG_ENABLE([error-injection],
+   AC_HELP_STRING([--enable-error-injection], [build and test with error injection]))
+
+dnl Enable building all static
+AC_ARG_ENABLE([all-static],
+   AC_HELP_STRING([--enable-all-static], [link jq with static libraries only]))
+
+AS_IF([test "x$enable_docs" != "xno"],[
+   AC_CHECK_PROGS(bundle_cmd, bundle)
+
+   AC_CACHE_CHECK([for Ruby dependencies], [jq_cv_ruby_deps],
+     [jq_cv_ruby_deps=yes;
+        AS_IF([test "x$bundle_cmd" = "x" || \
+        ! bmsg="`cd ${srcdir}/docs; "$bundle_cmd" check 2>/dev/null`"],[
+           AC_MSG_WARN([$bmsg])
+           cat <<EOF
+*****************************************************************
+*  Ruby dependencies for building jq documentation not found.   *
+*  You can still build, install and hack on jq, but the manpage *
+*  will not be rebuilt and some of the tests won't run.         *
+*  See docs/README.md for how to install the docs dependencies. *
+*****************************************************************
+EOF
+           jq_cv_ruby_deps=no
+     ])])
+
+   if test "x$jq_cv_ruby_deps" != "xyes"; then
+     enable_docs=no
+   fi
+])
+
+AM_CONDITIONAL([ENABLE_VALGRIND], [test "x$enable_valgrind" != xno])
+AM_CONDITIONAL([ENABLE_GCOV], [test "x$enable_gcov" = xyes])
+AM_CONDITIONAL([ENABLE_DOCS], [test "x$enable_docs" != xno])
+AM_CONDITIONAL([ENABLE_ERROR_INJECTION], [test "x$enable_error_injection" = xyes])
+AM_CONDITIONAL([ENABLE_ALL_STATIC], [test "x$enable_all_static" = xyes])
+
+AC_FUNC_ALLOCA
+
+AC_FIND_FUNC([isatty], [c], [#include <unistd.h>], [0])
+AC_FIND_FUNC([_isatty], [c], [#include <io.h>], [0])
+AC_FIND_FUNC([strptime], [c], [#include <time.h>], [0, 0, 0])
+AC_FIND_FUNC([strftime], [c], [#include <time.h>], [0, 0, 0, 0])
+AC_FIND_FUNC([timegm], [c], [#include <time.h>], [0])
+AC_FIND_FUNC([gmtime_r], [c], [#include <time.h>], [0, 0])
+AC_FIND_FUNC([gmtime], [c], [#include <time.h>], [0])
+AC_FIND_FUNC([gettimeofday], [c], [#include <time.h>], [0, 0])
+AC_CHECK_MEMBER([struct tm.tm_gmtoff], [AC_DEFINE([HAVE_TM_TM_GMT_OFF],1,[Define to 1 if the system has the tm_gmt_off field in struct tm])],
+                [], [[#include <time.h>]])
+AC_CHECK_MEMBER([struct tm.__tm_gmtoff], [AC_DEFINE([HAVE_TM___TM_GMT_OFF],1,[Define to 1 if the system has the __tm_gmt_off field in struct tm])],
+                [], [[#include <time.h>]])
+
+AC_ARG_ENABLE([pthread-tls],
+              [AC_HELP_STRING([--enable-pthread-tls],
+                              [Enable use of pthread thread local storage])],
+              [],
+              [enable_pthread_tls=no])
+
+if test $enable_pthread_tls = yes; then
+    AC_FIND_FUNC([pthread_key_create], [pthread], [#include <pthread.h>], [NULL, NULL])
+    AC_FIND_FUNC([pthread_once], [pthread], [#include <pthread.h>], [NULL, NULL])
+    AC_FIND_FUNC([atexit], [pthread], [#include <stdlib.h>], [NULL])
+fi
+
+dnl libm math.h functions
+AC_CHECK_MATH_FUNC(acos, [.5])
+AC_CHECK_MATH_FUNC(acosh, [.5])
+AC_CHECK_MATH_FUNC(asin, [.5])
+AC_CHECK_MATH_FUNC(asinh, [.5])
+AC_CHECK_MATH_FUNC(atan, [.5])
+AC_CHECK_MATH_FUNC(atanh, [.5])
+AC_CHECK_MATH_FUNC(cbrt, [.5])
+AC_CHECK_MATH_FUNC(cos, [.5])
+AC_CHECK_MATH_FUNC(cosh, [.5])
+AC_CHECK_MATH_FUNC(exp2, [.5])
+AC_CHECK_MATH_FUNC(exp, [.5])
+AC_CHECK_MATH_FUNC(floor, [.5])
+AC_CHECK_MATH_FUNC(j0, [.5])
+AC_CHECK_MATH_FUNC(j1, [.5])
+AC_CHECK_MATH_FUNC(log10, [.5])
+AC_CHECK_MATH_FUNC(log2, [.5])
+AC_CHECK_MATH_FUNC(log, [.5])
+AC_CHECK_MATH_FUNC(sin, [.5])
+AC_CHECK_MATH_FUNC(sinh, [.5])
+AC_CHECK_MATH_FUNC(sqrt, [.5])
+AC_CHECK_MATH_FUNC(tan, [.5])
+AC_CHECK_MATH_FUNC(tanh, [.5])
+AC_CHECK_MATH_FUNC(tgamma, [.5])
+AC_CHECK_MATH_FUNC(y0, [.5])
+AC_CHECK_MATH_FUNC(y1, [.5])
+AC_CHECK_MATH_FUNC(pow, [2,2])
+AC_CHECK_MATH_FUNC(atan2, [.5,.5])
+AC_CHECK_MATH_FUNC(hypot, [.5,.5])
+AC_CHECK_MATH_FUNC(remainder, [3,2])
+
+dnl Thread local storage
+have___thread=no
+AC_MSG_CHECKING(for thread-local storage)
+AC_LINK_IFELSE([AC_LANG_SOURCE([
+static __thread int x ;
+int main () { x = 123; return x; }
+])], have___thread=yes)
+if test $have___thread = yes; then 
+   AC_DEFINE([HAVE___THREAD],1,[Define to 1 if the system supports __thread])
+fi
+AC_MSG_RESULT($have___thread)
+
+AC_C_BIGENDIAN(
+   AC_DEFINE([IEEE_MC68k], 1, [machine is bigendian]),
+   AC_DEFINE([IEEE_8087], 1, [machine is littleendian]),
+   AC_MSG_ERROR(unknown endianess),
+   AC_MSG_ERROR(universial endianess not supported)
+)
+
+AC_SUBST([BUNDLER], ["$bundle_cmd"])
+
+AC_CONFIG_MACRO_DIR([config/m4])
+AC_CONFIG_FILES([Makefile])
+AC_OUTPUT
+
+

package/deps/jq/docs/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem "rake"
+gem "bonsai"
+gem "maruku"
+gem "ronn"
+gem "mustache", "<1.0" # to support ruby <2.0

package/deps/jq/docs/Gemfile.lock

@@ -0,0 +1,63 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.3)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.3.8)
+    bonsai (1.4.9)
+      activesupport (>= 3.0.3)
+      builder (>= 3.0.0)
+      i18n (>= 0.5.0)
+      launchy (>= 0.3.7)
+      liquid (>= 2.2.2)
+      maruku (>= 0.6.0)
+      rack
+      sass
+      sinatra (>= 1.0)
+      tilt (>= 1.3)
+      watch (>= 0.1.0)
+      yui-compressor
+    builder (3.2.2)
+    hpricot (0.8.6)
+    i18n (0.7.0)
+    json (1.8.3)
+    launchy (2.4.3)
+      addressable (~> 2.3)
+    liquid (3.0.6)
+    maruku (0.7.2)
+    minitest (5.8.0)
+    mustache (0.99.8)
+    rack (1.6.4)
+    rack-protection (1.5.3)
+      rack
+    rake (10.4.2)
+    rdiscount (2.1.8)
+    ronn (0.7.3)
+      hpricot (>= 0.8.2)
+      mustache (>= 0.7.0)
+      rdiscount (>= 1.5.8)
+    sass (3.4.16)
+    sinatra (1.4.6)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    thread_safe (0.3.5)
+    tilt (2.0.1)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    watch (0.1.0)
+    yui-compressor (0.12.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bonsai
+  maruku
+  mustache (< 1.0)
+  rake
+  ronn

package/deps/jq/docs/README.md

@@ -0,0 +1,25 @@
+Documentation
+=============
+
+The jq website, manpages and some of the tests are generated from this
+directory. The directory holds a [Bonsai](http://tinytree.info)
+website, and the manual is a YAML file in `content/3.manual`.
+
+To build the documentation (including building the jq manpage), you'll
+need a working Ruby setup. The easiest way to get one is to install
+RVM and Ruby 1.9.3 like so:
+
+    \curl -L https://get.rvm.io | bash -s stable --ruby=1.9.3
+
+After that finishes installing, you'll need to make sure RVM is on
+your path by doing `source $HOME/.rvm/scripts/rvm`, or just opening a
+new shell. See <https://rvm.io> for more info on RVM.
+
+Once RVM is installed, you can install all the dependencies for jq's
+documentation build by running this from the `docs` directory:
+
+    bundle install
+
+When bundle manages to install the dependencies, rerun `./configure`
+in the jq root directory and then the Makefile will be able to
+generate the jq manpage.

package/deps/jq/docs/Rakefile

@@ -0,0 +1,145 @@
+require 'yaml'
+require 'bonsai'
+require 'liquid'
+require 'maruku'
+require 'json'
+require 'ronn'
+require 'tempfile'
+require 'yaml'
+
+module ExtraFilters
+  def markdownify(input)
+    Maruku.new(input).to_html
+  end
+
+  def sanitize(input)
+    input.gsub(/[^a-zA-Z0-9_]/,"")
+  end
+
+  def json(input)
+    input.to_json
+  end
+  
+  def unique(input)
+    @n = (@n || 0) + 1
+    input + @n.to_s
+  end
+end
+
+Liquid::Template.register_filter(ExtraFilters)
+
+
+task :serve do
+  begin
+    Bonsai.log "Press Control+C to quit"
+    
+    require 'rack'
+    require 'sinatra'
+    require 'watch'
+    require 'launchy'
+    
+    Bonsai.root_dir = Dir.pwd
+    
+    server = fork {        
+      app = Rack::Builder.app {
+        map "/jq" do
+          use Bonsai::StaticPassThrough, :root => Bonsai.root_dir + "/output", :urls => ["/"]
+        end
+        run Bonsai::DevelopmentServer
+      }
+      Rack::Handler.default.run(app, :Port => 5000) do
+        Launchy.open("http://localhost:5000/jq/")
+      end
+    }    
+    Watch.new("{content,templates,public}/**/*") { Bonsai::Exporter.process! }
+  rescue Interrupt
+    Process.kill("QUIT", server)
+    Process.wait(server)
+    exit
+  end
+end
+
+task :build do
+  Bonsai.root_dir = Dir.pwd
+  Bonsai::Exporter.publish!
+end
+
+$BINARIES = {
+  :osx32 => "--host=i686-apple-darwin10 CFLAGS='-m32 -g -O'",
+  :osx64 => "--host=i686-apple-darwin10 CFLAGS='-m64 -g -O'",
+  :win32 => "--host=i686-w64-mingw32 CFLAGS='-g -O'",
+  :win64 => "--host=x86_64-w64-mingw32 CFLAGS='-g -O'",
+  :linux32 => "--host=x86_64-linux-gnu CFLAGS='-m32 -g -O'",
+  :linux64 => "--host=x86_64-linux-gnu CFLAGS='-m64 -g -O'"
+}
+
+$BINARIES.each do |name, args|
+  file "../build/#{name}" do |t|
+    sh "../scripts/crosscompile -j4 #{name} #{args}"
+  end
+  task :binaries => ["../build/#{name}"]
+end
+
+task :binaries => ["output/download"] do
+  $BINARIES.each do |name, args|
+    FileUtils.cp_r "../build/#{name}", "output/download/"
+  end
+end
+
+def load_manual
+  YAML::load(File.open("content/3.manual/manual.yml"))
+end
+
+task :manpage do
+  Tempfile.open "manpage" do |f|
+    manual = load_manual
+    f.puts manual['manpage_intro']
+    f.puts manual['body']
+    manual['sections'].each do |section|
+      
+      f.puts "## #{section['title'].upcase}\n"
+      f.puts section['body']
+      f.puts ""
+      (section['entries'] || []).each do |entry|
+        f.puts "### #{entry['title']}\n"
+        f.puts entry['body']
+        f.puts ""
+        (entry['examples'] || []).each do |example|
+          f.puts "    jq '#{example['program']}'"
+          f.puts "       #{example['input']}"
+          f.puts "    => #{example['output'].join(", ")}"
+          f.puts
+        end
+      end
+      f.puts ""
+    end
+    f.puts manual['manpage_epilogue']
+    f.close
+    puts Ronn::Document.new(f.path).convert('roff').gsub(/<\/?code>/,"")
+  end  
+end
+
+task :manpage_default => ["default_manpage.md"] do
+  puts Ronn::Document.new("default_manpage.md").convert('roff').gsub(/<\/?code>/,"")
+end
+
+task :mantests do
+  load_manual['sections'].each do |section|
+    (section['entries'] || []).each do |entry|
+      (entry['examples'] || []).each do |example|
+        puts example['program'].gsub("\n", " ")
+        puts example['input']
+        example['output'].each do |s| puts s end
+        puts
+      end
+    end
+  end
+end
+
+directory "output/download/source"
+task :tarball => ["output/download/source"] do
+  sh "cd ..; ./configure && make dist && make distclean"
+  sh "cp ../jq-*.tar.gz output/download/source"
+end
+
+task :dist => [:build, :binaries, :tarball]