lrama 0.6.4 → 0.6.6

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.
data/lib/lrama/state.rb CHANGED
@@ -70,38 +70,16 @@ module Lrama
70
70
  reduce.look_ahead = look_ahead
71
71
  end
72
72
 
73
- # Returns array of [Shift, next_state]
74
73
  def nterm_transitions
75
- return @nterm_transitions if @nterm_transitions
76
-
77
- @nterm_transitions = []
78
-
79
- shifts.each do |shift|
80
- next if shift.next_sym.term?
81
-
82
- @nterm_transitions << [shift, @items_to_state[shift.next_items]]
83
- end
84
-
85
- @nterm_transitions
74
+ @nterm_transitions ||= transitions.select {|shift, _| shift.next_sym.nterm? }
86
75
  end
87
76
 
88
- # Returns array of [Shift, next_state]
89
77
  def term_transitions
90
- return @term_transitions if @term_transitions
91
-
92
- @term_transitions = []
93
-
94
- shifts.each do |shift|
95
- next if shift.next_sym.nterm?
96
-
97
- @term_transitions << [shift, @items_to_state[shift.next_items]]
98
- end
99
-
100
- @term_transitions
78
+ @term_transitions ||= transitions.select {|shift, _| shift.next_sym.term? }
101
79
  end
102
80
 
103
81
  def transitions
104
- term_transitions + nterm_transitions
82
+ @transitions ||= shifts.map {|shift| [shift, @items_to_state[shift.next_items]] }
105
83
  end
106
84
 
107
85
  def selected_term_transitions
data/lib/lrama/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module Lrama
2
- VERSION = "0.6.4".freeze
2
+ VERSION = "0.6.6".freeze
3
3
  end
data/parser.y CHANGED
@@ -30,6 +30,7 @@ rule
30
30
 
31
31
  bison_declaration: grammar_declaration
32
32
  | rule_declaration
33
+ | inline_declaration
33
34
  | "%expect" INTEGER { @grammar.expect = val[1] }
34
35
  | "%define" variable value
35
36
  | "%param" params
@@ -237,6 +238,12 @@ rule
237
238
  @grammar.add_parameterizing_rule(rule)
238
239
  }
239
240
 
241
+ inline_declaration: "%rule" "%inline" id_colon ":" rule_rhs_list
242
+ {
243
+ rule = Grammar::ParameterizingRule::Rule.new(val[2].s_value, [], val[4], is_inline: true)
244
+ @grammar.add_parameterizing_rule(rule)
245
+ }
246
+
240
247
  rule_args: IDENTIFIER { result = [val[0]] }
241
248
  | rule_args "," IDENTIFIER { result = val[0].append(val[2]) }
242
249
 
@@ -462,10 +469,11 @@ rule
462
469
  {
463
470
  end_c_declaration
464
471
  }
