lrama 0.6.0 → 0.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (61) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/test.yaml +27 -7
  3. data/Gemfile +1 -1
  4. data/NEWS.md +55 -0
  5. data/Steepfile +2 -3
  6. data/lib/lrama/command.rb +25 -3
  7. data/lib/lrama/context.rb +3 -23
  8. data/lib/lrama/counterexamples/example.rb +2 -2
  9. data/lib/lrama/grammar/binding.rb +24 -0
  10. data/lib/lrama/grammar/code/rule_action.rb +1 -1
  11. data/lib/lrama/grammar/code.rb +1 -1
  12. data/lib/lrama/grammar/parameterizing_rule/resolver.rb +47 -0
  13. data/lib/lrama/grammar/parameterizing_rule/rhs.rb +15 -0
  14. data/lib/lrama/grammar/parameterizing_rule/rule.rb +16 -0
  15. data/lib/lrama/grammar/parameterizing_rule.rb +3 -6
  16. data/lib/lrama/grammar/percent_code.rb +3 -3
  17. data/lib/lrama/grammar/rule.rb +2 -2
  18. data/lib/lrama/grammar/rule_builder.rb +60 -31
  19. data/lib/lrama/grammar/stdlib.y +80 -0
  20. data/lib/lrama/grammar/type.rb +13 -1
  21. data/lib/lrama/grammar.rb +18 -11
  22. data/lib/lrama/lexer/grammar_file.rb +1 -1
  23. data/lib/lrama/lexer/token/instantiate_rule.rb +7 -2
  24. data/lib/lrama/lexer/token.rb +5 -0
  25. data/lib/lrama/lexer.rb +3 -7
  26. data/lib/lrama/output.rb +2 -2
  27. data/lib/lrama/parser.rb +508 -467
  28. data/lib/lrama/states/item.rb +17 -13
  29. data/lib/lrama/states_reporter.rb +8 -10
  30. data/lib/lrama/version.rb +1 -1
  31. data/parser.y +12 -13
  32. data/sig/lrama/grammar/binding.rbs +16 -0
  33. data/sig/lrama/grammar/parameterizing_rule/resolver.rbs +22 -0
  34. data/sig/lrama/grammar/parameterizing_rule/rhs.rbs +13 -0
  35. data/sig/lrama/grammar/parameterizing_rule/rule.rbs +14 -0
  36. data/sig/lrama/grammar/parameterizing_rule.rbs +0 -4
  37. data/sig/lrama/grammar/percent_code.rbs +3 -3
  38. data/sig/lrama/grammar/rule_builder.rbs +9 -6
  39. data/sig/lrama/lexer/token/instantiate_rule.rbs +4 -2
  40. data/sig/lrama/lexer/token.rbs +1 -0
  41. metadata +12 -23
  42. data/lib/lrama/grammar/parameterizing_rule_builder.rb +0 -34
  43. data/lib/lrama/grammar/parameterizing_rule_resolver.rb +0 -30
  44. data/lib/lrama/grammar/parameterizing_rule_rhs_builder.rb +0 -53
  45. data/lib/lrama/grammar/parameterizing_rules/builder/base.rb +0 -36
  46. data/lib/lrama/grammar/parameterizing_rules/builder/list.rb +0 -28
  47. data/lib/lrama/grammar/parameterizing_rules/builder/nonempty_list.rb +0 -28
  48. data/lib/lrama/grammar/parameterizing_rules/builder/option.rb +0 -28
  49. data/lib/lrama/grammar/parameterizing_rules/builder/separated_list.rb +0 -39
  50. data/lib/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rb +0 -34
  51. data/lib/lrama/grammar/parameterizing_rules/builder.rb +0 -60
  52. data/sig/lrama/grammar/parameterizing_rule_builder.rbs +0 -19
  53. data/sig/lrama/grammar/parameterizing_rule_resolver.rbs +0 -16
  54. data/sig/lrama/grammar/parameterizing_rule_rhs_builder.rbs +0 -18
  55. data/sig/lrama/grammar/parameterizing_rules/builder/base.rbs +0 -28
  56. data/sig/lrama/grammar/parameterizing_rules/builder/list.rbs +0 -10
  57. data/sig/lrama/grammar/parameterizing_rules/builder/nonempty_list.rbs +0 -10
  58. data/sig/lrama/grammar/parameterizing_rules/builder/option.rbs +0 -10
  59. data/sig/lrama/grammar/parameterizing_rules/builder/separated_list.rbs +0 -13
  60. data/sig/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rbs +0 -13
  61. data/sig/lrama/grammar/parameterizing_rules/builder.rbs +0 -24
