jsonnet 0.1.0 → 0.4.0

data/ext/jsonnet/jsonnet_values.c

@@ -0,0 +1,206 @@
+#include <libjsonnet.h>
+#include <ruby/ruby.h>
+#include <ruby/intern.h>
+
+#include "ruby_jsonnet.h"
+
+static struct JsonnetJsonValue *protect_obj_to_json(struct JsonnetVm *vm, VALUE obj,
+						    struct JsonnetJsonValue *parent);
+
+/**
+ * Converts a Jsonnet JSON value into a Ruby object.
+ *
+ * Arrays and objects in JSON are not supported due to the limitation of
+ * libjsonnet API.
+ */
+VALUE
+rubyjsonnet_json_to_obj(struct JsonnetVm *vm, const struct JsonnetJsonValue *value)
+{
+    union {
+	const char *str;
+	double num;
+    } typed_value;
+
+    if ((typed_value.str = jsonnet_json_extract_string(vm, value))) {
+	return rb_enc_str_new_cstr(typed_value.str, rb_utf8_encoding());
+    }
+    if (jsonnet_json_extract_number(vm, value, &typed_value.num)) {
+	return DBL2NUM(typed_value.num);
+    }
+
+    switch (jsonnet_json_extract_bool(vm, value)) {
+	case 0:
+	    return Qfalse;
+	case 1:
+	    return Qtrue;
+	case 2:
+	    break;
+	default:
+	    /* never happens */
+	    rb_raise(rb_eRuntimeError, "unrecognized json bool value");
+    }
+    if (jsonnet_json_extract_null(vm, value)) {
+	return Qnil;
+    }
+
+    /* TODO: support arrays and objects when they get accessible */
+    rb_raise(rb_eArgError, "unsupported type of JSON value");
+}
+
+static struct JsonnetJsonValue *
+string_to_json(struct JsonnetVm *vm, VALUE str)
+{
+    rubyjsonnet_assert_asciicompat(str);
+    return jsonnet_json_make_string(vm, RSTRING_PTR(str));
+}
+
+static struct JsonnetJsonValue *
+num_to_json(struct JsonnetVm *vm, VALUE n)
+{
+    return jsonnet_json_make_number(vm, NUM2DBL(n));
+}
+
+static struct JsonnetJsonValue *
+ary_to_json(struct JsonnetVm *vm, VALUE ary)
+{
+    struct JsonnetJsonValue *const json_array = jsonnet_json_make_array(vm);
+
+    int i;
+    for (i = 0; i < RARRAY_LEN(ary); ++i) {
+	struct JsonnetJsonValue *const v = protect_obj_to_json(vm, RARRAY_AREF(ary, i), json_array);
+	jsonnet_json_array_append(vm, json_array, v);
+    }
+    return json_array;
+}
+
+struct hash_to_json_params {
+    struct JsonnetVm *vm;
+    struct JsonnetJsonValue *obj;
+};
+
+static int
+hash_item_to_json(VALUE key, VALUE value, VALUE paramsval)
+{
+    const struct hash_to_json_params *const params = (const struct hash_to_json_params *)paramsval;
+
+    StringValue(key);
+    rubyjsonnet_assert_asciicompat(key);
+
+    jsonnet_json_object_append(params->vm, params->obj, StringValueCStr(key),
+			       protect_obj_to_json(params->vm, value, params->obj));
+
+    return ST_CONTINUE;
+}
+
+static struct JsonnetJsonValue *
+hash_to_json(struct JsonnetVm *vm, VALUE hash)
+{
+    struct JsonnetJsonValue *const json_obj = jsonnet_json_make_object(vm);
+    const struct hash_to_json_params args = {vm, json_obj};
+    rb_hash_foreach(hash, hash_item_to_json, (VALUE)&args);
+    return json_obj;
+}
+
+/**
+ * Converts a Ruby object into a Jsonnet JSON value
+ *
+ * TODO(yugui): Safely destorys an intermediate object on exception.
+ */
+static struct JsonnetJsonValue *
+obj_to_json(struct JsonnetVm *vm, VALUE obj)
+{
+    VALUE converted;
+
+    switch (obj) {
+	case Qnil:
+	    return jsonnet_json_make_null(vm);
+	case Qtrue:
+	    return jsonnet_json_make_bool(vm, 1);
+	case Qfalse:
+	    return jsonnet_json_make_bool(vm, 0);
+    }
+
+    converted = rb_check_string_type(obj);
+    if (converted != Qnil) {
+	return string_to_json(vm, converted);
+    }
+
+    converted = rb_check_to_float(obj);
+    if (converted != Qnil) {
+	return num_to_json(vm, converted);
+    }
+
+    converted = rb_check_array_type(obj);
+    if (converted != Qnil) {
+	return ary_to_json(vm, converted);
+    }
+
+    converted = rb_check_hash_type(obj);
+    if (converted != Qnil) {
+	return hash_to_json(vm, converted);
+    }
+
+    converted = rb_any_to_s(obj);
+    return string_to_json(vm, converted);
+}
+
+struct protect_args {
+    struct JsonnetVm *vm;
+    VALUE obj;
+};
+
+static VALUE
+protect_obj_to_json_block(VALUE paramsval)
+{
+    const struct protect_args *const params = (const struct protect_args *)paramsval;
+    return (VALUE)obj_to_json(params->vm, params->obj);
+}
+
+/**
+ * Safely converts a Ruby object into a JSON value.
+ *
+ * It automatically destroys \a parent on exception.
+ * @param[in] vm  a Jsonnet VM
+ * @param[in] obj a Ruby object to be converted
+ * @param[in] parent destroys this value on failure
+ * @throws can throw \c TypeError or other exceptions
+ */
+static struct JsonnetJsonValue *
+protect_obj_to_json(struct JsonnetVm *vm, VALUE obj, struct JsonnetJsonValue *parent)
+{
+    const struct protect_args args = {vm, obj};
+    int state = 0;
+
+    VALUE result = rb_protect(protect_obj_to_json_block, (VALUE)&args, &state);
+    if (!state) {
+	return (struct JsonnetJsonValue *)result;
+    }
+
+    jsonnet_json_destroy(vm, parent);
+    rb_jump_tag(state);
+}
+
+/**
+ * Converts a Ruby object into a JSON value.
+ * Returns an error message on failure.
+ *
+ * @param[in] vm  a Jsonnet VM
+ * @param[in] obj a Ruby object to be converted
+ * @param[out] success  set to 1 on success, set to 0 on failure.
+ * @returns the converted value on success, an error message on failure.
+ */
+struct JsonnetJsonValue *
+rubyjsonnet_obj_to_json(struct JsonnetVm *vm, VALUE obj, int *success)
+{
+    int state = 0;
+    const struct protect_args args = {vm, obj};
+    VALUE result = rb_protect(protect_obj_to_json_block, (VALUE)&args, &state);
+    if (state) {
+	const VALUE msg = rubyjsonnet_format_exception(rb_errinfo());
+	rb_set_errinfo(Qnil);
+	*success = 0;
+	return string_to_json(vm, msg);
+    }
+    *success = 1;
+    return (struct JsonnetJsonValue *)result;
+}

