lrama 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecd30d3fab4dd73442ed6d3b2802db5b463159cb6ddf1f1835d9b8e860d4c9dd
-  data.tar.gz: 79b6087e68d3c2e95db81fa1d25f58280a5543e9c5fa91f5b6ecc7c40b5599d7
+  metadata.gz: ce98751a4b4d20c20addf8eebf2a4eb22150b401abbb994941d73f2b2ef81a09
+  data.tar.gz: 94b83050b10ec5d01d61093cd2af595e52b3761cc8e86423fa8f30110e44e330
 SHA512:
-  metadata.gz: f3302156423399987015deb90afbaa0d6916e5e61b14c5297ff6a0e01ab9db3bbd164b334a11e26d38cf626425b7faee404e5d1cdec236a9b08b576ced4fe201
-  data.tar.gz: 380d8d31c93e5ae6c5a406c2b2eedad0d4b52dd311ecd742ca1412bd1acade7dae8fe12f7a6325ef8a0b4922ffd927b0dfa2caf3cd54c095669ab2b2cab85516
+  metadata.gz: e9e194703ec0b1657389f289b7c4d9cfd13326b1efe25e656080e5260ef2b7f3d4e93fd3d5d49e0934cfb394bc46b994c167a74c3dd2fb2ed3f3ebaaaf31647d
+  data.tar.gz: 59e1ed986bbea4ea4a56295d799f6ef5afee24e128fec66bc7ea8184f9bd849aa0807b5995b201e3dda274f6f0f023899a8c287e9a25818dae75c05e5c45cf6a

data/.github/workflows/test.yaml

@@ -124,9 +124,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # '3.0' is the oldest living ruby version
-        # '2.7' is for BASERUBY
-        baseruby: ['head', '3.0', '2.7']
+        # '3.0' is the oldest living ruby version and minimal BASERUBY version
+        baseruby: ['head', '3.0']
         ruby_branch: ['master']
     defaults:
       run:

data/Gemfile

@@ -12,6 +12,6 @@ gem "stackprof", platforms: [:ruby] # stackprof doesn't support Windows
 # Recent steep requires Ruby >= 3.0.0.
 # Then skip install on some CI jobs.
 if !ENV['GITHUB_ACTION'] || ENV['INSTALL_STEEP'] == 'true'
-  gem "rbs", "3.4.1", require: false
+  gem "rbs", "3.4.4", require: false
   gem "steep", "1.6.0", require: false
 end

data/NEWS.md

@@ -1,5 +1,69 @@
 # NEWS for Lrama
 
+## Lrama 0.6.4 (2024-03-22)
+
+### Parameterizing rules (preceded, terminated, delimited)
+
+Support `preceded`, `terminated` and `delimited` rules.
+
+```
+program: preceded(opening, X)
+
+// Expanded to
+
+program: preceded_opening_X
+preceded_opening_X: opening X
+```
+
+```
+program: terminated(X, closing)
+
+// Expanded to
+
+program: terminated_X_closing
+terminated_X_closing: X closing
+```
+
+```
+program: delimited(opening, X, closing)
+
+// Expanded to
+
+program: delimited_opening_X_closing
+delimited_opening_X_closing: opening X closing
+```
+
+https://github.com/ruby/lrama/pull/382
+
+### Support `%destructor` declaration
+
+User can set codes for freeing semantic value resources by using `%destructor`.
+In general, these resources are freed by actions or after parsing.
+However if syntax error happens in parsing, these codes may not be executed.
+Codes associated to `%destructor` are executed when semantic value is popped from the stack by an error.
+
+```
+%token <val1> NUM
+%type <val2> expr2
+%type <val3> expr
+
+%destructor {
+    printf("destructor for val1: %d\n", $$);
+} <val1> // printer for TAG
+
+%destructor {
+    printf("destructor for val2: %d\n", $$);
+} <val2>
+
+%destructor {
+    printf("destructor for expr: %d\n", $$);
+} expr // printer for symbol
+```
+
+Bison supports this feature from 1.75b.
+
+https://github.com/ruby/lrama/pull/385
+
 ## Lrama 0.6.3 (2024-02-15)
 
 ### Bring Your Own Stack
@@ -34,6 +98,8 @@ primary: k_if expr_value then compstmt if_tail k_end
           }
 ```
 
+https://github.com/ruby/lrama/pull/367
+
 ## Lrama 0.6.2 (2024-01-27)
 
 ### %no-stdlib directive
@@ -51,7 +117,7 @@ Allow to pass an instantiated rule to other parameterizing rules.
 
 ```
 %rule constant(X) : X
-              ;
+                  ;
 
 %rule option(Y) : /* empty */
                 | Y

data/Steepfile

@@ -5,6 +5,7 @@ target :lib do
   signature "sig"
 
   check "lib/lrama/grammar/binding.rb"
