ruby-ll 1.0.0-java → 1.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d6057306bad4fd2e4a743fa72915136c4acad96
-  data.tar.gz: 743344bbf8ef7d33fe98abbf07c459e63e83b2df
+  metadata.gz: 06f9ad3dfe90842c1422c69bb269f1731aebe32c
+  data.tar.gz: a7d4d5d8a177da5581cbc7ada29098ae40b697df
 SHA512:
-  metadata.gz: cde16b63f72e5f74ae2ccd5ecd6ad301a39b7826b10e4c0b4d117b31d5bdd3707f8b17e0f6fade697d4e3f2ec1e3fb8feeff47ec7a2e0649da5b56f7b5f279ec
-  data.tar.gz: 7642a32c7f1c76f5e76eddd6315f7eaca00b3f698c767e0000c5fcf81eb031df5849a7c682aa482b1dca2f1fe21c7eecfe5cc830872364d1e810e5c2c073abac
+  metadata.gz: e895126880a8ec33adeffc3655dfd55173607ab032e0fdac9b65c91b69d457a2835e33b772c73b29dc95cb4cf7712cbf061d067d0b9bfe2532b3d866e4293531
+  data.tar.gz: 322a99b744e74efe86185524c8c7bf86d2f4df95e4f85ab5537fbe7fbe7306127df1d6d262c09deaf487a5f46483853432255bc87a084206b6aae680734b921e

data/README.md

@@ -44,6 +44,12 @@ When hacking on Oga you'll also need to have the following installed:
 * Ragel 6 for building the grammar lexer
 * javac for building the JRuby extension
 
+## Installation
+
+ruby-ll can be installed from RubyGems:
+
+    gem install ruby-ll
+
 ## Usage
 
 The CLI takes a grammar input file (see below for the exact syntax) with the
@@ -74,6 +80,13 @@ parsing simply call the `parse` method:
 The return value of this method is whatever the root rule (= the first rule
 defined) returned.
 
+## Error Handling
+
+Parser errors are handled by `LL::Driver#parser_error`. By default this method
+raises an instance of `LL::ParserError` with a message depending on the current
+parser context and input. If you want to customize this behaviour simply
+overwrite the method (e.g. in an `%inner` block).
+
 ## Grammar Syntax
 
 The syntax of a ruby-ll grammar file is fairly simple and consists out of
@@ -353,7 +366,7 @@ performance gains of ruby-ll over Racc are as following:
 | JRuby 9000 pre1 | 7.50x |
 
 This benchmark was run on a Thinkpad T520 laptop so it's probably best to run
-the bencharmk yourself to see how it behaves on your platform.
+the benchmark yourself to see how it behaves on your platform.
 
 Depending on the complexity of your parser you might end up with different
 different numbers. The above metrics are simply an indication of the maximum

data/doc/changelog.md

@@ -3,6 +3,17 @@
 This document contains details of the various releases and their release dates.
 Dates are in the format `yyyy-mm-dd`.
 
+## 1.1.0 - 2015-02-16
+
+This release changes the way error handling is done. Instead of having multiple,
+separate error callbacks there's now only one error callback:
+`LL::Driver#parser_error`. See commit 22b6081e37509d10e3b31d6593b0a7f2e5fd7839
+for more information.
+
+While this change technically breaks backwards compatibility I do not consider
+the old error handling system part of the public API, mainly due to it being
+extremely painful to use.
+
 ## 1.0.0 - 2015-02-13
 
 The first public release of ruby-ll!

data/ext/c/driver.c

@@ -9,10 +9,7 @@
 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;
