compile.h

#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**);

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
Bind builtin functions in a slightly less ugly way. 2012-09-16 17:08:56 +01:00			`#ifndef COMPILE_H`
			`#define COMPILE_H`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00			`#include <stdint.h>`
Move all the includes one place to the left 2012-12-02 21:25:54 +00:00			`#include "jv.h"`
Fold opcode.{c,h} into bytecode.{c,h} 2013-06-18 01:36:18 +01:00			`#include "bytecode.h"`
More error handling - locations of refs to undefined symbols. 2012-09-11 12:24:54 +01:00			`#include "locfile.h"`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00
			`struct inst;`
			`typedef struct inst inst;`


			`typedef struct block {`
			`inst* first;`
			`inst* last;`
			`} block;`

Added library system with -l, -L, and JQ_LIBRARY_PATH Created util.[ch] to hold common utilities. 2014-07-09 00:55:20 -04:00			`block gen_location(location, struct locfile*, block);`
More error handling - locations of refs to undefined symbols. 2012-09-11 12:24:54 +01:00
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00			`block gen_noop();`
Fold constants (fix #504) 2014-07-27 17:33:22 -05:00			`int block_is_noop(block b);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00			`block gen_op_simple(opcode op);`
General cleanup - rename a few things, delete dead code. 2012-12-03 20:00:36 +00:00			`block gen_const(jv constant);`
Further module system revamp (fix #659) To import a module now use: # Import module.jq file: import "relative/path/to/module" as foo; # Use the module's defs as foo::<def-name> To import a JSON file: # Read file.json: import "relative/path/to/file" as $foo; # # Use as $foo::foo Using `-L` now drops the builtin library path and appends the requested path to the empty array (or the result of an earlier `-L`). Support for the `$JQ_LIBRARY_PATH` environment variable has been removed. 2014-12-30 13:13:30 -06:00			`block gen_const_global(jv constant, const char *name);`
Fold constants (fix #504) 2014-07-27 17:33:22 -05:00			`int block_is_const(block b);`
Fix #814: raise on div-0, add inf isinf nan isnan 2015-06-17 19:46:57 -05:00			`int block_is_const_inf(block b);`
Fold constants (fix #504) 2014-07-27 17:33:22 -05:00			`jv_kind block_const_kind(block b);`
			`jv block_const(block b);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00			`block gen_op_target(opcode op, block target);`
Simplify block functions for variables 2013-06-18 01:07:18 +01:00			`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);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00
Further module system revamp (fix #659) To import a module now use: # Import module.jq file: import "relative/path/to/module" as foo; # Use the module's defs as foo::<def-name> To import a JSON file: # Read file.json: import "relative/path/to/file" as $foo; # # Use as $foo::foo Using `-L` now drops the builtin library path and appends the requested path to the empty array (or the result of an earlier `-L`). Support for the `$JQ_LIBRARY_PATH` environment variable has been removed. 2014-12-30 13:13:30 -06:00			`block gen_module(block metadata);`
Add `module` directive, `modulemeta` builtin Fix #425. 2014-08-10 16:52:03 -05:00			`jv block_module_meta(block b);`
Further module system revamp (fix #659) To import a module now use: # Import module.jq file: import "relative/path/to/module" as foo; # Use the module's defs as foo::<def-name> To import a JSON file: # Read file.json: import "relative/path/to/file" as $foo; # # Use as $foo::foo Using `-L` now drops the builtin library path and appends the requested path to the empty array (or the result of an earlier `-L`). Support for the `$JQ_LIBRARY_PATH` environment variable has been removed. 2014-12-30 13:13:30 -06:00			`block gen_import(const char* name, block metadata, const char *as, int is_data);`
Refactor function argument passing into what it always should have been. Most visible change is that error messages when a function is called with the wrong number of arguments are much better. 2012-12-04 00:39:21 +00:00			`block gen_function(const char* name, block formals, block body);`
Add `def f($arg):` syntax (fix #524) 2014-08-08 18:00:47 -05:00			`block gen_param_regular(const char* name);`
Simplify block functions for variables 2013-06-18 01:07:18 +01:00			`block gen_param(const char* name);`
Transparent handling for CBV arguments to C functions. C function arguments closures are inlined before the call. 2012-11-26 01:36:55 +00:00			`block gen_lambda(block body);`
			`block gen_call(const char* name, block body);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00			`block gen_subexp(block a);`
			`block gen_both(block a, block b);`
Constant fold objects 2014-08-09 20:47:03 -05:00			`block gen_const_object(block expr);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00			`block gen_collect(block expr);`
array and object destructuring (fix #533) `. as [$i, $j, $k] \| ...` `. as {a: $i, b: $j} \| ...` `. as [[[$i]], {a: $j}] \| ...` `foreach . as [$i, $j, $k] (...)` `reduce . as {a: $i, b: $j} (...)` 2015-06-07 21:45:14 -07:00			`block gen_reduce(block source, block matcher, block init, block body);`
			`block gen_foreach(block source, block matcher, block init, block update, block extract);`
if-then-else and defined-or operators 2012-09-04 15:34:34 +01:00			`block gen_definedor(block a, block b);`
Make "not" a builtin function rather than syntax. Fixes a really awkward grammar issue. 2012-09-17 21:08:43 +01:00			`block gen_condbranch(block iftrue, block iffalse);`
Short-circuiting Boolean "and" and "or" operators. 2012-09-04 20:38:59 +01:00			`block gen_and(block a, block b);`
			`block gen_or(block a, block b);`
if-then-else and defined-or operators 2012-09-04 15:34:34 +01:00
Add a --arg option to allow variables to be passed from the cmdline. Closes #107 2013-05-06 14:21:00 +01:00			`block gen_var_binding(block var, const char* name, block body);`
array and object destructuring (fix #533) `. as [$i, $j, $k] \| ...` `. as {a: $i, b: $j} \| ...` `. as [[[$i]], {a: $j}] \| ...` `foreach . as [$i, $j, $k] (...)` `reduce . as {a: $i, b: $j} (...)` 2015-06-07 21:45:14 -07:00			`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);`
Add a --arg option to allow variables to be passed from the cmdline. Closes #107 2013-05-06 14:21:00 +01:00
if-then-else and defined-or operators 2012-09-04 15:34:34 +01:00			`block gen_cond(block cond, block iftrue, block iffalse);`
Add `label $name \| EXP`; fix `break` This is to fix the problem where `break` is dynamic, not lexical. With this it should be possible to do this sort of thing: label $break \| inputs \| if ... then $break\|error else . end This is a backwards-incompatible change for master, but the previous `break` hadn't shipped yet. Still needed: - testing 2014-12-28 00:32:06 -06:00			`block gen_try_handler(block handler);`
Add `try EXP catch EXP` 2014-07-05 20:54:42 -05:00			`block gen_try(block exp, block handler);`
Add `label $name \| EXP`; fix `break` This is to fix the problem where `break` is dynamic, not lexical. With this it should be possible to do this sort of thing: label $break \| inputs \| if ... then $break\|error else . end This is a backwards-incompatible change for master, but the previous `break` hadn't shipped yet. Still needed: - testing 2014-12-28 00:32:06 -06:00			`block gen_label(const char *label, block exp);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00
Make a few constant globals actually const. This means the .data and .bss sections are empty, a good thing in a shared library (see #98). 2013-05-05 22:37:46 +01:00			`block gen_cbinding(const struct cfunction* functions, int nfunctions, block b);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00
			`void block_append(block* b, block b2);`
			`block block_join(block a, block b);`
Added library system with -l, -L, and JQ_LIBRARY_PATH Created util.[ch] to hold common utilities. 2014-07-09 00:55:20 -04:00			`int block_has_only_binders_and_imports(block, int bindflags);`
Builtin functions defined in jq. 2012-09-18 10:17:38 +01:00			`int block_has_only_binders(block, int bindflags);`
Better check for lib has only functions (fix #138) 2014-07-07 16:03:32 -05:00			`int block_has_main(block);`
			`int block_is_funcdef(block b);`
Fold constants (fix #504) 2014-07-27 17:33:22 -05:00			`int block_is_single(block b);`
First pass at functions + tests 2012-08-21 18:14:13 +01:00			`block block_bind(block binder, block body, int bindflags);`
Added library system with -l, -L, and JQ_LIBRARY_PATH Created util.[ch] to hold common utilities. 2014-07-09 00:55:20 -04:00			`block block_bind_library(block binder, block body, int bindflags, const char* libname);`
Only generate code for those builtin functions actually used. Makes output of --debug-dump-disasm much simpler. 2013-05-15 01:37:15 +01:00			`block block_bind_referenced(block binder, block body, int bindflags);`
Added library system with -l, -L, and JQ_LIBRARY_PATH Created util.[ch] to hold common utilities. 2014-07-09 00:55:20 -04:00			`block block_drop_unreferenced(block body);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00
Added library system with -l, -L, and JQ_LIBRARY_PATH Created util.[ch] to hold common utilities. 2014-07-09 00:55:20 -04:00			`jv block_take_imports(block* body);`

			`int block_compile(block, struct bytecode**);`
Most of a C implementation of jq 2012-08-16 01:00:30 +01:00
			`void block_free(block);`
Remove syntax distinction between builtin and user calls 2012-08-27 11:19:42 +01:00

Bind builtin functions in a slightly less ugly way. 2012-09-16 17:08:56 +01:00
Add some preprocessor junk to make codegen cleaner. 2012-11-25 23:49:57 +00:00			`// 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)))`
Add BLOCK_8() macro 2014-12-26 03:31:54 -06:00			`#define BLOCK_8(b1,b2,b3,b4,b5,b6,b7,b8) (block_join(BLOCK_7(b1,b2,b3,b4,b5,b6,b7),(b8)))`
Add some preprocessor junk to make codegen cleaner. 2012-11-25 23:49:57 +00:00
Add BLOCK_8() macro 2014-12-26 03:31:54 -06:00			`#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME`
Add some preprocessor junk to make codegen cleaner. 2012-11-25 23:49:57 +00:00			`#define BLOCK(...) \`
Add BLOCK_8() macro 2014-12-26 03:31:54 -06:00			`BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__)`
Add some preprocessor junk to make codegen cleaner. 2012-11-25 23:49:57 +00:00

Bind builtin functions in a slightly less ugly way. 2012-09-16 17:08:56 +01:00			`#endif`