lrama 0.5.11 → 0.6.0

data/lib/lrama/states_reporter.rb

@@ -156,7 +156,7 @@ module Lrama
           nl = true
         end
 
-        if r = state.default_reduction_rule
+        if (r = state.default_reduction_rule)
           nl = true
           s = "$default".ljust(max_len)
 

data/lib/lrama/version.rb

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

data/parser.y

@@ -29,6 +29,7 @@ rule
                     | bison_declarations bison_declaration
 
   bison_declaration: grammar_declaration
+                   | rule_declaration
                    | "%expect" INTEGER { @grammar.expect = val[1] }
                    | "%define" variable value
                    | "%param" params
@@ -202,6 +203,85 @@ rule
 
   token_declaration: id int_opt alias { result = val }
 
+  rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" ":" rule_rhs_list
+                      {
+                        builder = Grammar::ParameterizingRuleBuilder.new(val[1].s_value, val[3], val[6])
+                        @grammar.add_parameterizing_rule_builder(builder)
+                      }
+
+  rule_args: IDENTIFIER { result = [val[0]] }
+           | rule_args "," IDENTIFIER { result = val[0].append(val[2]) }
+
+  rule_rhs_list: rule_rhs
+                {
+                  builder = val[0]
+                  result = [builder]
+                }
+          | rule_rhs_list "|" rule_rhs
+                {
+                  builder = val[2]
+                  result = val[0].append(builder)
+                }
+
+  rule_rhs: /* empty */
+            {
+              reset_precs
+              result = Grammar::ParameterizingRuleRhsBuilder.new
+            }
+          | "%empty"
+            {
+              reset_precs
+              result = Grammar::ParameterizingRuleRhsBuilder.new
+            }
+          | rule_rhs symbol named_ref_opt
+            {
+              token = val[1]
+              token.alias_name = val[2]
+              builder = val[0]
+              builder.symbols << token
+              result = builder
+            }
+          | rule_rhs IDENTIFIER parameterizing_suffix
+              {
+                builder = val[0]
+                builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
+                result = builder
+              }
+          | rule_rhs IDENTIFIER "(" parameterizing_args ")"
+              {
+                builder = val[0]
+                builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3])
+                result = builder
+              }
+          | rule_rhs "{"
+            {
+              if @prec_seen
+                on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
+                @code_after_prec = true
+              end
+              begin_c_declaration("}")
+            }
+          C_DECLARATION
+            {
+              end_c_declaration
+            }
+          "}" named_ref_opt
+            {
+              user_code = val[3]
+              user_code.alias_name = val[6]
+              builder = val[0]
+              builder.user_code = user_code
+              result = builder
+            }
+          | rule_rhs "%prec" symbol
+            {
+              sym = @grammar.find_symbol_by_id!(val[2])
+              @prec_seen = true
+              builder = val[0]
+              builder.precedence_sym = sym
+              result = builder
+            }
+
   int_opt: # empty
          | INTEGER
 
@@ -326,9 +406,9 @@ rule
            builder.add_rhs(token)
            result = builder
          }
-     | rhs IDENTIFIER parameterizing_suffix tag_opt
+     | rhs symbol parameterizing_suffix tag_opt
          {
-           token = Lrama::Lexer::Token::Parameterizing.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]])
            builder = val[0]
            builder.add_rhs(token)
            builder.lhs_tag = val[3]
@@ -337,7 +417,7 @@ rule
          }
      | rhs IDENTIFIER "(" parameterizing_args ")" tag_opt
          {
-           token = Lrama::Lexer::Token::Parameterizing.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])
            builder = val[0]
            builder.add_rhs(token)
            builder.lhs_tag = val[5]
@@ -421,8 +501,7 @@ end
 include Lrama::Report::Duration
 
 def initialize(text, path, debug = false)
