liquid-c 4.0.1 → 4.1.0

data/ext/liquid_c/expression.h

@@ -0,0 +1,24 @@
+#if !defined(LIQUID_EXPRESSION_H)
+#define LIQUID_EXPRESSION_H
+
+#include "vm_assembler.h"
+#include "parser.h"
+
+extern VALUE cLiquidCExpression;
+extern const rb_data_type_t expression_data_type;
+
+typedef struct expression {
+    vm_assembler_t code;
+} expression_t;
+
+extern const rb_data_type_t expression_data_type;
+#define Expression_Get_Struct(obj, sval) TypedData_Get_Struct(obj, expression_t, &expression_data_type, sval)
+
+void liquid_define_expression(void);
+
+VALUE expression_new(VALUE klass, expression_t **expression_ptr);
+VALUE expression_evaluate(VALUE self, VALUE context);
+VALUE internal_expression_evaluate(expression_t *expression, VALUE context);
+
+#endif
+

data/ext/liquid_c/extconf.rb

@@ -1,14 +1,24 @@
-require 'mkmf'
-$CFLAGS << ' -std=c99 -Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers'
+# frozen_string_literal: true
+
+require "mkmf"
+$CFLAGS << " -std=c11 -Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers"
+append_cflags("-fvisibility=hidden")
 # In Ruby 2.6 and earlier, the Ruby headers did not have struct timespec defined
-valid_headers = RbConfig::CONFIG['host_os'] !~ /linux/ || Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7")
-pedantic = !ENV['LIQUID_C_PEDANTIC'].to_s.empty?
+valid_headers = RbConfig::CONFIG["host_os"] !~ /linux/ || Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7")
+pedantic = !ENV["LIQUID_C_PEDANTIC"].to_s.empty?
 if pedantic && valid_headers
-  $CFLAGS << ' -Werror'
+  $CFLAGS << " -Werror"
 end
-compiler = RbConfig::MAKEFILE_CONFIG['CC']
-if ENV['DEBUG'] == 'true' && compiler =~ /gcc|g\+\+/
-  $CFLAGS << ' -fbounds-check'
+if ENV["DEBUG"] == "true"
+  append_cflags("-fbounds-check")
+  CONFIG["optflags"] = " -O0"
+else
+  $CFLAGS << " -DNDEBUG"
 end
-$warnflags.gsub!(/-Wdeclaration-after-statement/, "") if $warnflags
+
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0") # added in 2.7
+  $CFLAGS << " -DHAVE_RB_HASH_BULK_INSERT"
+end
+
+$warnflags&.gsub!(/-Wdeclaration-after-statement/, "")
 create_makefile("liquid_c")

data/ext/liquid_c/intutil.h

@@ -0,0 +1,22 @@
+#ifndef LIQUID_INTUTIL_H
+#define LIQUID_INTUTIL_H
+
+#include <stdint.h>
+
+static inline unsigned int bytes_to_uint24(const uint8_t *bytes)
+{
+    return (bytes[0] << 16) | (bytes[1] << 8) | bytes[2];
+}
+
+static inline void uint24_to_bytes(unsigned int num, uint8_t *bytes)
+{
+    assert(num < (1 << 24));
+
+    bytes[0] = num >> 16;
+    bytes[1] = num >> 8;
+    bytes[2] = num;
+
+    assert(bytes_to_uint24(bytes) == num);
+}
+
+#endif

data/ext/liquid_c/lexer.c

@@ -1,5 +1,6 @@
 #include "liquid.h"
 #include "lexer.h"
+#include "usage.h"
 #include <stdio.h>
 
 const char *symbol_names[TOKEN_END] = {
@@ -59,8 +60,6 @@ inline static const char *scan_past(const char *cur, const char *end, char targe
     const char *tok_end = str + (n); \
     token->type = (t); \
     token->val = str; \
-    if (str != start) token->flags |= TOKEN_SPACE_PREFIX; \
-    if (tok_end < end && ISSPACE(*tok_end)) token->flags |= TOKEN_SPACE_SUFFIX; \
     return (token->val_end = tok_end); \
 }
 
@@ -109,6 +108,11 @@ const char *lex_one(const char *start, const char *end, lexer_token_t *token)
         }
     }
 
