liquid-c 4.0.1 → 4.1.0

data/ext/liquid_c/c_buffer.c

@@ -0,0 +1,42 @@
+#include "c_buffer.h"
+
+static void c_buffer_expand_for_write(c_buffer_t *buffer, size_t write_size)
+{
+    size_t capacity = c_buffer_capacity(buffer);
+    size_t size = c_buffer_size(buffer);
+    size_t required_capacity = size + write_size;
+
+    if (capacity < 1)
+        capacity = 1;
+    do {
+        capacity *= 2;
+    } while (capacity < required_capacity);
+    buffer->data = xrealloc(buffer->data, capacity);
+    buffer->data_end = buffer->data + size;
+    buffer->capacity_end = buffer->data + capacity;
+}
+
+void c_buffer_zero_pad_for_alignment(c_buffer_t *buffer, size_t alignment)
+{
+    size_t unaligned_bytes = c_buffer_size(buffer) % alignment;
+    if (unaligned_bytes) {
+        size_t pad_size = alignment - unaligned_bytes;
+        uint8_t *padding = c_buffer_extend_for_write(buffer, pad_size);
+        memset(padding, 0, pad_size);
+    }
+}
+
+void c_buffer_reserve_for_write(c_buffer_t *buffer, size_t write_size)
+{
+    uint8_t *write_end = buffer->data_end + write_size;
+    if (write_end > buffer->capacity_end) {
+        c_buffer_expand_for_write(buffer, write_size);
+    }
+}
+
+void c_buffer_write(c_buffer_t *buffer, void *write_data, size_t write_size)
+{
+    c_buffer_reserve_for_write(buffer, write_size);
+    memcpy(buffer->data_end, write_data, write_size);
+    buffer->data_end += write_size;
+}

data/ext/liquid_c/c_buffer.h

@@ -0,0 +1,76 @@
+#ifndef LIQUID_C_BUFFER_H
+#define LIQUID_C_BUFFER_H
+
+#include <ruby.h>
+
+typedef struct c_buffer {
+    uint8_t *data;
+    uint8_t *data_end;
+    uint8_t *capacity_end;
+} c_buffer_t;
+
+static inline c_buffer_t c_buffer_init(void)
+{
+    return (c_buffer_t) { NULL, NULL, NULL };
+}
+
+static inline c_buffer_t c_buffer_allocate(size_t capacity)
+{
+    uint8_t *data = xmalloc(capacity);
+    return (c_buffer_t) { data, data, data + capacity };
+}
+
+static inline void c_buffer_free(c_buffer_t *buffer)
+{
+    xfree(buffer->data);
+}
+
+static inline void c_buffer_reset(c_buffer_t *buffer)
+{
+    buffer->data_end = buffer->data;
+}
+
+static inline size_t c_buffer_size(const c_buffer_t *buffer)
+{
+    return buffer->data_end - buffer->data;
+}
+
+static inline size_t c_buffer_capacity(const c_buffer_t *buffer)
+{
+    return buffer->capacity_end - buffer->data;
+}
+
+void c_buffer_zero_pad_for_alignment(c_buffer_t *buffer, size_t alignment);
+
+void c_buffer_reserve_for_write(c_buffer_t *buffer, size_t write_size);
+void c_buffer_write(c_buffer_t *buffer, void *data, size_t size);
+
+static inline void *c_buffer_extend_for_write(c_buffer_t *buffer, size_t write_size) {
+    c_buffer_reserve_for_write(buffer, write_size);
+    void *write_ptr = buffer->data_end;
+    buffer->data_end += write_size;
+    return write_ptr;
+}
+
+static inline void c_buffer_write_byte(c_buffer_t *buffer, uint8_t byte) {
+    c_buffer_write(buffer, &byte, 1);
+}
+
+static inline void c_buffer_write_ruby_value(c_buffer_t *buffer, VALUE value) {
+    c_buffer_write(buffer, &value, sizeof(VALUE));
+}
+
+static inline void c_buffer_rb_gc_mark(c_buffer_t *buffer)
+{
+    VALUE *buffer_end = (VALUE *)buffer->data_end;
+    for (VALUE *obj_ptr = (VALUE *)buffer->data; obj_ptr < buffer_end; obj_ptr++) {
+        rb_gc_mark(*obj_ptr);
+    }
+}
+
+static inline void c_buffer_concat(c_buffer_t *dest, c_buffer_t *src)
+{
+    c_buffer_write(dest, src->data, c_buffer_size(src));
+}
+
+#endif