data/ext/jsonnet/ruby_jsonnet.h

@@ -0,0 +1,39 @@
+#ifndef RUBY_JSONNET_RUBY_JSONNET_H_
+#define RUBY_JSONNET_RUBY_JSONNET_H_
+
+#include <ruby/ruby.h>
+#include <ruby/encoding.h>
+
+extern const rb_data_type_t jsonnet_vm_type;
+
+struct native_callback_ctx {
+    VALUE callback;
+    long arity;
+    VALUE vm;
+};
+
+struct jsonnet_vm_wrap {
+    struct JsonnetVm *vm;
+
+    VALUE import_callback;
+    struct {
+	long len;
+	struct native_callback_ctx **contexts;
+    } native_callbacks;
+};
+
+void rubyjsonnet_init_vm(VALUE mod);
+void rubyjsonnet_init_callbacks(VALUE cVM);
+void rubyjsonnet_init_helpers(VALUE mod);
+
+struct jsonnet_vm_wrap *rubyjsonnet_obj_to_vm(VALUE vm);
+
+VALUE rubyjsonnet_json_to_obj(struct JsonnetVm *vm, const struct JsonnetJsonValue *value);
+struct JsonnetJsonValue *rubyjsonnet_obj_to_json(struct JsonnetVm *vm, VALUE obj, int *success);
+
+rb_encoding *rubyjsonnet_assert_asciicompat(VALUE str);
+char *rubyjsonnet_str_to_cstr(struct JsonnetVm *vm, VALUE str);
+VALUE rubyjsonnet_format_exception(VALUE exc);
+int rubyjsonnet_jump_tag(const char *exc_mesg);
+
+#endif /* RUBY_JSONNET_RUBY_JSONNET_H_ */

