ruby-ll 1.0.0

data/ext/c/kvec.h

@@ -0,0 +1,90 @@
+/* The MIT License
+
+   Copyright (c) 2008, by Attractive Chaos <attractor@live.co.uk>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/*
+  An example:
+
+#include "kvec.h"
+int main() {
+	kvec_t(int) array;
+	kv_init(array);
+	kv_push(int, array, 10); // append
+	kv_a(int, array, 20) = 5; // dynamic
+	kv_A(array, 20) = 4; // static
+	kv_destroy(array);
+	return 0;
+}
+*/
+
+/*
+  2008-09-22 (0.1.0):
+
+	* The initial version.
+
+*/
+
+#ifndef AC_KVEC_H
+#define AC_KVEC_H
+
+#include <stdlib.h>
+
+#define kv_roundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+
+#define kvec_t(type) struct { size_t n, m; type *a; }
+#define kv_init(v) ((v).n = (v).m = 0, (v).a = 0)
+#define kv_destroy(v) free((v).a)
+#define kv_A(v, i) ((v).a[(i)])
+#define kv_pop(v) ((v).a[--(v).n])
+#define kv_size(v) ((v).n)
+#define kv_max(v) ((v).m)
+
+#define kv_resize(type, v, s)  ((v).m = (s), (v).a = (type*)realloc((v).a, sizeof(type) * (v).m))
+
+#define kv_copy(type, v1, v0) do {							\
+		if ((v1).m < (v0).n) kv_resize(type, v1, (v0).n);	\
+		(v1).n = (v0).n;									\
+		memcpy((v1).a, (v0).a, sizeof(type) * (v0).n);		\
+	} while (0)												\
+
+#define kv_push(type, v, x) do {									\
+		if ((v).n == (v).m) {										\
+			(v).m = (v).m? (v).m<<1 : 2;							\
+			(v).a = (type*)realloc((v).a, sizeof(type) * (v).m);	\
+		}															\
+		(v).a[(v).n++] = (x);										\
+	} while (0)
+
+#define kv_pushp(type, v) (((v).n == (v).m)?							\
+						   ((v).m = ((v).m? (v).m<<1 : 2),				\
+							(v).a = (type*)realloc((v).a, sizeof(type) * (v).m), 0)	\
+						   : 0), ((v).a + ((v).n++))
+
+#define kv_a(type, v, i) (((v).m <= (size_t)(i)? \
+						  ((v).m = (v).n = (i) + 1, kv_roundup32((v).m), \
+						   (v).a = (type*)realloc((v).a, sizeof(type) * (v).m), 0) \
+						  : (v).n <= (size_t)(i)? (v).n = (i) + 1 \
+						  : 0), (v).a[(i)])
+
+#endif

data/ext/c/libll.c

@@ -0,0 +1,7 @@
+#include "libll.h"
+
+void Init_libll()
+{
+    Init_ll_driver_config();
+    Init_ll_driver();
+}

data/ext/c/libll.h

@@ -0,0 +1,9 @@
+#ifndef LIBLL_H
+#define LIBLL_H
+
+#include <ruby.h>
+#include "driver.h"
+
+void Init_libll();
+
+#endif

data/ext/c/macros.h

@@ -0,0 +1,6 @@
+#ifndef LIBLL_MACROS_H
+#define LIBLL_MACROS_H
+
+#define FOR(index, max) for ( index = 0; index < max; index++ )
+
+#endif

data/ext/java/Libll.java

@@ -0,0 +1,12 @@
+package org.libll;
+
+import org.jruby.Ruby;
+
+public class Libll
+{
+    public static void load(final Ruby runtime)
+    {
+        org.libll.DriverConfig.load(runtime);
+        org.libll.Driver.load(runtime);
+    }
+}

data/ext/java/org/libll/Driver.java

