ruby-ll 1.0.0

data/doc/changelog.md

@@ -0,0 +1,8 @@
+# Changelog
+
+This document contains details of the various releases and their release dates.
+Dates are in the format `yyyy-mm-dd`.
+
+## 1.0.0 - 2015-02-13
+
+The first public release of ruby-ll!

data/doc/css/common.css

@@ -0,0 +1,77 @@
+body
+{
+    font-size:   14px;
+    line-height: 1.6;
+    margin:      0 auto;
+    max-width:   960px;
+}
+
+p code, dd code, li code
+{
+    background: #f9f2f4;
+    color: #c7254e;
+    border-radius: 4px;
+    padding: 2px 4px;
+}
+
+pre.code
+{
+    font-size:   13px;
+    line-height: 1.4;
+    overflow:    auto;
+}
+
+blockquote
+{
+    border-left: 5px solid #eee;
+    margin: 0px;
+    padding-left: 15px;
+}
+
+/**
+ * YARD uses generic table styles, using a special class means those tables
+ * don't get messed up.
+ */
+.table
+{
+    border:          1px solid #ccc;
+    border-right:    none;
+    border-collapse: separate;
+    border-spacing:  0;
+    text-align:      left;
+}
+
+.table.full
+{
+    width: 100%;
+}
+
+    .table .field_name
+    {
+        min-width: 160px;
+    }
+
+    .table thead tr th.no_sort:first-child
+    {
+        width: 25px;
+    }
+
+    .table thead tr th, .table tbody tr td
+    {
+        border-bottom:  1px solid #ccc;
+        border-right:   1px solid #ccc;
+        min-width:      20px;
+        padding:        8px 5px;
+        text-align:     left;
+        vertical-align: top;
+    }
+
+    .table tbody tr:last-child td
+    {
+        border-bottom: none;
+    }
+
+    .table tr:nth-child(odd) td
+    {
+        background: #f9f9f9;
+    }

data/ext/c/driver.c