@@ -5,7 +5,7 @@ module Lrama
5
5
  class Item < Struct.new(:rule, :position, keyword_init: true)
6
6
  # Optimization for States#setup_state
7
7
  def hash
8
- [rule.id, position].hash
8
+ [rule_id, position].hash
9
9
  end
10
10
 
11
11
  def rule_id
@@ -17,27 +17,31 @@ module Lrama
17
17
  end
18
18
 
19
19
  def number_of_rest_symbols
20
- rule.rhs.count - position
20
+ rhs.count - position
21
21
  end
22
22
 
23
23
  def lhs
24
24
  rule.lhs
25
25
  end
26
26
 
27
+ def rhs
28
+ rule.rhs
29
+ end
30
+
27
31
  def next_sym
28
- rule.rhs[position]
32
+ rhs[position]
29
33
  end
30
34
 
31
35
  def next_next_sym
32
- rule.rhs[position + 1]
36
+ rhs[position + 1]
33
37
  end
34
38
 
35
39
  def previous_sym
36
- rule.rhs[position - 1]
40
+ rhs[position - 1]
37
41
  end
38
42
 
39
43
  def end_of_rule?
40
- rule.rhs.count == position
44
+ rhs.count == position
41
45
  end
42
46
 
43
47
  def beginning_of_rule?
@@ -45,7 +49,7 @@ module Lrama
45
49
  end
46
50
 
47
51
  def start_item?
48
- rule.id == 0 && position == 0
52
+ rule.initial_rule? && beginning_of_rule?
49
53
  end
50
54
 
51
55
  def new_by_next_position
@@ -53,11 +57,11 @@ module Lrama
53
57
  end
54
58
 
55
59
  def symbols_before_dot
56
- rule.rhs[0...position]
60
+ rhs[0...position]
57
61
  end
58
62
 
59
63
  def symbols_after_dot
60
- rule.rhs[position..-1]
64
+ rhs[position..-1]
61
65
  end
62
66
 
63
67
  def to_s
@@ -65,14 +69,14 @@ module Lrama
65
69
  end
66
70
 
67
71
  def display_name
68
- r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
69
- "#{r} (rule #{rule.id})"
72
+ r = rhs.map(&:display_name).insert(position, "•").join(" ")
73
+ "#{r} (rule #{rule_id})"
70
74
  end
71
75
 
72
76
  # Right after position
73
77
  def display_rest
74
- r = rule.rhs[position..-1].map(&:display_name).join(" ")
75
- ". #{r} (rule #{rule.id})"
78
+ r = rhs[position..-1].map(&:display_name).join(" ")
79
+ ". #{r} (rule #{rule_id})"
76
80
  end
77
81
  end
78
82
  end
@@ -53,7 +53,7 @@ module Lrama
53
53
  last_lhs = nil
54
54
 
55
55
  @states.rules.each do |rule|
56
- if rule.rhs.empty?
56
+ if rule.empty_rule?
57
57
  r = "ε"
58
58
  else
59
59
  r = rule.rhs.map(&:display_name).join(" ")
@@ -84,17 +84,15 @@ module Lrama
84
84
  last_lhs = nil
85
85
  list = itemsets ? state.items : state.kernels
86
86
  list.sort_by {|i| [i.rule_id, i.position] }.each do |item|
87
- rule = item.rule
88
- position = item.position
89
- if rule.rhs.empty?
87
+ if item.empty_rule?
90
88
  r = "ε •"
91
89
  else
92
- r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
90
+ r = item.rhs.map(&:display_name).insert(item.position, "•").join(" ")
93
91
  end
94
- if rule.lhs == last_lhs
95
- l = " " * rule.lhs.id.s_value.length + "|"
92
+ if item.lhs == last_lhs
93
+ l = " " * item.lhs.id.s_value.length + "|"
96
94
  else
97
- l = rule.lhs.id.s_value + ":"
95
+ l = item.lhs.id.s_value + ":"
98
96
  end
99
97
  la = ""
100
98
  if lookaheads && item.end_of_rule?
@@ -104,9 +102,9 @@ module Lrama
104
102
  la = " [#{look_ahead.map(&:display_name).join(", ")}]"
