lrama 0.6.9 → 0.6.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9143e179e798e02afb8e7b2b4b1dd64291ac9ec128c851a4b4e660c647531675
-  data.tar.gz: 34613495597d6d8c9334034d7167f34253ca97e910752b446fa6cc26f773a2ce
+  metadata.gz: 1d566a5097f0fd579e70f94769cca4e68a8f0e810e10cd55556583b1c2653945
+  data.tar.gz: e5ab505df1a8fffe46a9f526456b593db786f36f0e998e7e3acbf5f68b76d9a9
 SHA512:
-  metadata.gz: a54f5f7096bc3f3f984a7da54945cd3913d02a16882975e99c982f06a2dd70988dba461106f000b54cc26f06c0e62eb294c63d3d35dd606b0e63ff6a17b127d4
-  data.tar.gz: 007f8c7b8cf7ad1690f3b59e505f790273ddfacdab18ede2f1e3667a48309487739310d065fd7c54ee7656f9ee3791e2e1ed29e69726b69a4b861c083b8e5b4e
+  metadata.gz: 753a7b6f0781f6b0bd2db8c98ef0e6171496d6fd8a2a16762b67dc471e34b4118b4439b89facc1915a364d4c4823edaef464d947cbda3d913ebd8eff87d91b76
+  data.tar.gz: 7f953657c7050c7d527bf190d284e5b56b3df5b92c2034d5f4425f73be1e21208d1869a4ffe6c9091b4adf79671e71865000797ec2d7ed1ad66cfe5d1846cd7b

data/.github/workflows/test.yaml

@@ -54,6 +54,25 @@ jobs:
       - run: flex --help
       - run: bundle install
       - run: bundle exec rspec