@@ -0,0 +1,258 @@
+#include "driver.h"
+
+#define T_EOF -1
+#define T_RULE 0
+#define T_TERMINAL 1
+#define T_EPSILON 2
+#define T_ACTION 3
+
+ID id_config_const;
+ID id_each_token;
+ID id_send;
+
+ID id_stack_input_error;
+ID id_unexpected_input_error;
+ID id_invalid_terminal_error;
+
+/**
+ * Releases the memory of the driver's internal state and associated objects.
+ * This function is called automatically when a Driver instance is garbage
+ * collected.
+ */
+void ll_driver_free(DriverState *state)
+{
+    kv_destroy(state->stack);
+    kv_destroy(state->value_stack);
+
+    free(state);
+}
+
+/**
+ * Marks the objects stored in the driver's internal state, preventing them from
+ * being garbage collected until the next GC run.
+ */
+void ll_driver_mark(DriverState *state)
+{
+    size_t index;
+
+    FOR(index, kv_size(state->value_stack))
+    {
+        rb_gc_mark(kv_A(state->value_stack, index));
+    }
+}
+
+/**
+ * Allocates a new instance of the Driver class and prepares its internal state.
+ */
+VALUE ll_driver_allocate(VALUE klass)
+{
+    DriverState *state = ALLOC(DriverState);
+    VALUE config       = rb_const_get(klass, id_config_const);
+
+    Data_Get_Struct(config, DriverConfig, state->config);
+
+    kv_init(state->stack);
+    kv_init(state->value_stack);
+
+    return Data_Wrap_Struct(klass, ll_driver_mark, ll_driver_free, state);
+}
+
+/**
+ * Callback function for iterating over every input token and actually parsing
+ * said input.
+ *
+ * @param token An Array containing the token type as a Symbol and its value.
+ * @param self The Driver instance currently in use.
+ */
+VALUE ll_driver_each_token(VALUE token, VALUE self)
+{
+    VALUE method;
+    VALUE action_args;
+    VALUE action_retval;
+    long num_args;
+    long args_i;
+
+    long token_id;
+
+    long rule_i;
+    long production_i;
+
+    long stack_type;
+    long stack_value;
+
+    DriverState *state;
+
+    VALUE type  = rb_ary_entry(token, 0);
+    VALUE value = rb_ary_entry(token, 1);
+
+    Data_Get_Struct(self, DriverState, state);
+
+    while ( 1 )
+    {
+        if ( kv_size(state->stack) == 0 )
+        {
+            rb_funcall(self, id_unexpected_input_error, 1, token);
+        }
+
+        stack_value = kv_pop(state->stack);
+        stack_type  = kv_pop(state->stack);
+        token_id    = 0;
+
+        if ( TYPE(type) == T_SYMBOL )
+        {
+            khint64_t found = kh_get(int64_map, state->config->terminals, type);
+
+            if ( found != kh_end(state->config->terminals) )
+            {
+                token_id = kh_value(state->config->terminals, found);
+            }
+        }
+
+        /* Rule */
+        if ( stack_type == T_RULE )
+        {
+            production_i = state->config->table[stack_value][token_id];
+
+            if ( production_i == T_EOF )
+            {
+                rb_funcall(
+                    self,
+                    id_stack_input_error,
+                    2,
+                    INT2NUM(stack_value),
+                    token
+                );
+            }
+            else
+            {
+                FOR(rule_i, state->config->rule_lengths[production_i])
+                {
+                    kv_push(
+                        long,
+                        state->stack,
+                        state->config->rules[production_i][rule_i]
+                    );
+                }
+            }
+        }
+        /* Terminal */
+        else if ( stack_type == T_TERMINAL )
+        {
+            if ( stack_value == token_id )
+            {
+                kv_push(VALUE, state->value_stack, value);
+
+                RB_GC_GUARD(value);
+
+                break;
+            }
+            else
+            {
+                rb_funcall(
+                    self,
+                    id_invalid_terminal_error,
+                    2,
+                    INT2NUM(token_id),
+                    INT2NUM(stack_value)
+                );
+            }
+        }
+        /* Action */
+        else if ( stack_type == T_ACTION )
+        {
+            method      = state->config->action_names[stack_value];
+            num_args    = state->config->action_arg_amounts[stack_value];
+            action_args = rb_ary_new2(num_args);
+            args_i      = num_args;
+
+            if ( args_i > (long) kv_size(state->value_stack) )
+            {
+                args_i = (long) kv_size(state->value_stack);
+            }
+
+            while ( args_i-- )
+            {
+                if ( kv_size(state->value_stack) > 0 )
+                {
+                    rb_ary_store(
+                        action_args,
+                        args_i,
+                        kv_pop(state->value_stack)
+                    );
+                }
+            }
+
+            action_retval = rb_funcall(self, id_send, 2, method, action_args);
+
+            kv_push(VALUE, state->value_stack, action_retval);
+
+            RB_GC_GUARD(action_retval);
+        }
+        /* EOF */
+        else if ( stack_type == T_EOF )
+        {
+            break;
+        }
+    }
+
+    return Qnil;
+}
+
+/**
+ * Starts the parser.
+ *
+ * @param self The Driver instance the "parse" method was called on.
+ */
+VALUE ll_driver_parse(VALUE self)
+{
+    long index;
+
+    DriverState *state;
+
+    Data_Get_Struct(self, DriverState, state);
+
+    /* EOF rule */
+    kv_push(long, state->stack, T_EOF);
+    kv_push(long, state->stack, T_EOF);
+
+    /* Start rule */
+    FOR(index, state->config->rule_lengths[0])
+    {
+        kv_push(long, state->stack, state->config->rules[0][index]);
+    }
+
+    rb_block_call(
+        self,
+        id_each_token,
+        0,
+        NULL,
+        RUBY_METHOD_FUNC(ll_driver_each_token),
+        self
+    );
+
+    if ( kv_size(state->value_stack) == 0 )
+    {
+        return Qnil;
+    }
+    else
+    {
+        return kv_pop(state->value_stack);
+    }
+}
+
+void Init_ll_driver()
+{
+    VALUE mLL     = rb_const_get(rb_cObject, rb_intern("LL"));
+    VALUE cDriver = rb_const_get(mLL, rb_intern("Driver"));
+
+    rb_define_method(cDriver, "parse", ll_driver_parse, 0);
+
+    rb_define_alloc_func(cDriver, ll_driver_allocate);
+
+    id_send                   = rb_intern("send");
+    id_config_const           = rb_intern("CONFIG");
+    id_each_token             = rb_intern("each_token");
+    id_stack_input_error      = rb_intern("stack_input_error");
+    id_invalid_terminal_error = rb_intern("invalid_terminal_error");
+    id_unexpected_input_error = rb_intern("unexpected_input_error");
+}