-  @text = text
-  @path = path
+  @grammar_file = Lrama::Lexer::GrammarFile.new(path, text)
   @yydebug = debug
   @rule_counter = Lrama::Grammar::Counter.new(0)
   @midrule_action_counter = Lrama::Grammar::Counter.new(1)
@@ -430,7 +509,7 @@ end
 
 def parse
   report_duration(:parse) do
-    @lexer = Lrama::Lexer.new(@text)
+    @lexer = Lrama::Lexer.new(@grammar_file)
     @grammar = Lrama::Grammar.new(@rule_counter)
     @precedence_number = 0
     reset_precs
@@ -447,40 +526,26 @@ end
 
 def on_error(error_token_id, error_value, value_stack)
   if error_value.is_a?(Lrama::Lexer::Token)
-    line = error_value.first_line
-    first_column = error_value.first_column
-    last_column = error_value.last_column
+    location = error_value.location
     value = "'#{error_value.s_value}'"
   else
-    line = @lexer.line
-    first_column = @lexer.head_column
-    last_column = @lexer.column
+    location = @lexer.location
     value = error_value.inspect
   end
 
-  raise ParseError, <<~ERROR
-    #{@path}:#{line}:#{first_column}: parse error on value #{value} (#{token_to_str(error_token_id) || '?'})
-    #{@text.split("\n")[line - 1]}
-    #{carrets(first_column, last_column)}
-  ERROR
+  error_message = "parse error on value #{value} (#{token_to_str(error_token_id) || '?'})"
+
+  raise_parse_error(error_message, location)
 end
 
 def on_action_error(error_message, error_value)
   if error_value.is_a?(Lrama::Lexer::Token)
-    line = error_value.first_line
-    first_column = error_value.first_column
-    last_column = error_value.last_column
+    location = error_value.location
   else
-    line = @lexer.line
-    first_column = @lexer.head_column
-    last_column = @lexer.column
+    location = @lexer.location
   end
 
-  raise ParseError, <<~ERROR
-    #{@path}:#{line}: #{error_message}
-    #{@text.split("\n")[line - 1]}
-    #{carrets(first_column, last_column)}
-  ERROR
+  raise_parse_error(error_message, location)
 end
 
 private
@@ -500,6 +565,6 @@ def end_c_declaration
   @lexer.end_symbol = nil
 end
 
-def carrets(first_column, last_column)
-  ' ' * (first_column + 1) + '^' * (last_column - first_column)
+def raise_parse_error(error_message, location)
+  raise ParseError, location.generate_error_message(error_message)
 end

data/sig/lrama/grammar/code/printer_code.rbs

@@ -3,7 +3,7 @@ module Lrama
     class Code
       class PrinterCode < Code
         @tag: untyped
-        def initialize: (?type: untyped, ?token_code: untyped, ?tag: untyped) -> void
+        def initialize: (type: untyped, token_code: untyped, tag: untyped) -> void
 
         private
 

data/sig/lrama/grammar/code.rbs

@@ -3,16 +3,16 @@ module Lrama
     class Code
       extend Forwardable
 
-      attr_accessor type: untyped
-      attr_accessor token_code: untyped
+      attr_accessor type: Symbol
+      attr_accessor token_code: Lexer::Token::UserCode
 
       # delegated
       def s_value: -> String
       def line: -> Integer
-      def column: -> untyped
-      def references: -> untyped
+      def column: -> Integer
+      def references: -> Array[Lrama::Grammar::Reference]
 
-      def initialize: (?type: untyped, ?token_code: untyped) -> void
+      def initialize: (type: Symbol, token_code: Lexer::Token::UserCode) -> void
 
       def translated_code: () -> String
 

data/sig/lrama/grammar/parameterizing_rule.rbs

@@ -0,0 +1,10 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      attr_accessor rules: Array[Rule]
+      attr_accessor token: Lexer::Token
+
+      def initialize: (?untyped rules, Lexer::Token token) -> void
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rule_builder.rbs