+ID id_parser_error;
 
 /**
  * Releases the memory of the driver's internal state and associated objects.
@@ -91,7 +88,15 @@ VALUE ll_driver_each_token(VALUE token, VALUE self)
     {
         if ( kv_size(state->stack) == 0 )
         {
-            rb_funcall(self, id_unexpected_input_error, 1, token);
+            rb_funcall(
+                self,
+                id_parser_error,
+                4,
+                INT2NUM(-1),
+                INT2NUM(-1),
+                type,
+                value
+            );
         }
 
         stack_value = kv_pop(state->stack);
@@ -117,10 +122,12 @@ VALUE ll_driver_each_token(VALUE token, VALUE self)
             {
                 rb_funcall(
                     self,
-                    id_stack_input_error,
-                    2,
+                    id_parser_error,
+                    4,
+                    INT2NUM(stack_type),
                     INT2NUM(stack_value),
-                    token
+                    type,
+                    value
                 );
             }
             else
@@ -150,10 +157,12 @@ VALUE ll_driver_each_token(VALUE token, VALUE self)
             {
                 rb_funcall(
                     self,
-                    id_invalid_terminal_error,
-                    2,
-                    INT2NUM(token_id),
-                    INT2NUM(stack_value)
+                    id_parser_error,
+                    4,
+                    INT2NUM(stack_type),
+                    INT2NUM(stack_value),
+                    type,
+                    value
                 );
             }
         }
@@ -249,10 +258,8 @@ void Init_ll_driver()
 
     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");
+    id_send         = rb_intern("send");
+    id_config_const = rb_intern("CONFIG");
+    id_each_token   = rb_intern("each_token");
+    id_parser_error = rb_intern("parser_error");
 }

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

@@ -113,11 +113,14 @@ public class Driver extends RubyObject
                 {
                     if ( stack.size() == 0 )
                     {
-                        self.callMethod(
-                            context,
-                            "unexpected_input_error",
-                            token
-                        );
+                        IRubyObject[] error_args = {
+                            RubyFixnum.newFixnum(self.runtime, -1),
+                            RubyFixnum.newFixnum(self.runtime, -1),
+                            type,
+                            value
+                        };
+
+                        self.callMethod(context, "parser_error", error_args);
                     }
 
                     Long stack_value = stack.pop();
@@ -138,16 +141,14 @@ public class Driver extends RubyObject
 
                         if ( production_i == self.T_EOF )
                         {
-                            IRubyObject[] stack_input_error_args = {
+                            IRubyObject[] error_args = {
+                                RubyFixnum.newFixnum(self.runtime, stack_type),
                                 RubyFixnum.newFixnum(self.runtime, stack_value),
-                                token
+                                type,
+                                value
                             };
 
-                            self.callMethod(
-                                context,
-                                "stack_input_error",
-                                stack_input_error_args
-                            );
+                            self.callMethod(context, "parser_error", error_args);
                         }
                         else
                         {
@@ -171,16 +172,14 @@ public class Driver extends RubyObject
                         }
                         else
                         {
-                            IRubyObject[] invalid_terminal_args = {
-                                RubyFixnum.newFixnum(self.runtime, token_id),
-                                RubyFixnum.newFixnum(self.runtime, stack_value)
+                            IRubyObject[] error_args = {
+                                RubyFixnum.newFixnum(self.runtime, stack_type),
+                                RubyFixnum.newFixnum(self.runtime, stack_value),
+                                type,
+                                value
                             };
 
-                            self.callMethod(
-                                context,
-                                "invalid_terminal_error",
-                                invalid_terminal_args
-                            );
+                            self.callMethod(context, "parser_error", error_args);
                         }
                     }
                     // Action

data/lib/ll/bootstrap/parser.rb

@@ -0,0 +1,326 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.12
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+module LL
+  module Bootstrap
+    class Parser < Racc::Parser
+
+  ##
+  # @see [LL::Lexer#initialize]
+  #
+  def initialize(*args)
+    @lexer = Lexer.new(*args)
+  end
+
+  ##
+  # Yields the next token from the lexer.
+  #
+  # @yieldparam [Array]
+  #
+  def yield_next_token
+    @lexer.advance do |token|
+      yield [token.type, token]
+    end
+
+    yield [false, false]
+  end
+
+  ##
+  # @see [LL::AST::Node#initialize]
+  # @return [LL::AST::Node]
+  #
+  def s(*args)
+    return AST::Node.new(*args)
+  end
+
+  ##
+  # Parses the input and returns the corresponding AST.
+  #
+  # @return [LL::AST::Node]
+  #
+  def parse
+    return yyparse(self, :yield_next_token)
+  end
+
+# vim: set ft=racc:
+##### State transition tables begin ###
+
+racc_action_table = [
+    14,    28,    16,    14,    26,    29,    10,    11,    12,    13,
+    14,    10,    11,    12,    13,    14,    14,    14,    14,    22,
+    33,    33,    22,    24,    25,    37,    38,    14,    22,    40,
+    41,    14,    28 ]
+
+racc_action_check = [
+    19,    18,     1,    10,    18,    19,     0,     0,     0,     0,
+     0,     2,     2,     2,     2,     2,    24,    40,    11,    12,
+    24,    40,    13,    15,    16,    27,    28,    31,    34,    35,
+    36,    38,    42 ]
+
+racc_action_pointer = [
+     3,     2,     8,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    -4,    11,    17,    20,   nil,    15,    24,   nil,    -8,    -7,
+   nil,   nil,   nil,   nil,     9,   nil,   nil,    13,    17,   nil,
+   nil,    20,   nil,   nil,    26,    19,    18,   nil,    24,   nil,
+    10,   nil,    23,   nil,   nil ]
+
+racc_action_default = [
+    -2,   -30,    -1,    -4,    -5,    -6,    -7,    -8,    -9,   -10,
+   -30,   -30,   -30,   -30,   -20,   -30,   -30,    -3,   -30,   -30,
+   -18,   -16,   -29,   -17,   -30,    45,   -11,   -30,   -30,   -15,
+   -19,   -21,   -22,   -23,   -24,   -26,   -30,   -12,   -30,   -25,
+   -30,   -28,   -13,   -27,   -14 ]
+
+racc_goto_table = [
+    15,    27,    15,     1,    21,    23,    36,     3,     2,    17,
+    18,    19,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    30,
+   nil,   nil,    43,   nil,   nil,    44,    39,   nil,   nil,   nil,
+   nil,    30,   nil,   nil,   nil,   nil,   nil,   nil,    42 ]
+
+racc_goto_check = [
+    10,    11,    10,     1,    13,    13,    17,     3,     2,     3,
+    10,    12,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    10,
+   nil,   nil,    17,   nil,   nil,    11,    13,   nil,   nil,   nil,
+   nil,    10,   nil,   nil,   nil,   nil,   nil,   nil,    10 ]
+
+racc_goto_pointer = [
+   nil,     3,     8,     7,   nil,   nil,   nil,   nil,   nil,   nil,
+     0,   -17,     0,    -8,   nil,   nil,   nil,   -18 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,     4,     5,     6,     7,     8,     9,
+    20,   nil,    31,   nil,    34,    32,    35,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 14, :_reduce_1,
+  0, 14, :_reduce_2,
+  2, 15, :_reduce_3,
+  1, 15, :_reduce_4,
+  1, 16, :_reduce_none,
+  1, 16, :_reduce_none,
+  1, 17, :_reduce_none,
+  1, 17, :_reduce_none,
+  1, 17, :_reduce_none,
+  1, 17, :_reduce_none,
+  3, 19, :_reduce_11,
+  4, 19, :_reduce_12,
+  3, 24, :_reduce_13,
+  4, 24, :_reduce_14,
+  3, 20, :_reduce_15,
+  2, 21, :_reduce_16,
+  2, 22, :_reduce_17,
+  1, 25, :_reduce_18,
+  2, 25, :_reduce_19,
+  1, 23, :_reduce_20,
+  1, 27, :_reduce_21,
+  1, 27, :_reduce_22,
+  1, 28, :_reduce_23,
+  1, 29, :_reduce_24,
+  2, 29, :_reduce_25,
+  1, 30, :_reduce_26,
+  3, 30, :_reduce_27,
+  4, 18, :_reduce_28,
+  1, 26, :_reduce_29 ]
+
+racc_reduce_n = 30
+
+racc_shift_n = 45
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :T_RUBY => 2,
+  :T_NAME => 3,
+  :T_TERMINALS => 4,
+  :T_INNER => 5,
+  :T_HEADER => 6,
+  :T_IDENT => 7,
+  :T_EQUALS => 8,
+  :T_COLON => 9,
+  :T_PIPE => 10,
+  :T_EPSILON => 11,
+  :T_SEMICOLON => 12 }
+
+racc_nt_base = 13
+
+racc_use_result_var = false
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "T_RUBY",
+  "T_NAME",
+  "T_TERMINALS",
+  "T_INNER",
+  "T_HEADER",
+  "T_IDENT",
+  "T_EQUALS",
+  "T_COLON",
+  "T_PIPE",
+  "T_EPSILON",
+  "T_SEMICOLON",
+  "$start",
+  "grammar",
+  "elements",
+  "element",
+  "directive",
+  "rule",
+  "name",
+  "terminals",
+  "inner",
+  "header",
+  "ident",
+  "name_ns",
+  "idents",
+  "ruby",
+  "idents_or_epsilon",
+  "epsilon",
+  "branch",
+  "branches" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values)
+ s(:grammar, val[0]) 
+end
+
+def _reduce_2(val, _values)
+ s(:grammar) 
+end
+
+def _reduce_3(val, _values)
+ val[0] << val[1] 
+end
+
+def _reduce_4(val, _values)
+ val 
+end
+
+# reduce 5 omitted
+
+# reduce 6 omitted
+
+# reduce 7 omitted
+
+# reduce 8 omitted
+
+# reduce 9 omitted
+
+# reduce 10 omitted
+
+def _reduce_11(val, _values)
+        s(:name, [val[1]], :source_line => val[0].source_line)
+      
+end
+
+def _reduce_12(val, _values)
+        s(:name, [val[1], *val[2]], :source_line => val[0].source_line)
+      
+end
+
+def _reduce_13(val, _values)
+ [val[2]] 
+end
+
+def _reduce_14(val, _values)
+ [val[2]] + val[3] 
+end
+
+def _reduce_15(val, _values)
+        s(:terminals, val[1], :source_line => val[0].source_line)
+      
+end
+
+def _reduce_16(val, _values)
+ s(:inner, [val[1]], :source_line => val[0].source_line) 
+end
+
+def _reduce_17(val, _values)
+ s(:header, [val[1]], :source_line => val[0].source_line) 
+end
+
+def _reduce_18(val, _values)
+ val 
+end
+
+def _reduce_19(val, _values)
+ val[0] << val[1] 
+end
+
+def _reduce_20(val, _values)
+ s(:ident, [val[0].value], :source_line => val[0].source_line) 
+end
+
+def _reduce_21(val, _values)
+        s(:steps, val[0], :source_line => val[0][0].source_line)
+      
+end
+
+def _reduce_22(val, _values)
+        s(:steps, [val[0]], :source_line => val[0].source_line)
+      
+end
+
+def _reduce_23(val, _values)
+ s(:epsilon, [], :source_line => val[0].source_line) 
+end
+
+def _reduce_24(val, _values)
+        s(:branch, [val[0]], :source_line => val[0].source_line)
+      
+end
+
+def _reduce_25(val, _values)
+        s(:branch, [val[0], val[1]], :source_line => val[0].source_line)
+      
+end
+
+def _reduce_26(val, _values)
+ val 
+end
+
+def _reduce_27(val, _values)
+ [val[0]] + val[2] 
+end
+
+def _reduce_28(val, _values)
+        s(:rule, [val[0], *val[2]], :source_line => val[0].source_line)
+      
+end
+
+def _reduce_29(val, _values)
+ s(:ruby, [val[0].value], :source_line => val[0].source_line) 
+end
+
+def _reduce_none(val, _values)
+  val[0]
+end
+
+    end   # class Parser
+    end   # module Bootstrap
+  end   # module LL

data/lib/ll/configuration_compiler.rb

@@ -8,6 +8,7 @@ module LL
     # @return [Hash]
     #
     TYPES = {
+      :eof      => -1,
       :rule     => 0,
       :terminal => 1,
       :epsilon  => 2,

data/lib/ll/driver.rb

@@ -4,43 +4,58 @@ module LL
   #
   class Driver
     ##
-    # Error method that is called when no rule was found for a table index.
+    # @param [Fixnum] stack_type
+    # @param [Fixnum] stack_value
+    # @param [Symbol] token_type
+    # @param [Mixed] token_value
     #
+    def parser_error(stack_type, stack_value, token_type, token_value)
+      message = parser_error_message(stack_type, stack_value, token_type)
+
+      raise ParserError, message
+    end
+
+    ##
+    # @param [Fixnum] stack_type
     # @param [Fixnum] stack_value
-    # @param [Array] token
+    # @param [Symbol] token_type
+    # @return [String]
     #
-    def stack_input_error(stack_value, token)
-      type = token[0].inspect
+    def parser_error_message(stack_type, stack_value, token_type)
+      case id_to_type(stack_type)
+      when :rule
+        message = "Unexpected #{token_type} for rule #{stack_value}"
+      when :terminal
+        expected = id_to_terminal(stack_value)
+        message  = "Unexpected #{token_type}, expected #{expected} instead"
+      when :eof
+        message = "Received #{token_type} but there's nothing left to parse"
+      end
 
-      raise ParserError, "Unexpected rule #{stack_value} for #{type}"
+      return message
     end
 
     ##
-    # Error method that is called when the stack has been consumed but there's
-    # still input being sent to the parser.
+    # Returns the Symbol that belongs to the stack type number.
+    #
+    # @example
+    #  id_to_type(1) # => :terminal
     #
-    # @param [Array] token
+    # @param [Fixnum] id
+    # @return [Symbol]
     #
-    def unexpected_input_error(token)
-      raise(
-        ParserError,
-        "Received token #{token[0].inspect} but there's nothing left to parse"
-      )
+    def id_to_type(id)
+      return ConfigurationCompiler::TYPES.invert[id]
     end
 
     ##
-    # Error method that is called when an invalid terminal was specified as the
-    # input.
+    # Returns the Symbol of the terminal index.
     #
-    # @param [Fixnum] got_id The ID of the received terminal.
-    # @param [Fixnum] expected_id The ID of the expected terminal.
+    # @param [Fixnum] id
+    # @return [Symbol]
     #
-    def invalid_terminal_error(got_id, expected_id)
-      terminals = self.class::CONFIG.terminals
-      expected  = terminals[expected_id].inspect
-      got       = terminals[got_id].inspect
-
-      raise ParserError, "Invalid terminal #{got}, expected #{expected}"
+    def id_to_terminal(id)
+      return self.class::CONFIG.terminals[id]
     end
   end # Driver
 end # LL

data/lib/ll/version.rb

@@ -1,3 +1,3 @@
 module LL
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end # LL

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-ll
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: java
 authors:
 - Yorick Peterse
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-02-12 00:00:00.000000000 Z
+date: 2015-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -166,6 +166,7 @@ files:
 - lib/libll.jar
 - lib/ll.rb
 - lib/ll/ast/node.rb
+- lib/ll/bootstrap/parser.rb
 - lib/ll/branch.rb
 - lib/ll/cli.rb
 - lib/ll/code_generator.rb