data/ext/c/driver.h

@@ -0,0 +1,28 @@
+#ifndef LIBLL_DRIVER_H
+#define LIBLL_DRIVER_H
+
+#include <ruby.h>
+#include "driver_config.h"
+#include "macros.h"
+#include "kvec.h"
+
+/**
+ * Struct containing the internal state of a Driver instance. This struct is
+ * sadly required as rb_block_call() doesn't take any extra, custom arguments
+ * (other than a single VALUE). This means we have to use
+ * Data_Wrap_Struct/Data_Get_Struct instead :<
+ */
+typedef struct
+{
+    DriverConfig *config;
+
+    /* Stack for storing the rules/actions/etc to process */
+    kvec_t(long) stack;
+
+    /* Stack for action return values */
+    kvec_t(VALUE) value_stack;
+} DriverState;
+
+extern void Init_ll_driver();
+
+#endif

data/ext/c/driver_config.c

@@ -0,0 +1,209 @@
+#include "driver_config.h"
+
+/**
+ * Releases memory of the DriverConfig struct and its members.
+ */
+void ll_driver_config_free(DriverConfig *config)
+{
+    long rindex;
+
+    FOR(rindex, config->rules_count)
+    {
+        free(config->rules[rindex]);
+    }
+
+    FOR(rindex, config->table_count)
+    {
+        free(config->table[rindex]);
+    }
+
+    free(config->rules);
+    free(config->rule_lengths);
+    free(config->table);
+    free(config->action_names);
+    free(config->action_arg_amounts);
+
+    kh_destroy(int64_map, config->terminals);
+
+    free(config);
+}
+
+/**
+ * Marks various members of the DriverConfig to ensure they are not garbage
+ * collected until at least the next GC run.
+ */
+void ll_driver_config_mark(DriverConfig *config)
+{
+    long index;
+
+    FOR(index, config->actions_count)
+    {
+        rb_gc_mark(config->action_names[index]);
+    }
+}
+
+/**
+ * Allocates a new DriverConfig.
+ */
+VALUE ll_driver_config_allocate(VALUE klass)
+{
+    DriverConfig *config = ALLOC(DriverConfig);
+
+    return Data_Wrap_Struct(
+        klass,
+        ll_driver_config_mark,
+        ll_driver_config_free, config
+    );
+}
+
+/**
+ * Stores the terminals of the parser in the DriverConfig struct.
+ *
+ * @param self The current DriverConfig instance.
+ * @param array The terminals to store in the struct.
+ */
+VALUE ll_driver_config_set_terminals(VALUE self, VALUE array)
+{
+    long index;
+
+    int key_ret;
+    khint64_t key;
+    VALUE token;
+    DriverConfig *config;
+    long count = RARRAY_LEN(array);
+
+    Data_Get_Struct(self, DriverConfig, config);
+
+    config->terminals = kh_init(int64_map);
+
+    FOR(index, count)
+    {
+        token = rb_ary_entry(array, index);
+        key   = kh_put(int64_map, config->terminals, token, &key_ret);
+
+        kh_value(config->terminals, key) = index;
+    }
+
+    return Qnil;
+}
+
+/**
+ * Stores the rules in the DriverConfig struct.
+ *
+ * @param self The DriverConfig instance.
+ * @param array The rules to store.
+ */
+VALUE ll_driver_config_set_rules(VALUE self, VALUE array)
+{
+    long rindex;
+    long cindex;
+    long col_count;
+    DriverConfig *config;
+    VALUE row;
+    long row_count = RARRAY_LEN(array);
+
+    Data_Get_Struct(self, DriverConfig, config);
+
+    config->rules        = ALLOC_N(long*, row_count);
+    config->rule_lengths = ALLOC_N(long, row_count);
+
+    FOR(rindex, row_count)
+    {
+        row       = rb_ary_entry(array, rindex);
+        col_count = RARRAY_LEN(row);
+
+        config->rules[rindex] = ALLOC_N(long, col_count);
+
+        FOR(cindex, col_count)
+        {
+            config->rules[rindex][cindex] = NUM2INT(rb_ary_entry(row, cindex));
+        }
+
+        config->rule_lengths[rindex] = col_count;
+    }
+
+    config->rules_count = row_count;
+
+    return Qnil;
+}
+
+/**
+ * Stores the lookup table in the DriverConfig struct.
+ *
+ * @param self The DriverConfig instance.
+ * @param array The lookup table.
+ */
+VALUE ll_driver_config_set_table(VALUE self, VALUE array)
+{
+    long rindex;
+    long cindex;
+    long col_count;
+    VALUE row;
+    DriverConfig *config;
+    long row_count = RARRAY_LEN(array);
+
+    Data_Get_Struct(self, DriverConfig, config);
+
+    config->table = ALLOC_N(long*, row_count);
+
+    FOR(rindex, row_count)
+    {
+        row       = rb_ary_entry(array, rindex);
+        col_count = RARRAY_LEN(row);
+
+        config->table[rindex] = ALLOC_N(long, col_count);
+
+        FOR(cindex, col_count)
+        {
+            config->table[rindex][cindex] = NUM2INT(rb_ary_entry(row, cindex));
+        }
+    }
+
+    config->table_count = row_count;
+
+    return Qnil;
+}
+
+/**
+ * Stores the callback actions in the DriverConfig struct.
+ *
+ * @param self The DriverConfig instance.
+ * @param array The callback actions and their arities.
+ */
+VALUE ll_driver_config_set_actions(VALUE self, VALUE array)
+{
+    long rindex;
+    VALUE row;
+    DriverConfig *config;
+    long row_count = RARRAY_LEN(array);
+
+    Data_Get_Struct(self, DriverConfig, config);
+
+    config->action_names       = ALLOC_N(ID, row_count);
+    config->action_arg_amounts = ALLOC_N(long, row_count);
+
+    FOR(rindex, row_count)
+    {
+        row = rb_ary_entry(array, rindex);
+
+        config->action_names[rindex]       = rb_ary_entry(row, 0);
+        config->action_arg_amounts[rindex] = NUM2INT(rb_ary_entry(row, 1));
+    }
+
+    config->actions_count = row_count;
+
+    return Qnil;
+}
+
+void Init_ll_driver_config()
+{
+    VALUE mLL   = rb_const_get(rb_cObject, rb_intern("LL"));
+    VALUE klass = rb_const_get(mLL, rb_intern("DriverConfig"));
+
+    rb_define_alloc_func(klass, ll_driver_config_allocate);
+
+    rb_define_method(klass, "terminals_native=", ll_driver_config_set_terminals, 1);
+    rb_define_method(klass, "rules_native=", ll_driver_config_set_rules, 1);
+    rb_define_method(klass, "table_native=", ll_driver_config_set_table, 1);
+    rb_define_method(klass, "actions_native=", ll_driver_config_set_actions, 1);
+}