105
103
  end
106
104
  end
107
- last_lhs = rule.lhs
105
+ last_lhs = item.lhs
108
106
 
109
- io << sprintf("%5i %s %s%s\n", rule.id, l, r, la)
107
+ io << sprintf("%5i %s %s%s\n", item.rule_id, l, r, la)
110
108
  end
111
109
  io << "\n"
112
110
 
data/lib/lrama/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module Lrama
2
- VERSION = "0.6.0".freeze
2
+ VERSION = "0.6.2".freeze
3
3
  end
data/parser.y CHANGED
@@ -69,6 +69,7 @@ rule
69
69
  {
70
70
  @grammar.initial_action = Grammar::Code::InitialActionCode.new(type: :initial_action, token_code: val[3])
71
71
  }
72
+ | "%no-stdlib" { @grammar.no_stdlib = true }
72
73
  | ";"
73
74
 
74
75
  grammar_declaration: "%union" "{"
@@ -205,8 +206,8 @@ rule
205
206
 
206
207
  rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" ":" rule_rhs_list
207
208
  {
208
- builder = Grammar::ParameterizingRuleBuilder.new(val[1].s_value, val[3], val[6])
209
- @grammar.add_parameterizing_rule_builder(builder)
209
+ rule = Grammar::ParameterizingRule::Rule.new(val[1].s_value, val[3], val[6])
210
+ @grammar.add_parameterizing_rule(rule)
210
211
  }
211
212
 
212
213
  rule_args: IDENTIFIER { result = [val[0]] }
@@ -226,12 +227,12 @@ rule
226
227
  rule_rhs: /* empty */
227
228
  {
228
229
  reset_precs
229
- result = Grammar::ParameterizingRuleRhsBuilder.new
230
+ result = Grammar::ParameterizingRule::Rhs.new
230
231
  }
231
232
  | "%empty"
232
233
  {
233
234
  reset_precs
234
- result = Grammar::ParameterizingRuleRhsBuilder.new
235
+ result = Grammar::ParameterizingRule::Rhs.new
235
236
  }
236
237
  | rule_rhs symbol named_ref_opt
237
238
  {
@@ -408,19 +409,17 @@ rule
408
409
  }
409
410
  | rhs symbol parameterizing_suffix tag_opt
410
411
  {
411
- token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
412
+ token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]], lhs_tag: val[3])
412
413
  builder = val[0]
413
414
  builder.add_rhs(token)
414
- builder.lhs_tag = val[3]
415
415
  builder.line = val[1].first_line
416
416
  result = builder
417
417
  }
418
418
  | rhs IDENTIFIER "(" parameterizing_args ")" tag_opt
419
419
  {
420
- token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3])
420
+ token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
421
421
  builder = val[0]
422
422
  builder.add_rhs(token)
423
- builder.lhs_tag = val[5]
424
423
  builder.line = val[1].first_line
425
424
  result = builder
426
425
  }
@@ -453,12 +452,14 @@ rule
453
452
  result = builder
454
453
  }
455
454
 
456
- parameterizing_suffix: "?"
457
- | "+"
458
- | "*"
455
+ parameterizing_suffix: "?" { result = "option" }
456
+ | "+" { result = "nonempty_list" }
457
+ | "*" { result = "list" }
459
458
 
460
459
  parameterizing_args: symbol { result = [val[0]] }
461
460
  | parameterizing_args ',' symbol { result = val[0].append(val[2]) }
461
+ | symbol parameterizing_suffix { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[0])] }
462
+ | IDENTIFIER "(" parameterizing_args ")" { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[0].s_value, location: @lexer.location, args: val[2])] }
462
463
 
463
464
  named_ref_opt: # empty
464
465
  | '[' IDENTIFIER ']' { result = val[1].s_value }
@@ -514,8 +515,6 @@ def parse
514
515
  @precedence_number = 0
515
516
  reset_precs
516
517
  do_parse
517
- @grammar.prepare
518
- @grammar.validate!
519
518
  @grammar
520
519
  end
521
520
  end