@@ -0,0 +1,247 @@
+package org.libll;
+
+import java.util.ArrayList;
+import java.util.ArrayDeque;
+
+import org.libll.DriverConfig;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyArray;
+import org.jruby.RubySymbol;
+import org.jruby.RubyFixnum;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Arity;
+import org.jruby.runtime.Helpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.BlockCallback;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.CallBlock19;
+import org.jruby.runtime.builtin.IRubyObject;
+
+@JRubyClass(name="LL::Driver", parent="Object")
+public class Driver extends RubyObject
+{
+    private static long T_EOF      = -1;
+    private static long T_RULE     = 0;
+    private static long T_TERMINAL = 1;
+    private static long T_EPSILON  = 2;
+    private static long T_ACTION   = 3;
+
+    /**
+     * The current Ruby runtime.
+     */
+    private Ruby runtime;
+
+    /**
+     * The driver configuration.
+     */
+    private DriverConfig config;
+
+    /**
+     * Sets up the class in the Ruby runtime.
+     */
+    public static void load(Ruby runtime)
+    {
+        RubyModule ll = (RubyModule) runtime.getModule("LL");
+
+        RubyClass driver = ll.defineClassUnder(
+            "Driver",
+            runtime.getObject(),
+            ALLOCATOR
+        );
+
+        driver.defineAnnotatedMethods(Driver.class);
+    }
+
+    private static final ObjectAllocator ALLOCATOR = new ObjectAllocator()
+    {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass)
+        {
+            return new org.libll.Driver(runtime, klass);
+        }
+    };
+
+    /**
+     * @param runtime The current Ruby runtime.
+     * @param klass The Driver class.
+     */
+    public Driver(Ruby runtime, RubyClass klass)
+    {
+        super(runtime, klass);
+
+        this.runtime = runtime;
+        this.config  = (DriverConfig) klass.getConstant("CONFIG");
+    }
+
+    /**
+     * The main parsing loop of the driver.
+     */
+    @JRubyMethod
+    public IRubyObject parse(ThreadContext context)
+    {
+        final ArrayDeque<Long> stack = new ArrayDeque<Long>();
+        final ArrayDeque<IRubyObject> value_stack = new ArrayDeque<IRubyObject>();
+        final Driver self = this;
+
+        // EOF
+        stack.push(this.T_EOF);
+        stack.push(this.T_EOF);
+
+        // Start rule
+        ArrayList<Long> start_row = self.config.rules.get(0);
+
+        for ( int index = 0; index < start_row.size(); index++ )
+        {
+            stack.push(start_row.get(index));
+        }
+
+        BlockCallback callback = new BlockCallback()
+        {
+            public IRubyObject call(ThreadContext context, IRubyObject[] args, Block block)
+            {
+                RubyArray token   = (RubyArray) args[0];
+                IRubyObject type  = token.entry(0);
+                IRubyObject value = token.entry(1);
+
+                while ( true )
+                {
+                    if ( stack.size() == 0 )
+                    {
+                        self.callMethod(
+                            context,
+                            "unexpected_input_error",
+                            token
+                        );
+                    }
+
+                    Long stack_value = stack.pop();
+                    Long stack_type  = stack.pop();
+                    Long token_id    = (long) 0;
+
+                    if ( self.config.terminals.containsKey(type) )
+                    {
+                        token_id = self.config.terminals.get(type);
+                    }
+
+                    // Rule
+                    if ( stack_type == self.T_RULE )
+                    {
+                        Long production_i = self.config.table
+                            .get(stack_value.intValue())
+                            .get(token_id.intValue());
+
+                        if ( production_i == self.T_EOF )
+                        {
+                            IRubyObject[] stack_input_error_args = {
+                                RubyFixnum.newFixnum(self.runtime, stack_value),
+                                token
+                            };
+
+                            self.callMethod(
+                                context,
+                                "stack_input_error",
+                                stack_input_error_args
+                            );
+                        }
+                        else
+                        {
+                            ArrayList<Long> row = self.config.rules
+                                .get(production_i.intValue());
+
+                            for ( int index = 0; index < row.size(); index++ )
+                            {
+                                stack.push(row.get(index));
+                            }
+                        }
+                    }
+                    // Terminal
+                    else if ( stack_type == self.T_TERMINAL )
+                    {
+                        if ( stack_value == token_id )
+                        {
+                            value_stack.push(value);
+
+                            break;
+                        }
+                        else
+                        {
+                            IRubyObject[] invalid_terminal_args = {
+                                RubyFixnum.newFixnum(self.runtime, token_id),
+                                RubyFixnum.newFixnum(self.runtime, stack_value)
+                            };
+
+                            self.callMethod(
+                                context,
+                                "invalid_terminal_error",
+                                invalid_terminal_args
+                            );
+                        }
+                    }
+                    // Action
+                    else if ( stack_type == self.T_ACTION )
+                    {
+                        String method = self.config.action_names
+                            .get(stack_value.intValue())
+                            .toString();
+
+                        long num_args = (long) self.config.action_arg_amounts
+                            .get(stack_value.intValue());
+
+                        RubyArray action_args = self.runtime.newArray();
+
+                        if ( num_args > (long) value_stack.size() )
+                        {
+                            num_args = (long) value_stack.size();
+                        }
+
+                        while ( (num_args--) > 0 )
+                        {
+                            if ( value_stack.size() > 0 )
+                            {
+                                action_args.store(num_args, value_stack.pop());
+                            }
+                        }
+
+                        value_stack.push(
+                            self.callMethod(context, method, action_args)
+                        );
+                    }
+                    else if ( stack_type == self.T_EOF )
+                    {
+                        break;
+                    }
+                }
+
+                return context.nil;
+            }
+        };
+
+        Helpers.invoke(
+            context,
+            this,
+            "each_token",
+            CallBlock19.newCallClosure(
+                this,
+                this.metaClass,
+                Arity.NO_ARGUMENTS,
+                callback,
+                context
+            )
+        );
+
+        if ( value_stack.isEmpty() )
+        {
+            return context.nil;
+        }
+        else
+        {
+            return value_stack.pop();
+        }
+    }
+}

