liquid-c 4.0.1 → 4.1.0

data/ext/liquid_c/raw.c

@@ -0,0 +1,110 @@
+#include "liquid.h"
+#include "raw.h"
+#include "stringutil.h"
+#include "tokenizer.h"
+
+static VALUE id_block_name, id_raise_tag_never_closed, id_block_delimiter, id_ivar_body;
+static VALUE cLiquidRaw;
+
+struct full_token_possibly_invalid_t {
+    long body_len;
+    const char *delimiter_start;
+    long delimiter_len;
+};
+
+static bool match_full_token_possibly_invalid(token_t *token, struct full_token_possibly_invalid_t *match)
+{
+    const char *str = token->str_full;
+    long len = token->len_full;
+
+    match->body_len = 0;
+    match->delimiter_start = NULL;
+    match->delimiter_len = 0;
+
+    if (len < 5) return false; // Must be at least 5 characters: \{%\w%\}
+    if (str[len - 1] != '}' || str[len - 2] != '%') return false;
+
+    const char *curr_delimiter_start;
+    long curr_delimiter_len = 0;
+
+    for (long i = len - 3; i >= 0; i--) {
+        char c = str[i];
+
+        if (is_word_char(c)) {
+            curr_delimiter_start = str + i;
+            curr_delimiter_len++;
+        } else {
+            if (curr_delimiter_len > 0) {
+                match->delimiter_start = curr_delimiter_start;
+                match->delimiter_len = curr_delimiter_len;
+            }
+            curr_delimiter_start = NULL;
+            curr_delimiter_len = 0;
+        }
+
+        if (c == '%' && match->delimiter_len > 0 &&
+                i - 1 >= 0 && str[i - 1] == '{') {
+            match->body_len = i - 1;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static VALUE raw_parse_method(VALUE self, VALUE tokens)
+{
+    tokenizer_t *tokenizer;
+    Tokenizer_Get_Struct(tokens, tokenizer);
+
+    token_t token;
+    struct full_token_possibly_invalid_t match;
+
+    VALUE block_delimiter = rb_funcall(self, id_block_delimiter, 0);
+    Check_Type(block_delimiter, T_STRING);
+    char *block_delimiter_str = RSTRING_PTR(block_delimiter);
+    long block_delimiter_len = RSTRING_LEN(block_delimiter);
+
+    const char *body = NULL;
+    long body_len = 0;
+
+    while (true) {
+        tokenizer_next(tokenizer, &token);
+
+        if (!token.type) break;
+
+        if (body == NULL) {
+            body = token.str_full;
+        }
+
+        if (match_full_token_possibly_invalid(&token, &match)
+                && match.delimiter_len == block_delimiter_len
+                && memcmp(match.delimiter_start, block_delimiter_str, block_delimiter_len) == 0) {
+            body_len += match.body_len;
+            VALUE body_str = rb_enc_str_new(body, body_len, utf8_encoding);
+            rb_ivar_set(self, id_ivar_body, body_str);
+            if (RBASIC_CLASS(self) == cLiquidRaw) {
+                tokenizer->raw_tag_body = RSTRING_PTR(body_str);
+                tokenizer->raw_tag_body_len = (unsigned int)body_len;
+            }
+            return Qnil;
+        }
+
+        body_len += token.len_full;
+    }
+
+    rb_funcall(self, id_raise_tag_never_closed, 1, rb_funcall(self, id_block_name, 0));
+    return Qnil;
+}
+
+void liquid_define_raw(void)
+{
+    id_block_name = rb_intern("block_name");
+    id_raise_tag_never_closed = rb_intern("raise_tag_never_closed");
+    id_block_delimiter = rb_intern("block_delimiter");
+    id_ivar_body = rb_intern("@body");
+
+    cLiquidRaw = rb_const_get(mLiquid, rb_intern("Raw"));
+
+    rb_define_method(cLiquidRaw, "c_parse", raw_parse_method, 1);
+}

data/ext/liquid_c/raw.h

@@ -0,0 +1,6 @@
+#ifndef LIQUID_RAW_H
+#define LIQUID_RAW_H
+
+void liquid_define_raw(void);
+
+#endif

data/ext/liquid_c/resource_limits.c

@@ -0,0 +1,279 @@
+#include "liquid.h"
+#include "resource_limits.h"
+
+VALUE cLiquidResourceLimits;
+
+static void resource_limits_free(void *ptr)
+{
+    resource_limits_t *resource_limits = ptr;
+    xfree(resource_limits);
+}
+
+static size_t resource_limits_memsize(const void *ptr)
+{
+    return sizeof(resource_limits_t);
+}
+
+const rb_data_type_t resource_limits_data_type = {
+    "liquid_resource_limits",
+    { NULL, resource_limits_free, resource_limits_memsize },
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void resource_limits_reset(resource_limits_t *resource_limit)
+{
+    resource_limit->reached_limit = true;
+    resource_limit->last_capture_length = -1;
+    resource_limit->render_score = 0;
+    resource_limit->assign_score = 0;
+}
+
+static VALUE resource_limits_allocate(VALUE klass)
+{
+    resource_limits_t *resource_limits;
+
+    VALUE obj = TypedData_Make_Struct(klass, resource_limits_t, &resource_limits_data_type, resource_limits);
+
+    resource_limits_reset(resource_limits);
+
+    return obj;
+}
+
+static VALUE resource_limits_render_length_limit_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    return LONG2NUM(resource_limits->render_length_limit);
+}
+
+static VALUE resource_limits_set_render_length_limit_method(VALUE self, VALUE render_length_limit)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+     if (render_length_limit == Qnil) {
+        resource_limits->render_length_limit = LONG_MAX;
+    } else {
+        resource_limits->render_length_limit = NUM2LONG(render_length_limit);
+    }
+
+    return Qnil;
+}
+
+static VALUE resource_limits_render_score_limit_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    return LONG2NUM(resource_limits->render_score_limit);
+}
+
+static VALUE resource_limits_set_render_score_limit_method(VALUE self, VALUE render_score_limit)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    if (render_score_limit == Qnil) {
+        resource_limits->render_score_limit = LONG_MAX;
+    } else {
+        resource_limits->render_score_limit = NUM2LONG(render_score_limit);
+    }
+
+    return Qnil;
+}
+
+static VALUE resource_limits_assign_score_limit_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    return LONG2NUM(resource_limits->assign_score_limit);
+}
+
+static VALUE resource_limits_set_assign_score_limit_method(VALUE self, VALUE assign_score_limit)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    if (assign_score_limit == Qnil) {
+        resource_limits->assign_score_limit = LONG_MAX;
+    } else {
+        resource_limits->assign_score_limit = NUM2LONG(assign_score_limit);
+    }
+
+    return Qnil;
+}
+
+static VALUE resource_limits_render_score_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    return LONG2NUM(resource_limits->render_score);
+}
+
+static VALUE resource_limits_assign_score_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    return LONG2NUM(resource_limits->assign_score);
+}
+
+static VALUE resource_limits_initialize_method(VALUE self, VALUE render_length_limit,
+                                               VALUE render_score_limit, VALUE assign_score_limit)
+{
+    resource_limits_set_render_length_limit_method(self, render_length_limit);
+    resource_limits_set_render_score_limit_method(self, render_score_limit);
+    resource_limits_set_assign_score_limit_method(self, assign_score_limit);
+
+    return Qnil;
+}
+
+__attribute__((noreturn))
+void resource_limits_raise_limits_reached(resource_limits_t *resource_limit)
+{
+    resource_limit->reached_limit = true;
+    rb_raise(cMemoryError, "Memory limits exceeded");
+}
+
+void resource_limits_increment_render_score(resource_limits_t *resource_limits, long amount)
+{
+    resource_limits->render_score = resource_limits->render_score + amount;
+
+    if (resource_limits->render_score > resource_limits->render_score_limit) {
+        resource_limits_raise_limits_reached(resource_limits);
+    }
+}
+
+static VALUE resource_limits_increment_render_score_method(VALUE self, VALUE amount)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    resource_limits_increment_render_score(resource_limits, NUM2LONG(amount));
+
+    return Qnil;
+}
+
+static void resource_limits_increment_assign_score(resource_limits_t *resource_limits, long amount)
+{
+    resource_limits->assign_score = resource_limits->assign_score + amount;
+
+    if (resource_limits->assign_score > resource_limits->assign_score_limit) {
+        resource_limits_raise_limits_reached(resource_limits);
+    }
+}
+
+static VALUE resource_limits_increment_assign_score_method(VALUE self, VALUE amount)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    resource_limits_increment_assign_score(resource_limits, NUM2LONG(amount));
+
+    return Qnil;
+}
+
+void resource_limits_increment_write_score(resource_limits_t *resource_limits, VALUE output)
+{
+    long captured = RSTRING_LEN(output);
+
+    if (resource_limits->last_capture_length >= 0) {
+        long increment = captured - resource_limits->last_capture_length;
+        resource_limits->last_capture_length = captured;
+        resource_limits_increment_assign_score(resource_limits, increment);
+    } else if (captured > resource_limits->render_length_limit) {
+        resource_limits_raise_limits_reached(resource_limits);
+    }
+}
+
+static VALUE resource_limits_increment_write_score_method(VALUE self, VALUE output)
+{
+    Check_Type(output, T_STRING);
+
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    resource_limits_increment_write_score(resource_limits, output);
+
+    return Qnil;
+}
+
+static VALUE resource_limits_raise_limits_reached_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    resource_limits_raise_limits_reached(resource_limits);
+}
+
+static VALUE resource_limits_reached_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    return resource_limits->reached_limit ? Qtrue : Qfalse;
+}
+
+struct capture_ensure_t {
+    resource_limits_t *resource_limits;
+    long old_capture_length;
+};
+
+static VALUE capture_ensure(VALUE data)
+{
+    struct capture_ensure_t *ensure_data = (struct capture_ensure_t *)data;
+    ensure_data->resource_limits->last_capture_length = ensure_data->old_capture_length;
+
+    return Qnil;
+}
+
+static VALUE resource_limits_with_capture_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+
+    struct capture_ensure_t ensure_data = {
+        .resource_limits = resource_limits,
+        .old_capture_length = resource_limits->last_capture_length
+    };
+
+    resource_limits->last_capture_length = 0;
+
+    return rb_ensure(rb_yield, Qundef, capture_ensure, (VALUE)&ensure_data);
+}
+
+
+static VALUE resource_limits_reset_method(VALUE self)
+{
+    resource_limits_t *resource_limits;
+    ResourceLimits_Get_Struct(self, resource_limits);
+    resource_limits_reset(resource_limits);
+    return Qnil;
+}
+
+void liquid_define_resource_limits(void)
+{
+    cLiquidResourceLimits = rb_define_class_under(mLiquidC, "ResourceLimits", rb_cObject);
+    rb_global_variable(&cLiquidResourceLimits);
+
+    rb_define_alloc_func(cLiquidResourceLimits, resource_limits_allocate);
+    rb_define_method(cLiquidResourceLimits, "initialize", resource_limits_initialize_method, 3);
+    rb_define_method(cLiquidResourceLimits, "render_length_limit", resource_limits_render_length_limit_method, 0);
+    rb_define_method(cLiquidResourceLimits, "render_length_limit=", resource_limits_set_render_length_limit_method, 1);
+    rb_define_method(cLiquidResourceLimits, "render_score_limit", resource_limits_render_score_limit_method, 0);
+    rb_define_method(cLiquidResourceLimits, "render_score_limit=", resource_limits_set_render_score_limit_method, 1);
+    rb_define_method(cLiquidResourceLimits, "assign_score_limit", resource_limits_assign_score_limit_method, 0);
+    rb_define_method(cLiquidResourceLimits, "assign_score_limit=", resource_limits_set_assign_score_limit_method, 1);
+    rb_define_method(cLiquidResourceLimits, "render_score", resource_limits_render_score_method, 0);
+    rb_define_method(cLiquidResourceLimits, "assign_score", resource_limits_assign_score_method, 0);
+    rb_define_method(cLiquidResourceLimits, "increment_render_score", resource_limits_increment_render_score_method, 1);
+    rb_define_method(cLiquidResourceLimits, "increment_assign_score", resource_limits_increment_assign_score_method, 1);
+    rb_define_method(cLiquidResourceLimits, "increment_write_score", resource_limits_increment_write_score_method, 1);
+    rb_define_method(cLiquidResourceLimits, "raise_limits_reached", resource_limits_raise_limits_reached_method, 0);
+    rb_define_method(cLiquidResourceLimits, "reached?", resource_limits_reached_method, 0);
+    rb_define_method(cLiquidResourceLimits, "reset", resource_limits_reset_method, 0);
+    rb_define_method(cLiquidResourceLimits, "with_capture", resource_limits_with_capture_method, 0);
+}