@@ -0,0 +1,16 @@
1
+ module Lrama
2
+ class Grammar
3
+ class Binding
4
+ attr_reader actual_args: Array[Lexer::Token]
5
+ attr_reader count: Integer
6
+
7
+ @rule_name: String
8
+ @required_parameters_count: Integer
9
+ @parameters: Array[Lexer::Token]
10
+ @parameter_to_arg: untyped
11
+
12
+ def initialize: (Grammar::ParameterizingRule::Rule parameterizing_rule, Array[Lexer::Token] actual_args) -> void
13
+ def resolve_symbol: (Lexer::Token symbol) -> Lexer::Token
14
+ end
15
+ end
16
+ end
@@ -0,0 +1,22 @@
1
+ module Lrama
2
+ class Grammar
3
+ class ParameterizingRule
4
+ class Resolver
5
+ attr_accessor created_lhs_list: Array[Lexer::Token]
6
+
7
+ @rules: Array[Grammar::ParameterizingRule::Rule]
8
+
9
+ def initialize: () -> void
10
+ def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> void
11
+ def defined?: (Lexer::Token::InstantiateRule token) -> bool
12
+ def find: (Lexer::Token::InstantiateRule token) -> Grammar::ParameterizingRule::Rule?
13
+ def created_lhs: (String lhs_s_value) -> Lexer::Token?
14
+
15
+ private
16
+
17
+ def select_rules: (Lexer::Token::InstantiateRule token) -> Array[Grammar::ParameterizingRule::Rule]
18
+ def select_rules_by_name: (String rule_name) -> Array[Grammar::ParameterizingRule::Rule]
19
+ end
20
+ end
21
+ end
22
+ end
@@ -0,0 +1,13 @@
1
+ module Lrama
2
+ class Grammar
3
+ class ParameterizingRule
4
+ class Rhs
5
+ attr_reader symbols: Array[untyped]
6
+ attr_reader user_code: Lexer::Token::UserCode?
7
+ attr_reader precedence_sym: Lexer::Token?
8
+
9
+ def initialize: () -> void
10
+ end
11
+ end
12
+ end
13
+ end
@@ -0,0 +1,14 @@
1
+ module Lrama
2
+ class Grammar
3
+ class ParameterizingRule
4
+ class Rule
5
+ attr_reader name: String
6
+ attr_reader parameters: Array[Lexer::Token]
7
+ attr_reader rhs_list: Array[Grammar::ParameterizingRule::Rhs]
8
+ attr_reader required_parameters_count: Integer
9
+
10
+ def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRule::Rhs] rhs_list) -> void
11
+ end
12
+ end
13
+ end
14
+ end
@@ -1,10 +1,6 @@
1
1
  module Lrama
2
2
  class Grammar
3
3
  class ParameterizingRule
4
- attr_accessor rules: Array[Rule]
5
- attr_accessor token: Lexer::Token
6
-
7
- def initialize: (?untyped rules, Lexer::Token token) -> void
8
4
  end
9
5
  end
10
6
  end
@@ -1,10 +1,10 @@
1
1
  module Lrama
2
2
  class Grammar
3
3
  class PercentCode
4
- attr_reader id: Lexer::Token::Ident
5
- attr_reader code: Lexer::Token::UserCode
4
+ attr_reader name: String
5
+ attr_reader code: String
6
6
 
7
- def initialize: (Lexer::Token::Ident id, Lexer::Token::UserCode code) -> void
7
+ def initialize: (String name, String code) -> void
8
8
  end
9
9
  end
10
10
  end
@@ -2,8 +2,8 @@ module Lrama
2
2
  class Grammar
3
3
  class RuleBuilder
4
4
  attr_accessor lhs: Lexer::Token
5
- attr_accessor lhs_tag: untyped
6
5
  attr_accessor line: Integer?
6
+ attr_reader lhs_tag: Lexer::Token::Tag?
7
7
  attr_reader rhs: Array[Lexer::Token]
8
8
  attr_reader user_code: Lexer::Token::UserCode?
9
9
  attr_reader precedence_sym: Lexer::Token?
@@ -13,18 +13,20 @@ module Lrama
13
13
  @position_in_original_rule_rhs: Integer?
14
14
  @skip_preprocess_references: bool
15
15
  @user_code: Lexer::Token::UserCode?
16
+ @rule_builders_for_parameterizing_rules: Array[RuleBuilder]
16
17
  @rule_builders_for_derived_rules: Array[RuleBuilder]
17
18
  @rules: Array[Rule]
18
19
  @replaced_rhs: Array[Lexer::Token]
19
20
  @parameterizing_rules: Array[Rule]
21
+ @old_parameterizing_rules: Array[Rule]
20
22
  @midrule_action_rules: Array[Rule]