@@ -0,0 +1,19 @@
+module Lrama
+  class Grammar
+    class ParameterizingRuleBuilder
+      attr_reader name: String
+      attr_reader parameters: Array[Lexer::Token]
+      attr_reader rhs: Array[Grammar::ParameterizingRuleRhsBuilder]
+
+      @required_parameters_count: Integer
+
+      def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRuleRhsBuilder] rhs) -> void
+      def build_rules: (Lexer::Token::InstantiateRule token, Array[Lexer::Token] actual_args, Counter rule_counter, untyped lhs_tag, Integer? line, Array[ParameterizingRuleBuilder] rule_builders) -> Array[Grammar::ParameterizingRule]
+
+      private
+
+      def validate_argument_number!: (Lexer::Token::InstantiateRule token) -> void
+      def lhs: (Array[Lexer::Token] actual_args) -> Lexer::Token
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rule_resolver.rbs

@@ -0,0 +1,16 @@
+module Lrama
+  class Grammar
+    class ParameterizingRuleResolver
+      @parameterizing_rule_builders: Array[Grammar::ParameterizingRuleBuilder]
+
+      def initialize: () -> void
+      def add_parameterizing_rule_builder: (Grammar::ParameterizingRuleBuilder builder) -> void
+      def defined?: (String) -> bool
+      def build_rules: (Lexer::Token::InstantiateRule token, Counter rule_counter, untyped lhs_tag, Integer? line) -> Array[Grammar::ParameterizingRule]
+
+      private
+
+      def rule_builders: (String) -> Array[Grammar::ParameterizingRuleBuilder]
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rule_rhs_builder.rbs

@@ -0,0 +1,18 @@
+module Lrama
+  class Grammar
+    class ParameterizingRuleRhsBuilder
+      attr_reader symbols: Array[untyped]
+      attr_reader user_code: Lexer::Token::UserCode?
+      attr_reader precedence_sym: Lexer::Token?
+
+      def initialize: () -> void
+      def build_rules: (Lexer::Token::InstantiateRule token, Array[Lexer::Token] actual_args, Array[Lexer::Token] parameters, Counter rule_counter, Lexer::Token lhs, untyped lhs_tag, Integer? line, Array[ParameterizingRuleBuilder] rule_builders) -> Grammar::ParameterizingRule
+
+      private
+
+      def build_nested_rules: (Lexer::Token::InstantiateRule token, Array[Lexer::Token] actual_args, Array[Lexer::Token] parameters, Counter rule_counter, untyped lhs_tag, Integer? line, Array[ParameterizingRuleBuilder] rule_builders) -> Array[Grammar::ParameterizingRule]
+      def nested_actual_args: (Array[Lexer::Token] actual_args, Array[Lexer::Token] parameters, Integer idx) -> Array[Lexer::Token]
+      def rhs: (Lexer::Token token, Array[Lexer::Token] actual_args, Array[Lexer::Token] parameters, ParameterizingRule? nested_rule) -> Array[Lexer::Token]
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rules/builder/base.rbs

@@ -3,14 +3,16 @@ module Lrama
     class ParameterizingRules
       class Builder
         class Base
-          def initialize: (Lexer::Token::Parameterizing token, Counter rule_counter, untyped lhs_tag, Lexer::Token::UserCode? user_code, Lexer::Token? precedence_sym, Integer? line) -> void
+          attr_reader build_token: Lexer::Token::Ident
+
+          def initialize: (Lexer::Token::InstantiateRule token, Counter rule_counter, untyped lhs_tag, Lexer::Token::UserCode? user_code, Lexer::Token? precedence_sym, Integer? line) -> void
           def build: () -> Array[Rule]
 
           @args: Array[Lexer::Token]
-          @token: Lexer::Token::Parameterizing
+          @token: Lexer::Token::InstantiateRule
           @key: Symbol
           @rule_counter: Counter
-          @lhs: Lexer::Token
+          @lhs_tag: untyped
           @user_code: Lexer::Token::UserCode?
           @precedence_sym: Lexer::Token?
           @line: Integer?

