1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Lrama v0.6.1

Browse Source
This commit is contained in:
yui-knk 2024-01-13 17:37:31 +09:00 committed by Yuichiro Kaneko
parent d999ed3a2f
commit b92c8934a2
23 changed files with 429 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
tool/lrama/NEWS.md
View File

@ -1,5 +1,49 @@
# NEWS for Lrama # NEWS for Lrama
## Lrama 0.6.1 (2024-01-13)
### Nested parameterizing rules
Allow to pass an instantiated rule to other parameterizing rules.
```
%rule constant(X) : X
;
%rule option(Y) : /* empty */
| Y
;
%%
program : option(constant(number)) // Nested rule
;
%%
```
Allow to use nested parameterizing rules when define parameterizing rules.
```
%rule option(x) : /* empty */
| X
;
%rule double(Y) : Y Y
;
%rule double_opt(A) : option(double(A)) // Nested rule
;
%%
program : double_opt(number)
;
%%
```
https://github.com/ruby/lrama/pull/337
## Lrama 0.6.0 (2023-12-25) ## Lrama 0.6.0 (2023-12-25)
### User defined parameterizing rules ### User defined parameterizing rules
@ -20,6 +64,8 @@ stmt: pair(ODD, EVEN) <num>
; ;
``` ```
https://github.com/ruby/lrama/pull/285
## Lrama 0.5.11 (2023-12-02) ## Lrama 0.5.11 (2023-12-02)
### Type specification of parameterizing rules ### Type specification of parameterizing rules

20
tool/lrama/lib/lrama/command.rb
View File

@ -1,14 +1,28 @@
module Lrama module Lrama
class Command class Command
def run(argv) def run(argv)
options = OptionParser.new.parse(argv) begin
options = OptionParser.new.parse(argv)
rescue => e
message = e.message
message = message.gsub(/.+/, "\e[1m\\&\e[m") if Exception.to_tty?
abort message
end
Report::Duration.enable if options.trace_opts[:time] Report::Duration.enable if options.trace_opts[:time]
warning = Lrama::Warning.new warning = Lrama::Warning.new
text = options.y.read text = options.y.read
options.y.close if options.y != STDIN options.y.close if options.y != STDIN
grammar = Lrama::Parser.new(text, options.grammar_file, options.debug).parse parser = Lrama::Parser.new(text, options.grammar_file, options.debug)
begin
grammar = parser.parse
rescue => e
raise e if options.debug
message = e.message
message = message.gsub(/.+/, "\e[1m\\&\e[m") if Exception.to_tty?
abort message
end
states = Lrama::States.new(grammar, warning, trace_state: (options.trace_opts[:automaton] || options.trace_opts[:closure])) states = Lrama::States.new(grammar, warning, trace_state: (options.trace_opts[:automaton] || options.trace_opts[:closure]))
states.compute states.compute
context = Lrama::Context.new(states) context = Lrama::Context.new(states)
@ -39,7 +53,7 @@ module Lrama
end end
if warning.has_error? if warning.has_error?
exit 1 exit false
end end
end end
end end

24
tool/lrama/lib/lrama/context.rb
View File

@ -9,7 +9,7 @@ module Lrama
BaseMin = -Float::INFINITY BaseMin = -Float::INFINITY
# TODO: It might be better to pass `states` to Output directly? # TODO: It might be better to pass `states` to Output directly?
attr_reader :states attr_reader :states, :yylast, :yypact_ninf, :yytable_ninf, :yydefact, :yydefgoto
def initialize(states) def initialize(states)
@states = states @states = states
@ -41,15 +41,11 @@ module Lrama
def yyfinal def yyfinal
@states.states.find do |state| @states.states.find do |state|
state.items.find do |item| state.items.find do |item|
item.rule.lhs.id.s_value == "$accept" && item.end_of_rule? item.rule.lhs.accept_symbol? && item.end_of_rule?
end end
end.id end.id
end end
def yylast
@yylast
end
# Number of terms # Number of terms
def yyntokens def yyntokens
@states.terms.count @states.terms.count
@ -119,30 +115,14 @@ module Lrama
end end
end end
def yypact_ninf
@yypact_ninf
end
def yytable_ninf
@yytable_ninf
end
def yypact def yypact
@base[0...yynstates] @base[0...yynstates]
end end
def yydefact
@yydefact
end
def yypgoto def yypgoto
@base[yynstates..-1] @base[yynstates..-1]
end end
def yydefgoto
@yydefgoto
end
def yytable def yytable
@table @table
end end

16
tool/lrama/lib/lrama/grammar.rb
View File

@ -1,4 +1,5 @@
require "lrama/grammar/auxiliary" require "lrama/grammar/auxiliary"
require "lrama/grammar/binding"
require "lrama/grammar/code" require "lrama/grammar/code"
require "lrama/grammar/counter" require "lrama/grammar/counter"
require "lrama/grammar/error_token" require "lrama/grammar/error_token"
@ -8,9 +9,6 @@ require "lrama/grammar/printer"
require "lrama/grammar/reference" require "lrama/grammar/reference"
require "lrama/grammar/rule" require "lrama/grammar/rule"
require "lrama/grammar/rule_builder" require "lrama/grammar/rule_builder"
require "lrama/grammar/parameterizing_rule_builder"
require "lrama/grammar/parameterizing_rule_resolver"
require "lrama/grammar/parameterizing_rule_rhs_builder"
require "lrama/grammar/parameterizing_rule" require "lrama/grammar/parameterizing_rule"
require "lrama/grammar/symbol" require "lrama/grammar/symbol"
require "lrama/grammar/type" require "lrama/grammar/type"
@ -40,7 +38,7 @@ module Lrama
@rule_builders = [] @rule_builders = []
@rules = [] @rules = []
@sym_to_rules = {} @sym_to_rules = {}
@parameterizing_resolver = ParameterizingRuleResolver.new @parameterizing_rule_resolver = ParameterizingRule::Resolver.new
@empty_symbol = nil @empty_symbol = nil
@eof_symbol = nil @eof_symbol = nil
@error_symbol = nil @error_symbol = nil
@ -52,7 +50,7 @@ module Lrama
end end
def add_percent_code(id:, code:) def add_percent_code(id:, code:)
@percent_codes << PercentCode.new(id, code) @percent_codes << PercentCode.new(id.s_value, code.s_value)
end end
def add_printer(ident_or_tags:, token_code:, lineno:) def add_printer(ident_or_tags:, token_code:, lineno:)
@ -134,8 +132,8 @@ module Lrama
@rule_builders << builder @rule_builders << builder
end end
def add_parameterizing_rule_builder(builder) def add_parameterizing_rule(rule)
@parameterizing_resolver.add_parameterizing_rule_builder(builder) @parameterizing_rule_resolver.add_parameterizing_rule(rule)
end end
def prologue_first_lineno=(prologue_first_lineno) def prologue_first_lineno=(prologue_first_lineno)
@ -171,7 +169,7 @@ module Lrama
# TODO: More validation methods # TODO: More validation methods
# #
# * Validaiton for no_declared_type_reference # * Validation for no_declared_type_reference
def validate! def validate!
validate_symbol_number_uniqueness! validate_symbol_number_uniqueness!
validate_symbol_alias_name_uniqueness! validate_symbol_alias_name_uniqueness!
@ -319,7 +317,7 @@ module Lrama
def setup_rules def setup_rules
@rule_builders.each do |builder| @rule_builders.each do |builder|
builder.setup_rules(@parameterizing_resolver) builder.setup_rules(@parameterizing_rule_resolver)
end end
end end