21
23
 
22
- def initialize: (Counter rule_counter, Counter midrule_action_counter, ?Integer position_in_original_rule_rhs, ?skip_preprocess_references: bool) -> void
24
+ def initialize: (Counter rule_counter, Counter midrule_action_counter, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
23
25
  def add_rhs: (Lexer::Token rhs) -> void
24
- def user_code=: (Lexer::Token::UserCode user_code) -> void
25
- def precedence_sym=: (Lexer::Token user_code) -> void
26
+ def user_code=: (Lexer::Token::UserCode? user_code) -> void
27
+ def precedence_sym=: (Lexer::Token? precedence_sym) -> void
26
28
  def complete_input: () -> void
27
- def setup_rules: (Grammar::ParameterizingRuleResolver parameterizing_resolver) -> void
29
+ def setup_rules: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
28
30
  def rules: () -> Array[Rule]
29
31
 
30
32
  private
@@ -32,7 +34,8 @@ module Lrama
32
34
  def freeze_rhs: () -> void
33
35
  def preprocess_references: () -> void
34
36
  def build_rules: () -> void
35
- def process_rhs: (Grammar::ParameterizingRuleResolver parameterizing_resolver) -> void
37
+ def process_rhs: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
38
+ def lhs_s_value: (Lexer::Token::InstantiateRule token, Grammar::Binding bindings) -> String
36
39
  def numberize_references: () -> void
37
40
  def flush_user_code: () -> void
38
41
  end
@@ -2,10 +2,12 @@ module Lrama
2
2
  class Lexer
3
3
  class Token
4
4
  class InstantiateRule < Token
5
- attr_accessor args: Array[Lexer::Token]
5
+ attr_reader args: Array[Lexer::Token]
6
+ attr_reader lhs_tag: Lexer::Token::Tag?
6
7
 
7
- def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token]) -> void
8
+ def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token], ?lhs_tag: Lexer::Token::Tag?) -> void
8
9
  def rule_name: () -> String
10
+ def args_count: () -> Integer
9
11
  end
10
12
  end
11
13
  end
@@ -17,6 +17,7 @@ module Lrama
17
17
  def last_column: () -> Integer
18
18
  alias line first_line
19
19
  alias column first_column
20
+ def invalid_ref: (Lrama::Grammar::Reference ref, String message) -> bot
20
21
  end
21
22
  end
22
23
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: lrama
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.6.0
4
+ version: 0.6.2
5
5
  platform: ruby
6
6
  authors:
7
7
  - Yuichiro Kaneko
8
8
  autorequire:
9
9
  bindir: exe
10
10
  cert_chain: []
11
- date: 2023-12-25 00:00:00.000000000 Z
11
+ date: 2024-01-27 00:00:00.000000000 Z
12
12
  dependencies: []
13
13
  description: LALR (1) parser generator written by Ruby
14
14
  email:
@@ -48,6 +48,7 @@ files:
48
48
  - lib/lrama/digraph.rb
49
49
  - lib/lrama/grammar.rb
50
50
  - lib/lrama/grammar/auxiliary.rb
51
+ - lib/lrama/grammar/binding.rb
51
52
  - lib/lrama/grammar/code.rb
52
53
  - lib/lrama/grammar/code/initial_action_code.rb
53
54
  - lib/lrama/grammar/code/no_reference_code.rb
@@ -56,22 +57,16 @@ files:
56
57
  - lib/lrama/grammar/counter.rb
57
58
  - lib/lrama/grammar/error_token.rb
58
59
  - lib/lrama/grammar/parameterizing_rule.rb
59
- - lib/lrama/grammar/parameterizing_rule_builder.rb
60
- - lib/lrama/grammar/parameterizing_rule_resolver.rb
61
- - lib/lrama/grammar/parameterizing_rule_rhs_builder.rb
62
- - lib/lrama/grammar/parameterizing_rules/builder.rb
63
- - lib/lrama/grammar/parameterizing_rules/builder/base.rb
64
- - lib/lrama/grammar/parameterizing_rules/builder/list.rb
65
- - lib/lrama/grammar/parameterizing_rules/builder/nonempty_list.rb
66
- - lib/lrama/grammar/parameterizing_rules/builder/option.rb
67
- - lib/lrama/grammar/parameterizing_rules/builder/separated_list.rb
68
- - lib/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rb
60
+ - lib/lrama/grammar/parameterizing_rule/resolver.rb
61
+ - lib/lrama/grammar/parameterizing_rule/rhs.rb
62
+ - lib/lrama/grammar/parameterizing_rule/rule.rb
69
63
  - lib/lrama/grammar/percent_code.rb