data/ext/liquid_c/context.c

@@ -0,0 +1,233 @@
+#include "liquid.h"
+#include "context.h"
+#include "variable_lookup.h"
+#include "variable.h"
+#include "vm.h"
+#include "expression.h"
+#include "document_body.h"
+
+static VALUE cLiquidUndefinedVariable;
+ID id_aset, id_set_context;
+static ID id_has_key, id_aref, id_strainer, id_filter_methods_hash, id_strict_filters, id_global_filter;
+static ID id_ivar_scopes, id_ivar_environments, id_ivar_static_environments, id_ivar_strict_variables, id_ivar_interrupts, id_ivar_resource_limits, id_ivar_document_body;
+
+void context_internal_init(VALUE context_obj, context_t *context)
+{
+    context->self = context_obj;
+
+    context->environments = rb_ivar_get(context_obj, id_ivar_environments);
+    Check_Type(context->environments, T_ARRAY);
+
+    context->static_environments = rb_ivar_get(context_obj, id_ivar_static_environments);
+    Check_Type(context->static_environments, T_ARRAY);
+
+    context->scopes = rb_ivar_get(context_obj, id_ivar_scopes);
+    Check_Type(context->scopes, T_ARRAY);
+
+    context->strainer = rb_funcall(context->self, id_strainer, 0);
+    Check_Type(context->strainer, T_OBJECT);
+
+    context->filter_methods = rb_funcall(RBASIC_CLASS(context->strainer), id_filter_methods_hash, 0);
+    Check_Type(context->filter_methods, T_HASH);
+
+    context->interrupts = rb_ivar_get(context->self, id_ivar_interrupts);
+    Check_Type(context->interrupts, T_ARRAY);
+
+    context->resource_limits_obj = rb_ivar_get(context->self, id_ivar_resource_limits);;
+    ResourceLimits_Get_Struct(context->resource_limits_obj, context->resource_limits);
+
+    context->strict_variables = false;
+    context->strict_filters = RTEST(rb_funcall(context->self, id_strict_filters, 0));
+    context->global_filter = rb_funcall(context->self, id_global_filter, 0);
+}
+
+void context_mark(context_t *context)
+{
+    rb_gc_mark(context->self);
+    rb_gc_mark(context->environments);
+    rb_gc_mark(context->static_environments);
+    rb_gc_mark(context->scopes);
+    rb_gc_mark(context->strainer);
+    rb_gc_mark(context->filter_methods);
+    rb_gc_mark(context->interrupts);
+    rb_gc_mark(context->resource_limits_obj);
+    rb_gc_mark(context->global_filter);
+}
+
+static context_t *context_from_obj(VALUE self)
+{
+    return &vm_from_context(self)->context;
+}
+
+static VALUE context_evaluate(VALUE self, VALUE expression)
+{
+    // Scalar type stored directly in the VALUE, this needs to be checked anyways to use RB_BUILTIN_TYPE
+    if (RB_SPECIAL_CONST_P(expression))
+        return expression;
+
+    switch (RB_BUILTIN_TYPE(expression)) {
+        case T_DATA:
+        {
+            if (RTYPEDDATA_P(expression) && RTYPEDDATA_TYPE(expression) == &expression_data_type) {
+                if (RBASIC_CLASS(expression) == cLiquidCExpression) {
+                    return internal_expression_evaluate(DATA_PTR(expression), self);
+                } else {
+                    assert(RBASIC_CLASS(expression) == cLiquidCVariableExpression);
+                    return internal_variable_expression_evaluate(DATA_PTR(expression), self);
+                }
+            }
+            break; // e.g. BigDecimal
+        }
+        case T_OBJECT: // may be Liquid::VariableLookup or Liquid::RangeLookup
+        {
+            VALUE result = rb_check_funcall(expression, id_evaluate, 1, &self);
+            return RB_LIKELY(result != Qundef) ? result : expression;
+        }
+        default:
+            break;
+    }
+    return expression;
+}
+
+void context_maybe_raise_undefined_variable(VALUE self, VALUE key)
+{
+    context_t *context = context_from_obj(self);
+    if (context->strict_variables) {
+        Check_Type(key, T_STRING);
+        rb_enc_raise(utf8_encoding, cLiquidUndefinedVariable, "undefined variable %s", RSTRING_PTR(key));
+    }
+}
+
+static bool environments_find_variable(VALUE environments, VALUE key, bool strict_variables, VALUE raise_on_not_found, VALUE *scope_out, VALUE *variable_out) {
+    VALUE variable = Qnil;
+    Check_Type(environments, T_ARRAY);
+
+    for (long i = 0; i < RARRAY_LEN(environments); i++) {
+        VALUE this_environ = RARRAY_AREF(environments, i);
+        if (RB_LIKELY(TYPE(this_environ) == T_HASH)) {
+            // Does not invoke any default value proc, this is equivalent in
+            // cost and semantics to #key? but loads the value as well
+            variable = rb_hash_lookup2(this_environ, key, Qundef);
+            if (variable != Qundef) {
+                *variable_out = variable;
+                *scope_out = this_environ;
+                return true;
+            }
+
+            if (!(RTEST(raise_on_not_found) && strict_variables)) {
+                // If we aren't running strictly, we need to invoke the default
+                // value proc, rb_hash_aref does this
+                variable = rb_hash_aref(this_environ, key);
+                if (variable != Qnil) {
+                    *variable_out = variable;
+                    *scope_out = this_environ;
+                    return true;
+                }
+            }
+        } else if (RTEST(rb_funcall(this_environ, id_has_key, 1, key))) {
+            // Slow path: It is valid to pass a non-hash value to Liquid as an
+            // environment if it supports #key? and #[]
+            *variable_out = rb_funcall(this_environ, id_aref, 1, key);
+            *scope_out = this_environ;
+            return true;
+        }
+    }
+    return false;
+}
+
+VALUE context_find_variable(context_t *context, VALUE key, VALUE raise_on_not_found)
+{
+    VALUE self = context->self;
+    VALUE scope = Qnil, variable = Qnil;
+
+    VALUE scopes = context->scopes;
+    for (long i = 0; i < RARRAY_LEN(scopes); i++) {
+        VALUE this_scope = RARRAY_AREF(scopes, i);
+        if (RB_LIKELY(TYPE(this_scope) == T_HASH)) {
+            // Does not invoke any default value proc, this is equivalent in
+            // cost and semantics to #key? but loads the value as well
+            variable = rb_hash_lookup2(this_scope, key, Qundef);
+            if (variable != Qundef) {
+                scope = this_scope;
+                goto variable_found;
+            }
+        } else if (RTEST(rb_funcall(this_scope, id_has_key, 1, key))) {
+            // Slow path: It is valid to pass a non-hash value to Liquid as a
+            // scope if it supports #key? and #[]
+            variable = rb_funcall(this_scope, id_aref, 1, key);
+            goto variable_found;
+        }
+    }
+
+    if (environments_find_variable(context->environments, key, context->strict_variables, raise_on_not_found,
+                                   &scope, &variable))
+        goto variable_found;
+
+    if (environments_find_variable(context->static_environments, key, context->strict_variables, raise_on_not_found,
+                                   &scope, &variable))
+        goto variable_found;
+
+    if (RTEST(raise_on_not_found)) {
+        context_maybe_raise_undefined_variable(self, key);
+    }
+    variable = Qnil;
+
+variable_found:
+    variable = materialize_proc(self, scope, key, variable);
+    variable = value_to_liquid_and_set_context(variable, self);
+
+    return variable;
+}
+
+static VALUE context_find_variable_method(VALUE self, VALUE key, VALUE raise_on_not_found)
+{
+    return context_find_variable(context_from_obj(self), key, raise_on_not_found);
+}
+
+static VALUE context_set_strict_variables(VALUE self, VALUE strict_variables)
+{
+    context_t *context = context_from_obj(self);
+    context->strict_variables = RTEST(strict_variables);
+    rb_ivar_set(self, id_ivar_strict_variables, strict_variables);
+    return Qnil;
+}
+
+// Shopify requires checking if we are filtering, so provide a
+// way to do that in liquid-c until we figure out how we want to
+// support that longer term.
+VALUE context_filtering_p(VALUE self)
+{
+    return liquid_vm_filtering(self) ? Qtrue : Qfalse;
+}
+
+void liquid_define_context(void)
+{
+    id_has_key = rb_intern("key?");
+    id_aset = rb_intern("[]=");
+    id_aref = rb_intern("[]");
+    id_set_context = rb_intern("context=");
+    id_strainer = rb_intern("strainer");
+    id_filter_methods_hash = rb_intern("filter_methods_hash");
+    id_strict_filters = rb_intern("strict_filters");
+    id_global_filter = rb_intern("global_filter");
+
+    id_ivar_scopes = rb_intern("@scopes");
+    id_ivar_environments = rb_intern("@environments");
+    id_ivar_static_environments = rb_intern("@static_environments");
+    id_ivar_strict_variables = rb_intern("@strict_variables");
+    id_ivar_interrupts = rb_intern("@interrupts");
+    id_ivar_resource_limits = rb_intern("@resource_limits");
+    id_ivar_document_body = rb_intern("@document_body");
+
+    cLiquidVariableLookup = rb_const_get(mLiquid, rb_intern("VariableLookup"));
+    rb_global_variable(&cLiquidVariableLookup);
+
+    cLiquidUndefinedVariable = rb_const_get(mLiquid, rb_intern("UndefinedVariable"));
+    rb_global_variable(&cLiquidUndefinedVariable);
+
+    VALUE cLiquidContext = rb_const_get(mLiquid, rb_intern("Context"));
+    rb_define_method(cLiquidContext, "c_evaluate", context_evaluate, 1);
+    rb_define_method(cLiquidContext, "c_find_variable", context_find_variable_method, 2);
+    rb_define_method(cLiquidContext, "c_strict_variables=", context_set_strict_variables, 1);
+    rb_define_private_method(cLiquidContext, "c_filtering?", context_filtering_p, 0);
+}