24
tool/lrama/lib/lrama/grammar/binding.rb Normal file
View File

@ -0,0 +1,24 @@
module Lrama
class Grammar
class Binding
attr_reader :actual_args, :count
def initialize(parameterizing_rule, actual_args)
@parameters = parameterizing_rule.parameters
@actual_args = actual_args
@parameter_to_arg = @parameters.zip(actual_args).map do |param, arg|
[param.s_value, arg]
end.to_h
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)
else
@parameter_to_arg[symbol.s_value] || symbol
end
end
end
end
end

2
tool/lrama/lib/lrama/grammar/code/rule_action.rb
View File

@ -22,7 +22,7 @@ module Lrama
# For the semantic action of original rule: # For the semantic action of original rule:
# #
# "Rule" class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end } # "Rule" class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
# "Position in grammar" $1 $2 $3 $4 $5 $6 # "Position in grammar" $1 $2 $3 $4 $5
# "Index for yyvsp" -4 -3 -2 -1 0 # "Index for yyvsp" -4 -3 -2 -1 0
# #
# #

9
tool/lrama/lib/lrama/grammar/parameterizing_rule.rb
View File

@ -1,6 +1,3 @@
module Lrama require_relative 'parameterizing_rule/resolver'
class Grammar require_relative 'parameterizing_rule/rhs'
class ParameterizingRule < Struct.new(:rules, :token, keyword_init: true) require_relative 'parameterizing_rule/rule'
end
end
end

39
tool/lrama/lib/lrama/grammar/parameterizing_rule/resolver.rb Normal file
View File

@ -0,0 +1,39 @@
module Lrama
class Grammar
class ParameterizingRule
class Resolver
attr_accessor :created_lhs_list
def initialize
@rules = []
@created_lhs_list = []
end
def add_parameterizing_rule(rule)
@rules << rule
end
def defined?(token)
!select_rules(token).empty?
end
def find(token)
select_rules(token).last
end
def created_lhs(lhs_s_value)
@created_lhs_list.select { |created_lhs| created_lhs.s_value == lhs_s_value }.last
end
private
def select_rules(token)
@rules.select do |rule|
rule.name == token.rule_name &&
rule.required_parameters_count == token.args_count
end
end
end
end
end
end

15
tool/lrama/lib/lrama/grammar/parameterizing_rule/rhs.rb Normal file
View File

@ -0,0 +1,15 @@
module Lrama
class Grammar
class ParameterizingRule
class Rhs
attr_accessor :symbols, :user_code, :precedence_sym
def initialize
@symbols = []
@user_code = nil
@precedence_sym = nil
end
end
end
end
end

16
tool/lrama/lib/lrama/grammar/parameterizing_rule/rule.rb Normal file
View File

@ -0,0 +1,16 @@
module Lrama
class Grammar
class ParameterizingRule
class Rule
attr_reader :name, :parameters, :rhs_list, :required_parameters_count
def initialize(name, parameters, rhs_list)
@name = name
@parameters = parameters
@rhs_list = rhs_list
@required_parameters_count = parameters.count
end
end
end
end
end

34
tool/lrama/lib/lrama/grammar/parameterizing_rule_builder.rb
View File

@ -1,34 +0,0 @@
module Lrama
class Grammar
class ParameterizingRuleBuilder
attr_reader :name, :parameters, :rhs
def initialize(name, parameters, rhs)
@name = name
@parameters = parameters
@rhs = rhs
@required_parameters_count = parameters.count
end
def build_rules(token, actual_args, rule_counter, lhs_tag, line, rule_builders)
validate_argument_number!(token)
lhs = lhs(actual_args)
@rhs.map do |rhs|
rhs.build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
end.flatten
end
private
def validate_argument_number!(token)
unless @required_parameters_count == token.args.count
raise "Invalid number of arguments. expect: #{@required_parameters_count} actual: #{token.args.count}"
end
end
def lhs(actual_args)
Lrama::Lexer::Token::Ident.new(s_value: "#{name}_#{actual_args.map(&:s_value).join('_')}")
end
end
end
end

30
tool/lrama/lib/lrama/grammar/parameterizing_rule_resolver.rb
View File

@ -1,30 +0,0 @@
module Lrama
class Grammar
class ParameterizingRuleResolver
def initialize
@parameterizing_rule_builders = []
end
def add_parameterizing_rule_builder(builder)
@parameterizing_rule_builders << builder
end
def defined?(name)
!rule_builders(name).empty?
end
def build_rules(token, rule_counter, lhs_tag, line)
builder = rule_builders(token.s_value).last
raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
builder.build_rules(token, token.args, rule_counter, lhs_tag, line, @parameterizing_rule_builders)
end
private
def rule_builders(name)
@parameterizing_rule_builders.select { |builder| builder.name == name }
end
end
end
end

53
tool/lrama/lib/lrama/grammar/parameterizing_rule_rhs_builder.rb
View File

@ -1,53 +0,0 @@
module Lrama
class Grammar
class ParameterizingRuleRhsBuilder
attr_accessor :symbols, :user_code, :precedence_sym
def initialize
@symbols = []
@user_code = nil
@precedence_sym = nil
end
def build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
nested_rules = build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
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)
ParameterizingRule.new(rules: nested_rules.map(&:rules) + [rule], token: lhs)
end
private
def build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
symbols.each_with_index.map do |sym, i|
next unless sym.is_a?(Lexer::Token::InstantiateRule)
builder = rule_builders.select { |builder| builder.name == sym.s_value }.last
raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
builder.build_rules(sym, nested_actual_args(actual_args, parameters, i), rule_counter, lhs_tag, line, rule_builders)
end.flatten.compact
end
def nested_actual_args(actual_args, parameters, idx)
symbols[idx].args.map do |arg|
i = parameters.index { |parameter| parameter.s_value == arg.s_value }
i.nil? ? arg : actual_args[i]
end
end
def rhs(token, actual_args, parameters, nested_rule)
symbols.map do |sym|
if sym.is_a?(Lexer::Token::InstantiateRule)
sym.args.map do |arg|
idx = parameters.index { |parameter| parameter.s_value == arg.s_value }
idx.nil? ? sym : nested_rule&.token
end
else
idx = parameters.index { |parameter| parameter.s_value == sym.s_value }
idx.nil? ? sym : actual_args[idx]
end
end.flatten
end
end
end
end

