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
## 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)
### 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)
### Type specification of parameterizing rules

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

@ -1,14 +1,28 @@
module Lrama
class Command
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]
warning = Lrama::Warning.new
text = options.y.read
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.compute
context = Lrama::Context.new(states)
@ -39,7 +53,7 @@ module Lrama
end
if warning.has_error?
exit 1
exit false
end
end
end

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

@ -9,7 +9,7 @@ module Lrama
BaseMin = -Float::INFINITY
# 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)
@states = states
@ -41,15 +41,11 @@ module Lrama
def yyfinal
@states.states.find do |state|
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.id
end
def yylast
@yylast
end
# Number of terms
def yyntokens
@states.terms.count
@ -119,30 +115,14 @@ module Lrama
end
end
def yypact_ninf
@yypact_ninf
end
def yytable_ninf
@yytable_ninf
end
def yypact
@base[0...yynstates]
end
def yydefact
@yydefact
end
def yypgoto
@base[yynstates..-1]
end
def yydefgoto
@yydefgoto
end
def yytable
@table
end

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

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

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

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

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
class Grammar
class PercentCode
attr_reader :id, :code
attr_reader :name, :code
def initialize(id, code)
@id = id
def initialize(name, code)
@name = name
@code = code
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
class Grammar
class RuleBuilder
attr_accessor :lhs, :lhs_tag, :line
attr_reader :rhs, :user_code, :precedence_sym
attr_accessor :lhs, :line
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
@midrule_action_counter = midrule_action_counter
@position_in_original_rule_rhs = position_in_original_rule_rhs
@skip_preprocess_references = skip_preprocess_references
@lhs = nil
@lhs_tag = lhs_tag
@rhs = []
@lhs_tag = nil
@user_code = nil
@precedence_sym = nil
@line = nil
@rule_builders_for_parameterizing_rules = []
@rule_builders_for_derived_rules = []
end
@ -33,7 +34,7 @@ module Lrama
def user_code=(user_code)
if !@line
@line = user_code.line
@line = user_code&.line
end
flush_user_code
@ -51,14 +52,14 @@ module Lrama
freeze_rhs
end
def setup_rules(parameterizing_resolver)
def setup_rules(parameterizing_rule_resolver)
preprocess_references unless @skip_preprocess_references
process_rhs(parameterizing_resolver)
process_rhs(parameterizing_rule_resolver)
build_rules
end
def rules
@parameterizing_rules + @midrule_action_rules + @rules
@parameterizing_rules + @old_parameterizing_rules + @midrule_action_rules + @rules
end
private
@ -75,10 +76,13 @@ module Lrama
tokens = @replaced_rhs
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
)
@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|
rule_builder.rules
end.flatten
@ -89,11 +93,11 @@ module Lrama
# 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`.
def process_rhs(parameterizing_resolver)
def process_rhs(parameterizing_rule_resolver)
return if @replaced_rhs
@replaced_rhs = []
@parameterizing_rules = []
@old_parameterizing_rules = []
rhs.each_with_index do |token, i|
case token
@ -102,26 +106,46 @@ module Lrama
when Lrama::Lexer::Token::Ident
@replaced_rhs << token
when Lrama::Lexer::Token::InstantiateRule
if parameterizing_resolver.defined?(token.rule_name)
parameterizing = parameterizing_resolver.build_rules(token, @rule_counter, @lhs_tag, line)
@parameterizing_rules = @parameterizing_rules + parameterizing.map(&:rules).flatten
@replaced_rhs = @replaced_rhs + parameterizing.map(&:token).flatten.uniq
if parameterizing_rule_resolver.defined?(token)
parameterizing_rule = parameterizing_rule_resolver.find(token)
raise "Unexpected token. #{token}" unless parameterizing_rule
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
# 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_rules = @parameterizing_rules + parameterizing.build
@replaced_rhs << parameterizing.build_token
parameterizing_rule = ParameterizingRules::Builder.new(token, @rule_counter, token.lhs_tag, user_code, precedence_sym, line)
@old_parameterizing_rules = @old_parameterizing_rules + parameterizing_rule.build
@replaced_rhs << parameterizing_rule.build_token
end
when Lrama::Lexer::Token::UserCode
prefix = token.referred ? "@" : "$@"
new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)
@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.user_code = token
rule_builder.complete_input
rule_builder.setup_rules(parameterizing_resolver)
rule_builder.setup_rules(parameterizing_rule_resolver)
@rule_builders_for_derived_rules << rule_builder
else
@ -130,6 +154,18 @@ module Lrama
end
end
def lhs_s_value(token, bindings)
s_values = token.args.map do |arg|
resolved = bindings.resolve_symbol(arg)
if resolved.is_a?(Lexer::Token::InstantiateRule)
[resolved.s_value, resolved.args.map(&:s_value)]
else
resolved.s_value
end
end
"#{token.rule_name}_#{s_values.join('_')}"
end
def numberize_references
# Bison n'th component is 1-origin
(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) }
if candidates.size >= 2
location = token.location.partial_location(ref.first_column, ref.last_column)
raise location.generate_error_message("Referring symbol `#{ref_name}` is duplicated.")
token.invalid_ref(ref, "Referring symbol `#{ref_name}` is duplicated.")
end
unless (referring_symbol = candidates.first)
location = token.location.partial_location(ref.first_column, ref.last_column)
raise location.generate_error_message("Referring symbol `#{ref_name}` is not found.")
token.invalid_ref(ref, "Referring symbol `#{ref_name}` is not found.")
end
ref.index = referring_symbol[1] + 1
@ -163,7 +197,7 @@ module Lrama
if ref.index
# TODO: Prohibit $0 even so Bison allows it?
# 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
end
end

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

@ -1,6 +1,18 @@
module Lrama
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

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

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

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

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

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

@ -46,6 +46,11 @@ module Lrama
def last_column
location.last_column
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

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

@ -2,16 +2,21 @@ module Lrama
class Lexer
class 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
@args = args
@lhs_tag = lhs_tag
end
def rule_name
s_value
end
def args_count
args.count
end
end
end
end

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

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

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

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

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

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