data/sig/lrama/grammar/parameterizing_rules/builder/separated_list.rbs

@@ -3,6 +3,8 @@ module Lrama
     class ParameterizingRules
       class Builder
         class SeparatedList < Base
+          @separator: Lexer::Token
+
           def initialize: (Lexer::Token token, Counter rule_counter, untyped lhs_tag, Lexer::Token::UserCode? user_code, Lexer::Token? precedence_sym, Integer? line) -> void
         end
       end

data/sig/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rbs

@@ -3,6 +3,8 @@ module Lrama
     class ParameterizingRules
       class Builder
         class SeparatedNonemptyList < Base
+          @separator: Lexer::Token
+
           def initialize: (Lexer::Token token, Counter rule_counter, untyped lhs_tag, Lexer::Token::UserCode? user_code, Lexer::Token? precedence_sym, Integer? line) -> void
         end
       end

data/sig/lrama/grammar/parameterizing_rules/builder.rbs

@@ -4,17 +4,18 @@ module Lrama
       class Builder
         RULES: Hash[Symbol, singleton(Base)]
 
-        @token: Lexer::Token::Parameterizing
+        @token: Lexer::Token::InstantiateRule
         @key: Symbol
         @rule_counter: Counter
-        @lhs: Lexer::Token
+        @lhs_tag: untyped
         @user_code: Lexer::Token::UserCode?
         @precedence_sym: Lexer::Token?
         @line: Integer?
+        @builder: Grammar::ParameterizingRules::Builder::Base
 
         def initialize: (Lexer::Token token, Counter rule_counter, untyped lhs_tag, Lexer::Token::UserCode? user_code, Lexer::Token? precedence_sym, Integer? line) -> void
         def build: () -> Array[Rule]
-        def build_token: () -> Lrama::Lexer::Token
+        def build_token: () -> Lexer::Token
         def create_builder: () -> void
         def validate_key!: () -> void
       end

data/sig/lrama/grammar/rule_builder.rbs

@@ -24,9 +24,7 @@ module Lrama
       def user_code=: (Lexer::Token::UserCode user_code) -> void
       def precedence_sym=: (Lexer::Token user_code) -> void
       def complete_input: () -> void
-      def setup_rules: () -> void
-      def parameterizing_rules: () -> Array[Rule]
-      def midrule_action_rules: () -> Array[Rule]
+      def setup_rules: (Grammar::ParameterizingRuleResolver parameterizing_resolver) -> void
       def rules: () -> Array[Rule]
 
       private
@@ -34,7 +32,7 @@ module Lrama
       def freeze_rhs: () -> void
       def preprocess_references: () -> void
       def build_rules: () -> void
-      def process_rhs: () -> void
+      def process_rhs: (Grammar::ParameterizingRuleResolver parameterizing_resolver) -> void
       def numberize_references: () -> void
       def flush_user_code: () -> void
     end

data/sig/lrama/lexer/grammar_file.rbs

@@ -0,0 +1,15 @@
+module Lrama
+  class Lexer
+    class GrammarFile
+      attr_reader path: String
+      attr_reader text: String
+
+      @lines: Array[String]
+
+      def initialize: (String path, String text) -> void
+
+      def ==: (GrammarFile other) -> bool
+      def lines: () -> Array[String]
+    end
+  end
+end

data/sig/lrama/lexer/location.rbs

@@ -1,14 +1,26 @@
 module Lrama
   class Lexer
     class Location
+      attr_reader grammar_file: GrammarFile
       attr_reader first_line: Integer
       attr_reader first_column: Integer
       attr_reader last_line: Integer
       attr_reader last_column: Integer
 
-      def initialize: (first_line: Integer, first_column: Integer, last_line: Integer, last_column: Integer) -> void
+      def initialize: (grammar_file: GrammarFile, first_line: Integer, first_column: Integer, last_line: Integer, last_column: Integer) -> void
 
       def ==: (Location other) -> bool