70
64
  - lib/lrama/grammar/precedence.rb
71
65
  - lib/lrama/grammar/printer.rb
72
66
  - lib/lrama/grammar/reference.rb
73
67
  - lib/lrama/grammar/rule.rb
74
68
  - lib/lrama/grammar/rule_builder.rb
69
+ - lib/lrama/grammar/stdlib.y
75
70
  - lib/lrama/grammar/symbol.rb
76
71
  - lib/lrama/grammar/type.rb
77
72
  - lib/lrama/grammar/union.rb
@@ -112,21 +107,15 @@ files:
112
107
  - sig/lrama/bitmap.rbs
113
108
  - sig/lrama/digraph.rbs
114
109
  - sig/lrama/grammar.rbs
110
+ - sig/lrama/grammar/binding.rbs
115
111
  - sig/lrama/grammar/code.rbs
116
112
  - sig/lrama/grammar/code/printer_code.rbs
117
113
  - sig/lrama/grammar/counter.rbs
118
114
  - sig/lrama/grammar/error_token.rbs
119
115
  - sig/lrama/grammar/parameterizing_rule.rbs
120
- - sig/lrama/grammar/parameterizing_rule_builder.rbs
121
- - sig/lrama/grammar/parameterizing_rule_resolver.rbs
122
- - sig/lrama/grammar/parameterizing_rule_rhs_builder.rbs
123
- - sig/lrama/grammar/parameterizing_rules/builder.rbs
124
- - sig/lrama/grammar/parameterizing_rules/builder/base.rbs
125
- - sig/lrama/grammar/parameterizing_rules/builder/list.rbs
126
- - sig/lrama/grammar/parameterizing_rules/builder/nonempty_list.rbs
127
- - sig/lrama/grammar/parameterizing_rules/builder/option.rbs
128
- - sig/lrama/grammar/parameterizing_rules/builder/separated_list.rbs
129
- - sig/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rbs
116
+ - sig/lrama/grammar/parameterizing_rule/resolver.rbs
117
+ - sig/lrama/grammar/parameterizing_rule/rhs.rbs
118
+ - sig/lrama/grammar/parameterizing_rule/rule.rbs
130
119
  - sig/lrama/grammar/percent_code.rbs
131
120
  - sig/lrama/grammar/precedence.rbs
132
121
  - sig/lrama/grammar/printer.rbs
@@ -168,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
168
157
  - !ruby/object:Gem::Version
169
158
  version: '0'
170
159
  requirements: []
171
- rubygems_version: 3.5.1
160
+ rubygems_version: 3.5.3
172
161
  signing_key:
173
162
  specification_version: 4
174
163
  summary: LALR (1) parser generator written by Ruby