data/ext/jsonnet/vm.c

@@ -0,0 +1,508 @@
+#include <libjsonnet.h>
+#ifdef HAVE_LIBJSONNET_FMT_H
+# include <libjsonnet_fmt.h>
+#endif
+#include <ruby/ruby.h>
+#include <ruby/intern.h>
+
+#include "ruby_jsonnet.h"
+
+/*
+ * defines the core part of Jsonnet::VM
+ */
+
+/*
+ * Jsonnet evaluator
+ *
+ * call-seq:
+ *   Jsonnet::VM
+ */
+static VALUE cVM;
+
+/*
+ * Raised on evaluation errors in a Jsonnet VM.
+ */
+static VALUE eEvaluationError;
+static VALUE eFormatError;
+
+static void raise_eval_error(struct JsonnetVm *vm, char *msg, rb_encoding *enc);
+static void raise_format_error(struct JsonnetVm *vm, char *msg, rb_encoding *enc);
+static VALUE str_new_json(struct JsonnetVm *vm, char *json, rb_encoding *enc);
+static VALUE fileset_new(struct JsonnetVm *vm, char *buf, rb_encoding *enc);
+
+static void vm_free(void *ptr);
+static void vm_mark(void *ptr);
+
+const rb_data_type_t jsonnet_vm_type = {
+    "JsonnetVm",
+    {
+	/* dmark = */ vm_mark,
+	/* dfree = */ vm_free,
+	/* dsize = */ 0,
+    },
+    /* parent = */ 0,
+    /* data = */ 0,
+    /* flags = */ RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+struct jsonnet_vm_wrap *
+rubyjsonnet_obj_to_vm(VALUE wrap)
+{
+    struct jsonnet_vm_wrap *vm;
+    TypedData_Get_Struct(wrap, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
+
+    return vm;
+}
+
+static VALUE
+vm_s_new(int argc, const VALUE *argv, VALUE klass)
+{
+    struct jsonnet_vm_wrap *vm;
+    VALUE self = TypedData_Make_Struct(cVM, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
+    vm->vm = jsonnet_make();
+    vm->import_callback = Qnil;
+    vm->native_callbacks.len = 0;
+    vm->native_callbacks.contexts = NULL;
+
+    rb_obj_call_init(self, argc, argv);
+    return self;
+}
+
+static void
+vm_free(void *ptr)
+{
+    int i;
+    struct jsonnet_vm_wrap *vm = (struct jsonnet_vm_wrap *)ptr;
+    jsonnet_destroy(vm->vm);
+
+    for (i = 0; i < vm->native_callbacks.len; ++i) {
+	struct native_callback_ctx *ctx = vm->native_callbacks.contexts[i];
+	RB_REALLOC_N(ctx, struct native_callback_ctx, 0);
+    }
+    RB_REALLOC_N(vm->native_callbacks.contexts, struct native_callback_ctx *, 0);
+
+    RB_REALLOC_N(vm, struct jsonnet_vm_wrap, 0);
+}
+
+static void
+vm_mark(void *ptr)
+{
+    int i;
+    struct jsonnet_vm_wrap *vm = (struct jsonnet_vm_wrap *)ptr;
+
+    rb_gc_mark(vm->import_callback);
+    for (i = 0; i < vm->native_callbacks.len; ++i) {
+	rb_gc_mark(vm->native_callbacks.contexts[i]->callback);
+    }
+}
+
+static VALUE
+vm_evaluate_file(VALUE self, VALUE fname, VALUE encoding, VALUE multi_p)
+{
+    int error;
+    char *result;
+    rb_encoding *const enc = rb_to_encoding(encoding);
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+
+    FilePathValue(fname);
+    if (RTEST(multi_p)) {
+	result = jsonnet_evaluate_file_multi(vm->vm, StringValueCStr(fname), &error);
+    } else {
+	result = jsonnet_evaluate_file(vm->vm, StringValueCStr(fname), &error);
+    }
+
+    if (error) {
+	raise_eval_error(vm->vm, result, rb_enc_get(fname));
+    }
+    return RTEST(multi_p) ? fileset_new(vm->vm, result, enc) : str_new_json(vm->vm, result, enc);
+}
+
+static VALUE
+vm_evaluate(VALUE self, VALUE snippet, VALUE fname, VALUE multi_p)
+{
+    int error;
+    char *result;
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+
+    rb_encoding *enc = rubyjsonnet_assert_asciicompat(StringValue(snippet));
+    FilePathValue(fname);
+    if (RTEST(multi_p)) {
+	result = jsonnet_evaluate_snippet_multi(vm->vm, StringValueCStr(fname),
+						StringValueCStr(snippet), &error);
+    } else {
+	result = jsonnet_evaluate_snippet(vm->vm, StringValueCStr(fname), StringValueCStr(snippet),
+					  &error);
+    }
+
+    if (error) {
+	raise_eval_error(vm->vm, result, rb_enc_get(fname));
+    }
+    return RTEST(multi_p) ? fileset_new(vm->vm, result, enc) : str_new_json(vm->vm, result, enc);
+}
+
+#define vm_bind_variable(type, self, key, val)                                    \
+    do {                                                                          \
+	struct jsonnet_vm_wrap *vm;                                               \
+                                                                                  \
+	rubyjsonnet_assert_asciicompat(StringValue(key));                         \
+	rubyjsonnet_assert_asciicompat(StringValue(val));                         \
+	TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm); \
+	jsonnet_##type(vm->vm, StringValueCStr(key), StringValueCStr(val));       \
+    } while (0)
+
+/*
+ * Binds an external variable to a value.
+ * @param [String] key name of the variable
+ * @param [String] val the value
+ */
+static VALUE
+vm_ext_var(VALUE self, VALUE key, VALUE val)
+{
+    vm_bind_variable(ext_var, self, key, val);
+    return Qnil;
+}
+
+/*
+ * Binds an external variable to a code fragment.
+ * @param [String] key  name of the variable
+ * @param [String] code Jsonnet expression
+ */
+static VALUE
+vm_ext_code(VALUE self, VALUE key, VALUE code)
+{
+    vm_bind_variable(ext_code, self, key, code);
+    return Qnil;
+}
+
+/*
+ * Binds a top-level argument to a value.
+ * @param [String] key name of the variable
+ * @param [String] val the value
+ */
+static VALUE
+vm_tla_var(VALUE self, VALUE key, VALUE val)
+{
+    vm_bind_variable(tla_var, self, key, val);
+    return Qnil;
+}
+
+/*
+ * Binds a top-level argument to a code fragment.
+ * @param [String] key  name of the variable
+ * @param [String] code Jsonnet expression
+ */
+static VALUE
+vm_tla_code(VALUE self, VALUE key, VALUE code)
+{
+    vm_bind_variable(tla_code, self, key, code);
+    return Qnil;
+}
+
+/*
+ * Adds library search paths
+ */
+static VALUE
+vm_jpath_add_m(int argc, const VALUE *argv, VALUE self)
+{
+    int i;
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+
+    for (i = 0; i < argc; ++i) {
+	VALUE jpath = argv[i];
+	FilePathValue(jpath);
+	jsonnet_jpath_add(vm->vm, StringValueCStr(jpath));
+    }
+    return Qnil;
+}
+
+static VALUE
+vm_set_max_stack(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_max_stack(vm->vm, NUM2UINT(val));
+    return Qnil;
+}
+
+static VALUE
+vm_set_gc_min_objects(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_gc_min_objects(vm->vm, NUM2UINT(val));
+    return Qnil;
+}
+
+static VALUE
+vm_set_gc_growth_trigger(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_gc_growth_trigger(vm->vm, NUM2DBL(val));
+    return Qnil;
+}
+
+/*
+ * Let #evaluate and #evaluate_file return a raw String instead of JSON-encoded string if val is
+ * true
+ * @param [Boolean] val
+ */
+static VALUE
+vm_set_string_output(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_string_output(vm->vm, RTEST(val));
+    return Qnil;
+}
+
+static VALUE
+vm_set_max_trace(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_max_trace(vm->vm, NUM2UINT(val));
+    return Qnil;
+}
+
+static VALUE
+vm_set_fmt_indent(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_fmt_indent(vm->vm, NUM2INT(val));
+    return val;
+}
+
+static VALUE
+vm_set_fmt_max_blank_lines(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_fmt_max_blank_lines(vm->vm, NUM2INT(val));
+    return val;
+}
+
+static VALUE
+vm_set_fmt_string(VALUE self, VALUE str)
+{
+    const char *ptr;
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    StringValue(str);
+    if (RSTRING_LEN(str) != 1) {
+	rb_raise(rb_eArgError, "fmt_string must have a length of 1");
+    }
+    ptr = RSTRING_PTR(str);
+    switch (*ptr) {
+	case 'd':
+	case 's':
+	case 'l':
+	    jsonnet_fmt_string(vm->vm, *ptr);
+	    return str;
+	default:
+	    rb_raise(rb_eArgError, "fmt_string only accepts 'd', 's', or 'l'");
+    }
+}
+
+static VALUE
+vm_set_fmt_comment(VALUE self, VALUE str)
+{
+    const char *ptr;
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    StringValue(str);
+    if (RSTRING_LEN(str) != 1) {
+	rb_raise(rb_eArgError, "fmt_comment must have a length of 1");
+    }
+    ptr = RSTRING_PTR(str);
+    switch (*ptr) {
+	case 'h':
+	case 's':
+	case 'l':
+	    jsonnet_fmt_comment(vm->vm, *ptr);
+	    return str;
+	default:
+	    rb_raise(rb_eArgError, "fmt_comment only accepts 'h', 's', or 'l'");
+    }
+}
+
+static VALUE
+vm_set_fmt_pad_arrays(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_fmt_pad_objects(vm->vm, RTEST(val) ? 1 : 0);
+    return val;
+}
+
+static VALUE
+vm_set_fmt_pad_objects(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_fmt_pad_objects(vm->vm, RTEST(val) ? 1 : 0);
+    return val;
+}
+
+static VALUE
+vm_set_fmt_pretty_field_names(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_fmt_pretty_field_names(vm->vm, RTEST(val) ? 1 : 0);
+    return val;
+}
+
+static VALUE
+vm_set_fmt_sort_imports(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    jsonnet_fmt_sort_imports(vm->vm, RTEST(val) ? 1 : 0);
+    return val;
+}
+
+static VALUE
+vm_fmt_file(VALUE self, VALUE fname, VALUE encoding)
+{
+    int error;
+    char *result;
+    rb_encoding *const enc = rb_to_encoding(encoding);
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+
+    FilePathValue(fname);
+    result = jsonnet_fmt_file(vm->vm, StringValueCStr(fname), &error);
+    if (error) {
+	raise_format_error(vm->vm, result, rb_enc_get(fname));
+    }
+    return str_new_json(vm->vm, result, enc);
+}
+
+static VALUE
+vm_fmt_snippet(VALUE self, VALUE snippet, VALUE fname)
+{
+    int error;
+    char *result;
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+
+    rb_encoding *enc = rubyjsonnet_assert_asciicompat(StringValue(snippet));
+    FilePathValue(fname);
+    result = jsonnet_fmt_snippet(vm->vm, StringValueCStr(fname), StringValueCStr(snippet), &error);
+    if (error) {
+	raise_format_error(vm->vm, result, rb_enc_get(fname));
+    }
+    return str_new_json(vm->vm, result, enc);
+}
+
+void
+rubyjsonnet_init_vm(VALUE mJsonnet)
+{
+    cVM = rb_define_class_under(mJsonnet, "VM", rb_cData);
+    rb_define_singleton_method(cVM, "new", vm_s_new, -1);
+    rb_define_private_method(cVM, "eval_file", vm_evaluate_file, 3);
+    rb_define_private_method(cVM, "eval_snippet", vm_evaluate, 3);
+    rb_define_private_method(cVM, "fmt_file", vm_fmt_file, 2);
+    rb_define_private_method(cVM, "fmt_snippet", vm_fmt_snippet, 2);
+    rb_define_method(cVM, "ext_var", vm_ext_var, 2);
+    rb_define_method(cVM, "ext_code", vm_ext_code, 2);
+    rb_define_method(cVM, "tla_var", vm_tla_var, 2);
+    rb_define_method(cVM, "tla_code", vm_tla_code, 2);
+    rb_define_method(cVM, "jpath_add", vm_jpath_add_m, -1);
+    rb_define_method(cVM, "max_stack=", vm_set_max_stack, 1);
+    rb_define_method(cVM, "gc_min_objects=", vm_set_gc_min_objects, 1);
+    rb_define_method(cVM, "gc_growth_trigger=", vm_set_gc_growth_trigger, 1);
+    rb_define_method(cVM, "string_output=", vm_set_string_output, 1);
+    rb_define_method(cVM, "max_trace=", vm_set_max_trace, 1);
+    rb_define_method(cVM, "fmt_indent=", vm_set_fmt_indent, 1);
+    rb_define_method(cVM, "fmt_max_blank_lines=", vm_set_fmt_max_blank_lines, 1);
+    rb_define_method(cVM, "fmt_string=", vm_set_fmt_string, 1);
+    rb_define_method(cVM, "fmt_comment=", vm_set_fmt_comment, 1);
+    rb_define_method(cVM, "fmt_pad_arrays=", vm_set_fmt_pad_arrays, 1);
+    rb_define_method(cVM, "fmt_pad_objects=", vm_set_fmt_pad_objects, 1);
+    rb_define_method(cVM, "fmt_pretty_field_names=", vm_set_fmt_pretty_field_names, 1);
+    rb_define_method(cVM, "fmt_sort_imports=", vm_set_fmt_sort_imports, 1);
+
+    rb_define_const(mJsonnet, "STRING_STYLE_DOUBLE", rb_str_new_cstr("d"));
+    rb_define_const(mJsonnet, "STRING_STYLE_SINGLE", rb_str_new_cstr("s"));
+    rb_define_const(mJsonnet, "STRING_STYLE_LEAVE", rb_str_new_cstr("l"));
+    rb_define_const(mJsonnet, "COMMENT_STYLE_HASH", rb_str_new_cstr("h"));
+    rb_define_const(mJsonnet, "COMMENT_STYLE_SLASH", rb_str_new_cstr("s"));
+    rb_define_const(mJsonnet, "COMMENT_STYLE_LEAVE", rb_str_new_cstr("l"));
+
+    rubyjsonnet_init_callbacks(cVM);
+
+    eEvaluationError = rb_define_class_under(mJsonnet, "EvaluationError", rb_eRuntimeError);
+    eFormatError = rb_define_class_under(mJsonnet, "FormatError", rb_eRuntimeError);
+}
+
+static void
+raise_error(VALUE exception_class, struct JsonnetVm *vm, char *msg, rb_encoding *enc)
+{
+    VALUE ex;
+    const int state = rubyjsonnet_jump_tag(msg);
+    if (state) {
+	/*
+	 * This is not actually an exception but another type of long jump
+	 * with the state, temporarily caught by rescue_callback().
+	 */
+	jsonnet_realloc(vm, msg, 0);
+	rb_jump_tag(state);
+    }
+
+    ex = rb_exc_new3(exception_class, rb_enc_str_new_cstr(msg, enc));
+    jsonnet_realloc(vm, msg, 0);
+    rb_exc_raise(ex);
+}
+
+/**
+ * raises an EvaluationError whose message is \c msg.
+ * @param[in] vm  a JsonnetVM
+ * @param[in] msg must be a NUL-terminated string returned by \c vm.
+ * @return never returns
+ * @throw EvaluationError
+ * @sa rescue_callback
+ */
+static void
+raise_eval_error(struct JsonnetVm *vm, char *msg, rb_encoding *enc)
+{
+    raise_error(eEvaluationError, vm, msg, enc);
+}
+
+static void
+raise_format_error(struct JsonnetVm *vm, char *msg, rb_encoding *enc)
+{
+    raise_error(eFormatError, vm, msg, enc);
+}
+
+/**
+ * Returns a String whose contents is equal to \c json.
+ * It automatically frees \c json just after constructing the return value.
+ *
+ * @param[in] vm   a JsonnetVM
+ * @param[in] json must be a NUL-terminated string returned by \c vm.
+ * @return Ruby string equal to \c json.
+ */
+static VALUE
+str_new_json(struct JsonnetVm *vm, char *json, rb_encoding *enc)
+{
+    VALUE str = rb_enc_str_new_cstr(json, enc);
+    jsonnet_realloc(vm, json, 0);
+    return str;
+}
+
+/**
+ * Returns a Hash, whose keys are file names in the multi-mode of Jsonnet,
+ * and whose values are corresponding JSON values.
+ * It automatically frees \c json just after constructing the return value.
+ *
+ * @param[in] vm   a JsonnetVM
+ * @param[in] buf  NUL-separated and double-NUL-terminated sequence of strings returned by \c vm.
+ * @return Hash
+ */
+static VALUE
+fileset_new(struct JsonnetVm *vm, char *buf, rb_encoding *enc)
+{
+    VALUE fileset = rb_hash_new();
+    char *ptr, *json;
+    for (ptr = buf; *ptr; ptr = json + strlen(json) + 1) {
+	json = ptr + strlen(ptr) + 1;
+	if (!*json) {
+	    VALUE ex = rb_exc_new3(eEvaluationError,
+				   rb_enc_sprintf(enc, "output file %s without body", ptr));
+	    jsonnet_realloc(vm, buf, 0);
+	    rb_exc_raise(ex);
+	}
+
+	rb_hash_aset(fileset, rb_enc_str_new_cstr(ptr, enc), rb_enc_str_new_cstr(json, enc));
+    }
+    jsonnet_realloc(vm, buf, 0);
+    return fileset;
+}