+      def partial_location: (Integer, Integer) -> Location
+      def generate_error_message: (String) -> String
+      def line_with_carets: () -> String
+
+      private
+
+      def path: () -> String
+      def blanks: () -> String
+      def carets: () -> String
+      def text: () -> String
+      def _text: () -> Array[String]
     end
   end
 end

data/sig/lrama/lexer/token/instantiate_rule.rbs

@@ -0,0 +1,12 @@
+module Lrama
+  class Lexer
+    class Token
+      class InstantiateRule < Token
+        attr_accessor args: Array[Lexer::Token]
+
+        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token]) -> void
+        def rule_name: () -> String
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.5.11
+  version: 0.6.0
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-01 00:00:00.000000000 Z
+date: 2023-12-25 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email:
@@ -27,10 +27,10 @@ files:
 - Gemfile
 - LEGAL.md
 - MIT
+- NEWS.md
 - README.md
 - Rakefile
 - Steepfile
-- doc/TODO.md
 - exe/lrama
 - lib/lrama.rb
 - lib/lrama/bitmap.rb
@@ -55,6 +55,10 @@ files:
 - lib/lrama/grammar/code/rule_action.rb
 - lib/lrama/grammar/counter.rb
 - lib/lrama/grammar/error_token.rb
+- lib/lrama/grammar/parameterizing_rule.rb
+- lib/lrama/grammar/parameterizing_rule_builder.rb
+- lib/lrama/grammar/parameterizing_rule_resolver.rb
+- lib/lrama/grammar/parameterizing_rule_rhs_builder.rb
 - lib/lrama/grammar/parameterizing_rules/builder.rb
 - lib/lrama/grammar/parameterizing_rules/builder/base.rb
 - lib/lrama/grammar/parameterizing_rules/builder/list.rb
@@ -72,11 +76,12 @@ files:
 - lib/lrama/grammar/type.rb
 - lib/lrama/grammar/union.rb
 - lib/lrama/lexer.rb
+- lib/lrama/lexer/grammar_file.rb
 - lib/lrama/lexer/location.rb
 - lib/lrama/lexer/token.rb
 - lib/lrama/lexer/token/char.rb
 - lib/lrama/lexer/token/ident.rb
-- lib/lrama/lexer/token/parameterizing.rb
+- lib/lrama/lexer/token/instantiate_rule.rb
 - lib/lrama/lexer/token/tag.rb
 - lib/lrama/lexer/token/user_code.rb
 - lib/lrama/option_parser.rb
@@ -111,6 +116,10 @@ files:
 - sig/lrama/grammar/code/printer_code.rbs
 - sig/lrama/grammar/counter.rbs
 - sig/lrama/grammar/error_token.rbs
+- sig/lrama/grammar/parameterizing_rule.rbs
+- sig/lrama/grammar/parameterizing_rule_builder.rbs
+- sig/lrama/grammar/parameterizing_rule_resolver.rbs
+- sig/lrama/grammar/parameterizing_rule_rhs_builder.rbs
 - sig/lrama/grammar/parameterizing_rules/builder.rbs
 - sig/lrama/grammar/parameterizing_rules/builder/base.rbs
 - sig/lrama/grammar/parameterizing_rules/builder/list.rbs
@@ -125,11 +134,12 @@ files:
 - sig/lrama/grammar/rule.rbs
 - sig/lrama/grammar/rule_builder.rbs
 - sig/lrama/grammar/symbol.rbs
+- sig/lrama/lexer/grammar_file.rbs
 - sig/lrama/lexer/location.rbs
 - sig/lrama/lexer/token.rbs
 - sig/lrama/lexer/token/char.rbs
 - sig/lrama/lexer/token/ident.rbs
-- sig/lrama/lexer/token/parameterizing.rbs
+- sig/lrama/lexer/token/instantiate_rule.rbs
 - sig/lrama/lexer/token/tag.rbs
 - sig/lrama/lexer/token/user_code.rbs
 - sig/lrama/report/duration.rbs