465
- "}" named_ref_opt
472
+ "}" named_ref_opt tag_opt
466
473
  {
467
474
  user_code = val[3]
468
475
  user_code.alias_name = val[6]
476
+ user_code.tag = val[7]
469
477
  builder = val[0]
470
478
  builder.user_code = user_code
471
479
  result = builder
data/sample/calc.y CHANGED
@@ -31,6 +31,12 @@ static int yyerror(YYLTYPE *loc, const char *str);
31
31
  %left '+' '-'
32
32
  %left '*' '/'
33
33
 
34
+ %rule %inline op : '+' { + }
35
+ | '-' { - }
36
+ | '*' { * }
37
+ | '/' { / }
38
+ ;
39
+
34
40
  %%
35
41
 
36
42
  list : /* empty */
@@ -38,10 +44,7 @@ list : /* empty */
38
44
  | list expr LF { printf("=> %d\n", $2); }
39
45
  ;
40
46
  expr : NUM
41
- | expr '+' expr { $$ = $1 + $3; }
42
- | expr '-' expr { $$ = $1 - $3; }
43
- | expr '*' expr { $$ = $1 * $3; }
44
- | expr '/' expr { $$ = $1 / $3; }
47
+ | expr op expr { $$ = $1 $2 $3; }
45
48
  | '(' expr ')' { $$ = $2; }
46
49
  ;
47
50
 
@@ -8,13 +8,15 @@ module Lrama
8
8
 
9
9
  def initialize: () -> void
10
10
  def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> void
11
- def find: (Lexer::Token::InstantiateRule token) -> Grammar::ParameterizingRule::Rule?
11
+ def find_rule: (Lexer::Token::InstantiateRule token) -> Grammar::ParameterizingRule::Rule?
12
+ def find_inline: (Lexer::Token token) -> Grammar::ParameterizingRule::Rule?
12
13
  def created_lhs: (String lhs_s_value) -> Lexer::Token?
13
14
 
14
15
  private
15
16
 
16
- def select_rules: (Lexer::Token::InstantiateRule token) -> Array[Grammar::ParameterizingRule::Rule]
17
- def select_rules_by_name: (String rule_name) -> Array[Grammar::ParameterizingRule::Rule]
17
+ def select_rules: (Array[Grammar::ParameterizingRule::Rule] rules, Lexer::Token::InstantiateRule token) -> Array[Grammar::ParameterizingRule::Rule]
18
+ def select_not_inline_rules: (Array[Grammar::ParameterizingRule::Rule] rules) -> Array[Grammar::ParameterizingRule::Rule]
19
+ def select_rules_by_name: (Array[Grammar::ParameterizingRule::Rule] rules, String rule_name) -> Array[Grammar::ParameterizingRule::Rule]
18
20
  end
19
21
  end
20
22
  end
@@ -6,8 +6,9 @@ module Lrama
6
6
  attr_reader parameters: Array[Lexer::Token]
7
7
  attr_reader rhs_list: Array[Grammar::ParameterizingRule::Rhs]
8
8
  attr_reader required_parameters_count: Integer
9
+ attr_reader is_inline: bool
9
10
 
10
- def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRule::Rhs] rhs_list) -> void
11
+ def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRule::Rhs] rhs_list, ?is_inline: bool) -> void
11
12
  end
12
13
  end
13
14
  end
@@ -15,10 +15,11 @@ module Lrama
15
15
  @user_code: Lexer::Token::UserCode?
16
16
  @rule_builders_for_parameterizing_rules: Array[RuleBuilder]
17
17
  @rule_builders_for_derived_rules: Array[RuleBuilder]
18
+ @rule_builders_for_inline_rules: Array[RuleBuilder]
18
19
  @rules: Array[Rule]
19
20
  @replaced_rhs: Array[Lexer::Token]
20
21
  @parameterizing_rules: Array[Rule]
21
- @old_parameterizing_rules: Array[Rule]
22
+ @inline_rules: Array[Rule]
22
23
  @midrule_action_rules: Array[Rule]
23
24
 
24
25
  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
@@ -36,6 +37,9 @@ module Lrama
36
37
  def build_rules: () -> void
37
38
  def process_rhs: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
38
39
  def lhs_s_value: (Lexer::Token::InstantiateRule token, Grammar::Binding bindings) -> String
40
+ def resolve_inline: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
41
+ def resolve_inline_rhs: (RuleBuilder rule_builder, Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> void
42
+ def replace_inline_user_code: (Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> Lexer::Token::UserCode?
39
43
  def numberize_references: () -> void
40
44
  def flush_user_code: () -> void
41
45
  end
@@ -1,6 +1,8 @@
1
1
  module Lrama
2
2
  class Lexer
3
3
  class GrammarFile
4
+ class Text < String
5
+ end
4
6
  attr_reader path: String
5
7
  attr_reader text: String
6
8
 
@@ -2,6 +2,7 @@ module Lrama
2
2
  class Lexer
3
3
  class Token
4
4
  class UserCode < Token
5
+ attr_accessor tag: Lexer::Token::Tag
5
6
  @references: Array[Lrama::Grammar::Reference]
6
7
 
7
8
  def references: () -> Array[Lrama::Grammar::Reference]
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.4
4
+ version: 0.6.6
5
5
  platform: ruby
6
6
  authors:
7
7
  - Yuichiro Kaneko
8
8
  autorequire:
9
9
  bindir: exe
10
10
  cert_chain: []
11
- date: 2024-03-22 00:00:00.000000000 Z
11
+ date: 2024-04-27 00:00:00.000000000 Z
12
12
  dependencies: []
13
13
  description: LALR (1) parser generator written by Ruby
14
14
  email: