liquid-c 4.0.1 → 4.2.0

data/ext/liquid_c/usage.h

@@ -0,0 +1,9 @@
+#ifndef LIQUID_USAGE_H
+#define LIQUID_USAGE_H
+
+#include "liquid.h"
+
+void liquid_define_usage(void);
+void usage_increment(const char *name);
+
+#endif

data/ext/liquid_c/variable.c

@@ -1,25 +1,43 @@
 #include "liquid.h"
 #include "variable.h"
 #include "parser.h"
+#include "expression.h"
+#include "liquid_vm.h"
+
 #include <stdio.h>
 
-static VALUE rb_variable_parse(VALUE self, VALUE markup, VALUE filters)
-{
-    StringValue(markup);
-    char *start = RSTRING_PTR(markup);
+static ID id_rescue_strict_parse_syntax_error;
+
+static ID id_ivar_parse_context;
+static ID id_ivar_name;
+static ID id_ivar_filters;
 
+VALUE cLiquidCVariableExpression;
+
+static VALUE frozen_empty_array;
+
+static VALUE try_variable_strict_parse(VALUE uncast_args)
+{
+    variable_parse_args_t *parse_args = (void *)uncast_args;
     parser_t p;
-    init_parser(&p, start, start + RSTRING_LEN(markup));
+    init_parser(&p, parse_args->markup, parse_args->markup_end);
+    vm_assembler_t *code = parse_args->code;
 
-    if (p.cur.type == TOKEN_EOS)
+    if (p.cur.type == TOKEN_EOS) {
+        vm_assembler_add_push_nil(code);
         return Qnil;
+    }
 
-    VALUE name = parse_expression(&p);
+    parse_and_compile_expression(&p, code);
 
     while (parser_consume(&p, TOKEN_PIPE).type) {
-        lexer_token_t filter_name = parser_must_consume(&p, TOKEN_IDENTIFIER);
+        lexer_token_t filter_name_token = parser_must_consume(&p, TOKEN_IDENTIFIER);
+        VALUE filter_name = token_to_rsym(filter_name_token);
 
-        VALUE filter_args = rb_ary_new(), keyword_args = Qnil, filter;
+        size_t arg_count = 0;
+        size_t keyword_arg_count = 0;
+        VALUE push_keywords_obj = Qnil;
+        vm_assembler_t *push_keywords_code = NULL;
 
         if (parser_consume(&p, TOKEN_COLON).type) {
             do {
@@ -27,28 +45,186 @@ static VALUE rb_variable_parse(VALUE self, VALUE markup, VALUE filters)
                     VALUE key = token_to_rstr(parser_consume_any(&p));
                     parser_consume_any(&p);
 
-                    if (keyword_args == Qnil) keyword_args = rb_hash_new();
-                    rb_hash_aset(keyword_args, key, parse_expression(&p));
+                    keyword_arg_count++;
+
+                    if (push_keywords_obj == Qnil) {
+                        expression_t *push_keywords_expr;
+                        // use an object to automatically free on an exception
+                        push_keywords_obj = expression_new(cLiquidCExpression, &push_keywords_expr);
+                        rb_obj_hide(push_keywords_obj);
+                        push_keywords_code = &push_keywords_expr->code;
+                    }
+
+                    vm_assembler_add_push_const(push_keywords_code, key);
+                    parse_and_compile_expression(&p, push_keywords_code);
                 } else {
-                    rb_ary_push(filter_args, parse_expression(&p));
+                    parse_and_compile_expression(&p, code);
+                    arg_count++;
                 }
             } while (parser_consume(&p, TOKEN_COMMA).type);
         }
 
-        if (keyword_args == Qnil) {
-            filter = rb_ary_new3(2, token_to_rstr(filter_name), filter_args);
-        } else {
-            filter = rb_ary_new3(3, token_to_rstr(filter_name), filter_args, keyword_args);
+        if (keyword_arg_count) {
+            arg_count++;
+            if (keyword_arg_count > 255)
+                rb_enc_raise(utf8_encoding, cLiquidSyntaxError, "Too many filter keyword arguments");
+
+            vm_assembler_concat(code, push_keywords_code);
+            vm_assembler_add_hash_new(code, keyword_arg_count);
+
+            RB_GC_GUARD(push_keywords_obj);
         }
-        rb_ary_push(filters, filter);
+        vm_assembler_add_filter(code, filter_name, arg_count);
     }
 
     parser_must_consume(&p, TOKEN_EOS);
-    return name;
+
+    return Qnil;
+}
+
+typedef struct variable_strict_parse_rescue {
+    variable_parse_args_t *parse_args;
+    size_t instructions_size;
+    size_t constants_size;
+    size_t stack_size;
+} variable_strict_parse_rescue_t;
+
+static VALUE variable_strict_parse_rescue(VALUE uncast_args, VALUE exception)
+{
+    variable_strict_parse_rescue_t *rescue_args = (void *)uncast_args;
+    variable_parse_args_t *parse_args = rescue_args->parse_args;
+    vm_assembler_t *code = parse_args->code;
+
+    // undo partial strict parse
+    uint8_t *last_constants_data_end = (uint8_t *)code->constants.data + rescue_args->constants_size;
+    VALUE *const_ptr = (VALUE *)last_constants_data_end;
+    st_table *constants_table = code->constants_table;
+
+    while((uint8_t *)const_ptr < code->constants.data_end) {
+        st_data_t key = (st_data_t)const_ptr[0];
+        st_delete(constants_table, &key, 0);
+        const_ptr++;
+    }
+
+    code->instructions.data_end = code->instructions.data + rescue_args->instructions_size;
+    code->constants.data_end = last_constants_data_end;
+    code->stack_size = rescue_args->stack_size;
+
+    if (rb_obj_is_kind_of(exception, cLiquidSyntaxError) == Qfalse)
+        rb_exc_raise(exception);
+
+    VALUE markup_obj = rb_enc_str_new(parse_args->markup, parse_args->markup_end - parse_args->markup, utf8_encoding);
+    VALUE variable_obj = rb_funcall(
+        cLiquidVariable, id_rescue_strict_parse_syntax_error, 3,
+        exception, markup_obj, parse_args->parse_context
+    );
+
+    // lax parse
+    code->protected_stack_size = code->stack_size;
+    rb_funcall(variable_obj, id_compile_evaluate, 1, parse_args->code_obj);
+    if (code->stack_size != code->protected_stack_size + 1) {
+        rb_raise(rb_eRuntimeError, "Liquid::Variable#compile_evaluate didn't leave exactly 1 new element on the stack");
+    }
+
+    return Qnil;
+}
+
+void internal_variable_compile_evaluate(variable_parse_args_t *parse_args)
+{
+    vm_assembler_t *code = parse_args->code;
+    variable_strict_parse_rescue_t rescue_args = {
+        .parse_args = parse_args,
+        .instructions_size = c_buffer_size(&code->instructions),
+        .constants_size = c_buffer_size(&code->constants),
+        .stack_size = code->stack_size,
+    };
+    rb_rescue(try_variable_strict_parse, (VALUE)parse_args, variable_strict_parse_rescue, (VALUE)&rescue_args);
 }
 
-void init_liquid_variable(void)
+void internal_variable_compile(variable_parse_args_t *parse_args, unsigned int line_number)
 {
-    rb_define_singleton_method(cLiquidVariable, "c_strict_parse", rb_variable_parse, 2);
+    vm_assembler_t *code = parse_args->code;
+    vm_assembler_add_render_variable_rescue(code, line_number);
+    internal_variable_compile_evaluate(parse_args);
+    vm_assembler_add_pop_write(code);
+}
+
+static VALUE variable_strict_parse_method(VALUE self, VALUE markup)
+{
+    StringValue(markup);
+    check_utf8_encoding(markup, "markup");
+
+    VALUE parse_context = rb_ivar_get(self, id_ivar_parse_context);
+
+    expression_t *expression;
+    VALUE expression_obj = expression_new(cLiquidCVariableExpression, &expression);
+
+    variable_parse_args_t parse_args = {
+        .markup = RSTRING_PTR(markup),
+        .markup_end = RSTRING_END(markup),
+        .code = &expression->code,
+        .code_obj = expression_obj,
+        .parse_context = parse_context,
+    };
+    try_variable_strict_parse((VALUE)&parse_args);
+    RB_GC_GUARD(markup);
+    assert(expression->code.stack_size == 1);
+    vm_assembler_add_leave(&expression->code);
+
+    rb_ivar_set(self, id_ivar_name, expression_obj);
+    rb_ivar_set(self, id_ivar_filters, frozen_empty_array);
+
+    return Qnil;
+}
+
+typedef struct {
+    expression_t *expression;
+    VALUE context;
+} variable_expression_evaluate_args_t;
+
+static VALUE try_variable_expression_evaluate(VALUE uncast_args)
+{
+    variable_expression_evaluate_args_t *args = (void *)uncast_args;
+    return liquid_vm_evaluate(args->context, &args->expression->code);
+}
+
+static VALUE rescue_variable_expression_evaluate(VALUE uncast_args, VALUE exception)
+{
+    variable_expression_evaluate_args_t *args = (void *)uncast_args;
+    vm_t *vm = vm_from_context(args->context);
+    exception = vm_translate_if_filter_argument_error(vm, exception);
+    rb_exc_raise(exception);
+}
+
+VALUE internal_variable_expression_evaluate(expression_t *expression, VALUE context)
+{
+    variable_expression_evaluate_args_t args = { expression, context };
+    return rb_rescue(try_variable_expression_evaluate, (VALUE)&args, rescue_variable_expression_evaluate, (VALUE)&args);
+}
+
+static VALUE variable_expression_evaluate_method(VALUE self, VALUE context)
+{
+    expression_t *expression;
+    Expression_Get_Struct(self, expression);
+    return internal_variable_expression_evaluate(expression, context);
+}
+
+void liquid_define_variable(void)
+{
+    id_rescue_strict_parse_syntax_error = rb_intern("rescue_strict_parse_syntax_error");
+
+    id_ivar_parse_context = rb_intern("@parse_context");
+    id_ivar_name = rb_intern("@name");
+    id_ivar_filters = rb_intern("@filters");
+
+    frozen_empty_array = rb_ary_new();
+    rb_ary_freeze(frozen_empty_array);
+    rb_global_variable(&frozen_empty_array);
+
+    rb_define_method(cLiquidVariable, "c_strict_parse", variable_strict_parse_method, 1);
+
+    cLiquidCVariableExpression = rb_define_class_under(mLiquidC, "VariableExpression", cLiquidCExpression);
+    rb_global_variable(&cLiquidCVariableExpression);
+    rb_define_method(cLiquidCVariableExpression, "evaluate", variable_expression_evaluate_method, 1);
 }
 

data/ext/liquid_c/variable.h

@@ -1,7 +1,24 @@
 #if !defined(LIQUID_VARIABLE_H)
 #define LIQUID_VARIABLE_H
 
-void init_liquid_variable(void);
+#include "vm_assembler.h"
+#include "block.h"
+#include "expression.h"
+
+extern VALUE cLiquidCVariableExpression;
+
+typedef struct variable_parse_args {
+    const char *markup;
+    const char *markup_end;
+    vm_assembler_t *code;
+    VALUE code_obj;
+    VALUE parse_context;
+} variable_parse_args_t;
+
+void liquid_define_variable(void);
+void internal_variable_compile(variable_parse_args_t *parse_args, unsigned int line_number);
+void internal_variable_compile_evaluate(variable_parse_args_t *parse_args);
+VALUE internal_variable_expression_evaluate(expression_t *expression, VALUE context);
 
 #endif
 

data/ext/liquid_c/variable_lookup.c

@@ -0,0 +1,44 @@
+#include "liquid.h"
+#include "context.h"
+
+static ID id_has_key, id_aref, id_fetch, id_to_liquid_value;
+
+VALUE variable_lookup_key(VALUE context, VALUE object, VALUE key, bool is_command)
+{
+    if (rb_obj_class(key) != rb_cString) {
+        VALUE key_value = rb_check_funcall(key, id_to_liquid_value, 0, 0);
+
+        if (key_value != Qundef) {
+            key = key_value;
+        }
+    }
+
+    if (rb_respond_to(object, id_aref) && (
+        (rb_respond_to(object, id_has_key) && rb_funcall(object, id_has_key, 1, key)) ||
+        (rb_obj_is_kind_of(key, rb_cInteger) && rb_respond_to(object, id_fetch))
+    )) {
+        VALUE next_object = rb_funcall(object, id_aref, 1, key);
+        next_object = materialize_proc(context, object, key, next_object);
+        return value_to_liquid_and_set_context(next_object, context);
+    }
+
+    if (is_command) {
+        Check_Type(key, T_STRING);
+        ID intern_key = rb_intern(RSTRING_PTR(key));
+        if (rb_respond_to(object, intern_key)) {
+            VALUE next_object = rb_funcall(object, intern_key, 0);
+            return value_to_liquid_and_set_context(next_object, context);
+        }
+    }
+
+    context_maybe_raise_undefined_variable(context, key);
+    return Qnil;
+}
+
+void liquid_define_variable_lookup(void)
+{
+    id_has_key = rb_intern("key?");
+    id_aref = rb_intern("[]");
+    id_fetch = rb_intern("fetch");
+    id_to_liquid_value = rb_intern("to_liquid_value");
+}

data/ext/liquid_c/variable_lookup.h

@@ -0,0 +1,8 @@
+#if !defined(LIQUID_VARIABLE_LOOKUP_H)
+#define LIQUID_VARIABLE_LOOKUP_H
+
+void liquid_define_variable_lookup(void);
+VALUE variable_lookup_key(VALUE context, VALUE object, VALUE key, bool is_command);
+
+#endif
+