@@ -158,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.0.dev
+rubygems_version: 3.5.1
 signing_key:
 specification_version: 4
 summary: LALR (1) parser generator written by Ruby

data/doc/TODO.md

@@ -1,59 +0,0 @@
-# TODO
-
-* command
-* lexer
-  * [x] Basic functionalities
-* parser
-  * [x] Basic functionalities
-  * [x] Precedence in grammar
-* LALR
-  * [x] compute_nullable
-  * [x] compute_lr0_states
-  * [x] Direct Read Sets
-  * [x] Reads Relation
-  * [x] Read Sets
-  * [x] Includes Relation
-  * [x] Lookback Relation
-  * [x] Follow Sets
-  * [x] Look-Ahead Sets
-  * [x] Precedence support
-  * [x] Conflict check
-  * [x] Algorithm Digraph
-  * [ ] Conflict resolution
-    * [x] Do not generate default action if states have conflicts
-    * [ ] Fix number of s/r conflicts of basic.y. See basic.output file generated by Bison.
-* Rendering
-  * [x] Table compaction
-  * [x] -d option
-  * yacc.c
-    * [x] %lex-param
-    * [x] %parse-param
-    * [x] %printer
-    * [x] Replace $, @ in user codes
-    * [x] `[@oline@]`
-    * [ ] b4_symbol (for eof, error and so on)
-    * Assumption
-      * b4_locations_if is true
-      * b4_pure_if is true
-      * b4_pull_if is false
-      * b4_lac_if is false
-* Performance improvement
-  * [ ]
-* Licenses
-  * [x] Write down something about licenses
-* Reporting
-  * [ ] Bison style
-    * [ ] Wrap not selected reduce with "[]". See basic.output file generated by Bison.
-* Counterexamples
-  * [x] Nonunifying Counterexamples
-  * [ ] Unifying Counterexamples
-  * [ ] Performance improvement using reverse_transitions and reverse_productions
-* Error Tolerance
-  * [x] Corchuelo et al. algorithm with N = 1 (this means the next token when error is raised)
-  * [x] Add new decl for error token semantic value initialization (%error-token)
-  * [x] Use YYMALLOC & YYFREE
-* Lex state
-* CI
-  * [x] Setup CI
-  * [x] Add ruby 3.1 or under
-  * [x] Add integration tests which installs Lrama, build ruby and run `make test`

data/lib/lrama/lexer/token/parameterizing.rb

@@ -1,34 +0,0 @@
-module Lrama
-  class Lexer
-    class Token
-      class Parameterizing < Token
-        attr_accessor :args
-
-        def initialize(s_value:, alias_name: nil, location: nil, args: [])
-          super s_value: s_value, alias_name: alias_name, location: location
-          @args = args
-        end
-
-        def option?
-          %w(option ?).include?(self.s_value)
-        end
-
-        def nonempty_list?
-          %w(nonempty_list +).include?(self.s_value)
-        end
-
-        def list?
-          %w(list *).include?(self.s_value)
-        end
-
-        def separated_nonempty_list?
-          %w(separated_nonempty_list).include?(self.s_value)
-        end
-
-        def separated_list?
-          %w(separated_list).include?(self.s_value)
-        end
-      end
-    end
-  end
-end

data/sig/lrama/lexer/token/parameterizing.rbs

@@ -1,17 +0,0 @@
-module Lrama
-  class Lexer
-    class Token
-      class Parameterizing < Token
-        attr_accessor args: Array[Lrama::Lexer::Token]
-
-        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lrama::Lexer::Token]) -> void
-
-        def option?: () -> bool
-        def nonempty_list?: () -> bool
-        def list?: () -> bool
-        def separated_nonempty_list?: () -> bool
-        def separated_list?: () -> bool
-      end
-    end
-  end
-end