lrama 0.6.11 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d566a5097f0fd579e70f94769cca4e68a8f0e810e10cd55556583b1c2653945
-  data.tar.gz: e5ab505df1a8fffe46a9f526456b593db786f36f0e998e7e3acbf5f68b76d9a9
+  metadata.gz: 9c967547ee9de2d87e1e275bf5d9b1f525b7040f110ee41b9144b163923a3dd6
+  data.tar.gz: f9ada41c05e186245e11dfca1dc31da2f2bf8987090b91ed5312369ad1306e64
 SHA512:
-  metadata.gz: 753a7b6f0781f6b0bd2db8c98ef0e6171496d6fd8a2a16762b67dc471e34b4118b4439b89facc1915a364d4c4823edaef464d947cbda3d913ebd8eff87d91b76
-  data.tar.gz: 7f953657c7050c7d527bf190d284e5b56b3df5b92c2034d5f4425f73be1e21208d1869a4ffe6c9091b4adf79671e71865000797ec2d7ed1ad66cfe5d1846cd7b
+  metadata.gz: efa3c528e1f8070c26b42e71329c058b874b530d3e13a64047898928099994a94de131a05c491464cdd566c806a2424e427113987f5240ec13e281c7bcb9bdd2
+  data.tar.gz: da9ea52d9fa0534e168baf3f62fab8df091caca127201c085c641552fd3f7aaf09ad7f60ad49725a8874b444eb655e881064481907bd1f5ba82481d9db118398

data/.github/workflows/gh-pages.yml

@@ -0,0 +1,46 @@
+name: Deploy Lrama documentation to GitHub Pages
+
+on:
+  push:
+    branches: ["master"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    if: ${{ github.repository == 'ruby/lrama' && !startsWith(github.event_name, 'pull') }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@f26937343756480a8cb3ae1f623b9c8d89ed6984 # v1.196.0
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v5
+      - name: Build with Lrama
+        run: bundle exec rake rdoc
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

data/.github/workflows/test.yaml

@@ -16,7 +16,7 @@ jobs:
 
   test:
     needs: ruby-versions
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
@@ -54,9 +54,28 @@ jobs:
       - run: flex --help
       - run: bundle install
       - run: bundle exec rspec
+  test-c:
+    needs: ruby-versions
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['head']
+        compiler: ['cc', 'gcc', 'clang']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: flex --help
+      - run: bundle install
+      - run: bundle exec rspec
+        env:
+          COMPILER: ${{ matrix.compiler }}
   test-cpp:
     needs: ruby-versions
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
@@ -74,7 +93,7 @@ jobs:
         env:
           COMPILER: ${{ matrix.compiler }}
   test-memory:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
@@ -94,7 +113,7 @@ jobs:
         env:
           ENABEL_VALGRIND: 'true'
   check-misc:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       matrix:
         ruby: ['head']
@@ -122,7 +141,7 @@ jobs:
           bundle exec rake build:parser
           git diff --color --no-ext-diff --ignore-submodules --exit-code lib/lrama/parser.rb
   steep-check:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
@@ -136,10 +155,19 @@ jobs:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
       - run: bundle install
+      - run: bundle exec rbs-inline --output lib/
+      - name: Check for uncommitted changes
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "Uncommitted changes detected after running rbs-inline."
+            echo "Please run 'bundle rake rbs_inline' and commit the changes generated by rbs-inline." >&2
+            exit 1
+          fi
+        shell: bash
       - run: bundle exec rbs collection install
       - run: bundle exec steep check
   test-ruby:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
@@ -184,7 +212,7 @@ jobs:
           sudo apt-get install -q -y pkg-config${arch} || :
       - run: sudo apt-get --purge remove bison
       - run: ../autogen.sh
-      - run: ../configure -C --disable-install-doc
+      - run: ../configure -C --disable-install-doc --with-parser=parse.y
       - run: make
       - run: make test-all RUN_OPTS="$RUN_OPTS" SPECOPTS="$SPECOPTS"
         env:

data/.gitignore

@@ -10,3 +10,4 @@
 /tmp/
 /vendor/bundle
 /.idea/
+_site/

data/.rdoc_options

@@ -0,0 +1,2 @@
+page_dir: doc
+warn_missing_rdoc_ref: true

data/Gemfile

@@ -7,6 +7,7 @@ gemspec
 gem "pry"
 gem "racc", "1.8.1"
 gem "rake"
+gem "rdoc"
 gem "rspec"
 gem "simplecov", require: false
 gem "stackprof", platforms: [:ruby] # stackprof doesn't support Windows
@@ -15,6 +16,7 @@ gem "memory_profiler"
 # 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.7.0", require: false
-  gem "steep", "1.9.1", require: false
+  gem "rbs", "3.8.1", require: false
+  gem "rbs-inline", require: false
+  gem "steep", "1.9.3", require: false
 end

data/NEWS.md

@@ -1,5 +1,65 @@
 # NEWS for Lrama
 
+## Lrama 0.7.0 (2025-01-21)
+
+## [EXPERIMENTAL] Support the generation of the IELR(1) parser described in this paper
+
+Support the generation of the IELR(1) parser described in this paper.
+https://www.sciencedirect.com/science/article/pii/S0167642309001191
+
+If you use IELR(1) parser, you can write the following directive in your grammar file.
+
+```yacc
+%define lr.type ielr
+```
+
+But, currently IELR(1) parser is experimental feature. If you find any bugs, please report it to us. Thank you.
+
+## Support `-t` option as same as `--debug` option
+
+Support to `-t` option as same as `--debug` option.
+These options align with Bison behavior. So same as `--debug` option.
+
+## Trace only explicit rules
+
+Support to trace only explicit rules.
+If you use `--trace=rules` option, it shows include mid-rule actions. If you want to show only explicit rules, you can use `--trace=only-explicit-rules` option.
+
+Example:
+
+```yacc
+%{
+%}
+%union {
+    int i;
+}
+%token <i> number
+%type <i> program
+%%
+program         : number { printf("%d", $1); } number { $$ = $1 + $3; }
+                ;
+%%
+```
+
+Result of `--trace=rules`:
+
+```console
+$ exe/lrama --trace=rules sample.y
+Grammar rules:
+$accept -> program YYEOF
+$@1 -> ε
+program -> number $@1 number
+```
+
+Result of `--trace=only-explicit-rules`:
+
+```console
+$ exe/lrama --trace=explicit-rules sample.y
+Grammar rules:
+$accept -> program YYEOF
+program -> number number
+```
+
 ## Lrama 0.6.11 (2024-12-23)
 
 ### Add support for %type declarations using %nterm in Nonterminal Symbols

data/README.md

@@ -6,19 +6,32 @@
 
 Lrama is LALR (1) parser generator written by Ruby. The first goal of this project is providing error tolerant parser for CRuby with minimal changes on CRuby parse.y file.
 
-* [Features](#features)
-* [Installation](#installation)
-* [Usage](#usage)
-* [Versions and Branches](#versions-and-branches)
-* [Supported Ruby version](#supported-ruby-version)
-* [Development](#development)
-  * [How to generate parser.rb](#how-to-generate-parserrb)
-  * [Test](#test)
-  * [Call-stack Profiling Lrama](#call-stack-profiling-lrama)
-  * [Memory Profiling Lrama](#memory-profiling-lrama)
-  * [Build Ruby](#build-ruby)
-* [Release flow](#release-flow)
-* [License](#license)
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Documentation](#documentation)
+- [Versions and Branches](#versions-and-branches)
+  - [v0\_7 (`master` branch)](#v0_7-master-branch)
+  - [v0\_6 (`lrama_0_6` branch)](#v0_6-lrama_0_6-branch)
+  - [v0\_5 (`lrama_0_5` branch)](#v0_5-lrama_0_5-branch)
+  - [v0\_4 (`lrama_0_4` branch)](#v0_4-lrama_0_4-branch)
+- [Supported Ruby version](#supported-ruby-version)
+- [Development](#development)
+  - [How to generate parser.rb](#how-to-generate-parserrb)
+  - [How to Write a Type Signature](#how-to-write-a-type-signature)
+  - [Test](#test)
+  - [Call-stack Profiling Lrama](#call-stack-profiling-lrama)
+    - [1. Create parse.tmp.y in ruby/ruby](#1-create-parsetmpy-in-rubyruby)
+    - [2. Enable Profiler](#2-enable-profiler)
+    - [3. Run Lrama](#3-run-lrama)
+    - [4. Generate Flamegraph](#4-generate-flamegraph)
+  - [Memory Profiling Lrama](#memory-profiling-lrama)
+    - [1. Create parse.tmp.y in ruby/ruby](#1-create-parsetmpy-in-rubyruby-1)
+    - [2. Enable Profiler](#2-enable-profiler-1)
+    - [3. Run Lrama](#3-run-lrama-1)
+  - [Build Ruby](#build-ruby)
+- [Release flow](#release-flow)
+- [License](#license)
 
 ## Features
 
@@ -71,11 +84,19 @@ Enter the formula:
 => 9
 ```
 
+## Documentation
+
+https://ruby.github.io/lrama/ provides a comprehensive guide to Lrama's features and usage.
+
 ## Versions and Branches
 
-### v0_6 (`master` branch)
+### v0_7 (`master` branch)
+
+This branch is for Ruby 3.5. `lrama_0_7` branch is created from this branch, once Ruby 3.5 is released.
+
+### v0_6 (`lrama_0_6` branch)
 
-This branch is for Ruby 3.4. `lrama_0_6` branch is created from this branch, once Ruby 3.4 is released.
+This branch is for Ruby 3.4.
 
 ### v0_5 (`lrama_0_5` branch)
 
@@ -102,6 +123,14 @@ $ bundle exec rake build:parser
 `parser.rb` is generated from `parser.y` by Racc.
 Run the rake command when you update `parser.y` then commit changes of both files.
 
+### How to Write a Type Signature
+
+We use [Steep](https://github.com/soutaro/steep) for type checking and [rbs-inline](https://github.com/soutaro/rbs-inline) for type declarations.
+
+Currently, type signatures are declared in the [sig/lrama](https://github.com/ruby/lrama/blob/master/sig/lrama) directory. However, these files will be replaced with `rbs-inline`. This means type signatures should be written directly in the source code.
+
+For guidance on writing type signatures, refer to the [Syntax Guide](https://github.com/soutaro/rbs-inline/wiki/Syntax-guide) in the rbs-inline documentation.
+
 ### Test
 
 Running tests:

data/Rakefile

@@ -15,9 +15,21 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
 end
 task :spec => "build:parser"
 
+require "rdoc/task"
+RDoc::Task.new do |rdoc|
+  rdoc.title = "Lrama Documentation"
+  rdoc.main = "Index.md"
+  rdoc.rdoc_dir = "_site"
+end
+
 desc "steep check"
 task :steep do
   sh "bundle exec steep check"
 end
 
-task default: %i[spec steep]
+desc "Run rbs-inline"
+task :rbs_inline do
+  sh "bundle exec rbs-inline --output lib/"
+end
+
+task default: %i[spec rbs_inline steep]

data/Steepfile

@@ -17,6 +17,8 @@ target :lib do
   check "lib/lrama/counterexamples.rb"
   check "lib/lrama/digraph.rb"
   check "lib/lrama/grammar.rb"
+  check "lib/lrama/logger.rb"
   check "lib/lrama/options.rb"
+  check "lib/lrama/trace_reporter.rb"
   check "lib/lrama/warning.rb"
 end

data/doc/Index.md

@@ -0,0 +1,58 @@
+# Lrama
+
+[![Gem Version](https://badge.fury.io/rb/lrama.svg)](https://badge.fury.io/rb/lrama)
+[![build](https://github.com/ruby/lrama/actions/workflows/test.yaml/badge.svg)](https://github.com/ruby/lrama/actions/workflows/test.yaml)
+
+
+## Overview
+
+Lrama is LALR (1) parser generator written by Ruby. The first goal of this project is providing error tolerant parser for CRuby with minimal changes on CRuby parse.y file.
+
+## Installation
+
+Lrama's installation is simple. You can install it via RubyGems.
+
+```shell
+$ gem install lrama
+```
+
+From source codes, you can install it as follows:
+
+```shell
+$ cd "$(lrama root)"
+$ bundle install
+$ bundle exec rake install
+$ bundle exec lrama --version
+lrama 0.7.0
+```
+## Usage
+
+Lrama is a command line tool. You can generate a parser from a grammar file by running `lrama` command.
+
+```shell
+# "y.tab.c" and "y.tab.h" are generated
+$ lrama -d sample/parse.y
+```
+Specify the output file with `-o` option. The following example generates "calc.c" and "calc.h".
+
+```shell
+# "calc", "calc.c", and "calc.h" are generated
+$ lrama -d sample/calc.y -o calc.c && gcc -Wall calc.c -o calc && ./calc
+Enter the formula:
+1
+=> 1
+1+2*3
+=> 7
+(1+2)*3
+=> 9
+```
+
+## Supported Ruby version
+
+Lrama is executed with BASERUBY when building ruby from source code. Therefore Lrama needs to support BASERUBY, currently 2.5, or later version.
+
+This also requires Lrama to be able to run with only default gems because BASERUBY runs with `--disable=gems` option.
+
+## License
+
+See [LEGAL.md](https://github.com/ruby/lrama/blob/master/LEGAL.md) file.

data/lib/lrama/bitmap.rb

@@ -1,7 +1,9 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   module Bitmap
+    # @rbs (Array[Integer] ary) -> Integer
     def self.from_array(ary)
       bit = 0
 
@@ -12,6 +14,7 @@ module Lrama
       bit
     end
 
+    # @rbs (Integer int) -> Array[Integer]
     def self.to_array(int)
       a = [] #: Array[Integer]
       i = 0

data/lib/lrama/command.rb

@@ -19,7 +19,7 @@ module Lrama
       text = options.y.read
       options.y.close if options.y != STDIN
       begin
-        grammar = Lrama::Parser.new(text, options.grammar_file, options.debug).parse
+        grammar = Lrama::Parser.new(text, options.grammar_file, options.debug, options.define).parse
         unless grammar.no_stdlib
           stdlib_grammar = Lrama::Parser.new(File.read(STDLIB_FILE_PATH), STDLIB_FILE_PATH, options.debug).parse
           grammar.insert_before_parameterizing_rules(stdlib_grammar.parameterizing_rules)
@@ -34,6 +34,7 @@ module Lrama
       end
       states = Lrama::States.new(grammar, trace_state: (options.trace_opts[:automaton] || options.trace_opts[:closure]))
       states.compute
+      states.compute_ielr if grammar.ielr_defined?
       context = Lrama::Context.new(states)
 
       if options.report_file

data/lib/lrama/digraph.rb

@@ -1,23 +1,52 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   # Algorithm Digraph of https://dl.acm.org/doi/pdf/10.1145/69622.357187 (P. 625)
+  #
+  # @rbs generic X < Object -- Type of a member of `sets`
+  # @rbs generic Y < _Or    -- Type of sets assigned to a member of `sets`
   class Digraph
+    # TODO: rbs-inline 0.10.0 doesn't support instance variables.
+    #       Move these type declarations above instance variable definitions, once it's supported.
+    #
+    # @rbs!
+    #   interface _Or
+    #     def |: (self) -> self
+    #   end
+    #   @sets: Array[X]
+    #   @relation: Hash[X, Array[X]]
+    #   @base_function: Hash[X, Y]
+    #   @stack: Array[X]
+    #   @h: Hash[X, (Integer|Float)?]
+    #   @result: Hash[X, Y]
+
+    # @rbs sets: Array[X]
+    # @rbs relation: Hash[X, Array[X]]
+    # @rbs base_function: Hash[X, Y]
+    # @rbs return: void
     def initialize(sets, relation, base_function)
+
       # X in the paper
       @sets = sets
+
       # R in the paper
       @relation = relation
+
       # F' in the paper
       @base_function = base_function
+
       # S in the paper
       @stack = []
+
       # N in the paper
       @h = Hash.new(0)
+
       # F in the paper
       @result = {}
     end
 
+    # @rbs () -> Hash[X, Y]
     def compute
       @sets.each do |x|
         next if @h[x] != 0
@@ -29,6 +58,7 @@ module Lrama
 
     private
 
+    # @rbs (X x) -> void
     def traverse(x)
       @stack.push(x)
       d = @stack.count

data/lib/lrama/grammar/binding.rb

@@ -1,34 +1,66 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     class Binding
-      attr_reader :actual_args, :count
+      # @rbs @actual_args: Array[Lexer::Token]
+      # @rbs @param_to_arg: Hash[String, Lexer::Token]
 
-      def initialize(parameterizing_rule, actual_args)
-        @parameters = parameterizing_rule.parameters
+      # @rbs (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> void
+      def initialize(params, actual_args)
         @actual_args = actual_args
-        @parameter_to_arg = @parameters.zip(actual_args).map do |param, arg|
-          [param.s_value, arg]
-        end.to_h
+        @param_to_arg = map_params_to_args(params, @actual_args)
       end
 
-      def resolve_symbol(symbol)
-        if symbol.is_a?(Lexer::Token::InstantiateRule)
-          resolved_args = symbol.args.map { |arg| resolve_symbol(arg) }
-          Lrama::Lexer::Token::InstantiateRule.new(s_value: symbol.s_value, location: symbol.location, args: resolved_args, lhs_tag: symbol.lhs_tag)
+      # @rbs (Lexer::Token sym) -> Lexer::Token
+      def resolve_symbol(sym)
+        if sym.is_a?(Lexer::Token::InstantiateRule)
+          Lrama::Lexer::Token::InstantiateRule.new(
+            s_value: sym.s_value, location: sym.location, args: resolved_args(sym), lhs_tag: sym.lhs_tag
+          )
         else
-          parameter_to_arg(symbol) || symbol
+          param_to_arg(sym)
         end
       end
 
+      # @rbs (Lexer::Token::InstantiateRule token) -> String
+      def concatenated_args_str(token)
+        "#{token.rule_name}_#{token_to_args_s_values(token).join('_')}"
+      end
+
       private
 
-      def parameter_to_arg(symbol)
-        if (arg = @parameter_to_arg[symbol.s_value].dup)
-          arg.alias_name = symbol.alias_name
+      # @rbs (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> Hash[String, Lexer::Token]
+      def map_params_to_args(params, actual_args)
+        params.zip(actual_args).map do |param, arg|
+          [param.s_value, arg]
+        end.to_h
+      end
+
+      # @rbs (Lexer::Token::InstantiateRule sym) -> Array[Lexer::Token]
+      def resolved_args(sym)
+        sym.args.map { |arg| resolve_symbol(arg) }
+      end
+
+      # @rbs (Lexer::Token sym) -> Lexer::Token
+      def param_to_arg(sym)
+        if (arg = @param_to_arg[sym.s_value].dup)
+          arg.alias_name = sym.alias_name
+        end
+        arg || sym
+      end
+
+      # @rbs (Lexer::Token::InstantiateRule token) -> Array[String]
+      def token_to_args_s_values(token)
+        token.args.flat_map do |arg|
+          resolved = resolve_symbol(arg)
+          if resolved.is_a?(Lexer::Token::InstantiateRule)
+            [resolved.s_value] + resolved.args.map(&:s_value)
+          else
+            [resolved.s_value]
+          end
         end
-        arg
       end
     end
   end

data/lib/lrama/grammar/rule.rb

@@ -21,6 +21,14 @@ module Lrama
       def display_name
         l = lhs.id.s_value
         r = empty_rule? ? "ε" : rhs.map {|r| r.id.s_value }.join(" ")
+        "#{l} -> #{r}"
+      end
+
+      def display_name_without_action
+        l = lhs.id.s_value
+        r = empty_rule? ? "ε" : rhs.map do |r|
+          r.id.s_value if r.first_set.any?
+        end.compact.join(" ")
 
         "#{l} -> #{r}"
       end

data/lib/lrama/grammar/rule_builder.rb

@@ -73,7 +73,7 @@ module Lrama
             inline_rule.rhs_list.each do |inline_rhs|
               rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, @parameterizing_rule_resolver, lhs_tag: lhs_tag)
               if token.is_a?(Lexer::Token::InstantiateRule)
-                resolve_inline_rhs(rule_builder, inline_rhs, i, Binding.new(inline_rule, token.args))
+                resolve_inline_rhs(rule_builder, inline_rhs, i, Binding.new(inline_rule.parameters, token.args))
               else
                 resolve_inline_rhs(rule_builder, inline_rhs, i)
               end
@@ -135,8 +135,8 @@ module Lrama
             parameterizing_rule = @parameterizing_rule_resolver.find_rule(token)
             raise "Unexpected token. #{token}" unless parameterizing_rule
 
-            bindings = Binding.new(parameterizing_rule, token.args)
-            lhs_s_value = lhs_s_value(token, bindings)
+            bindings = Binding.new(parameterizing_rule.parameters, token.args)
+            lhs_s_value = bindings.concatenated_args_str(token)
             if (created_lhs = @parameterizing_rule_resolver.created_lhs(lhs_s_value))
               @replaced_rhs << created_lhs
             else
@@ -174,18 +174,6 @@ module Lrama
         end
       end
 
-      def lhs_s_value(token, bindings)
-        s_values = token.args.map do |arg|
-          resolved = bindings.resolve_symbol(arg)
-          if resolved.is_a?(Lexer::Token::InstantiateRule)
-            [resolved.s_value, resolved.args.map(&:s_value)]
-          else
-            resolved.s_value
-          end
-        end
-        "#{token.rule_name}_#{s_values.join('_')}"
-      end
-
       def resolve_inline_rhs(rule_builder, inline_rhs, index, bindings = nil)
         rhs.each_with_index do |token, i|
           if index == i