+  check "lib/lrama/grammar/code/destructor_code.rb"
   check "lib/lrama/grammar/code/printer_code.rb"
   check "lib/lrama/grammar/code.rb"
   check "lib/lrama/grammar/counter.rb"
@@ -14,6 +15,7 @@ target :lib do
   check "lib/lrama/grammar/symbols"
   check "lib/lrama/grammar/percent_code.rb"
   check "lib/lrama/grammar/precedence.rb"
+  check "lib/lrama/grammar/destructor.rb"
   check "lib/lrama/grammar/printer.rb"
   check "lib/lrama/grammar/reference.rb"
   check "lib/lrama/grammar/rule_builder.rb"
@@ -23,5 +25,6 @@ target :lib do
   check "lib/lrama/report"
   check "lib/lrama/bitmap.rb"
   check "lib/lrama/digraph.rb"
+  check "lib/lrama/options.rb"
   check "lib/lrama/warning.rb"
 end

data/lib/lrama/grammar/code/destructor_code.rb

@@ -0,0 +1,40 @@
+module Lrama
+  class Grammar
+    class Code
+      class DestructorCode < Code
+        def initialize(type:, token_code:, tag:)
+          super(type: type, token_code: token_code)
+          @tag = tag
+        end
+
+        private
+
+        # * ($$) *yyvaluep
+        # * (@$) *yylocationp
+        # * ($:$) error
+        # * ($1) error
+        # * (@1) error
+        # * ($:1) error
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar && ref.name == "$" # $$
+            member = @tag.member
+            "((*yyvaluep).#{member})"
+          when ref.type == :at && ref.name == "$" # @$
+            "(*yylocationp)"
+          when ref.type == :index && ref.name == "$" # $:$
+            raise "$:#{ref.value} can not be used in #{type}."
+          when ref.type == :dollar # $n
+            raise "$#{ref.value} can not be used in #{type}."
+          when ref.type == :at # @n
+            raise "@#{ref.value} can not be used in #{type}."
+          when ref.type == :index # $:n
+            raise "$:#{ref.value} can not be used in #{type}."
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code.rb

@@ -1,4 +1,5 @@
 require "forwardable"
+require "lrama/grammar/code/destructor_code"
 require "lrama/grammar/code/initial_action_code"
 require "lrama/grammar/code/no_reference_code"
 require "lrama/grammar/code/printer_code"

data/lib/lrama/grammar/destructor.rb

@@ -0,0 +1,9 @@
+module Lrama
+  class Grammar
+    class Destructor < Struct.new(:ident_or_tags, :token_code, :lineno, keyword_init: true)
+      def translated_code(tag)
+        Code::DestructorCode.new(type: :destructor, token_code: token_code, tag: tag).translated_code
+      end
+    end
+  end
+end

data/lib/lrama/grammar/rule_builder.rb

@@ -115,12 +115,12 @@ module Lrama
               @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 = RuleBuilder.new(@rule_counter, @midrule_action_counter, 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.user_code = r.user_code
                 rule_builder.complete_input
                 rule_builder.setup_rules(parameterizing_rule_resolver)
                 @rule_builders_for_parameterizing_rules << rule_builder

data/lib/lrama/grammar/stdlib.y

@@ -8,6 +8,9 @@
 
 **********************************************************************/
 
+// -------------------------------------------------------------------
+// Options
+
 /*
  * program: option(number)
  *
@@ -21,6 +24,45 @@
                | X
                ;
 
+// -------------------------------------------------------------------
+// Sequences
+
+/*
+ * program: preceded(opening, X)
+ *
+ * =>
+ *
+ * program: preceded_opening_X
+ * preceded_opening_X: opening X
+ */
+%rule preceded(opening, X): opening X { $$ = $2; }
+                          ;
+
+/*
+ * program: terminated(X, closing)
+ *
+ * =>
+ *
+ * program: terminated_X_closing
+ * terminated_X_closing: X closing
+ */
+%rule terminated(X, closing): X closing { $$ = $1; }
+                            ;
+
+/*
+ * program: delimited(opening, X, closing)
+ *
+ * =>
+ *
+ * program: delimited_opening_X_closing
+ * delimited_opening_X_closing: opening X closing
+ */
+%rule delimited(opening, X, closing): opening X closing { $$ = $2; }
+                                     ;
+
+// -------------------------------------------------------------------
+// Lists
+
 /*
  * program: list(number)
  *

data/lib/lrama/grammar/symbol.rb

@@ -7,11 +7,12 @@
 module Lrama
   class Grammar
     class Symbol
-      attr_accessor :id, :alias_name, :tag, :number, :token_id, :nullable, :precedence, :printer, :error_token, :first_set, :first_set_bitmap
+      attr_accessor :id, :alias_name, :tag, :number, :token_id, :nullable, :precedence,
+                    :printer, :destructor, :error_token, :first_set, :first_set_bitmap
       attr_reader :term
       attr_writer :eof_symbol, :error_symbol, :undef_symbol, :accept_symbol
 
-      def initialize(id:, term:, alias_name: nil, number: nil, tag: nil, token_id: nil, nullable: nil, precedence: nil, printer: nil)
+      def initialize(id:, term:, alias_name: nil, number: nil, tag: nil, token_id: nil, nullable: nil, precedence: nil, printer: nil, destructor: nil)
         @id = id
         @alias_name = alias_name
         @number = number
@@ -21,6 +22,7 @@ module Lrama
         @nullable = nullable
         @precedence = precedence
         @printer = printer
+        @destructor = destructor
       end
 
       def term?

data/lib/lrama/grammar/symbols/resolver.rb

@@ -58,7 +58,7 @@ module Lrama
         end
 
         def find_symbol_by_s_value!(s_value)
-          find_symbol_by_s_value(s_value) || (raise "Symbol not found: #{s_value}")
+          find_symbol_by_s_value(s_value) || (raise "Symbol not found. value: `#{s_value}`")
         end
 
         def find_symbol_by_id(id)
@@ -68,7 +68,7 @@ module Lrama
         end
 
         def find_symbol_by_id!(id)
-          find_symbol_by_id(id) || (raise "Symbol not found: #{id}")
+          find_symbol_by_id(id) || (raise "Symbol not found. #{id}")
         end
 
         def find_symbol_by_token_id(token_id)
@@ -78,7 +78,7 @@ module Lrama
         def find_symbol_by_number!(number)
           sym = symbols[number]
 
-          raise "Symbol not found: #{number}" unless sym
+          raise "Symbol not found. number: `#{number}`" unless sym
           raise "[BUG] Symbol number mismatch. #{number}, #{sym}" if sym.number != number
 
           sym
@@ -118,6 +118,23 @@ module Lrama
           end
         end
 
+        def fill_destructor(destructors)
+          symbols.each do |sym|
+            destructors.each do |destructor|
+              destructor.ident_or_tags.each do |ident_or_tag|
+                case ident_or_tag
+                when Lrama::Lexer::Token::Ident
+                  sym.destructor = destructor if sym.id == ident_or_tag
+                when Lrama::Lexer::Token::Tag
+                  sym.destructor = destructor if sym.tag == ident_or_tag
+                else
+                  raise "Unknown token type. #{destructor}"
+                end
+              end
+            end
+          end
+        end
+
         def fill_error_token(error_tokens)
           symbols.each do |sym|
             error_tokens.each do |token|
@@ -154,7 +171,7 @@ module Lrama
         def find_nterm_by_id!(id)
           @nterms.find do |s|
             s.id == id
-          end || (raise "Symbol not found: #{id}")
+          end || (raise "Symbol not found. #{id}")
         end
 
         def fill_terms_number

data/lib/lrama/grammar.rb

@@ -3,6 +3,7 @@ require "lrama/grammar/auxiliary"
 require "lrama/grammar/binding"
 require "lrama/grammar/code"
 require "lrama/grammar/counter"
+require "lrama/grammar/destructor"
 require "lrama/grammar/error_token"
 require "lrama/grammar/parameterizing_rule"
 require "lrama/grammar/percent_code"
@@ -34,7 +35,7 @@ module Lrama
     def_delegators "@symbols_resolver", :symbols, :nterms, :terms, :add_nterm, :add_term,
                                         :find_symbol_by_number!, :find_symbol_by_id!, :token_to_symbol,
                                         :find_symbol_by_s_value!, :fill_symbol_number, :fill_nterm_type,
-                                        :fill_printer, :fill_error_token, :sort_by_number!
+                                        :fill_printer, :fill_destructor, :fill_error_token, :sort_by_number!
 
 
     def initialize(rule_counter)
@@ -43,6 +44,7 @@ module Lrama
       # Code defined by "%code"
       @percent_codes = []
       @printers = []
+      @destructors = []
       @error_tokens = []
       @symbols_resolver = Grammar::Symbols::Resolver.new
       @types = []
@@ -65,6 +67,10 @@ module Lrama
       @percent_codes << PercentCode.new(id.s_value, code.s_value)
     end
 
+    def add_destructor(ident_or_tags:, token_code:, lineno:)
+      @destructors << Destructor.new(ident_or_tags: ident_or_tags, token_code: token_code, lineno: lineno)
+    end
+
     def add_printer(ident_or_tags:, token_code:, lineno:)
       @printers << Printer.new(ident_or_tags: ident_or_tags, token_code: token_code, lineno: lineno)
     end
@@ -345,6 +351,7 @@ module Lrama
       fill_symbol_number
       fill_nterm_type(@types)
       fill_printer(@printers)
+      fill_destructor(@destructors)
       fill_error_token(@error_tokens)
       sort_by_number!
     end

data/lib/lrama/lexer/token.rb

@@ -18,7 +18,7 @@ module Lrama
       end
 
       def to_s
-        "#{super} location: #{location}"
+        "value: `#{s_value}`, location: #{location}"
       end
 
       def referred_by?(string)

data/lib/lrama/lexer.rb

@@ -21,6 +21,7 @@ module Lrama
       %define
       %require
       %printer
+      %destructor
       %lex-param
       %parse-param
       %initial-action

data/lib/lrama/option_parser.rb

@@ -64,9 +64,18 @@ module Lrama
         o.on('-H', '--header=[FILE]', 'also produce a header file named FILE') {|v| @options.header = true; @options.header_file = v }
         o.on('-d', 'also produce a header file') { @options.header = true }
         o.on('-r', '--report=THINGS', Array, 'also produce details on the automaton') {|v| @report = v }
+        o.on_tail ''
+        o.on_tail 'Valid Reports:'
+        o.on_tail "    #{VALID_REPORTS.join(' ')}"
+
         o.on('--report-file=FILE', 'also produce details on the automaton output to a file named FILE') {|v| @options.report_file = v }
         o.on('-o', '--output=FILE', 'leave output to FILE') {|v| @options.outfile = v }
+
         o.on('--trace=THINGS', Array, 'also output trace logs at runtime') {|v| @trace = v }
+        o.on_tail ''
+        o.on_tail 'Valid Traces:'
+        o.on_tail "    #{VALID_TRACES.join(' ')}"
+
         o.on('-v', 'reserved, do nothing') { }
         o.separator ''
         o.separator 'Error Recovery:'
@@ -75,20 +84,22 @@ module Lrama
         o.separator 'Other options:'
         o.on('-V', '--version', "output version information and exit") {|v| puts "lrama #{Lrama::VERSION}"; exit 0 }
         o.on('-h', '--help', "display this help and exit") {|v| puts o; exit 0 }
-        o.separator ''
+        o.on_tail
         o.parse!(argv)
       end
     end
 
+    BISON_REPORTS = %w[states itemsets lookaheads solved counterexamples cex all none]
+    OTHER_REPORTS = %w[verbose]
+    NOT_SUPPORTED_REPORTS = %w[cex none]
+    VALID_REPORTS = BISON_REPORTS + OTHER_REPORTS - NOT_SUPPORTED_REPORTS
+
     def validate_report(report)
-      bison_list = %w[states itemsets lookaheads solved counterexamples cex all none]
-      others = %w[verbose]
-      list = bison_list + others
-      not_supported = %w[cex none]
+      list = VALID_REPORTS
       h = { grammar: true }
 
       report.each do |r|
-        if list.include?(r) && !not_supported.include?(r)
+        if list.include?(r)
           h[r.to_sym] = true
         else
           raise "Invalid report option \"#{r}\"."
@@ -96,7 +107,7 @@ module Lrama
       end
 
       if h[:all]
-        (bison_list - not_supported).each do |r|
+        (BISON_REPORTS - NOT_SUPPORTED_REPORTS).each do |r|
           h[r.to_sym] = true
         end
 
@@ -106,12 +117,14 @@ module Lrama
       return h
     end
 
+    VALID_TRACES = %w[
+      none locations scan parse automaton bitsets
+      closure grammar rules resource sets muscles tools
+      m4-early m4 skeleton time ielr cex all
+    ]
+
     def validate_trace(trace)
-      list = %w[
-        none locations scan parse automaton bitsets
-        closure grammar rules resource sets muscles tools
-        m4-early m4 skeleton time ielr cex all
-      ]
+      list = VALID_TRACES
       h = {}
 
       trace.each do |t|

data/lib/lrama/options.rb

@@ -18,6 +18,7 @@ module Lrama
       @trace_opts = nil
       @report_opts = nil
       @y = STDIN
+      @debug = false
     end
   end
 end

data/lib/lrama/output.rb

@@ -150,6 +150,25 @@ module Lrama
       str
     end
 
+    def symbol_actions_for_destructor
+      str = ""
+
+      @grammar.symbols.each do |sym|
+        next unless sym.destructor
+
+        str << <<-STR
+    case #{sym.enum_name}: /* #{sym.comment}  */
+#line #{sym.destructor.lineno} "#{@grammar_file_path}"
+         {#{sym.destructor.translated_code(sym.tag)}}
+#line [@oline@] [@ofile@]
+        break;
+
+        STR
+      end
+
+      str
+    end
+
     # b4_user_initial_action
     def user_initial_action(comment = "")
       return "" unless @grammar.initial_action