Provide standard library as standard.y

lib/lrama/grammar/parameterizing_rule/resolver.rb

@@ -13,10 +13,6 @@ def add_parameterizing_rule(rule)
           @rules << rule
         end
 
-        def defined?(token)
-          !select_rules(token).empty?
-        end
-
         def find(token)
           select_rules(token).last
         end
@@ -28,9 +24,21 @@ def created_lhs(lhs_s_value)
         private
 
         def select_rules(token)
-          @rules.select do |rule|
-            rule.name == token.rule_name &&
-              rule.required_parameters_count == token.args_count
+          rules = select_rules_by_name(token.rule_name)
+          rules = rules.select { |rule| rule.required_parameters_count == token.args_count }
+          if rules.empty?
+            raise "Invalid number of arguments. `#{token.rule_name}`"
+          else
+            rules
+          end
+        end
+
+        def select_rules_by_name(rule_name)
+          rules = @rules.select { |rule| rule.name == rule_name }
+          if rules.empty?
+            raise "Parameterizing rule does not exist. `#{rule_name}`"
+          else
+            rules
           end
         end
       end

lib/lrama/grammar/rule_builder.rb

@@ -1,5 +1,3 @@
-require 'lrama/grammar/parameterizing_rules/builder'
-
 module Lrama
   class Grammar
     class RuleBuilder
@@ -59,7 +57,7 @@ def setup_rules(parameterizing_rule_resolver)
       end
 
       def rules
-        @parameterizing_rules + @old_parameterizing_rules + @midrule_action_rules + @rules
+        @parameterizing_rules + @midrule_action_rules + @rules
       end
 
       private
@@ -97,7 +95,6 @@ def process_rhs(parameterizing_rule_resolver)
         return if @replaced_rhs
 
         @replaced_rhs = []
-        @old_parameterizing_rules = []
 
         rhs.each_with_index do |token, i|
           case token
@@ -106,35 +103,28 @@ def process_rhs(parameterizing_rule_resolver)
           when Lrama::Lexer::Token::Ident
             @replaced_rhs << token
           when Lrama::Lexer::Token::InstantiateRule
-            if parameterizing_rule_resolver.defined?(token)
-              parameterizing_rule = parameterizing_rule_resolver.find(token)
-              raise "Unexpected token. #{token}" unless parameterizing_rule
-
-              bindings = Binding.new(parameterizing_rule, token.args)
-              lhs_s_value = lhs_s_value(token, bindings)
-              if (created_lhs = parameterizing_rule_resolver.created_lhs(lhs_s_value))
-                @replaced_rhs << created_lhs
-              else
-                lhs_token = Lrama::Lexer::Token::Ident.new(s_value: lhs_s_value, location: token.location)
-                @replaced_rhs << lhs_token
-                parameterizing_rule_resolver.created_lhs_list << lhs_token
-                parameterizing_rule.rhs_list.each do |r|
-                  rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, lhs_tag: token.lhs_tag, skip_preprocess_references: true)
-                  rule_builder.lhs = lhs_token
-                  r.symbols.each { |sym| rule_builder.add_rhs(bindings.resolve_symbol(sym)) }
-                  rule_builder.line = line
-                  rule_builder.user_code = r.user_code
-                  rule_builder.precedence_sym = r.precedence_sym
-                  rule_builder.complete_input
-                  rule_builder.setup_rules(parameterizing_rule_resolver)
-                  @rule_builders_for_parameterizing_rules << rule_builder
-                end
-              end
+            parameterizing_rule = parameterizing_rule_resolver.find(token)
+            raise "Unexpected token. #{token}" unless parameterizing_rule
+
+            bindings = Binding.new(parameterizing_rule, token.args)
+            lhs_s_value = lhs_s_value(token, bindings)
+            if (created_lhs = parameterizing_rule_resolver.created_lhs(lhs_s_value))
+              @replaced_rhs << created_lhs
             else
-              # TODO: Delete when the standard library will defined as a grammar file.
-              parameterizing_rule = ParameterizingRules::Builder.new(token, @rule_counter, token.lhs_tag, user_code, precedence_sym, line)
-              @old_parameterizing_rules = @old_parameterizing_rules + parameterizing_rule.build
-              @replaced_rhs << parameterizing_rule.build_token
+              lhs_token = Lrama::Lexer::Token::Ident.new(s_value: lhs_s_value, location: token.location)
+              @replaced_rhs << lhs_token
+              parameterizing_rule_resolver.created_lhs_list << lhs_token
+              parameterizing_rule.rhs_list.each do |r|
+                rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, lhs_tag: token.lhs_tag, skip_preprocess_references: true)
+                rule_builder.lhs = lhs_token
+                r.symbols.each { |sym| rule_builder.add_rhs(bindings.resolve_symbol(sym)) }
+                rule_builder.line = line
+                rule_builder.user_code = r.user_code
+                rule_builder.precedence_sym = r.precedence_sym
+                rule_builder.complete_input
+                rule_builder.setup_rules(parameterizing_rule_resolver)
+                @rule_builders_for_parameterizing_rules << rule_builder
+              end
             end
           when Lrama::Lexer::Token::UserCode
             prefix = token.referred ? "@" : "$@"

lib/lrama/lexer.rb

@@ -29,6 +29,7 @@ class Lexer
       %empty
       %code
       %rule
+      %include-stdlib
     )
 
     def initialize(grammar_file)