6
tool/lrama/lib/lrama/grammar/percent_code.rb
View File

@ -1,10 +1,10 @@
module Lrama module Lrama
class Grammar class Grammar
class PercentCode class PercentCode
attr_reader :id, :code attr_reader :name, :code
def initialize(id, code) def initialize(name, code)
@id = id @name = name
@code = code @code = code
end end
end end

84
tool/lrama/lib/lrama/grammar/rule_builder.rb
View File

@ -3,21 +3,22 @@ require 'lrama/grammar/parameterizing_rules/builder'
module Lrama module Lrama
class Grammar class Grammar
class RuleBuilder class RuleBuilder
attr_accessor :lhs, :lhs_tag, :line attr_accessor :lhs, :line
attr_reader :rhs, :user_code, :precedence_sym attr_reader :lhs_tag, :rhs, :user_code, :precedence_sym
def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, skip_preprocess_references: false) def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, lhs_tag: nil, skip_preprocess_references: false)
@rule_counter = rule_counter @rule_counter = rule_counter
@midrule_action_counter = midrule_action_counter @midrule_action_counter = midrule_action_counter
@position_in_original_rule_rhs = position_in_original_rule_rhs @position_in_original_rule_rhs = position_in_original_rule_rhs
@skip_preprocess_references = skip_preprocess_references @skip_preprocess_references = skip_preprocess_references
@lhs = nil @lhs = nil
@lhs_tag = lhs_tag
@rhs = [] @rhs = []
@lhs_tag = nil
@user_code = nil @user_code = nil
@precedence_sym = nil @precedence_sym = nil
@line = nil @line = nil
@rule_builders_for_parameterizing_rules = []
@rule_builders_for_derived_rules = [] @rule_builders_for_derived_rules = []
end end
@ -33,7 +34,7 @@ module Lrama
def user_code=(user_code) def user_code=(user_code)
if !@line if !@line
@line = user_code.line @line = user_code&.line
end end
flush_user_code flush_user_code
@ -51,14 +52,14 @@ module Lrama
freeze_rhs freeze_rhs
end end
def setup_rules(parameterizing_resolver) def setup_rules(parameterizing_rule_resolver)
preprocess_references unless @skip_preprocess_references preprocess_references unless @skip_preprocess_references
process_rhs(parameterizing_resolver) process_rhs(parameterizing_rule_resolver)
build_rules build_rules
end end
def rules def rules
@parameterizing_rules + @midrule_action_rules + @rules @parameterizing_rules + @old_parameterizing_rules + @midrule_action_rules + @rules
end end
private private
@ -75,10 +76,13 @@ module Lrama
tokens = @replaced_rhs tokens = @replaced_rhs
rule = Rule.new( rule = Rule.new(
id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, token_code: user_code, id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, lhs_tag: lhs_tag, token_code: user_code,
position_in_original_rule_rhs: @position_in_original_rule_rhs, precedence_sym: precedence_sym, lineno: line position_in_original_rule_rhs: @position_in_original_rule_rhs, precedence_sym: precedence_sym, lineno: line
) )
@rules = [rule] @rules = [rule]
@parameterizing_rules = @rule_builders_for_parameterizing_rules.map do |rule_builder|
rule_builder.rules
end.flatten
@midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder| @midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder|
rule_builder.rules rule_builder.rules
end.flatten end.flatten
@ -89,11 +93,11 @@ module Lrama
# rhs is a mixture of variety type of tokens like `Ident`, `InstantiateRule`, `UserCode` and so on. # rhs is a mixture of variety type of tokens like `Ident`, `InstantiateRule`, `UserCode` and so on.
# `#process_rhs` replaces some kind of tokens to `Ident` so that all `@replaced_rhs` are `Ident` or `Char`. # `#process_rhs` replaces some kind of tokens to `Ident` so that all `@replaced_rhs` are `Ident` or `Char`.
def process_rhs(parameterizing_resolver) def process_rhs(parameterizing_rule_resolver)
return if @replaced_rhs return if @replaced_rhs
@replaced_rhs = [] @replaced_rhs = []
@parameterizing_rules = [] @old_parameterizing_rules = []
rhs.each_with_index do |token, i| rhs.each_with_index do |token, i|
case token case token
@ -102,26 +106,46 @@ module Lrama
when Lrama::Lexer::Token::Ident when Lrama::Lexer::Token::Ident
@replaced_rhs << token @replaced_rhs << token
when Lrama::Lexer::Token::InstantiateRule when Lrama::Lexer::Token::InstantiateRule
if parameterizing_resolver.defined?(token.rule_name) if parameterizing_rule_resolver.defined?(token)
parameterizing = parameterizing_resolver.build_rules(token, @rule_counter, @lhs_tag, line) parameterizing_rule = parameterizing_rule_resolver.find(token)
@parameterizing_rules = @parameterizing_rules + parameterizing.map(&:rules).flatten raise "Unexpected token. #{token}" unless parameterizing_rule
@replaced_rhs = @replaced_rhs + parameterizing.map(&:token).flatten.uniq
bindings = Binding.new(parameterizing_rule, token.args)
lhs_s_value = lhs_s_value(token, bindings)
if (created_lhs = parameterizing_rule_resolver.created_lhs(lhs_s_value))
@replaced_rhs << created_lhs
else
lhs_token = Lrama::Lexer::Token::Ident.new(s_value: lhs_s_value, location: token.location)
@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.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.complete_input
rule_builder.setup_rules(parameterizing_rule_resolver)
@rule_builders_for_parameterizing_rules << rule_builder
end
end
else else
# TODO: Delete when the standard library will defined as a grammar file. # TODO: Delete when the standard library will defined as a grammar file.
parameterizing = ParameterizingRules::Builder.new(token, @rule_counter, @lhs_tag, user_code, precedence_sym, line) parameterizing_rule = ParameterizingRules::Builder.new(token, @rule_counter, token.lhs_tag, user_code, precedence_sym, line)
@parameterizing_rules = @parameterizing_rules + parameterizing.build @old_parameterizing_rules = @old_parameterizing_rules + parameterizing_rule.build
@replaced_rhs << parameterizing.build_token @replaced_rhs << parameterizing_rule.build_token
end end
when Lrama::Lexer::Token::UserCode when Lrama::Lexer::Token::UserCode
prefix = token.referred ? "@" : "$@" prefix = token.referred ? "@" : "$@"
new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s) new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)
@replaced_rhs << new_token @replaced_rhs << new_token
rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, skip_preprocess_references: true) rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, lhs_tag: lhs_tag, skip_preprocess_references: true)
rule_builder.lhs = new_token rule_builder.lhs = new_token
rule_builder.user_code = token rule_builder.user_code = token
rule_builder.complete_input rule_builder.complete_input
rule_builder.setup_rules(parameterizing_resolver) rule_builder.setup_rules(parameterizing_rule_resolver)
@rule_builders_for_derived_rules << rule_builder @rule_builders_for_derived_rules << rule_builder
else else
@ -130,6 +154,18 @@ module Lrama
end end
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 numberize_references def numberize_references
# Bison n'th component is 1-origin # Bison n'th component is 1-origin
(rhs + [user_code]).compact.each.with_index(1) do |token, i| (rhs + [user_code]).compact.each.with_index(1) do |token, i|
@ -144,13 +180,11 @@ module Lrama
candidates = rhs.each_with_index.select {|token, i| token.referred_by?(ref_name) } candidates = rhs.each_with_index.select {|token, i| token.referred_by?(ref_name) }
if candidates.size >= 2 if candidates.size >= 2
location = token.location.partial_location(ref.first_column, ref.last_column) token.invalid_ref(ref, "Referring symbol `#{ref_name}` is duplicated.")
raise location.generate_error_message("Referring symbol `#{ref_name}` is duplicated.")
end end
unless (referring_symbol = candidates.first) unless (referring_symbol = candidates.first)
location = token.location.partial_location(ref.first_column, ref.last_column) token.invalid_ref(ref, "Referring symbol `#{ref_name}` is not found.")
raise location.generate_error_message("Referring symbol `#{ref_name}` is not found.")
end end
ref.index = referring_symbol[1] + 1 ref.index = referring_symbol[1] + 1
@ -163,7 +197,7 @@ module Lrama
if ref.index if ref.index
# TODO: Prohibit $0 even so Bison allows it? # TODO: Prohibit $0 even so Bison allows it?
# See: https://www.gnu.org/software/bison/manual/html_node/Actions.html # See: https://www.gnu.org/software/bison/manual/html_node/Actions.html
raise "Can not refer following component. #{ref.index} >= #{i}. #{token}" if ref.index >= i token.invalid_ref(ref, "Can not refer following component. #{ref.index} >= #{i}.") if ref.index >= i
rhs[ref.index - 1].referred = true rhs[ref.index - 1].referred = true
end end
end end