@@ -1,34 +0,0 @@
1
- module Lrama
2
- class Grammar
3
- class ParameterizingRuleBuilder
4
- attr_reader :name, :parameters, :rhs
5
-
6
- def initialize(name, parameters, rhs)
7
- @name = name
8
- @parameters = parameters
9
- @rhs = rhs
10
- @required_parameters_count = parameters.count
11
- end
12
-
13
- def build_rules(token, actual_args, rule_counter, lhs_tag, line, rule_builders)
14
- validate_argument_number!(token)
15
- lhs = lhs(actual_args)
16
- @rhs.map do |rhs|
17
- rhs.build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
18
- end.flatten
19
- end
20
-
21
- private
22
-
23
- def validate_argument_number!(token)
24
- unless @required_parameters_count == token.args.count
25
- raise "Invalid number of arguments. expect: #{@required_parameters_count} actual: #{token.args.count}"
26
- end
27
- end
28
-
29
- def lhs(actual_args)
30
- Lrama::Lexer::Token::Ident.new(s_value: "#{name}_#{actual_args.map(&:s_value).join('_')}")
31
- end
32
- end
33
- end
34
- end
@@ -1,30 +0,0 @@
1
- module Lrama
2
- class Grammar
3
- class ParameterizingRuleResolver
4
- def initialize
5
- @parameterizing_rule_builders = []
6
- end
7
-
8
- def add_parameterizing_rule_builder(builder)
9
- @parameterizing_rule_builders << builder
10
- end
11
-
12
- def defined?(name)
13
- !rule_builders(name).empty?
14
- end
15
-
16
- def build_rules(token, rule_counter, lhs_tag, line)
17
- builder = rule_builders(token.s_value).last
18
- raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
19
-
20
- builder.build_rules(token, token.args, rule_counter, lhs_tag, line, @parameterizing_rule_builders)
21
- end
22
-
23
- private
24
-
25
- def rule_builders(name)
26
- @parameterizing_rule_builders.select { |builder| builder.name == name }
27
- end
28
- end
29
- end
30
- end
@@ -1,53 +0,0 @@
1
- module Lrama
2
- class Grammar
3
- class ParameterizingRuleRhsBuilder
4
- attr_accessor :symbols, :user_code, :precedence_sym
5
-
6
- def initialize
7
- @symbols = []
8
- @user_code = nil
9
- @precedence_sym = nil
10
- end
11
-
12
- def build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
13
- nested_rules = build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
14
- rule = Rule.new(id: rule_counter.increment, _lhs: lhs, _rhs: rhs(token, actual_args, parameters, nested_rules.last), lhs_tag: lhs_tag, token_code: user_code, precedence_sym: precedence_sym, lineno: line)
15
- ParameterizingRule.new(rules: nested_rules.map(&:rules) + [rule], token: lhs)
16
- end
17
-
18
- private
19
-
20
- def build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
21
- symbols.each_with_index.map do |sym, i|
22
- next unless sym.is_a?(Lexer::Token::InstantiateRule)
23
-
24
- builder = rule_builders.select { |builder| builder.name == sym.s_value }.last
25
- raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
26
-
27
- builder.build_rules(sym, nested_actual_args(actual_args, parameters, i), rule_counter, lhs_tag, line, rule_builders)
28
- end.flatten.compact
29
- end
30
-
31
- def nested_actual_args(actual_args, parameters, idx)
32
- symbols[idx].args.map do |arg|
33
- i = parameters.index { |parameter| parameter.s_value == arg.s_value }
34
- i.nil? ? arg : actual_args[i]
35
- end
36
- end
37
-
38
- def rhs(token, actual_args, parameters, nested_rule)
39
- symbols.map do |sym|
40
- if sym.is_a?(Lexer::Token::InstantiateRule)
41
- sym.args.map do |arg|
42
- idx = parameters.index { |parameter| parameter.s_value == arg.s_value }
43
- idx.nil? ? sym : nested_rule&.token
44
- end
45
- else
46
- idx = parameters.index { |parameter| parameter.s_value == sym.s_value }
47
- idx.nil? ? sym : actual_args[idx]
48
- end
49
- end.flatten
50
- end
51
- end
52
- end
53
- end
@@ -1,36 +0,0 @@
1
- module Lrama
2
- class Grammar
3
- class ParameterizingRules
4
- class Builder
5
- # Base class for parameterizing rules builder
6
- class Base
7
- attr_reader :build_token
8
-
9
- def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
10
- @args = token.args
11
- @token = @args.first
12
- @rule_counter = rule_counter
13
- @lhs_tag = lhs_tag
14
- @user_code = user_code
15
- @precedence_sym = precedence_sym
16
- @line = line
17
- @expected_argument_num = 1
18
- @build_token = nil
19
- end
20
-
21
- def build
22
- raise NotImplementedError
23
- end
24
-
25
- private
26
-
27
- def validate_argument_number!
28
- unless @args.count == @expected_argument_num
29
- raise "Invalid number of arguments. expect: #{@expected_argument_num} actual: #{@args.count}"
30
- end
31
- end
32
- end
33
- end
34
- end
35
- end
36
- end
@@ -1,28 +0,0 @@
1
- module Lrama
2
- class Grammar
3
- class ParameterizingRules
4
- class Builder
5
- # Builder for list of general parameterizing rules
6
- class List < Base
7
-
8
- # program: list(number)
9
- #
10
- # =>
11
- #
12
- # program: list_number
13
- # list_number: ε
14
- # list_number: list_number number
15
- def build
16
- validate_argument_number!
17
-
18
- rules = []
19
- @build_token = Lrama::Lexer::Token::Ident.new(s_value: "list_#{@token.s_value}")
20
- rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
21
- rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
22
- rules
23
- end
24
- end
25
- end
26
- end
27
- end
28
- end