+  test-cpp:
+    needs: ruby-versions
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['head']
+        compiler: ['g++', '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-memory:
     runs-on: ubuntu-20.04
     strategy:
@@ -167,4 +186,8 @@ jobs:
       - run: ../autogen.sh
       - run: ../configure -C --disable-install-doc
       - run: make
-      - run: make test-all
+      - run: make test-all RUN_OPTS="$RUN_OPTS" SPECOPTS="$SPECOPTS"
+        env:
+          EXCLUDES: '../test/.excludes-parsey'
+          RUN_OPTS: ${{ matrix.run_opts || '--parser=parse.y' }}
+          SPECOPTS: ${{ matrix.specopts || '-T --parser=parse.y' }}

data/.gitignore

@@ -2,9 +2,11 @@
 /.bundle/
 /.gem_rbs_collection/
 /.irbrc
+/.vscode/
 /Gemfile.lock
 /coverage/
 /parser.output
 /pkg/
 /tmp/
 /vendor/bundle
+/.idea/

data/Gemfile

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
 
 gem "pry"
-gem "racc", "1.7.3"
+gem "racc", "1.8.1"
 gem "rake"
 gem "rspec"
 gem "simplecov", require: false
 gem "stackprof", platforms: [:ruby] # stackprof doesn't support Windows
+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.4.4", require: false
-  gem "steep", "1.6.0", require: false
+  gem "rbs", "3.7.0", require: false
+  gem "steep", "1.9.1", require: false
 end

data/NEWS.md

@@ -1,12 +1,267 @@
 # NEWS for Lrama
 
+## Lrama 0.6.11 (2024-12-23)
+
+### Add support for %type declarations using %nterm in Nonterminal Symbols
+
+Allow to use `%nterm` in Nonterminal Symbols for `%type` declarations.
+
+```yacc
+%nterm <type> nonterminal…
+```
+
+This directive is also supported for compatibility with Bison, and only non-terminal symbols are allowed. In other words, definitions like the following will result in an error:
+
+```yacc
+%{
+// Prologue
+%}
+
+%token EOI 0 "EOI"
+%nterm EOI
+
+%%
+
+program: /* empty */
+        ;
+```
+
+It show an error message like the following:
+
+```command
+❯ exe/lrama nterm.y
+nterm.y:6:7: symbol EOI redeclared as a nonterminal
+%nterm EOI
+       ^^^
+```
+
+## Lrama 0.6.10 (2024-09-11)
+
+### Aliased Named References for actions of RHS in parameterizing rules
+
+Allow to use aliased named references for actions of RHS in parameterizing rules.
+
+```yacc
+%rule sum(X, Y): X[summand] '+' Y[addend] { $$ = $summand + $addend }
+               ;
+```
+
+https://github.com/ruby/lrama/pull/410
+
+
+### Named References for actions of RHS in parameterizing rules caller side
+
+Allow to use named references for actions of RHS in parameterizing rules caller side.
+
+```yacc
+opt_nl: '\n'?[nl] <str> { $$ = $nl; }
+      ;
+```
+
+https://github.com/ruby/lrama/pull/414
+
+### Widen the definable position of parameterizing rules
+
+Allow to define parameterizing rules in the middle of the grammar.
+
+```yacc
+%rule defined_option(X): /* empty */
+                       | X
+                       ;
+
+%%
+
+program         : defined_option(number) <i>
+                | defined_list(number) <i>
+                ;
+
+%rule defined_list(X): /* empty */  /* <--- here */
+                     | defined_list(X) number
+                     ;
+```
+
+https://github.com/ruby/lrama/pull/420
+
+### Report unused terminal symbols
+
+Support to report unused terminal symbols.
+Run `exe/lrama --report=terms` to show unused terminal symbols.
+
+```console
+$ exe/lrama --report=terms sample/calc.y
+ 11 Unused Terms
+     0 YYerror
+     1 YYUNDEF
+     2 '\\\\'
+     3 '\\13'
+     4 keyword_class2
+     5 tNUMBER
+     6 tPLUS
+     7 tMINUS
+     8 tEQ
+     9 tEQEQ
+    10 '>'
+```
+https://github.com/ruby/lrama/pull/439
+
+### Report unused rules
+
+Support to report unused rules.
+Run `exe/lrama --report=rules` to show unused rules.
+
+```console
+$ exe/lrama --report=rules sample/calc.y
+  3 Unused Rules
+     0 unused_option
+     1 unused_list
+     2 unused_nonempty_list
+```
+
+https://github.com/ruby/lrama/pull/441
+
+### Ensure compatibility with Bison for `%locations` directive
+
+Support `%locations` directive to ensure compatibility with Bison.
+Change to `%locations` directive not set by default.
+
+https://github.com/ruby/lrama/pull/446
+
+### Diagnostics report for parameterizing rules redefine
+
+Support to warning redefined parameterizing rules.
+Run `exe/lrama -W` or  `exe/lrama --warnings` to show redefined parameterizing rules.
+
+```console
+$ exe/lrama -W sample/calc.y
+parameterizing rule redefined: redefined_method(X)
+parameterizing rule redefined: redefined_method(X)
+```
+
+https://github.com/ruby/lrama/pull/448
+
+### Support `-v` and `--verbose` option
+
+Support to `-v` and `--verbose` option.
+These options align with Bison behavior. So same as '--report=state' option.
+
+https://github.com/ruby/lrama/pull/457
+
+## Lrama 0.6.9 (2024-05-02)
+
+### Callee side tag specification of parameterizing rules
+
+Allow to specify tag on callee side of parameterizing rules.
+
+```yacc
+%union {
+    int i;
+}
+
+%rule with_tag(X) <i>: X { $$ = $1; }
+                     ;
+```
+
+### Named References for actions of RHS in parameterizing rules
+
+Allow to use named references for actions of RHS in parameterizing rules.
+
+```yacc
+%rule option(number): /* empty */
+                    | number { $$ = $number; }
+                    ;
+```
+
+## Lrama 0.6.8 (2024-04-29)
+
+### Nested parameterizing rules with tag
+
+Allow to nested parameterizing rules with tag.
+
+```yacc
+%union {
+    int i;
+}
+
+%rule nested_nested_option(X): /* empty */
+                              | X
+                              ;
+
+%rule nested_option(X): /* empty */
+                       | nested_nested_option(X) <i>
+                       ;
+
+%rule option(Y): /* empty */
+               | nested_option(Y) <i>
+               ;
+```
+
+## Lrama 0.6.7 (2024-04-28)
+
+### RHS of user defined parameterizing rules contains `'symbol'?`, `'symbol'+` and `'symbol'*`.
+
+User can use `'symbol'?`, `'symbol'+` and `'symbol'*` in RHS of user defined parameterizing rules.
+
+```
+%rule with_word_seps(X): /* empty */
+                   | X ' '+
+                   ;
+```
+
+## Lrama 0.6.6 (2024-04-27)
+
+### Trace actions
+
+Support trace actions for debugging.
+Run `exe/lrama --trace=actions` to show grammar rules with actions.
+
+```console
+$ exe/lrama --trace=actions sample/calc.y
+Grammar rules with actions:
+$accept -> list, YYEOF {}
+list -> ε {}
+list -> list, LF {}
+list -> list, expr, LF { printf("=> %d\n", $2); }
+expr -> NUM {}
+expr -> expr, '+', expr { $$ = $1  +  $3; }
+expr -> expr, '-', expr { $$ = $1  -  $3; }
+expr -> expr, '*', expr { $$ = $1  *  $3; }
+expr -> expr, '/', expr { $$ = $1  /  $3; }
+expr -> '(', expr, ')' { $$ = $2; }
+```
+
+### Inlining
+
+Support inlining for rules.
+The `%inline` directive causes all references to symbols to be replaced with its definition.
+
+```yacc
+%rule %inline op: PLUS { + }
+                | TIMES { * }
+                ;
+
+%%
+
+expr : number { $$ = $1; }
+     | expr op expr { $$ = $1 $2 $3; }
+     ;
+```
+
+as same as
+
+```yacc
+expr : number { $$ = $1; }
+     | expr '+' expr { $$ = $1 + $3; }
+     | expr '*' expr { $$ = $1 * $3; }
+     ;
+```
+
 ## Lrama 0.6.5 (2024-03-25)
 
 ### Typed Midrule Actions
 
 User can specify the type of mid rule action by tag (`<bar>`) instead of specifying it with in an action.
 
-```
+```yacc
 primary: k_case expr_value terms?
            {
                $<val>$ = p->case_labels;
@@ -21,7 +276,7 @@ primary: k_case expr_value terms?
 
 can be written as
 
-```
+```yacc
 primary: k_case expr_value terms?
            {
                $$ = p->case_labels;
@@ -46,7 +301,7 @@ Bison supports this feature from 3.1.
 
 Support `preceded`, `terminated` and `delimited` rules.
 
-```
+```text
 program: preceded(opening, X)
 
 // Expanded to
@@ -82,7 +337,7 @@ 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.
 
-```
+```yacc
 %token <val1> NUM
 %type <val2> expr2
 %type <val3> expr
@@ -130,7 +385,7 @@ Lrama provides these five callbacks. Registered functions are called when each e
 User also needs to access semantic value of their stack in grammar action. `$:n` provides the way to access to it. `$:n` is translated to the minus index from the top of the stack.
 For example
 
-```
+```yacc
 primary: k_if expr_value then compstmt if_tail k_end
           {
           /*% ripper: if!($:2, $:4, $:5) %*/
@@ -155,7 +410,7 @@ https://github.com/ruby/lrama/pull/344
 
 Allow to pass an instantiated rule to other parameterizing rules.
 
-```
+```yacc
 %rule constant(X) : X
                   ;
 
@@ -172,7 +427,7 @@ program         : option(constant(number)) // Nested rule
 
 Allow to use nested parameterizing rules when define parameterizing rules.
 
-```
+```yacc
 %rule option(x) : /* empty */
                 | X
                 ;
@@ -199,7 +454,7 @@ https://github.com/ruby/lrama/pull/337
 
 Allow to define parameterizing rule by `%rule` directive.
 
-```
+```yacc
 %rule pair(X, Y): X Y { $$ = $1 + $2; }
                 ;
 
@@ -222,7 +477,7 @@ https://github.com/ruby/lrama/pull/285
 Allow to specify type of rules by specifying tag, `<i>` in below example.
 Tag is post-modification style.
 
-```
+```yacc
 %union {
     int i;
 }
@@ -249,7 +504,7 @@ https://github.com/ruby/lrama/pull/197
 
 Support `separated_list` and `separated_nonempty_list` parameterizing rules.
 
-```
+```text
 program: separated_list(',', number)
 
 // Expanded to
@@ -280,7 +535,7 @@ https://github.com/ruby/lrama/pull/204
 Parameterizing rules are template of rules.
 It's very common pattern to write "list" grammar rule like:
 
-```
+```yacc
 opt_args: /* none */
         | args
         ;
@@ -312,7 +567,7 @@ https://github.com/ruby/lrama/pull/62
 
 ### Runtime configuration for error recovery
 
-Meke error recovery function configurable on runtime by two new macros.
+Make error recovery function configurable on runtime by two new macros.
 
 * `YYMAXREPAIR`: Expected to return max length of repair operations. `%parse-param` is passed to this function.
 * `YYERROR_RECOVERY_ENABLED`: Expected to return bool value to determine error recovery is enabled or not. `%parse-param` is passed to this function.
@@ -335,7 +590,7 @@ https://github.com/ruby/lrama/pull/44
 Instead of positional references like `$1` or `$$`,
 named references allow to access to symbol by name.
 
-```
+```yacc
 primary: k_class cpath superclass bodystmt k_end
            {
              $primary = new_class($cpath, $bodystmt, $superclass);
@@ -344,7 +599,7 @@ primary: k_class cpath superclass bodystmt k_end
 
 Alias name can be declared.
 
-```
+```yacc
 expr[result]: expr[ex-left] '+' expr[ex.right]
                 {
                   $result = $[ex-left] + $[ex.right];

data/README.md

@@ -2,6 +2,7 @@
 
 [![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)
+[![RubyDoc](https://img.shields.io/badge/%F0%9F%93%9ARubyDoc-documentation-informational.svg)](https://www.rubydoc.info/gems/lrama)
 
 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.
 
@@ -13,7 +14,8 @@ Lrama is LALR (1) parser generator written by Ruby. The first goal of this proje
 * [Development](#development)
   * [How to generate parser.rb](#how-to-generate-parserrb)
   * [Test](#test)
-  * [Profiling Lrama](#profiling-lrama)
+  * [Call-stack Profiling Lrama](#call-stack-profiling-lrama)
+  * [Memory Profiling Lrama](#memory-profiling-lrama)
   * [Build Ruby](#build-ruby)
 * [Release flow](#release-flow)
 * [License](#license)
@@ -94,7 +96,7 @@ This also requires Lrama to be able to run with only default gems because BASERU
 ### How to generate parser.rb
 
 ```shell
-$ rake build:parser
+$ bundle exec rake build:parser
 ```
 
 `parser.rb` is generated from `parser.y` by Racc.
@@ -128,7 +130,7 @@ $ bundle install
 $ bundle exec rake
 ```
 
-### Profiling Lrama
+### Call-stack Profiling Lrama
 
 #### 1. Create parse.tmp.y in ruby/ruby
 
@@ -166,6 +168,41 @@ $ exe/lrama -o parse.tmp.c --header=parse.tmp.h tmp/parse.tmp.y
 $ stackprof --d3-flamegraph tmp/stackprof-cpu-myapp.dump > tmp/flamegraph.html
 ```
 
+### Memory Profiling Lrama
+
+#### 1. Create parse.tmp.y in ruby/ruby
+
+```shell
+$ ruby tool/id2token.rb parse.y > parse.tmp.y
+$ cp parse.tmp.y dir/lrama/tmp
+```
+
+#### 2. Enable Profiler
+
+```diff
+diff --git a/exe/lrama b/exe/lrama
+index 1aece5d141..f5f94cf7fa 100755
+--- a/exe/lrama
++++ b/exe/lrama
+@@ -3,5 +3,9 @@
+
+ $LOAD_PATH << File.join(__dir__, "../lib")
+ require "lrama"
++require 'memory_profiler'
+
+-Lrama::Command.new.run(ARGV.dup)
++report = MemoryProfiler.report do
++  Lrama::Command.new.run(ARGV.dup)
++end
++report.pretty_print
+```
+
+#### 3. Run Lrama
+
+```shell
+$ exe/lrama -o parse.tmp.c --header=parse.tmp.h tmp/parse.tmp.y > report.txt
+```
+
 ### Build Ruby
 
 1. Install Lrama
@@ -180,4 +217,4 @@ $ stackprof --d3-flamegraph tmp/stackprof-cpu-myapp.dump > tmp/flamegraph.html
 
 ## License
 
-See LEGAL.md file.
+See [LEGAL.md](./LEGAL.md) file.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 
 namespace "build" do

data/Steepfile

@@ -1,30 +1,22 @@
+# frozen_string_literal: true
+
 # D = Steep::Diagnostic
 #
 target :lib do
   repo_path '.gem_rbs_collection/'
   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"
-  check "lib/lrama/grammar/error_token.rb"
-  check "lib/lrama/grammar/parameterizing_rule"
-  check "lib/lrama/grammar/parameterizing_rules"
-  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"
-  check "lib/lrama/grammar/symbol.rb"
-  check "lib/lrama/grammar/type.rb"
+  check "lib/lrama/grammar"
+
+  check "lib/lrama/counterexamples"
   check "lib/lrama/lexer"
   check "lib/lrama/report"
+  check "lib/lrama/state"
+  check "lib/lrama/states"
   check "lib/lrama/bitmap.rb"
+  check "lib/lrama/counterexamples.rb"
   check "lib/lrama/digraph.rb"
+  check "lib/lrama/grammar.rb"
   check "lib/lrama/options.rb"
   check "lib/lrama/warning.rb"
 end