data/ext/liquid_c/context.h

@@ -0,0 +1,70 @@
+#if !defined(LIQUID_CONTEXT_H)
+#define LIQUID_CONTEXT_H
+
+#include "resource_limits.h"
+
+typedef struct context {
+    VALUE self;
+    VALUE environments;
+    VALUE static_environments;
+    VALUE scopes;
+    VALUE strainer;
+    VALUE filter_methods;
+    VALUE interrupts;
+    VALUE resource_limits_obj;
+    resource_limits_t *resource_limits;
+    VALUE global_filter;
+    bool strict_variables;
+    bool strict_filters;
+} context_t;
+
+void liquid_define_context(void);
+void context_internal_init(VALUE context_obj, context_t *context);
+void context_mark(context_t *context);
+VALUE context_find_variable(context_t *context, VALUE key, VALUE raise_on_not_found);
+void context_maybe_raise_undefined_variable(VALUE self, VALUE key);
+
+extern ID id_aset, id_set_context;
+
+#ifndef RB_SPECIAL_CONST_P
+// RB_SPECIAL_CONST_P added in Ruby 2.3
+#define RB_SPECIAL_CONST_P SPECIAL_CONST_P
+#endif
+
+inline static VALUE value_to_liquid_and_set_context(VALUE value, VALUE context_to_set)
+{
+    // Scalar type stored directly in the VALUE, these all have a #to_liquid
+    // that returns self, and should have no #context= method
+    if (RB_SPECIAL_CONST_P(value))
+        return value;
+
+    VALUE klass = RBASIC(value)->klass;
+
+    // More basic types having #to_liquid of self and no #context=
+    if (klass == rb_cString || klass == rb_cArray || klass == rb_cHash)
+        return value;
+
+    value = rb_funcall(value, id_to_liquid, 0);
+
+    if (rb_respond_to(value, id_set_context))
+        rb_funcall(value, id_set_context, 1, context_to_set);
+
+    return value;
+}
+
+
+inline static VALUE materialize_proc(VALUE context, VALUE scope, VALUE key, VALUE value)
+{
+    if (scope != Qnil && rb_obj_is_proc(value) && rb_respond_to(scope, id_aset)) {
+        if (rb_proc_arity(value) == 1) {
+            value = rb_funcall(value, id_call, 1, context);
+        } else {
+            value = rb_funcall(value, id_call, 0);
+        }
+        rb_funcall(scope, id_aset, 2, key, value);
+    }
+    return value;
+}
+
+#endif
+

data/ext/liquid_c/document_body.c

@@ -0,0 +1,89 @@
+#include <ruby.h>
+#include <stdalign.h>
+#include "liquid.h"
+#include "vm_assembler.h"
+#include "document_body.h"
+
+static VALUE cLiquidCDocumentBody;
+
+static void document_body_mark(void *ptr)
+{
+    document_body_t *body = ptr;
+    rb_gc_mark(body->constants);
+}
+
+static void document_body_free(void *ptr)
+{
+    document_body_t *body = ptr;
+    c_buffer_free(&body->buffer);
+    xfree(body);
+}
+
+static size_t document_body_memsize(const void *ptr)
+{
+    const document_body_t *body = ptr;
+    return sizeof(document_body_t) + c_buffer_size(&body->buffer);
+}
+
+const rb_data_type_t document_body_data_type = {
+    "liquid_document_body",
+    { document_body_mark, document_body_free, document_body_memsize },
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE document_body_allocate(VALUE klass)
+{
+    document_body_t *body;
+
+    VALUE obj = TypedData_Make_Struct(klass, document_body_t, &document_body_data_type, body);
+    body->self = obj;
+    body->constants = rb_ary_new();
+    body->buffer = c_buffer_init();
+
+    return obj;
+}
+
+#define DocumentBody_Get_Struct(obj, sval) TypedData_Get_Struct(obj, document_body_t, &document_body_data_type, sval)
+
+VALUE document_body_new_instance(void)
+{
+    return rb_class_new_instance(0, NULL, cLiquidCDocumentBody);
+}
+
+document_body_entry_t document_body_write_block_body(VALUE self, bool blank, uint32_t render_score, vm_assembler_t *code)
+{
+    assert(!RB_OBJ_FROZEN(self));
+
+    document_body_t *body;
+    DocumentBody_Get_Struct(self, body);
+
+    c_buffer_zero_pad_for_alignment(&body->buffer, alignof(block_body_header_t));
+
+    size_t buffer_offset = c_buffer_size(&body->buffer);
+
+    assert(c_buffer_size(&code->constants) % sizeof(VALUE) == 0);
+    uint32_t constants_len = (uint32_t)(c_buffer_size(&code->constants) / sizeof(VALUE));
+
+    block_body_header_t *buf_block_body = c_buffer_extend_for_write(&body->buffer, sizeof(block_body_header_t));
+    buf_block_body->instructions_offset = (uint32_t)sizeof(block_body_header_t);
+    buf_block_body->instructions_bytes = (uint32_t)c_buffer_size(&code->instructions);
+    buf_block_body->constants_offset = (uint32_t)RARRAY_LEN(body->constants);
+    buf_block_body->constants_len = constants_len;
+    buf_block_body->flags = 0;
+    if (blank) buf_block_body->flags |= BLOCK_BODY_HEADER_FLAG_BLANK;
+    buf_block_body->render_score = render_score;
+    buf_block_body->max_stack_size = code->max_stack_size;
+
+    c_buffer_concat(&body->buffer, &code->instructions);
+
+    rb_ary_cat(body->constants, (VALUE *)code->constants.data, constants_len);
+
+    return (document_body_entry_t) { .body = body, .buffer_offset = buffer_offset };
+}
+
+void liquid_define_document_body(void)
+{
+    cLiquidCDocumentBody = rb_define_class_under(mLiquidC, "DocumentBody", rb_cObject);
+    rb_global_variable(&cLiquidCDocumentBody);
+    rb_define_alloc_func(cLiquidCDocumentBody, document_body_allocate);
+}

data/ext/liquid_c/document_body.h

@@ -0,0 +1,59 @@
+#ifndef LIQUID_DOCUMENT_BODY_H
+#define LIQUID_DOCUMENT_BODY_H
+
+#include "c_buffer.h"
+#include "vm_assembler.h"
+
+typedef struct block_body_header {
+    uint32_t instructions_offset;
+    uint32_t instructions_bytes;
+    uint32_t constants_offset;
+    uint32_t constants_len;
+    uint32_t flags;
+    uint32_t render_score;
+    uint64_t max_stack_size;
+} block_body_header_t;
+
+#define BLOCK_BODY_HEADER_FLAG_BLANK (1 << 0)
+#define BLOCK_BODY_HEADER_BLANK_P(header) (header->flags & BLOCK_BODY_HEADER_FLAG_BLANK)
+
+typedef struct document_body {
+    VALUE self;
+    VALUE constants;
+    c_buffer_t buffer;
+} document_body_t;
+
+typedef struct document_body_entry {
+    document_body_t *body;
+    size_t buffer_offset;
+} document_body_entry_t;
+
+void liquid_define_document_body(void);
+VALUE document_body_new_instance(void);
+document_body_entry_t document_body_write_block_body(VALUE self, bool blank, uint32_t render_score, vm_assembler_t *code);
+
+static inline void document_body_entry_mark(document_body_entry_t *entry)
+{
+    rb_gc_mark(entry->body->self);
+    rb_gc_mark(entry->body->constants);
+}
+
+static inline block_body_header_t *document_body_get_block_body_header_ptr(const document_body_entry_t *entry)
+{
+    return (block_body_header_t *)(entry->body->buffer.data + entry->buffer_offset);
+}
+
+static inline const VALUE *document_body_get_constants_ptr(const document_body_entry_t *entry)
+{
+    block_body_header_t *header = document_body_get_block_body_header_ptr(entry);
+    return RARRAY_PTR(entry->body->constants) + header->constants_offset;
+}
+
+static inline void document_body_ensure_compile_finished(document_body_t *body)
+{
+    if (RB_UNLIKELY(!RB_OBJ_FROZEN(body->self))) {
+        rb_raise(rb_eRuntimeError, "Liquid document hasn't finished compilation");
+    }
+}
+
+#endif

data/ext/liquid_c/expression.c

@@ -0,0 +1,116 @@
+#include "liquid.h"
+#include "vm_assembler.h"
+#include "parser.h"
+#include "vm.h"
+#include "expression.h"
+
+VALUE cLiquidCExpression;
+
+static void expression_mark(void *ptr)
+{
+    expression_t *expression = ptr;
+    vm_assembler_gc_mark(&expression->code);
+}
+
+static void expression_free(void *ptr)
+{
+    expression_t *expression = ptr;
+    vm_assembler_free(&expression->code);
+    xfree(expression);
+}
+
+static size_t expression_memsize(const void *ptr)
+{
+    const expression_t *expression = ptr;
+    return sizeof(expression_t) + vm_assembler_alloc_memsize(&expression->code);
+}
+
+const rb_data_type_t expression_data_type = {
+    "liquid_expression",
+    { expression_mark, expression_free, expression_memsize, },
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE expression_new(VALUE klass, expression_t **expression_ptr)
+{
+    expression_t *expression;
+    VALUE obj = TypedData_Make_Struct(klass, expression_t, &expression_data_type, expression);
+    *expression_ptr = expression;
+    vm_assembler_init(&expression->code);
+    return obj;
+}
+
+static VALUE internal_expression_parse(parser_t *p)
+{
+    if (p->cur.type == TOKEN_EOS)
+        return Qnil;
+
+    // Avoid allocating an expression object just to wrap a constant
+    VALUE const_obj = try_parse_constant_expression(p);
+    if (const_obj != Qundef)
+        return const_obj;
+
+    expression_t *expression;
+    VALUE expr_obj = expression_new(cLiquidCExpression, &expression);
+
+    parse_and_compile_expression(p, &expression->code);
+    assert(expression->code.stack_size == 1);
+    vm_assembler_add_leave(&expression->code);
+
+    return expr_obj;
+}
+
+static VALUE expression_strict_parse(VALUE klass, VALUE markup)
+{
+    if (NIL_P(markup))
+        return Qnil;
+
+    StringValue(markup);
+    char *start = RSTRING_PTR(markup);
+
+    parser_t p;
+    init_parser(&p, start, start + RSTRING_LEN(markup));
+    VALUE expr_obj = internal_expression_parse(&p);
+
+    if (p.cur.type != TOKEN_EOS)
+        rb_enc_raise(utf8_encoding, cLiquidSyntaxError, "[:%s] is not a valid expression", symbol_names[p.cur.type]);
+
+    return expr_obj;
+}
+
+VALUE expression_evaluate(VALUE self, VALUE context)
+{
+    expression_t *expression;
+    Expression_Get_Struct(self, expression);
+    return liquid_vm_evaluate(context, &expression->code);
+}
+
+VALUE internal_expression_evaluate(expression_t *expression, VALUE context)
+{
+    return liquid_vm_evaluate(context, &expression->code);
+}
+
+static VALUE expression_disassemble(VALUE self)
+{
+    expression_t *expression;
+    Expression_Get_Struct(self, expression);
+
+    VALUE constants = rb_ary_new();
+    uint32_t constants_len = (uint32_t)(c_buffer_size(&expression->code.constants) / sizeof(VALUE));
+    rb_ary_cat(constants, (VALUE *)expression->code.constants.data, constants_len);
+
+    return vm_assembler_disassemble(
+        expression->code.instructions.data,
+        expression->code.instructions.data_end,
+        &constants
+    );
+}
+
+void liquid_define_expression(void)
+{
+    cLiquidCExpression = rb_define_class_under(mLiquidC, "Expression", rb_cObject);
+    rb_undef_alloc_func(cLiquidCExpression);
+    rb_define_singleton_method(cLiquidCExpression, "strict_parse", expression_strict_parse, 1);
+    rb_define_method(cLiquidCExpression, "evaluate", expression_evaluate, 1);
+    rb_define_method(cLiquidCExpression, "disassemble", expression_disassemble, 0);
+}