lrama 0.6.9 → 0.6.10

data/parser.y

@@ -1,14 +1,12 @@
 class Lrama::Parser
   expect 0
+  error_on_expect_mismatch
 
   token C_DECLARATION CHARACTER IDENT_COLON IDENTIFIER INTEGER STRING TAG
 
 rule
 
-  input: prologue_declarations bison_declarations "%%" grammar epilogue_opt
-
-  prologue_declarations: # empty
-                       | prologue_declarations prologue_declaration
+  input: prologue_declaration* bison_declaration* "%%" rules_or_grammar_declaration+ epilogue_declaration?
 
   prologue_declaration: "%{"
                           {
@@ -25,116 +23,66 @@ rule
                           }
                       | "%require" STRING
 
-  bison_declarations: /* empty */ { result = "" }
-                    | bison_declarations bison_declaration
-
   bison_declaration: grammar_declaration
-                   | rule_declaration
-                   | inline_declaration
                    | "%expect" INTEGER { @grammar.expect = val[1] }
                    | "%define" variable value
-                   | "%param" params
-                   | "%lex-param" params
+                   | "%param" param+
+                   | "%lex-param" param+
                        {
                          val[1].each {|token|
                            @grammar.lex_param = Grammar::Code::NoReferenceCode.new(type: :lex_param, token_code: token).token_code.s_value
                          }
                        }
-                   | "%parse-param" params
+                   | "%parse-param" param+
                        {
                          val[1].each {|token|
                            @grammar.parse_param = Grammar::Code::NoReferenceCode.new(type: :parse_param, token_code: token).token_code.s_value
                          }
                        }
-                   | "%code" IDENTIFIER "{"
-                       {
-                         begin_c_declaration("}")
-                       }
-                     C_DECLARATION
-                       {
-                         end_c_declaration
-                       }
-                     "}"
-                       {
-                         @grammar.add_percent_code(id: val[1], code: val[4])
-                       }
-                   | "%initial-action" "{"
-                       {
-                         begin_c_declaration("}")
-                       }
-                     C_DECLARATION
+                   | "%code" IDENTIFIER param
                        {
-                         end_c_declaration
+                         @grammar.add_percent_code(id: val[1], code: val[2])
                        }
-                     "}"
+                   | "%initial-action" param
                        {
-                         @grammar.initial_action = Grammar::Code::InitialActionCode.new(type: :initial_action, token_code: val[3])
+                         @grammar.initial_action = Grammar::Code::InitialActionCode.new(type: :initial_action, token_code: val[1])
                        }
                    | "%no-stdlib" { @grammar.no_stdlib = true }
-                   | ";"
+                   | "%locations" { @grammar.locations = true }
+                   | bison_declaration ";"
 
-  grammar_declaration: "%union" "{"
-                         {
-                           begin_c_declaration("}")
-                         }
-                       C_DECLARATION
-                         {
-                           end_c_declaration
-                         }
-                       "}"
+  grammar_declaration: "%union" param
                          {
                            @grammar.set_union(
-                             Grammar::Code::NoReferenceCode.new(type: :union, token_code: val[3]),
-                             val[3].line
+                             Grammar::Code::NoReferenceCode.new(type: :union, token_code: val[1]),
+                             val[1].line
                            )
                          }
                      | symbol_declaration
-                     | "%destructor" "{"
-                         {
-                           begin_c_declaration("}")
-                         }
-                       C_DECLARATION
-                         {
-                           end_c_declaration
-                         }
-                       "}" generic_symlist
+                     | rule_declaration
+                     | inline_declaration
+                     | "%destructor" param generic_symbol+
                          {
                            @grammar.add_destructor(
-                             ident_or_tags: val[6],
-                             token_code: val[3],
-                             lineno: val[3].line
+                             ident_or_tags: val[2],
+                             token_code: val[1],
+                             lineno: val[1].line
                            )
                          }
-                     | "%printer" "{"
-                         {
-                           begin_c_declaration("}")
-                         }
-                       C_DECLARATION
-                         {
-                           end_c_declaration
-                         }
-                       "}" generic_symlist
+                     | "%printer" param generic_symbol+
                          {
                            @grammar.add_printer(
-                             ident_or_tags: val[6],
-                             token_code: val[3],
-                             lineno: val[3].line
+                             ident_or_tags: val[2],
+                             token_code: val[1],
+                             lineno: val[1].line
                            )
                          }