data/ext/java/org/libll/DriverConfig.java

@@ -0,0 +1,193 @@
+package org.libll;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubySymbol;
+import org.jruby.RubyArray;
+import org.jruby.RubyFixnum;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Class used for storing the configuration (e.g. the rules and the lookup
+ * table) of a parser driver. This class mimics its C equivalent (also called
+ * "DriverConfig").
+ */
+@JRubyClass(name="LL::DriverConfig", parent="Object")
+public class DriverConfig extends RubyObject
+{
+    /**
+     * The current Ruby runtime.
+     */
+    private Ruby runtime;
+
+    /**
+     * Hash mapping Ruby Symbols with their indexes.
+     */
+    public HashMap<RubySymbol, Long> terminals = new HashMap<RubySymbol, Long>();
+
+    /**
+     * 2-dimensional array containing the rules and their steps.
+     */
+    public ArrayList<ArrayList<Long>> rules = new ArrayList<ArrayList<Long>>();
+
+    /**
+     * 2-dimensional array used as the lookup table.
+     */
+    public ArrayList<ArrayList<Long>> table = new ArrayList<ArrayList<Long>>();
+
+    /**
+     * Array containing the callback names.
+     */
+    public ArrayList<RubySymbol> action_names = new ArrayList<RubySymbol>();
+
+    /**
+     * Array containing the arities of every callback.
+     */
+    public ArrayList<Integer> action_arg_amounts = new ArrayList<Integer>();
+
+    /**
+     * Sets up the class in the Ruby runtime.
+     */
+    public static void load(Ruby runtime)
+    {
+        RubyModule ll = (RubyModule) runtime.getModule("LL");
+
+        RubyClass config = ll.defineClassUnder(
+            "DriverConfig",
+            runtime.getObject(),
+            ALLOCATOR
+        );
+
+        config.defineAnnotatedMethods(DriverConfig.class);
+    }
+
+    private static final ObjectAllocator ALLOCATOR = new ObjectAllocator()
+    {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass)
+        {
+            return new org.libll.DriverConfig(runtime, klass);
+        }
+    };
+
+    /**
+     * @param runtime The current Ruby runtime.
+     * @param klass The DriverConfig class.
+     */
+    public DriverConfig(Ruby runtime, RubyClass klass)
+    {
+        super(runtime, klass);
+
+        this.runtime = runtime;
+    }
+
+    /**
+     * Stores the terminals of the parser in the current DriverConfig instance.
+     *
+     * @param arg Array of terminals to store.
+     */
+    @JRubyMethod(name="terminals_native=")
+    public IRubyObject set_terminals_native(ThreadContext context, IRubyObject arg)
+    {
+        RubyArray array = arg.convertToArray();
+
+        for ( long index = 0; index < array.size(); index++ )
+        {
+            RubySymbol sym = (RubySymbol) array.entry(index);
+
+            this.terminals.put(sym, index);
+        }
+
+        return context.nil;
+    }
+
+    /**
+     * Stores the rules in the current DriverConfig instance.
+     *
+     * @param arg Array of rules to store.
+     */
+    @JRubyMethod(name="rules_native=")
+    public IRubyObject set_rules_native(ThreadContext context, IRubyObject arg)
+    {
+        RubyArray array = arg.convertToArray();
+
+        for ( long rindex = 0; rindex < array.size(); rindex++ )
+        {
+            RubyArray ruby_row  = (RubyArray) array.entry(rindex);
+            ArrayList<Long> row = new ArrayList<Long>();
+
+            for ( long cindex = 0; cindex < ruby_row.size(); cindex++ )
+            {
+                RubyFixnum column = (RubyFixnum) ruby_row.entry(cindex);
+
+                row.add(column.getLongValue());
+            }
+
+            this.rules.add(row);
+        }
+
+        return context.nil;
+    }
+
+    /**
+     * Stores the lookup table in the current DriverConfig instance.
+     *
+     * @param arg Array containing the rows/columns of the lookup table.
+     */
+    @JRubyMethod(name="table_native=")
+    public IRubyObject set_table_native(ThreadContext context, IRubyObject arg)
+    {
+        RubyArray array = arg.convertToArray();
+
+        for ( long rindex = 0; rindex < array.size(); rindex++ )
+        {
+            RubyArray ruby_row  = (RubyArray) array.entry(rindex);
+            ArrayList<Long> row = new ArrayList<Long>();
+
+            for ( long cindex = 0; cindex < ruby_row.size(); cindex++ )
+            {
+                RubyFixnum column = (RubyFixnum) ruby_row.entry(cindex);
+
+                row.add(column.getLongValue());
+            }
+
+            this.table.add(row);
+        }
+
+        return context.nil;
+    }
+
+    /**
+     * Stores the callback actions and their arities in the current DriverConfig
+     * instance.
+     *
+     * @param arg Array containing the callback names and their arguments.
+     */
+    @JRubyMethod(name="actions_native=")
+    public IRubyObject set_actions_native(ThreadContext context, IRubyObject arg)
+    {
+        RubyArray array = arg.convertToArray();
+
+        for ( long rindex = 0; rindex < array.size(); rindex++ )
+        {
+            RubyArray row = (RubyArray) array.entry(rindex);
+
+            RubySymbol name  = (RubySymbol) row.entry(0);
+            RubyFixnum arity = (RubyFixnum) row.entry(1);
+
+            this.action_names.add(name);
+            this.action_arg_amounts.add((int) arity.getLongValue());
+        }
+
+        return context.nil;
+    }
+}