14
tool/lrama/lib/lrama/grammar/type.rb
View File

@ -1,6 +1,18 @@
module Lrama module Lrama
class Grammar class Grammar
class Type < Struct.new(:id, :tag, keyword_init: true) class Type
attr_reader :id, :tag
def initialize(id:, tag:)
@id = id
@tag = tag
end
def ==(other)
self.class == other.class &&
self.id == other.id &&
self.tag == other.tag
end
end end
end end
end end

9
tool/lrama/lib/lrama/lexer.rb
View File

@ -5,9 +5,8 @@ require "lrama/lexer/token"
module Lrama module Lrama
class Lexer class Lexer
attr_reader :head_line, :head_column attr_reader :head_line, :head_column, :line
attr_accessor :status attr_accessor :status, :end_symbol
attr_accessor :end_symbol
SYMBOLS = ['%{', '%}', '%%', '{', '}', '\[', '\]', '\(', '\)', '\,', ':', '\|', ';'] SYMBOLS = ['%{', '%}', '%%', '{', '}', '\[', '\]', '\(', '\)', '\,', ':', '\|', ';']
PERCENT_TOKENS = %w( PERCENT_TOKENS = %w(
@ -50,10 +49,6 @@ module Lrama
end end
end end
def line
@line
end
def column def column
@scanner.pos - @head @scanner.pos - @head
end end

2
tool/lrama/lib/lrama/lexer/grammar_file.rb
View File

@ -5,7 +5,7 @@ module Lrama
def initialize(path, text) def initialize(path, text)
@path = path @path = path
@text = text @text = text.freeze
end end
def ==(other) def ==(other)

5
tool/lrama/lib/lrama/lexer/token.rb
View File

@ -46,6 +46,11 @@ module Lrama
def last_column def last_column
location.last_column location.last_column
end end
def invalid_ref(ref, message)
location = self.location.partial_location(ref.first_column, ref.last_column)
raise location.generate_error_message(message)
end
end end
end end
end end

9
tool/lrama/lib/lrama/lexer/token/instantiate_rule.rb
View File

@ -2,16 +2,21 @@ module Lrama
class Lexer class Lexer
class Token class Token
class InstantiateRule < Token class InstantiateRule < Token
attr_accessor :args attr_reader :args, :lhs_tag
def initialize(s_value:, alias_name: nil, location: nil, args: []) def initialize(s_value:, alias_name: nil, location: nil, args: [], lhs_tag: nil)
super s_value: s_value, alias_name: alias_name, location: location super s_value: s_value, alias_name: alias_name, location: location
@args = args @args = args
@lhs_tag = lhs_tag
end end
def rule_name def rule_name
s_value s_value
end end
def args_count
args.count
end
end end
end end
end end

4
tool/lrama/lib/lrama/output.rb
View File

@ -352,9 +352,9 @@ module Lrama
# b4_percent_code_get # b4_percent_code_get
def percent_code(name) def percent_code(name)
@grammar.percent_codes.select do |percent_code| @grammar.percent_codes.select do |percent_code|
percent_code.id.s_value == name percent_code.name == name
end.map do |percent_code| end.map do |percent_code|
percent_code.code.s_value percent_code.code
end.join end.join
end end

314
tool/lrama/lib/lrama/parser.rb
View File

@ -734,11 +734,11 @@ end
##### State transition tables begin ### ##### State transition tables begin ###
racc_action_table = [ racc_action_table = [
85, 44, 86, 145, 144, 67, 44, 44, 145, 187, 85, 44, 86, 145, 144, 67, 44, 44, 145, 188,
67, 67, 44, 6, 187, 7, 67, 147, 196, 44, 67, 67, 44, 6, 188, 7, 67, 147, 199, 44,
143, 43, 147, 188, 58, 163, 164, 165, 188, 3, 143, 43, 147, 189, 58, 163, 164, 165, 189, 3,
44, 40, 43, 8, 67, 63, 34, 44, 148, 43, 44, 40, 43, 8, 67, 63, 34, 44, 148, 43,
41, 87, 40, 148, 189, 47, 44, 80, 43, 189, 41, 87, 40, 148, 190, 47, 44, 80, 43, 190,
21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 21, 23, 24, 25, 26, 27, 28, 29, 30, 31,
47, 21, 23, 24, 25, 26, 27, 28, 29, 30, 47, 21, 23, 24, 25, 26, 27, 28, 29, 30,
31, 9, 44, 47, 43, 13, 14, 15, 16, 17, 31, 9, 44, 47, 43, 13, 14, 15, 16, 17,
@ -750,22 +750,23 @@ racc_action_table = [
43, 43, 67, 173, 44, 44, 43, 43, 67, 173, 43, 43, 67, 173, 44, 44, 43, 43, 67, 173,
44, 44, 43, 43, 67, 173, 44, 44, 43, 43, 44, 44, 43, 43, 67, 173, 44, 44, 43, 43,
67, 67, 44, 44, 43, 43, 67, 67, 44, 44, 67, 67, 44, 44, 43, 43, 67, 67, 44, 44,
43, 43, 67, 67, 44, 44, 43, 43, 67, 67, 43, 43, 67, 67, 44, 44, 179, 43, 67, 67,
44, 44, 43, 43, 67, 67, 163, 164, 165, 83, 44, 44, 179, 43, 67, 67, 44, 44, 179, 43,
44, 44, 43, 43, 141, 190, 142, 191, 205, 54, 67, 163, 164, 165, 83, 44, 141, 43, 142, 192,
191, 55, 76, 77, 81, 83, 88, 88, 88, 90, 54, 193, 163, 164, 165, 208, 210, 193, 193, 55,
96, 100, 101, 104, 104, 104, 104, 107, 110, 111, 76, 77, 81, 83, 88, 88, 88, 90, 96, 100,
113, 115, 116, 117, 118, 119, 122, 126, 127, 128, 101, 104, 104, 104, 104, 107, 110, 111, 113, 115,
131, 132, 133, 135, 150, 152, 153, 154, 155, 156, 116, 117, 118, 119, 122, 126, 127, 128, 131, 132,
157, 158, 131, 160, 168, 169, 178, 182, 183, 185, 133, 135, 150, 152, 153, 154, 155, 156, 157, 158,
178, 83, 182, 201, 203, 83, 207, 83 ] 131, 160, 168, 169, 178, 183, 184, 186, 191, 178,
83, 183, 205, 207, 83, 212, 83 ]
racc_action_check = [ racc_action_check = [
42, 130, 42, 130, 129, 130, 159, 177, 159, 177, 42, 130, 42, 130, 129, 130, 159, 177, 159, 177,
159, 177, 193, 2, 193, 2, 193, 130, 187, 26, 159, 177, 196, 2, 196, 2, 196, 130, 188, 26,
129, 26, 159, 177, 26, 187, 187, 187, 193, 1, 129, 26, 159, 177, 26, 188, 188, 188, 196, 1,
27, 9, 27, 3, 27, 27, 7, 14, 130, 14, 27, 9, 27, 3, 27, 27, 7, 14, 130, 14,
13, 42, 35, 159, 177, 15, 57, 35, 57, 193, 13, 42, 35, 159, 177, 15, 57, 35, 57, 196,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
16, 35, 35, 35, 35, 35, 35, 35, 35, 35, 16, 35, 35, 35, 35, 35, 35, 35, 35, 35,
35, 4, 58, 17, 58, 4, 4, 4, 4, 4, 35, 4, 58, 17, 58, 4, 4, 4, 4, 4,
@ -777,110 +778,113 @@ racc_action_check = [
170, 98, 170, 170, 174, 104, 174, 104, 174, 174, 170, 98, 170, 170, 174, 104, 174, 104, 174, 174,
175, 106, 175, 106, 175, 175, 62, 63, 62, 63, 175, 106, 175, 106, 175, 175, 62, 63, 62, 63,
62, 63, 101, 103, 101, 103, 101, 103, 123, 148, 62, 63, 101, 103, 101, 103, 101, 103, 123, 148,
123, 148, 123, 148, 160, 189, 160, 189, 160, 189, 123, 148, 123, 148, 160, 190, 160, 190, 160, 190,
191, 196, 191, 196, 191, 196, 146, 146, 146, 146, 191, 193, 191, 193, 191, 193, 199, 120, 199, 120,
120, 124, 120, 124, 125, 179, 125, 179, 202, 24, 199, 146, 146, 146, 146, 124, 125, 124, 125, 180,
202, 25, 32, 33, 38, 39, 46, 48, 49, 50, 24, 180, 181, 181, 181, 202, 206, 202, 206, 25,
56, 60, 61, 68, 73, 74, 75, 76, 82, 83, 32, 33, 38, 39, 46, 48, 49, 50, 56, 60,
89, 91, 92, 93, 94, 95, 99, 107, 108, 109, 61, 68, 73, 74, 75, 76, 82, 83, 89, 91,
110, 111, 112, 114, 134, 136, 137, 138, 139, 140, 92, 93, 94, 95, 99, 107, 108, 109, 110, 111,
141, 142, 143, 145, 149, 151, 157, 162, 166, 176, 112, 114, 134, 136, 137, 138, 139, 140, 141, 142,
185, 186, 190, 192, 197, 201, 206, 207 ] 143, 145, 149, 151, 157, 162, 166, 176, 179, 186,
187, 192, 195, 200, 205, 211, 212 ]
racc_action_pointer = [ racc_action_pointer = [
nil, 29, 3, 33, 62, nil, nil, 29, nil, 27, nil, 29, 3, 33, 62, nil, nil, 29, nil, 27,
nil, nil, nil, 34, 34, 26, 41, 54, 76, 63, nil, nil, nil, 34, 34, 26, 41, 54, 76, 63,
nil, 81, nil, 88, 170, 172, 16, 27, 93, 94, nil, 81, nil, 88, 171, 180, 16, 27, 93, 94,
100, 101, 187, 191, nil, 38, nil, nil, 172, 151, 100, 101, 195, 199, nil, 38, nil, nil, 180, 159,
nil, nil, -5, nil, nil, nil, 177, nil, 178, 179, nil, nil, -5, nil, nil, nil, 185, nil, 186, 187,
180, nil, nil, nil, nil, nil, 192, 43, 69, nil, 188, nil, nil, nil, nil, nil, 200, 43, 69, nil,
195, 194, 143, 144, nil, nil, nil, nil, 195, 108, 203, 202, 143, 144, nil, nil, nil, nil, 203, 108,
114, nil, nil, 196, 197, 198, 173, nil, nil, nil, 114, nil, nil, 204, 205, 206, 181, nil, nil, nil,
nil, nil, 172, 204, nil, nil, nil, nil, nil, 208, nil, nil, 180, 212, nil, nil, nil, nil, nil, 216,
nil, 209, 210, 211, 212, 213, 120, nil, 126, 209, nil, 217, 218, 219, 220, 221, 120, nil, 126, 217,
nil, 149, nil, 150, 132, nil, 138, 212, 207, 217, nil, 149, nil, 150, 132, nil, 138, 220, 215, 225,
181, 176, 220, nil, 221, nil, nil, nil, nil, nil, 189, 184, 228, nil, 229, nil, nil, nil, nil, nil,
177, nil, nil, 155, 178, 149, nil, nil, nil, -18, 174, nil, nil, 155, 182, 151, nil, nil, nil, -18,
-2, nil, nil, nil, 204, nil, 205, 206, 207, 208, -2, nil, nil, nil, 212, nil, 213, 214, 215, 216,
209, 194, 226, 193, nil, 199, 135, nil, 156, 214, 217, 202, 234, 201, nil, 207, 140, nil, 156, 222,
nil, 215, nil, nil, 107, 113, 119, 197, nil, 3, nil, 223, nil, nil, 107, 113, 119, 205, nil, 3,
161, nil, 229, nil, nil, nil, 236, nil, nil, nil, 161, nil, 237, nil, nil, nil, 244, nil, nil, nil,
125, nil, nil, nil, 131, 137, 201, 4, nil, 150, 125, nil, nil, nil, 131, 137, 209, 4, nil, 214,
nil, nil, nil, nil, nil, 201, 197, -16, nil, 162, 154, 151, nil, nil, nil, nil, 210, 206, -16, nil,
234, 167, 223, 9, nil, nil, 168, 242, nil, nil, 162, 167, 243, 168, nil, 232, 9, nil, nil, 173,
nil, 201, 153, nil, nil, nil, 226, 203, nil ] 251, nil, 160, nil, nil, 210, 161, nil, nil, nil,
nil, 235, 212, nil ]
racc_action_default = [ racc_action_default = [
-2, -128, -8, -128, -128, -3, -4, -128, 209, -128, -2, -130, -8, -130, -130, -3, -4, -130, 214, -130,
-9, -10, -11, -128, -128, -128, -128, -128, -128, -128, -9, -10, -11, -130, -130, -130, -130, -130, -130, -130,
-23, -128, -27, -128, -128, -128, -128, -128, -128, -128, -23, -130, -27, -130, -130, -130, -130, -130, -130, -130,
-128, -128, -128, -128, -7, -113, -88, -90, -128, -110, -130, -130, -130, -130, -7, -115, -88, -90, -130, -112,
-112, -12, -117, -86, -87, -116, -14, -77, -15, -16, -114, -12, -119, -86, -87, -118, -14, -77, -15, -16,
-128, -20, -24, -28, -31, -34, -37, -43, -128, -46, -130, -20, -24, -28, -31, -34, -37, -43, -130, -46,
-63, -38, -67, -128, -70, -72, -73, -125, -39, -80, -63, -38, -67, -130, -70, -72, -73, -127, -39, -80,
-128, -83, -85, -40, -41, -42, -128, -5, -1, -89, -130, -83, -85, -40, -41, -42, -130, -5, -1, -89,
-114, -91, -128, -128, -13, -118, -119, -120, -74, -128, -116, -91, -130, -130, -13, -120, -121, -122, -74, -130,
-17, -128, -128, -128, -128, -128, -128, -47, -44, -65, -17, -130, -130, -130, -130, -130, -130, -47, -44, -65,
-64, -128, -71, -68, -128, -84, -81, -128, -128, -128, -64, -130, -71, -68, -130, -84, -81, -130, -130, -130,
-96, -128, -128, -78, -128, -21, -25, -29, -32, -35, -96, -130, -130, -78, -130, -21, -25, -29, -32, -35,
-45, -48, -66, -69, -82, -128, -50, -6, -115, -92, -45, -48, -66, -69, -82, -130, -50, -6, -117, -92,
-93, -97, -111, -75, -128, -18, -128, -128, -128, -128, -93, -97, -113, -75, -130, -18, -130, -130, -130, -130,
-128, -128, -128, -96, -95, -86, -110, -101, -128, -128, -130, -130, -130, -96, -95, -86, -112, -101, -130, -130,
-79, -128, -22, -26, -128, -128, -128, -54, -51, -94, -79, -130, -22, -26, -130, -130, -130, -54, -51, -94,
-128, -98, -126, -105, -106, -107, -128, -104, -76, -19, -130, -98, -128, -105, -106, -107, -130, -104, -76, -19,
-30, -121, -123, -124, -33, -36, -49, -52, -55, -128, -30, -123, -125, -126, -33, -36, -49, -52, -55, -86,
-108, -99, -127, -102, -122, -54, -110, -86, -59, -128, -130, -108, -99, -129, -102, -124, -54, -112, -86, -59,
-126, -128, -128, -53, -56, -57, -128, -128, -62, -100, -130, -130, -128, -130, -110, -130, -53, -56, -57, -130,
-109, -110, -128, -60, -103, -58, -128, -110, -61 ] -130, -62, -130, -100, -109, -112, -130, -60, -111, -103,
-58, -130, -112, -61 ]
racc_goto_table = [ racc_goto_table = [
64, 45, 57, 62, 105, 82, 97, 162, 106, 177, 82, 62, 57, 45, 97, 64, 105, 162, 182, 36,
179, 1, 181, 60, 2, 72, 72, 72, 72, 130, 177, 1, 2, 180, 106, 60, 4, 72, 72, 72,
184, 4, 35, 36, 184, 184, 68, 73, 74, 75, 72, 130, 185, 46, 48, 49, 185, 185, 68, 73,
46, 48, 49, 78, 98, 102, 64, 193, 5, 103, 74, 75, 35, 78, 98, 79, 5, 103, 203, 196,
199, 105, 124, 33, 60, 60, 202, 97, 195, 79, 102, 64, 194, 105, 202, 97, 60, 60, 124, 198,
108, 10, 159, 170, 174, 175, 72, 72, 11, 105, 33, 108, 206, 10, 159, 170, 174, 175, 72, 72,
12, 42, 84, 114, 151, 91, 136, 92, 137, 97, 11, 105, 12, 42, 84, 114, 151, 97, 91, 136,
93, 138, 120, 94, 64, 139, 102, 123, 95, 140, 92, 137, 120, 93, 138, 123, 94, 139, 95, 64,
56, 61, 99, 60, 121, 60, 125, 176, 197, 206, 140, 102, 56, 61, 99, 60, 121, 60, 125, 176,
112, 72, 149, 72, 89, 134, 102, 129, 166, 192, 200, 211, 112, 72, 149, 72, 89, 134, 129, 166,
109, nil, nil, 146, nil, nil, nil, 60, nil, nil, 195, 102, 109, nil, nil, nil, nil, 161, 146, 60,
nil, 72, 161, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 72, nil, nil, nil, nil, nil, nil,
nil, 167, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 167, nil, nil, nil,
nil, nil, 146, 180, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 146, 181, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 197, nil,
186, nil, 194, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 187, nil, nil, nil, nil,
nil, nil, 198, nil, 200, nil, 186, 204, nil, 180, nil, nil, nil, nil, nil, nil, 209, nil, 201, 181,
nil, nil, nil, 208 ] nil, 204, nil, 213, 187, nil, nil, 181 ]
racc_goto_check = [ racc_goto_check = [
40, 34, 32, 46, 53, 41, 33, 42, 52, 39, 41, 46, 32, 34, 33, 40, 53, 42, 59, 54,
43, 1, 59, 34, 2, 34, 34, 34, 34, 58, 39, 1, 2, 43, 52, 34, 3, 34, 34, 34,
63, 3, 4, 54, 63, 63, 31, 31, 31, 31, 34, 58, 63, 14, 14, 14, 63, 63, 31, 31,
14, 14, 14, 5, 32, 40, 40, 39, 6, 46, 31, 31, 4, 5, 32, 54, 6, 46, 59, 39,
59, 53, 52, 7, 34, 34, 43, 33, 42, 54, 40, 40, 42, 53, 43, 33, 34, 34, 52, 42,
8, 9, 58, 20, 20, 20, 34, 34, 10, 53, 7, 8, 43, 9, 58, 20, 20, 20, 34, 34,
11, 12, 13, 15, 16, 17, 18, 21, 22, 33, 10, 53, 11, 12, 13, 15, 16, 33, 17, 18,
23, 24, 32, 25, 40, 26, 40, 46, 27, 28, 21, 22, 32, 23, 24, 46, 25, 26, 27, 40,
29, 30, 35, 34, 36, 34, 37, 38, 44, 45, 28, 40, 29, 30, 35, 34, 36, 34, 37, 38,
48, 34, 49, 34, 50, 51, 40, 57, 60, 61, 44, 45, 48, 34, 49, 34, 50, 51, 57, 60,
62, nil, nil, 40, nil, nil, nil, 34, nil, nil, 61, 40, 62, nil, nil, nil, nil, 41, 40, 34,
nil, 34, 41, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 34, nil, nil, nil, nil, nil, nil,
nil, 40, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 40, nil, nil, nil,
nil, nil, 40, 40, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 40, 40, nil,
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 41, nil,
40, nil, 41, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 40, nil, nil, nil, nil,
nil, nil, 40, nil, 40, nil, 40, 41, nil, 40, nil, nil, nil, nil, nil, nil, 41, nil, 40, 40,
nil, nil, nil, 41 ] nil, 40, nil, 41, 40, nil, nil, 40 ]
racc_goto_pointer = [ racc_goto_pointer = [
nil, 11, 14, 19, 13, -2, 36, 37, -27, 47, nil, 11, 12, 14, 23, -2, 34, 44, -26, 49,
54, 56, 47, 20, 15, -27, -71, 14, -49, nil, 56, 58, 49, 22, 8, -25, -69, 17, -46, nil,
-101, 15, -48, 17, -46, 19, -43, 23, -40, 54, -99, 18, -45, 20, -43, 22, -41, 23, -39, 56,
54, -2, -24, -51, -13, 22, -15, -21, -70, -148, 56, 0, -24, -53, -11, 24, -13, -19, -68, -147,
-27, -34, -139, -150, -100, -114, -24, nil, 2, -41, -22, -39, -139, -147, -99, -116, -26, nil, 4, -39,
47, -18, -62, -65, 14, nil, nil, -13, -91, -150, 49, -16, -56, -63, 0, nil, nil, -12, -89, -154,
-49, -84, 20, -150 ] -48, -84, 22, -148 ]
racc_goto_default = [ racc_goto_default = [
nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
@ -1002,28 +1006,30 @@ racc_reduce_table = [
1, 89, :_reduce_none, 1, 89, :_reduce_none,
1, 90, :_reduce_108, 1, 90, :_reduce_108,
3, 90, :_reduce_109, 3, 90, :_reduce_109,
2, 90, :_reduce_110,
4, 90, :_reduce_111,
0, 88, :_reduce_none, 0, 88, :_reduce_none,
3, 88, :_reduce_111, 3, 88, :_reduce_113,
1, 103, :_reduce_none, 1, 103, :_reduce_none,
0, 52, :_reduce_none, 0, 52, :_reduce_none,
0, 109, :_reduce_114, 0, 109, :_reduce_116,
3, 52, :_reduce_115, 3, 52, :_reduce_117,
1, 59, :_reduce_none, 1, 59, :_reduce_none,
0, 60, :_reduce_none, 0, 60, :_reduce_none,
1, 60, :_reduce_none, 1, 60, :_reduce_none,
1, 60, :_reduce_none, 1, 60, :_reduce_none,
1, 60, :_reduce_none, 1, 60, :_reduce_none,
1, 67, :_reduce_121, 1, 67, :_reduce_123,
2, 67, :_reduce_122, 2, 67, :_reduce_124,
1, 110, :_reduce_none, 1, 110, :_reduce_none,
1, 110, :_reduce_none, 1, 110, :_reduce_none,
1, 94, :_reduce_125, 1, 94, :_reduce_127,
0, 106, :_reduce_none, 0, 106, :_reduce_none,
1, 106, :_reduce_none ] 1, 106, :_reduce_none ]
racc_reduce_n = 128 racc_reduce_n = 130
racc_shift_n = 209 racc_shift_n = 214
racc_token_table = { racc_token_table = {
false => 0, false => 0,
@ -1568,8 +1574,8 @@ module_eval(<<'.,.,', 'parser.y', 203)
module_eval(<<'.,.,', 'parser.y', 207) module_eval(<<'.,.,', 'parser.y', 207)
def _reduce_49(val, _values, result) def _reduce_49(val, _values, result)
builder = Grammar::ParameterizingRuleBuilder.new(val[1].s_value, val[3], val[6]) rule = Grammar::ParameterizingRule::Rule.new(val[1].s_value, val[3], val[6])
@grammar.add_parameterizing_rule_builder(builder) @grammar.add_parameterizing_rule(rule)
result result
end end
@ -1610,7 +1616,7 @@ module_eval(<<'.,.,', 'parser.y', 221)
module_eval(<<'.,.,', 'parser.y', 227) module_eval(<<'.,.,', 'parser.y', 227)
def _reduce_54(val, _values, result) def _reduce_54(val, _values, result)
reset_precs reset_precs
result = Grammar::ParameterizingRuleRhsBuilder.new result = Grammar::ParameterizingRule::Rhs.new
result result
end end
@ -1619,7 +1625,7 @@ module_eval(<<'.,.,', 'parser.y', 227)
module_eval(<<'.,.,', 'parser.y', 232) module_eval(<<'.,.,', 'parser.y', 232)
def _reduce_55(val, _values, result) def _reduce_55(val, _values, result)
reset_precs reset_precs
result = Grammar::ParameterizingRuleRhsBuilder.new result = Grammar::ParameterizingRule::Rhs.new
result result
end end
@ -1933,10 +1939,9 @@ module_eval(<<'.,.,', 'parser.y', 402)
module_eval(<<'.,.,', 'parser.y', 410) module_eval(<<'.,.,', 'parser.y', 410)
def _reduce_99(val, _values, result) def _reduce_99(val, _values, result)
token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]]) token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]], lhs_tag: val[3])
builder = val[0] builder = val[0]
builder.add_rhs(token) builder.add_rhs(token)
builder.lhs_tag = val[3]
builder.line = val[1].first_line builder.line = val[1].first_line
result = builder result = builder
@ -1944,12 +1949,11 @@ module_eval(<<'.,.,', 'parser.y', 410)
end end
.,., .,.,
module_eval(<<'.,.,', 'parser.y', 419) module_eval(<<'.,.,', 'parser.y', 418)
def _reduce_100(val, _values, result) def _reduce_100(val, _values, result)
token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3]) token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
builder = val[0] builder = val[0]
builder.add_rhs(token) builder.add_rhs(token)
builder.lhs_tag = val[5]
builder.line = val[1].first_line builder.line = val[1].first_line
result = builder result = builder
@ -1957,7 +1961,7 @@ module_eval(<<'.,.,', 'parser.y', 419)
end end
.,., .,.,
module_eval(<<'.,.,', 'parser.y', 428) module_eval(<<'.,.,', 'parser.y', 426)
def _reduce_101(val, _values, result) def _reduce_101(val, _values, result)
if @prec_seen if @prec_seen
on_action_error("multiple User_code after %prec", val[0]) if @code_after_prec on_action_error("multiple User_code after %prec", val[0]) if @code_after_prec
@ -1969,7 +1973,7 @@ module_eval(<<'.,.,', 'parser.y', 428)
end end
.,., .,.,
module_eval(<<'.,.,', 'parser.y', 436) module_eval(<<'.,.,', 'parser.y', 434)
def _reduce_102(val, _values, result) def _reduce_102(val, _values, result)
end_c_declaration end_c_declaration
@ -1977,7 +1981,7 @@ module_eval(<<'.,.,', 'parser.y', 436)
end end
.,., .,.,
module_eval(<<'.,.,', 'parser.y', 440) module_eval(<<'.,.,', 'parser.y', 438)
def _reduce_103(val, _values, result) def _reduce_103(val, _values, result)
user_code = val[3] user_code = val[3]
user_code.alias_name = val[6] user_code.alias_name = val[6]
@ -1989,7 +1993,7 @@ module_eval(<<'.,.,', 'parser.y', 440)
end end
.,., .,.,
module_eval(<<'.,.,', 'parser.y', 448) module_eval(<<'.,.,', 'parser.y', 446)
def _reduce_104(val, _values, result) def _reduce_104(val, _values, result)
sym = @grammar.find_symbol_by_id!(val[2]) sym = @grammar.find_symbol_by_id!(val[2])
@prec_seen = true @prec_seen = true
@ -2007,35 +2011,49 @@ module_eval(<<'.,.,', 'parser.y', 448)
# reduce 107 omitted # reduce 107 omitted
module_eval(<<'.,.,', 'parser.y', 459) module_eval(<<'.,.,', 'parser.y', 457)
def _reduce_108(val, _values, result) def _reduce_108(val, _values, result)
result = [val[0]] result = [val[0]]
result result
end end
.,., .,.,
module_eval(<<'.,.,', 'parser.y', 460) module_eval(<<'.,.,', 'parser.y', 458)
def _reduce_109(val, _values, result) def _reduce_109(val, _values, result)
result = val[0].append(val[2]) result = val[0].append(val[2])
result result
end end
.,., .,.,
# reduce 110 omitted module_eval(<<'.,.,', 'parser.y', 459)
def _reduce_110(val, _values, result)
result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[0])]
result
end
.,.,
module_eval(<<'.,.,', 'parser.y', 463) module_eval(<<'.,.,', 'parser.y', 460)
def _reduce_111(val, _values, result) def _reduce_111(val, _values, result)
result = val[1].s_value result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[0].s_value, location: @lexer.location, args: val[2])]
result result
end end
.,., .,.,
# reduce 112 omitted # reduce 112 omitted
# reduce 113 omitted module_eval(<<'.,.,', 'parser.y', 463)
def _reduce_113(val, _values, result)
result = val[1].s_value
result
end
.,.,
# reduce 114 omitted
# reduce 115 omitted
module_eval(<<'.,.,', 'parser.y', 470) module_eval(<<'.,.,', 'parser.y', 470)
def _reduce_114(val, _values, result) def _reduce_116(val, _values, result)
begin_c_declaration('\Z') begin_c_declaration('\Z')
@grammar.epilogue_first_lineno = @lexer.line + 1 @grammar.epilogue_first_lineno = @lexer.line + 1
@ -2044,7 +2062,7 @@ module_eval(<<'.,.,', 'parser.y', 470)
.,., .,.,
module_eval(<<'.,.,', 'parser.y', 475) module_eval(<<'.,.,', 'parser.y', 475)
def _reduce_115(val, _values, result) def _reduce_117(val, _values, result)
end_c_declaration end_c_declaration
@grammar.epilogue = val[2].s_value @grammar.epilogue = val[2].s_value
@ -2052,44 +2070,44 @@ module_eval(<<'.,.,', 'parser.y', 475)
end end
.,., .,.,
# reduce 116 omitted
# reduce 117 omitted
# reduce 118 omitted # reduce 118 omitted
# reduce 119 omitted # reduce 119 omitted
# reduce 120 omitted # reduce 120 omitted
# reduce 121 omitted
# reduce 122 omitted
module_eval(<<'.,.,', 'parser.y', 486) module_eval(<<'.,.,', 'parser.y', 486)
def _reduce_121(val, _values, result) def _reduce_123(val, _values, result)
result = [val[0]] result = [val[0]]
result result
end end
.,., .,.,
module_eval(<<'.,.,', 'parser.y', 487) module_eval(<<'.,.,', 'parser.y', 487)
def _reduce_122(val, _values, result) def _reduce_124(val, _values, result)
result = val[0].append(val[1]) result = val[0].append(val[1])
result result
end end
.,., .,.,
# reduce 123 omitted # reduce 125 omitted
# reduce 124 omitted # reduce 126 omitted
module_eval(<<'.,.,', 'parser.y', 492) module_eval(<<'.,.,', 'parser.y', 492)
def _reduce_125(val, _values, result) def _reduce_127(val, _values, result)
result = Lrama::Lexer::Token::Ident.new(s_value: val[0]) result = Lrama::Lexer::Token::Ident.new(s_value: val[0])
result result
end end
.,., .,.,
# reduce 126 omitted # reduce 128 omitted
# reduce 127 omitted # reduce 129 omitted
def _reduce_none(val, _values, result) def _reduce_none(val, _values, result)
val[0] val[0]

2
tool/lrama/lib/lrama/version.rb
View File

@ -1,3 +1,3 @@
module Lrama module Lrama
VERSION = "0.6.0".freeze VERSION = "0.6.1".freeze
end end