-                     | "%error-token" "{"
-                         {
-                           begin_c_declaration("}")
-                         }
-                       C_DECLARATION
-                         {
-                           end_c_declaration
-                         }
-                       "}" generic_symlist
+                     | "%error-token" param generic_symbol+
                          {
                            @grammar.add_error_token(
-                             ident_or_tags: val[6],
-                             token_code: val[3],
-                             lineno: val[3].line
+                             ident_or_tags: val[2],
+                             token_code: val[1],
+                             lineno: val[1].line
                            )
                          }
                      | "%after-shift" IDENTIFIER
@@ -208,41 +156,43 @@ rule
                           @precedence_number += 1
                         }
 
-  token_declarations: token_declaration_list
+  token_declarations: token_declaration+
                         {
                           val[0].each {|token_declaration|
                             @grammar.add_term(id: token_declaration[0], alias_name: token_declaration[2], token_id: token_declaration[1], tag: nil, replace: true)
                           }
                         }
-                    | TAG token_declaration_list
+                    | TAG token_declaration+
                         {
                           val[1].each {|token_declaration|
                             @grammar.add_term(id: token_declaration[0], alias_name: token_declaration[2], token_id: token_declaration[1], tag: val[0], replace: true)
                           }
                         }
-                    | token_declarations TAG token_declaration_list
+                    | token_declarations TAG token_declaration+
                         {
                           val[2].each {|token_declaration|
                             @grammar.add_term(id: token_declaration[0], alias_name: token_declaration[2], token_id: token_declaration[1], tag: val[1], replace: true)
                           }
                         }
 
-  token_declaration_list: token_declaration { result = [val[0]] }
-                        | token_declaration_list token_declaration { result = val[0].append(val[1]) }
-
-  token_declaration: id int_opt alias { result = val }
+  token_declaration: id INTEGER? alias { result = val }
 
-  rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" tag_opt ":" rule_rhs_list
+  rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" TAG? ":" rule_rhs_list
                       {
                         rule = Grammar::ParameterizingRule::Rule.new(val[1].s_value, val[3], val[7], tag: val[5])
                         @grammar.add_parameterizing_rule(rule)
                       }
 
-  inline_declaration: "%rule" "%inline" id_colon ":" rule_rhs_list
+  inline_declaration: "%rule" "%inline" IDENT_COLON ":" rule_rhs_list
                       {
                         rule = Grammar::ParameterizingRule::Rule.new(val[2].s_value, [], val[4], is_inline: true)
                         @grammar.add_parameterizing_rule(rule)
                       }
+                    | "%rule" "%inline" IDENTIFIER "(" rule_args ")" ":" rule_rhs_list
+                      {
+                        rule = Grammar::ParameterizingRule::Rule.new(val[2].s_value, val[4], val[7], is_inline: true)
+                        @grammar.add_parameterizing_rule(rule)
+                      }
 
   rule_args: IDENTIFIER { result = [val[0]] }
            | rule_args "," IDENTIFIER { result = val[0].append(val[2]) }
@@ -258,17 +208,12 @@ rule
                   result = val[0].append(builder)
                 }
 
-  rule_rhs: /* empty */
+  rule_rhs: empty
             {
               reset_precs
               result = Grammar::ParameterizingRule::Rhs.new
             }
-          | "%empty"
-            {
-              reset_precs
-              result = Grammar::ParameterizingRule::Rhs.new
-            }
-          | rule_rhs symbol named_ref_opt
+          | rule_rhs symbol named_ref?
             {
               token = val[1]
               token.alias_name = val[2]
@@ -282,28 +227,16 @@ rule
                 builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
                 result = builder
               }
-          | rule_rhs IDENTIFIER "(" parameterizing_args ")" tag_opt
+          | rule_rhs IDENTIFIER "(" parameterizing_args ")" TAG?
               {
                 builder = val[0]
                 builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
                 result = builder
               }
-          | rule_rhs "{"
+          | rule_rhs midrule_action named_ref?
             {
-              if @prec_seen
-                on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
-                @code_after_prec = true
-              end
-              begin_c_declaration("}")
-            }
-          C_DECLARATION
-            {
-              end_c_declaration
-            }
-          "}" named_ref_opt
-            {
-              user_code = val[3]
-              user_code.alias_name = val[6]
+              user_code = val[1]
+              user_code.alias_name = val[2]
               builder = val[0]
               builder.user_code = user_code
               result = builder
@@ -317,84 +250,40 @@ rule
               result = builder
             }
 
-  int_opt: # empty
-         | INTEGER
-
   alias: # empty
-       | STRING # TODO: change this to string_as_id
+       | string_as_id { result = val[0].s_value }
 
-  symbol_declarations: symbol_declaration_list
-                         {
-                           result = [{tag: nil, tokens: val[0]}]
-                         }
-                     | TAG symbol_declaration_list
-                         {
-                           result = [{tag: val[0], tokens: val[1]}]
-                         }
-                     | symbol_declarations TAG symbol_declaration_list
-                       {
-                         result = val[0].append({tag: val[1], tokens: val[2]})
-                       }
-
-  symbol_declaration_list: symbol { result = [val[0]] }
-                         | symbol_declaration_list symbol { result = val[0].append(val[1]) }
+  symbol_declarations: symbol+ { result = [{tag: nil, tokens: val[0]}] }
+                     | TAG symbol+ { result = [{tag: val[0], tokens: val[1]}] }
+                     | symbol_declarations TAG symbol+ { result = val[0].append({tag: val[1], tokens: val[2]}) }
 
   symbol: id
         | string_as_id
 
-  params: params "{"
-            {
-              begin_c_declaration("}")
-            }
-          C_DECLARATION
-            {
-              end_c_declaration
-            }
-          "}"
-            {
-              result = val[0].append(val[3])
-            }
-        | "{"
-            {
-              begin_c_declaration("}")
-            }
-          C_DECLARATION
-            {
-              end_c_declaration
-            }
-          "}"
-            {
-              result = [val[2]]
-            }
-
-  token_declarations_for_precedence: token_declaration_list_for_precedence
-                                       {
-                                         result = [{tag: nil, tokens: val[0]}]
-                                       }
-                                   | TAG token_declaration_list_for_precedence
-                                       {
-                                         result = [{tag: val[0], tokens: val[1]}]
-                                       }
-                                   | token_declarations_for_precedence TAG token_declaration_list_for_precedence
-                                       {
-                                         result = val[0].append({tag: val[1], tokens: val[2]})
-                                       }
-
-  token_declaration_list_for_precedence: token_declaration_for_precedence { result = [val[0]] }
-                                       | token_declaration_list_for_precedence token_declaration_for_precedence { result = val[0].append(val[1]) }
-
-  token_declaration_for_precedence: id
+  param: "{" {
+               begin_c_declaration("}")
+             }
+         C_DECLARATION
+             {
+               end_c_declaration
+             }
+         "}"
+             {
+               result = val[2]
+             }
+
+  token_declarations_for_precedence: id+ { result = [{tag: nil, tokens: val[0]}] }
+                                   | TAG id+ { result = [{tag: val[0], tokens: val[1]}] }
+                                   | id TAG id+ { result = val[0].append({tag: val[1], tokens: val[2]}) }
 
   id: IDENTIFIER { on_action_error("ident after %prec", val[0]) if @prec_seen }
     | CHARACTER { on_action_error("char after %prec", val[0]) if @prec_seen }
 
-  grammar: rules_or_grammar_declaration
-         | grammar rules_or_grammar_declaration
 
-  rules_or_grammar_declaration: rules
+  rules_or_grammar_declaration: rules ";"?
                               | grammar_declaration ";"
 
-  rules: id_colon named_ref_opt ":" rhs_list
+  rules: IDENT_COLON named_ref? ":" rhs_list
            {
              lhs = val[0]
              lhs.alias_name = val[1]
@@ -421,19 +310,13 @@ rule
                 end
                 result = val[0].append(builder)
               }
-          | rhs_list ";"
 
-  rhs: /* empty */
-         {
-           reset_precs
-           result = Grammar::RuleBuilder.new(@rule_counter, @midrule_action_counter)
-         }
-     | "%empty"
+  rhs: empty
          {
            reset_precs
-           result = Grammar::RuleBuilder.new(@rule_counter, @midrule_action_counter)
+           result = @grammar.create_rule_builder(@rule_counter, @midrule_action_counter)
          }
-     | rhs symbol named_ref_opt
+     | rhs symbol named_ref?
          {
            token = val[1]
            token.alias_name = val[2]
@@ -441,39 +324,27 @@ rule
            builder.add_rhs(token)
            result = builder
          }
-     | rhs symbol parameterizing_suffix tag_opt
+     | rhs symbol parameterizing_suffix named_ref? TAG?
          {
-           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]], lhs_tag: val[3])
+           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], alias_name: val[3], location: @lexer.location, args: [val[1]], lhs_tag: val[4])
            builder = val[0]
            builder.add_rhs(token)
            builder.line = val[1].first_line
            result = builder
          }
-     | rhs IDENTIFIER "(" parameterizing_args ")" tag_opt
+     | rhs IDENTIFIER "(" parameterizing_args ")" named_ref? TAG?
          {
-           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
+           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, alias_name: val[5], location: @lexer.location, args: val[3], lhs_tag: val[6])
            builder = val[0]
            builder.add_rhs(token)
            builder.line = val[1].first_line
            result = builder
          }
-     | rhs "{"
-         {
-           if @prec_seen
-             on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
-             @code_after_prec = true
-           end
-           begin_c_declaration("}")
-         }
-       C_DECLARATION
-         {
-           end_c_declaration
-         }
-       "}" named_ref_opt tag_opt
+     | rhs midrule_action named_ref? TAG?
          {
-           user_code = val[3]
-           user_code.alias_name = val[6]
-           user_code.tag = val[7]
+           user_code = val[1]
+           user_code.alias_name = val[2]
+           user_code.tag = val[3]
            builder = val[0]
            builder.user_code = user_code
            result = builder
@@ -496,22 +367,35 @@ rule
                      | symbol parameterizing_suffix { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[0])] }
                      | IDENTIFIER "(" parameterizing_args ")" { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[0].s_value, location: @lexer.location, args: val[2])] }
 
-  named_ref_opt: # empty
-               | '[' IDENTIFIER ']' { result = val[1].s_value }
-
-  id_colon: IDENT_COLON
-
-  epilogue_opt: # empty
-              | "%%"
-                  {
-                    begin_c_declaration('\Z')
-                    @grammar.epilogue_first_lineno = @lexer.line + 1
-                  }
-                C_DECLARATION
-                  {
-                    end_c_declaration
-                    @grammar.epilogue = val[2].s_value
-                  }
+  midrule_action: "{"
+                    {
+                      if @prec_seen
+                        on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
+                        @code_after_prec = true
+                      end
+                      begin_c_declaration("}")
+                    }
+                  C_DECLARATION
+                    {
+                      end_c_declaration
+                    }
+                  "}"
+                    {
+                      result = val[2]
+                    }
+
+  named_ref: '[' IDENTIFIER ']' { result = val[1].s_value }
+
+  epilogue_declaration: "%%"
+                          {
+                            begin_c_declaration('\Z')
+                            @grammar.epilogue_first_lineno = @lexer.line + 1
+                          }
+                        C_DECLARATION
+                          {
+                            end_c_declaration
+                            @grammar.epilogue = val[2].s_value
+                          }
 
   variable: id
 
@@ -520,16 +404,13 @@ rule
        | STRING
        | "{...}"
 
-  generic_symlist: generic_symlist_item { result = [val[0]] }
-                 | generic_symlist generic_symlist_item { result = val[0].append(val[1]) }
+  generic_symbol: symbol
+                | TAG
 
-  generic_symlist_item: symbol
-                      | TAG
+  empty: /* empty */
+       | "%empty"
 
   string_as_id: STRING { result = Lrama::Lexer::Token::Ident.new(s_value: val[0]) }
-
-  tag_opt: # empty
-         | TAG
 end
 
 ---- inner

data/sig/lrama/grammar/auxiliary.rbs

@@ -0,0 +1,10 @@
+module Lrama
+  class Grammar
+    class Auxiliary
+      attr_accessor prologue_first_lineno: Integer
+      attr_accessor prologue: String
+      attr_accessor epilogue_first_lineno: Integer
+      attr_accessor epilogue: String
+    end
+  end
+end

data/sig/lrama/grammar/binding.rbs

@@ -10,6 +10,10 @@ module Lrama
 
       def initialize: (Grammar::ParameterizingRule::Rule parameterizing_rule, Array[Lexer::Token] actual_args) -> void
       def resolve_symbol: (Lexer::Token symbol) -> Lexer::Token
+
+      private
+
+      def parameter_to_arg: (Lexer::Token symbol) -> Lexer::Token?
     end
   end
 end

data/sig/lrama/grammar/code/destructor_code.rbs

@@ -2,13 +2,12 @@ module Lrama
   class Grammar
     class Code
       class DestructorCode < Code
-        @tag: untyped
-        def initialize: (type: untyped, token_code: untyped, tag: untyped) -> void
+        @tag: Lexer::Token::Tag
+        def initialize: (type: ::Symbol, token_code: Grammar::Code, tag: Lexer::Token::Tag) -> void
 
         private
 
-        # ref: Lrama::Grammar::Code.token_code.references
-        def reference_to_c: (untyped ref) -> untyped
+        def reference_to_c: (Reference ref) -> (String | bot)
       end
     end
   end

data/sig/lrama/grammar/code/initial_action_code.rbs

@@ -0,0 +1,15 @@
+module Lrama
+  class Grammar
+    class Code
+      class InitialActionCode < Code
+        private
+
+        # * ($$) yylval
+        # * (@$) yylloc
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c: (Reference ref) -> (String | bot)
+      end
+    end
+  end
+end

data/sig/lrama/grammar/code/no_reference_code.rbs

@@ -0,0 +1,15 @@
+module Lrama
+  class Grammar
+    class Code
+      class NoReferenceCode < Code
+        private
+
+        # * ($$) error
+        # * (@$) error
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c: (Reference ref) -> bot
+      end
+    end
+  end
+end

data/sig/lrama/grammar/code/printer_code.rbs

@@ -2,13 +2,12 @@ module Lrama
   class Grammar
     class Code
       class PrinterCode < Code
-        @tag: untyped
-        def initialize: (type: untyped, token_code: untyped, tag: untyped) -> void
+        @tag: Lexer::Token::Tag
+        def initialize: (type: ::Symbol, token_code: Grammar::Code, tag: Lexer::Token::Tag) -> void
 
         private
 
-        # ref: Lrama::Grammar::Code.token_code.references
-        def reference_to_c: (untyped ref) -> untyped
+        def reference_to_c: (Reference ref) -> (String | bot)
       end
     end
   end

data/sig/lrama/grammar/code/rule_action.rbs

@@ -0,0 +1,19 @@
+module Lrama
+  class Grammar
+    class Code
+      class RuleAction < Code
+        @rule: Rule
+
+        def initialize: (type: ::Symbol, token_code: Grammar::Code, rule: Rule) -> void
+
+        private
+
+        def reference_to_c: (Reference ref) -> String
+        def position_in_rhs: () -> Integer
+        def rhs: () -> Array[Grammar::Symbol]
+        def lhs: () -> Grammar::Symbol
+        def raise_tag_not_found_error: (Reference ref) -> bot
+      end
+    end
+  end
+end

data/sig/lrama/grammar/code.rbs

@@ -3,8 +3,8 @@ module Lrama
     class Code
       extend Forwardable
 
-      attr_accessor type: Symbol
-      attr_accessor token_code: Lexer::Token::UserCode
+      attr_accessor type: ::Symbol
+      attr_accessor token_code: Grammar::Code
 
       # delegated
       def s_value: -> String
@@ -12,7 +12,7 @@ module Lrama
       def column: -> Integer
       def references: -> Array[Lrama::Grammar::Reference]
 
-      def initialize: (type: Symbol, token_code: Lexer::Token::UserCode) -> void
+      def initialize: (type: ::Symbol, token_code: Grammar::Code) -> void
 
       def translated_code: () -> String
 

data/sig/lrama/grammar/destructor.rbs

@@ -5,7 +5,9 @@ module Lrama
       attr_accessor token_code: Grammar::Code
       attr_accessor lineno: Integer
 
-      def translated_code: (Lexer::Token member) -> String
+      def initialize: (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Grammar::Code, lineno: Integer) -> void
+
+      def translated_code: (Lexer::Token::Tag tag) -> String
     end
   end
 end

data/sig/lrama/grammar/error_token.rbs

@@ -2,10 +2,12 @@ module Lrama
   class Grammar
     class ErrorToken
       attr_accessor ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag]
-      attr_accessor token_code: Symbol
+      attr_accessor token_code: Grammar::Code
       attr_accessor lineno: Integer
 
-      def translated_code: (Lexer::Token? tag) -> String
+      def initialize: (?ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], ?token_code: Grammar::Code, ?lineno: Integer) -> void
+
+      def translated_code: (Lexer::Token::Tag tag) -> String
     end
   end
 end