+    // Instrument for bug: https://github.com/Shopify/liquid-c/pull/120
+    if (c == '-' && str + 1 < end && str[1] == '.') {
+        usage_increment("liquid_c_negative_float_without_integer");
+    }
+
     if (ISDIGIT(c) || c == '-') {
         int has_dot = 0;
         cur = str;

data/ext/liquid_c/lexer.h

@@ -24,9 +24,6 @@ enum lexer_token_type {
     TOKEN_END = 256
 };
 
-#define TOKEN_SPACE_PREFIX 0x1
-#define TOKEN_SPACE_SUFFIX 0x2
-#define TOKEN_SPACE_AFFIX (TOKEN_SPACE_PREFIX | TOKEN_SPACE_SUFFIX)
 #define TOKEN_FLOAT_NUMBER 0x4
 
 typedef struct lexer_token {
@@ -42,5 +39,23 @@ inline static VALUE token_to_rstr(lexer_token_t token) {
     return rb_enc_str_new(token.val, token.val_end - token.val, utf8_encoding);
 }
 
+inline static VALUE token_check_for_symbol(lexer_token_t token) {
+    return rb_check_symbol_cstr(token.val, token.val_end - token.val, utf8_encoding);
+}
+
+inline static VALUE token_to_rstr_leveraging_existing_symbol(lexer_token_t token) {
+    VALUE sym = token_check_for_symbol(token);
+    if (RB_LIKELY(sym != Qnil))
+        return rb_sym2str(sym);
+    return token_to_rstr(token);
+}
+
+inline static VALUE token_to_rsym(lexer_token_t token) {
+    VALUE sym = token_check_for_symbol(token);
+    if (RB_LIKELY(sym != Qnil))
+        return sym;
+    return rb_str_intern(token_to_rstr(token));
+}
+
 #endif
 

data/ext/liquid_c/liquid.c

@@ -3,23 +3,93 @@
 #include "variable.h"
 #include "lexer.h"
 #include "parser.h"
+#include "raw.h"
+#include "resource_limits.h"
+#include "expression.h"
+#include "document_body.h"
 #include "block.h"
+#include "context.h"
+#include "parse_context.h"
+#include "variable_lookup.h"
+#include "vm_assembler_pool.h"
+#include "vm.h"
+#include "usage.h"
+
+ID id_evaluate;
+ID id_to_liquid;
+ID id_to_s;
+ID id_call;
+ID id_compile_evaluate;
+ID id_ivar_line_number;
+
+VALUE mLiquid, mLiquidC, cLiquidVariable, cLiquidTemplate, cLiquidBlockBody;
+VALUE cLiquidVariableLookup, cLiquidRangeLookup;
+VALUE cLiquidArgumentError, cLiquidSyntaxError, cMemoryError;
 
-VALUE mLiquid, mLiquidC, cLiquidSyntaxError, cLiquidVariable, cLiquidTemplate;
 rb_encoding *utf8_encoding;
+int utf8_encoding_index;
+
+__attribute__((noreturn)) void raise_non_utf8_encoding_error(VALUE string, const char *value_name)
+{
+    rb_raise(rb_eEncCompatError, "non-UTF8 encoded %s (%"PRIsVALUE") not supported", value_name, rb_obj_encoding(string));
+}
 
-void Init_liquid_c(void)
+RUBY_FUNC_EXPORTED void Init_liquid_c(void)
 {
+    id_evaluate = rb_intern("evaluate");
+    id_to_liquid = rb_intern("to_liquid");
+    id_to_s = rb_intern("to_s");
+    id_call = rb_intern("call");
+    id_compile_evaluate = rb_intern("compile_evaluate");
+    id_ivar_line_number = rb_intern("@line_number");
+
     utf8_encoding = rb_utf8_encoding();
+    utf8_encoding_index = rb_enc_to_index(utf8_encoding);
+
     mLiquid = rb_define_module("Liquid");
+    rb_global_variable(&mLiquid);
+
     mLiquidC = rb_define_module_under(mLiquid, "C");
+    rb_global_variable(&mLiquidC);
+
+    cLiquidArgumentError = rb_const_get(mLiquid, rb_intern("ArgumentError"));
+    rb_global_variable(&cLiquidArgumentError);
+
     cLiquidSyntaxError = rb_const_get(mLiquid, rb_intern("SyntaxError"));
+    rb_global_variable(&cLiquidSyntaxError);
+
+    cMemoryError = rb_const_get(mLiquid, rb_intern("MemoryError"));
+    rb_global_variable(&cMemoryError);
+
     cLiquidVariable = rb_const_get(mLiquid, rb_intern("Variable"));
+    rb_global_variable(&cLiquidVariable);
+
     cLiquidTemplate = rb_const_get(mLiquid, rb_intern("Template"));
+    rb_global_variable(&cLiquidTemplate);
+
+    cLiquidBlockBody = rb_const_get(mLiquid, rb_intern("BlockBody"));
+    rb_global_variable(&cLiquidBlockBody);
+
+    cLiquidVariableLookup = rb_const_get(mLiquid, rb_intern("VariableLookup"));
+    rb_global_variable(&cLiquidVariableLookup);
+
+    cLiquidRangeLookup = rb_const_get(mLiquid, rb_intern("RangeLookup"));
+    rb_global_variable(&cLiquidRangeLookup);
 
-    init_liquid_tokenizer();
-    init_liquid_parser();
-    init_liquid_variable();
-    init_liquid_block();
+    liquid_define_tokenizer();
+    liquid_define_parser();
+    liquid_define_raw();
+    liquid_define_resource_limits();
+    liquid_define_expression();
+    liquid_define_variable();
+    liquid_define_document_body();
+    liquid_define_block_body();
+    liquid_define_context();
+    liquid_define_parse_context();
+    liquid_define_variable_lookup();
+    liquid_define_vm_assembler_pool();
+    liquid_define_vm_assembler();
+    liquid_define_vm();
+    liquid_define_usage();
 }
 

data/ext/liquid_c/liquid.h

@@ -5,8 +5,31 @@
 #include <ruby/encoding.h>
 #include <stdbool.h>
 
-extern VALUE mLiquid, mLiquidC, cLiquidSyntaxError, cLiquidVariable, cLiquidTemplate;
+extern ID id_evaluate;
+extern ID id_to_liquid;
+extern ID id_to_s;
+extern ID id_call;
+extern ID id_compile_evaluate;
+extern ID id_ivar_line_number;
+
+extern VALUE mLiquid, mLiquidC, cLiquidVariable, cLiquidTemplate, cLiquidBlockBody;
+extern VALUE cLiquidVariableLookup, cLiquidRangeLookup;
+extern VALUE cLiquidArgumentError, cLiquidSyntaxError, cMemoryError;
 extern rb_encoding *utf8_encoding;
+extern int utf8_encoding_index;
+
+__attribute__((noreturn)) void raise_non_utf8_encoding_error(VALUE string, const char *string_name);
+
+static inline void check_utf8_encoding(VALUE string, const char *string_name)
+{
+    if (RB_UNLIKELY(RB_ENCODING_GET_INLINED(string) != utf8_encoding_index))
+        raise_non_utf8_encoding_error(string, string_name);
+}
+
+#ifndef RB_LIKELY
+// RB_LIKELY added in Ruby 2.4
+#define RB_LIKELY(x) (__builtin_expect(!!(x), 1))
+#endif
 
 #endif
 

data/ext/liquid_c/parse_context.c

@@ -0,0 +1,76 @@
+#include "parse_context.h"
+#include "document_body.h"
+
+static ID id_document_body, id_vm_assembler_pool;
+
+static bool parse_context_document_body_initialized_p(VALUE self)
+{
+    return RTEST(rb_attr_get(self, id_document_body));
+}
+
+static void parse_context_init_document_body(VALUE self)
+{
+    VALUE document_body = document_body_new_instance();
+    rb_ivar_set(self, id_document_body, document_body);
+}
+
+VALUE parse_context_get_document_body(VALUE self)
+{
+    assert(parse_context_document_body_initialized_p(self));
+
+    return rb_ivar_get(self, id_document_body);
+}
+
+vm_assembler_pool_t *parse_context_init_vm_assembler_pool(VALUE self)
+{
+    assert(!RTEST(rb_attr_get(self, id_vm_assembler_pool)));
+
+    VALUE vm_assembler_pool_obj = vm_assembler_pool_new();
+    rb_ivar_set(self, id_vm_assembler_pool, vm_assembler_pool_obj);
+
+    vm_assembler_pool_t *vm_assembler_pool;
+    VMAssemblerPool_Get_Struct(vm_assembler_pool_obj, vm_assembler_pool);
+
+    return vm_assembler_pool;
+}
+
+vm_assembler_pool_t *parse_context_get_vm_assembler_pool(VALUE self)
+{
+    VALUE obj = rb_ivar_get(self, id_vm_assembler_pool);
+
+    if (obj == Qnil) {
+        rb_raise(rb_eRuntimeError, "Liquid::ParseContext#start_liquid_c_parsing has not yet been called");
+    }
+
+    vm_assembler_pool_t *vm_assembler_pool;
+    VMAssemblerPool_Get_Struct(obj, vm_assembler_pool);
+    return vm_assembler_pool;
+}
+
+static VALUE parse_context_start_liquid_c_parsing(VALUE self)
+{
+    if (RB_UNLIKELY(parse_context_document_body_initialized_p(self))) {
+        rb_raise(rb_eRuntimeError, "liquid-c parsing already started for this parse context");
+    }
+    parse_context_init_document_body(self);
+    parse_context_init_vm_assembler_pool(self);
+    return Qnil;
+}
+
+static VALUE parse_context_cleanup_liquid_c_parsing(VALUE self)
+{
+    rb_obj_freeze(rb_ivar_get(self, id_document_body));
+    rb_ivar_set(self, id_document_body, Qnil);
+    rb_ivar_set(self, id_vm_assembler_pool, Qnil);
+    return Qnil;
+}
+
+void liquid_define_parse_context(void)
+{
+    id_document_body = rb_intern("document_body");
+    id_vm_assembler_pool = rb_intern("vm_assembler_pool");
+
+    VALUE cLiquidParseContext = rb_const_get(mLiquid, rb_intern("ParseContext"));
+    rb_define_method(cLiquidParseContext, "start_liquid_c_parsing", parse_context_start_liquid_c_parsing, 0);
+    rb_define_method(cLiquidParseContext, "cleanup_liquid_c_parsing", parse_context_cleanup_liquid_c_parsing, 0);
+}

data/ext/liquid_c/parse_context.h

@@ -0,0 +1,13 @@
+#ifndef LIQUID_PARSE_CONTEXT_H
+#define LIQUID_PARSE_CONTEXT_H
+
+#include <ruby.h>
+#include <stdbool.h>
+#include "vm_assembler_pool.h"
+
+void liquid_define_parse_context(void);
+VALUE parse_context_get_document_body(VALUE self);
+
+vm_assembler_pool_t *parse_context_get_vm_assembler_pool(VALUE self);
+
+#endif

data/ext/liquid_c/parser.c

@@ -2,8 +2,8 @@
 #include "parser.h"
 #include "lexer.h"
 
-static VALUE cLiquidRangeLookup, cLiquidVariableLookup, cRange, vLiquidExpressionLiterals;
-static ID idToI, idEvaluate;
+static VALUE empty_string;
+static ID id_to_i, idEvaluate;
 
 void init_parser(parser_t *p, const char *str, const char *end)
 {
@@ -67,79 +67,133 @@ static VALUE parse_number(parser_t *p)
     return out;
 }
 
-static VALUE parse_range(parser_t *p)
+static VALUE try_parse_constant_range(parser_t *p)
 {
+    parser_t saved_state = *p;
+
     parser_must_consume(p, TOKEN_OPEN_ROUND);
 
-    VALUE args[2];
-    args[0] = parse_expression(p);
+    VALUE begin = try_parse_constant_expression(p);
+    if (begin == Qundef) {
+        *p = saved_state;
+        return Qundef;
+    }
     parser_must_consume(p, TOKEN_DOTDOT);
 
-    args[1] = parse_expression(p);
+    VALUE end = try_parse_constant_expression(p);
+    if (end == Qundef) {
+        *p = saved_state;
+        return Qundef;
+    }
     parser_must_consume(p, TOKEN_CLOSE_ROUND);
 
-    if (rb_respond_to(args[0], idEvaluate) || rb_respond_to(args[1], idEvaluate))
-        return rb_class_new_instance(2, args, cLiquidRangeLookup);
+    begin = rb_funcall(begin, id_to_i, 0);
+    end = rb_funcall(end, id_to_i, 0);
 
-    return rb_class_new_instance(2, args, cRange);
+    bool exclude_end = false;
+    return rb_range_new(begin, end, exclude_end);
 }
 
-static VALUE parse_variable(parser_t *p)
+static void parse_and_compile_range(parser_t *p, vm_assembler_t *code)
 {
-    VALUE name, lookups = rb_ary_new(), lookup;
-    unsigned long long command_flags = 0;
+    VALUE const_range = try_parse_constant_range(p);
+    if (const_range != Qundef) {
+        vm_assembler_add_push_const(code, const_range);
+        return;
+    }
 
+    parser_must_consume(p, TOKEN_OPEN_ROUND);
+    parse_and_compile_expression(p, code);
+    parser_must_consume(p, TOKEN_DOTDOT);
+    parse_and_compile_expression(p, code);
+    parser_must_consume(p, TOKEN_CLOSE_ROUND);
+    vm_assembler_add_new_int_range(code);
+}
+
+static void parse_and_compile_variable_lookup(parser_t *p, vm_assembler_t *code)
+{
     if (parser_consume(p, TOKEN_OPEN_SQUARE).type) {
-        name = parse_expression(p);
+        parse_and_compile_expression(p, code);
         parser_must_consume(p, TOKEN_CLOSE_SQUARE);
+        vm_assembler_add_find_variable(code);
     } else {
-        name = token_to_rstr(parser_must_consume(p, TOKEN_IDENTIFIER));
+        VALUE name = token_to_rstr_leveraging_existing_symbol(parser_must_consume(p, TOKEN_IDENTIFIER));
+        vm_assembler_add_find_static_variable(code, name);
     }
 
     while (true) {
         if (p->cur.type == TOKEN_OPEN_SQUARE) {
             parser_consume_any(p);
-            lookup = parse_expression(p);
+            parse_and_compile_expression(p, code);
             parser_must_consume(p, TOKEN_CLOSE_SQUARE);
-
-            rb_ary_push(lookups, lookup);
+            vm_assembler_add_lookup_key(code);
         } else if (p->cur.type == TOKEN_DOT) {
-            int has_space_affix = parser_consume_any(p).flags & TOKEN_SPACE_AFFIX;
-            lookup = token_to_rstr(parser_must_consume(p, TOKEN_IDENTIFIER));
-
-            if (has_space_affix)
-                rb_enc_raise(utf8_encoding, cLiquidSyntaxError, "Unexpected dot");
-
-            if (rstring_eq(lookup, "size") || rstring_eq(lookup, "first") || rstring_eq(lookup, "last"))
-                command_flags |= 1 << RARRAY_LEN(lookups);
+            parser_consume_any(p);
+            VALUE key = token_to_rstr_leveraging_existing_symbol(parser_must_consume(p, TOKEN_IDENTIFIER));
 
-            rb_ary_push(lookups, lookup);
+            if (rstring_eq(key, "size") || rstring_eq(key, "first") || rstring_eq(key, "last"))
+                vm_assembler_add_lookup_command(code, key);
+            else
+                vm_assembler_add_lookup_const_key(code, key);
         } else {
             break;
         }
     }
+}
 
-    if (RARRAY_LEN(lookups) == 0) {
-        VALUE literal = rb_hash_lookup2(vLiquidExpressionLiterals, name, Qundef);
-        if (literal != Qundef) return literal;
+static VALUE try_parse_literal(parser_t *p)
+{
+    if (p->next.type == TOKEN_DOT || p->next.type == TOKEN_OPEN_SQUARE)
+        return Qundef;
+
+    const char *str = p->cur.val;
+    long size = p->cur.val_end - str;
+    VALUE result = Qundef;
+    switch (size) {
+        case 3:
+            if (memcmp(str, "nil", size) == 0)
+                result = Qnil;
+            break;
+        case 4:
+            if (memcmp(str, "null", size) == 0) {
+                result = Qnil;
+            } else if (memcmp(str, "true", size) == 0) {
+                result = Qtrue;
+            }
+            break;
+        case 5:
+            switch (*str) {
+                case 'f':
+                    if (memcmp(str, "false", size) == 0)
+                        result = Qfalse;
+                    break;
+                case 'b':
+                    if (memcmp(str, "blank", size) == 0)
+                        result = empty_string;
+                    break;
+                case 'e':
+                    if (memcmp(str, "empty", size) == 0)
+                        result = empty_string;
+                    break;
+            }
+            break;
     }
-
-    VALUE args[4] = {Qfalse, name, lookups, INT2FIX(command_flags)};
-    return rb_class_new_instance(4, args, cLiquidVariableLookup);
+    if (result != Qundef)
+        parser_consume_any(p);
+    return result;
 }
 
-VALUE parse_expression(parser_t *p)
+VALUE try_parse_constant_expression(parser_t *p)
 {
     switch (p->cur.type) {
         case TOKEN_IDENTIFIER:
-        case TOKEN_OPEN_SQUARE:
-            return parse_variable(p);
+            return try_parse_literal(p);
 
         case TOKEN_NUMBER:
             return parse_number(p);
 
         case TOKEN_OPEN_ROUND:
-            return parse_range(p);
+            return try_parse_constant_range(p);
 
         case TOKEN_STRING:
         {
@@ -149,47 +203,69 @@ VALUE parse_expression(parser_t *p)
             return token_to_rstr(token);
         }
     }
-
-    if (p->cur.type == TOKEN_EOS) {
-        rb_enc_raise(utf8_encoding, cLiquidSyntaxError, "[:%s] is not a valid expression", symbol_names[p->cur.type]);
-    } else {
-        rb_enc_raise(utf8_encoding, cLiquidSyntaxError, "[:%s, \"%.*s\"] is not a valid expression",
-                 symbol_names[p->cur.type], (int)(p->cur.val_end - p->cur.val), p->cur.val);
-    }
-    return Qnil;
+    return Qundef;
 }
 
-static VALUE rb_parse_expression(VALUE self, VALUE markup)
+static void parse_and_compile_number(parser_t *p, vm_assembler_t *code)
 {
-    StringValue(markup);
-    char *start = RSTRING_PTR(markup);
+    VALUE num = parse_number(p);
+    if (RB_FIXNUM_P(num))
+        vm_assembler_add_push_fixnum(code, num);
+    else
+        vm_assembler_add_push_const(code, num);
+    return;
+}
 
-    parser_t p;
-    init_parser(&p, start, start + RSTRING_LEN(markup));
+void parse_and_compile_expression(parser_t *p, vm_assembler_t *code)
+{
+    switch (p->cur.type) {
+        case TOKEN_IDENTIFIER:
+        {
+            VALUE literal = try_parse_literal(p);
+            if (literal != Qundef) {
+                vm_assembler_add_push_literal(code, literal);
+                return;
+            }
+            
+             __attribute__ ((fallthrough));
+        }
+        case TOKEN_OPEN_SQUARE:
+            parse_and_compile_variable_lookup(p, code);
+            return;
 
-    if (p.cur.type == TOKEN_EOS)
-        return Qnil;
+        case TOKEN_NUMBER:
+            parse_and_compile_number(p, code);
+            return;
 
-    VALUE expr = parse_expression(&p);
+        case TOKEN_OPEN_ROUND:
+            parse_and_compile_range(p, code);
+            return;
 
-    if (p.cur.type != TOKEN_EOS)
-        rb_enc_raise(utf8_encoding, cLiquidSyntaxError, "[:%s] is not a valid expression", symbol_names[p.cur.type]);
+        case TOKEN_STRING:
+        {
+            lexer_token_t token = parser_consume_any(p);
+            token.val++;
+            token.val_end--;
+            VALUE str = token_to_rstr(token);
+            vm_assembler_add_push_const(code, str);
+            return;
+        }
+    }
 
-    return expr;
+    if (p->cur.type == TOKEN_EOS) {
+        rb_enc_raise(utf8_encoding, cLiquidSyntaxError, "[:%s] is not a valid expression", symbol_names[p->cur.type]);
+    } else {
+        rb_enc_raise(utf8_encoding, cLiquidSyntaxError, "[:%s, \"%.*s\"] is not a valid expression",
+                 symbol_names[p->cur.type], (int)(p->cur.val_end - p->cur.val), p->cur.val);
+    }
 }
 
-void init_liquid_parser(void)
+void liquid_define_parser(void)
 {
-    idToI = rb_intern("to_i");
+    id_to_i = rb_intern("to_i");
     idEvaluate = rb_intern("evaluate");
 
-    cLiquidRangeLookup = rb_const_get(mLiquid, rb_intern("RangeLookup"));
-    cRange = rb_const_get(rb_cObject, rb_intern("Range"));
-    cLiquidVariableLookup = rb_const_get(mLiquid, rb_intern("VariableLookup"));
-
-    VALUE cLiquidExpression = rb_const_get(mLiquid, rb_intern("Expression"));
-    rb_define_singleton_method(cLiquidExpression, "c_parse", rb_parse_expression, 1);
-
-    vLiquidExpressionLiterals = rb_const_get(cLiquidExpression, rb_intern("LITERALS"));
+    empty_string = rb_utf8_str_new_literal("");
+    rb_global_variable(&empty_string);
 }
 

data/ext/liquid_c/parser.h

@@ -2,6 +2,7 @@
 #define LIQUID_PARSER_H
 
 #include "lexer.h"
+#include "vm_assembler.h"
 
 typedef struct parser {
     lexer_token_t cur, next;
@@ -14,9 +15,10 @@ lexer_token_t parser_must_consume(parser_t *parser, unsigned char type);
 lexer_token_t parser_consume(parser_t *parser, unsigned char type);
 lexer_token_t parser_consume_any(parser_t *parser);
 
-VALUE parse_expression(parser_t *parser);
+void parse_and_compile_expression(parser_t *p, vm_assembler_t *code);
+VALUE try_parse_constant_expression(parser_t *p);
 
-void init_liquid_parser(void);
+void liquid_define_parser(void);
 
 #endif