data/ext/liquid_c/resource_limits.h

@@ -0,0 +1,23 @@
+#ifndef LIQUID_RESOURCE_LIMITS
+#define LIQUID_RESOURCE_LIMITS
+
+typedef struct resource_limits {
+    long render_length_limit;
+    long render_score_limit;
+    long assign_score_limit;
+    bool reached_limit;
+    long last_capture_length;
+    long render_score;
+    long assign_score;
+} resource_limits_t;
+
+extern VALUE cLiquidResourceLimits;
+extern const rb_data_type_t resource_limits_data_type;
+#define ResourceLimits_Get_Struct(obj, sval) TypedData_Get_Struct(obj, resource_limits_t, &resource_limits_data_type, sval)
+
+void liquid_define_resource_limits(void);
+void resource_limits_raise_limits_reached(resource_limits_t *resource_limit);
+void resource_limits_increment_render_score(resource_limits_t *resource_limits, long amount);
+void resource_limits_increment_write_score(resource_limits_t *resource_limits, VALUE output);
+
+#endif

data/ext/liquid_c/stringutil.h

@@ -0,0 +1,44 @@
+#if !defined(LIQUID_UTIL_H)
+#define LIQUID_UTIL_H
+
+inline static const char *read_while(const char *start, const char *end, int (func)(int))
+{
+    while (start < end && func((unsigned char) *start)) start++;
+    return start;
+}
+
+inline static const char *read_while_reverse(const char *start, const char *end, int (func)(int))
+{
+    end--;
+    while (start <= end && func((unsigned char) *end)) end--;
+    end++;
+    return end;
+}
+
+inline static int count_newlines(const char *start, const char *end)
+{
+    int count = 0;
+    while (start < end) {
+        if (*start == '\n') count++;
+        start++;
+    }
+    return count;
+}
+
+inline static int is_non_newline_space(int c)
+{
+    return rb_isspace(c) && c != '\n';
+}
+
+inline static int not_newline(int c)
+{
+    return c != '\n';
+}
+
+inline static bool is_word_char(char c)
+{
+    return ISALNUM(c) || c == '_';
+}
+
+#endif
+