regexp_parser 1.5.0 → 1.8.0

data/lib/regexp_parser/syntax/tokens/unicode_property.rb

@@ -53,6 +53,10 @@ module Regexp::Syntax
 
       Age_V2_6_0 = [:'age=11.0']
 
+      Age_V2_6_2 = [:'age=12.0']
+
+      Age_V2_6_3 = [:'age=12.1']
+
       Age = all[:Age_V]
 
       Derived_V1_9_0 = [
@@ -297,6 +301,18 @@ module Regexp::Syntax
         :sogdian,
       ]
 
+      Script_V2_6_2 = [
+        :egyptian_hieroglyph_format_controls,
+        :elymaic,
+        :nandinagari,
+        :nyiakeng_puachue_hmong,
+        :ottoman_siyaq_numbers,
+        :small_kana_extension,
+        :symbols_and_pictographs_extended_a,
+        :tamil_supplement,
+        :wancho,
+      ]
+
       Script = all[:Script_V]
 
       UnicodeBlock_V1_9_0 = [
@@ -612,6 +628,18 @@ module Regexp::Syntax
         :in_sogdian,
       ]
 
+      UnicodeBlock_V2_6_2 = [
+        :in_egyptian_hieroglyph_format_controls,
+        :in_elymaic,
+        :in_nandinagari,
+        :in_nyiakeng_puachue_hmong,
+        :in_ottoman_siyaq_numbers,
+        :in_small_kana_extension,
+        :in_symbols_and_pictographs_extended_a,
+        :in_tamil_supplement,
+        :in_wancho,
+      ]
+
       UnicodeBlock = all[:UnicodeBlock_V]
 
       Emoji_V2_5_0 = [
@@ -632,6 +660,8 @@ module Regexp::Syntax
       V2_4_0 = all[:V2_4_0]
       V2_5_0 = all[:V2_5_0]
       V2_6_0 = all[:V2_6_0]
+      V2_6_2 = all[:V2_6_2]
+      V2_6_3 = all[:V2_6_3]
 
       All = all[/^V\d+_\d+_\d+$/]
 

data/lib/regexp_parser/syntax/versions/2.6.2.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V2_6_2 < Regexp::Syntax::V2_6_0
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V2_6_2
+      implements :nonproperty, UnicodeProperty::V2_6_2
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/2.6.3.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V2_6_3 < Regexp::Syntax::V2_6_2
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V2_6_3
+      implements :nonproperty, UnicodeProperty::V2_6_3
+    end
+  end
+end

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '1.5.0'
+    VERSION = '1.8.0'
   end
 end

data/spec/expression/base_spec.rb

@@ -77,4 +77,18 @@ RSpec.describe(Regexp::Expression::Base) do
     expect([root[2][1].coded_offset, root[2][1].to_s]).to eq ['@6+4', '(c?)']
     expect([root[2][1][0].coded_offset, root[2][1][0].to_s]).to eq ['@7+2', 'c?']
   end
+
+  specify('#quantity') do
+    expect(RP.parse(/aa/)[0].quantity).to eq [nil, nil]
+    expect(RP.parse(/a?/)[0].quantity).to eq [0, 1]
+    expect(RP.parse(/a*/)[0].quantity).to eq [0, -1]
+    expect(RP.parse(/a+/)[0].quantity).to eq [1, -1]
+  end
+
+  specify('#repetitions') do
+    expect(RP.parse(/aa/)[0].repetitions).to eq 1..1
+    expect(RP.parse(/a?/)[0].repetitions).to eq 0..1
+    expect(RP.parse(/a*/)[0].repetitions).to eq 0..(Float::INFINITY)
+    expect(RP.parse(/a+/)[0].repetitions).to eq 1..(Float::INFINITY)
+  end
 end

data/spec/expression/methods/match_length_spec.rb

@@ -30,6 +30,12 @@ RSpec.describe(Regexp::MatchLength) do
     specify('absence group') { expect(ML.of('(?~abc)').minmax).to eq [0, Float::INFINITY] }
   end
 
+  specify('raises for missing references') do
+    exp = RP.parse(/(a)\1/).last
+    exp.referenced_expression = nil
+    expect { exp.match_length }.to raise_error(ArgumentError)
+  end
+
   describe('::of') do
     it('works with Regexps') { expect(ML.of(/foo/).minmax).to eq [3, 3] }
     it('works with Strings') { expect(ML.of('foo').minmax).to eq [3, 3] }
@@ -114,6 +120,13 @@ RSpec.describe(Regexp::MatchLength) do
       expect { result.next }.to raise_error(StopIteration)
     end
 
+    it 'is aware of limit option even if called without a block' do
+      result = ML.of(/a?/).each(limit: 1)
+      expect(result).to be_a(Enumerator)
+      expect(result.next).to eq 0
+      expect { result.next }.to raise_error(StopIteration)
+    end
+
     it 'is limited to 1000 iterations in case there are infinite match lengths' do
       expect(ML.of(/a*/).first(3000).size).to eq 1000
     end
@@ -138,4 +151,11 @@ RSpec.describe(Regexp::MatchLength) do
       expect(ML.of(/a*/).endless_each.first(3000).size).to eq 3000
     end
   end
+
+  describe('#inspect') do
+    it 'is nice' do
+      result = RP.parse(/a{2,4}/)[0].match_length
+      expect(result.inspect).to eq '#<Regexp::MatchLength<Literal> min=2 max=4>'
+    end
+  end
 end

data/spec/expression/methods/match_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#match') do
+  it 'returns the #match result of the respective Regexp' do
+    expect(RP.parse(/a/).match('a')[0]).to eq 'a'
+  end
+
+  it 'can be given an offset, just like Regexp#match' do
+    expect(RP.parse(/./).match('ab', 1)[0]).to eq 'b'
+  end
+
+  it 'works with the #=~ alias' do
+    expect(RP.parse(/a/) =~ 'a').to be_a MatchData
+  end
+end
+
+RSpec.describe('Expression#match?') do
+  it 'returns true if the Respective Regexp matches' do
+    expect(RP.parse(/a/).match?('a')).to be true
+  end
+
+  it 'returns false if the Respective Regexp does not match' do
+    expect(RP.parse(/a/).match?('b')).to be false
+  end
+end

data/spec/expression/methods/tests_spec.rb

@@ -93,5 +93,7 @@ RSpec.describe('ExpressionTests') do
     expect(seq_2.last.one_of?(meta: [:*], anchor: :eos)).to be true
     expect(seq_2.last.one_of?(meta: [:*], anchor: [:bos])).to be false
     expect(seq_2.last.one_of?(meta: [:*], anchor: %i[bos eos])).to be true
+
+    expect { root.one_of?(Object.new) }.to raise_error(ArgumentError)
   end
 end

data/spec/expression/methods/traverse_spec.rb

@@ -39,6 +39,17 @@ RSpec.describe('Subexpression#traverse') do
     expect(visits).to eq 9
   end
 
+  specify('Subexpression#traverse without a block') do
+    root = RP.parse(/abc/)
+    enum = root.traverse
+
+    expect(enum).to be_a(Enumerator)
+    event, expr, idx = enum.next
+    expect(event).to eq(:visit)
+    expect(expr).to be_a(Regexp::Expression::Literal)
+    expect(idx).to eq(0)
+  end
+
   specify('Subexpression#walk alias') do
     root = RP.parse(/abc/)
 
@@ -81,6 +92,16 @@ RSpec.describe('Subexpression#traverse') do
     expect(indices).to eq [0, 0, 1, 0, 2]
   end
 
+  specify('Subexpression#each_expression without a block') do
+    root = RP.parse(/abc/)
+    enum = root.each_expression
+
+    expect(enum).to be_a(Enumerator)
+    expr, idx = enum.next
+    expect(expr).to be_a(Regexp::Expression::Literal)
+    expect(idx).to eq(0)
+  end
+
   specify('Subexpression#flat_map without block') do
     root = RP.parse(/a(b([c-e]+))?/)
 

data/spec/expression/options_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#options') do
+  it 'returns a hash of options/flags that affect the expression' do
+    exp = RP.parse(/a/ix)[0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(i: true, x: true)
+  end
+
+  it 'includes options that are locally enabled via special groups' do
+    exp = RP.parse(/(?x)(?m:a)/i)[1][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(i: true, m: true, x: true)
+  end
+
+  it 'excludes locally disabled options' do
+    exp = RP.parse(/(?x)(?-im:a)/i)[1][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(x: true)
+  end
+
+  it 'gives correct precedence to negative options' do
+    # Negative options have precedence. E.g. /(?i-i)a/ is case-sensitive.
+    regexp = /(?i-i:a)/
+    expect(regexp).to match 'a'
+    expect(regexp).not_to match 'A'
+
+    exp = RP.parse(regexp)[0][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq({})
+  end
+
+  it 'correctly handles multiple negative option parts' do
+    regexp = /(?--m--mx--) . /mx
+    expect(regexp).to match ' . '
+    expect(regexp).not_to match '.'
+    expect(regexp).not_to match "\n"
+
+    exp = RP.parse(regexp)[2]
+    expect(exp.options).to eq({})
+  end
+
+  it 'gives correct precedence when encountering multiple encoding flags' do
+    # Any encoding flag overrides all previous encoding flags. If there are
+    # multiple encoding flags in an options string, the last one wins.
+    # E.g. /(?dau)\w/ matches UTF8 chars but /(?dua)\w/ only ASCII chars.
+    regexp1 = /(?dau)\w/
+    regexp2 = /(?dua)\w/
+    expect(regexp1).to match 'ü'
+    expect(regexp2).not_to match 'ü'
+
+    exp1 = RP.parse(regexp1)[1]
+    exp2 = RP.parse(regexp2)[1]
+    expect(exp1.options).to eq(u: true)
+    expect(exp2.options).to eq(a: true)
+  end
+
+  it 'is accessible via shortcuts' do
+    exp = Root.build
+
+    expect { exp.options[:i] = true }
+      .to  change { exp.i? }.from(false).to(true)
+      .and change { exp.ignore_case? }.from(false).to(true)
+      .and change { exp.case_insensitive? }.from(false).to(true)
+
+    expect { exp.options[:m] = true }
+      .to  change { exp.m? }.from(false).to(true)
+      .and change { exp.multiline? }.from(false).to(true)
+
+    expect { exp.options[:x] = true }
+      .to  change { exp.x? }.from(false).to(true)
+      .and change { exp.extended? }.from(false).to(true)
+      .and change { exp.free_spacing? }.from(false).to(true)
+
+    expect { exp.options[:a] = true }
+      .to  change { exp.a? }.from(false).to(true)
+      .and change { exp.ascii_classes? }.from(false).to(true)
+
+    expect { exp.options[:d] = true }
+      .to  change { exp.d? }.from(false).to(true)
+      .and change { exp.default_classes? }.from(false).to(true)
+
+    expect { exp.options[:u] = true }
+      .to  change { exp.u? }.from(false).to(true)
+      .and change { exp.unicode_classes? }.from(false).to(true)
+  end
+
+  RSpec.shared_examples '#options' do |regexp, path, klass|
+    it "works for expression class #{klass}" do
+      exp = RP.parse(/#{regexp.source}/i).dig(*path)
+      expect(exp).to be_a(klass)
+      expect(exp).to be_i
+      expect(exp).not_to be_x
+    end
+  end
+
+  include_examples '#options', //, [], Root
+  include_examples '#options', /a/, [0], Literal
+  include_examples '#options', /\A/, [0], Anchor::Base
+  include_examples '#options', /\d/, [0], CharacterType::Base
+  include_examples '#options', /\n/, [0], EscapeSequence::Base
+  include_examples '#options', /\K/, [0], Keep::Mark
+  include_examples '#options', /./, [0], CharacterType::Any
+  include_examples '#options', /(a)/, [0], Group::Base
+  include_examples '#options', /(a)/, [0, 0], Literal
+  include_examples '#options', /(?=a)/, [0], Assertion::Base
+  include_examples '#options', /(?=a)/, [0, 0], Literal
+  include_examples '#options', /(a|b)/, [0], Group::Base
+  include_examples '#options', /(a|b)/, [0, 0], Alternation
+  include_examples '#options', /(a|b)/, [0, 0, 0], Alternative
+  include_examples '#options', /(a|b)/, [0, 0, 0, 0], Literal
+  include_examples '#options', /(a)\1/, [1], Backreference::Base
+  include_examples '#options', /(a)\k<1>/, [1], Backreference::Number
+  include_examples '#options', /(a)\g<1>/, [1], Backreference::NumberCall
+  include_examples '#options', /[a]/, [0], CharacterSet
+  include_examples '#options', /[a]/, [0, 0], Literal
+  include_examples '#options', /[a-z]/, [0, 0], CharacterSet::Range
+  include_examples '#options', /[a-z]/, [0, 0, 0], Literal
+  include_examples '#options', /[a&&z]/, [0, 0], CharacterSet::Intersection
+  include_examples '#options', /[a&&z]/, [0, 0, 0], CharacterSet::IntersectedSequence
+  include_examples '#options', /[a&&z]/, [0, 0, 0, 0], Literal
+  include_examples '#options', /[[:ascii:]]/, [0, 0], PosixClass
+  include_examples '#options', /\p{word}/, [0], UnicodeProperty::Base
+  include_examples '#options', /(a)(?(1)b|c)/, [1], Conditional::Expression
+  include_examples '#options', /(a)(?(1)b|c)/, [1, 0], Conditional::Condition
+  include_examples '#options', /(a)(?(1)b|c)/, [1, 1], Conditional::Branch
+  include_examples '#options', /(a)(?(1)b|c)/, [1, 1, 0], Literal
+end

data/spec/expression/root_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Root) do
+  describe('#initialize') do
+    it 'supports the old, nonstandard arity for backwards compatibility' do
+      expect { Root.new }.to output.to_stderr
+    end
+  end
+end

data/spec/expression/sequence_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Sequence) do
+  describe('#initialize') do
+    it 'supports the old, nonstandard arity for backwards compatibility' do
+      expect { Sequence.new(0, 0, 0) }.to output.to_stderr
+    end
+  end
+end

data/spec/lexer/conditionals_spec.rb

@@ -1,123 +1,53 @@
 require 'spec_helper'
 
 RSpec.describe('Conditional lexing') do
-  # Basic lexer output and nesting tests
-  tests = {
-    '(?<A>a)(?(<A>)b|c)'  => [3, :conditional, :open,       '(?',     7,  9, 0, 0, 0],
-    '(?<B>a)(?(<B>)b|c)'  => [4, :conditional, :condition,  '(<B>)',  9, 14, 0, 0, 1],
-    '(?<C>a)(?(<C>)b|c)'  => [6, :conditional, :separator,  '|',     15, 16, 0, 0, 1],
-    '(?<D>a)(?(<D>)b|c)'  => [8, :conditional, :close,      ')',     17, 18, 0, 0, 0],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, text, ts, te, level, set_level, conditional_level)), count|
-    specify("lexer_#{type}_#{token}_#{count}") do
-      tokens = RL.lex(pattern)
-      struct = tokens.at(index)
-
-      expect(struct.type).to eq type
-      expect(struct.token).to eq token
-      expect(struct.text).to eq text
-      expect(struct.ts).to eq ts
-      expect(struct.te).to eq te
-      expect(struct.level).to eq level
-      expect(struct.set_level).to eq set_level
-      expect(struct.conditional_level).to eq conditional_level
-    end
-  end
-
-  specify('lexer conditional mixed nesting') do
-    regexp = '((?<A>a)(?<B>(?(<A>)b|((?(<B>)[e-g]|[h-j])))))'
-    tokens = RL.lex(regexp)
-
-    [
-      [ 0, :group,       :capture,          '(',       0,  1, 0, 0, 0],
-      [ 1, :group,       :named,            '(?<A>',   1,  6, 1, 0, 0],
-
-      [ 5, :conditional, :open,             '(?',     13, 15, 2, 0, 0],
-      [ 6, :conditional, :condition,        '(<A>)',  15, 20, 2, 0, 1],
-      [ 8, :conditional, :separator,        '|',      21, 22, 2, 0, 1],
-
-      [10, :conditional, :open,             '(?',     23, 25, 3, 0, 1],
-      [11, :conditional, :condition,        '(<B>)',  25, 30, 3, 0, 2],
-
-      [12, :set,         :open,             '[',      30, 31, 3, 0, 2],
-      [13, :literal,     :literal,          'e',      31, 32, 3, 1, 2],
-      [14, :set,         :range,            '-',      32, 33, 3, 1, 2],
-      [15, :literal,     :literal,          'g',      33, 34, 3, 1, 2],
-      [16, :set,         :close,            ']',      34, 35, 3, 0, 2],
-
-      [17, :conditional, :separator,        '|',      35, 36, 3, 0, 2],
-      [23, :conditional, :close,            ')',      41, 42, 3, 0, 1],
-      [25, :conditional, :close,            ')',      43, 44, 2, 0, 0],
-
-      [26, :group,       :close,            ')',      44, 45, 1, 0, 0],
-      [27, :group,       :close,            ')',      45, 46, 0, 0, 0]
-    ].each do |index, type, token, text, ts, te, level, set_level, conditional_level|
-      struct = tokens.at(index)
-
-      expect(struct.type).to eq type
-      expect(struct.token).to eq token
-      expect(struct.text).to eq text
-      expect(struct.ts).to eq ts
-      expect(struct.te).to eq te
-      expect(struct.level).to eq level
-      expect(struct.set_level).to eq set_level
-      expect(struct.conditional_level).to eq conditional_level
-    end
-  end
-
-  specify('lexer conditional deep nesting') do
-    regexp = '(a(b(c)))(?(1)(?(2)(?(3)d|e))|(?(3)(?(2)f|g)|(?(1)f|g)))'
-    tokens = RL.lex(regexp)
-
-    [
-      [ 9, :conditional, :open,       '(?',    9, 11, 0, 0, 0],
-      [10, :conditional, :condition,  '(1)',  11, 14, 0, 0, 1],
-
-      [11, :conditional, :open,       '(?',   14, 16, 0, 0, 1],
-      [12, :conditional, :condition,  '(2)',  16, 19, 0, 0, 2],
-
-      [13, :conditional, :open,       '(?',   19, 21, 0, 0, 2],
-      [14, :conditional, :condition,  '(3)',  21, 24, 0, 0, 3],
-
-      [16, :conditional, :separator,  '|',    25, 26, 0, 0, 3],
-
-      [18, :conditional, :close,      ')',    27, 28, 0, 0, 2],
-      [19, :conditional, :close,      ')',    28, 29, 0, 0, 1],
-
-      [20, :conditional, :separator,  '|',    29, 30, 0, 0, 1],
-
-      [21, :conditional, :open,       '(?',   30, 32, 0, 0, 1],
-      [22, :conditional, :condition,  '(3)',  32, 35, 0, 0, 2],
-
-      [23, :conditional, :open,       '(?',   35, 37, 0, 0, 2],
-      [24, :conditional, :condition,  '(2)',  37, 40, 0, 0, 3],
-
-      [26, :conditional, :separator,  '|',    41, 42, 0, 0, 3],
-
-      [28, :conditional, :close,      ')',    43, 44, 0, 0, 2],
-
-      [29, :conditional, :separator,  '|',    44, 45, 0, 0, 2],
-
-      [30, :conditional, :open,       '(?',   45, 47, 0, 0, 2],
-      [31, :conditional, :condition,  '(1)',  47, 50, 0, 0, 3],
-
-      [33, :conditional, :separator,  '|',    51, 52, 0, 0, 3],
-
-      [35, :conditional, :close,      ')',    53, 54, 0, 0, 2],
-      [36, :conditional, :close,      ')',    54, 55, 0, 0, 1],
-      [37, :conditional, :close,      ')',    55, 56, 0, 0, 0]
-    ].each do |index, type, token, text, ts, te, level, set_level, conditional_level|
-      struct = tokens.at(index)
-
-      expect(struct.type).to eq type
-      expect(struct.token).to eq token
-      expect(struct.text).to eq text
-      expect(struct.ts).to eq ts
-      expect(struct.te).to eq te
-      expect(struct.level).to eq level
-      expect(struct.set_level).to eq set_level
-      expect(struct.conditional_level).to eq conditional_level
-    end
-  end
+  include_examples 'lex', /(?<A>a)(?(<A>)b|c)/,
+    3 => [:conditional, :open,       '(?',     7,  9, 0, 0, 0],
+    4 => [:conditional, :condition,  '(<A>)',  9, 14, 0, 0, 1],
+    6 => [:conditional, :separator,  '|',     15, 16, 0, 0, 1],
+    8 => [:conditional, :close,      ')',     17, 18, 0, 0, 0]
+
+  include_examples 'lex', /((?<A>a)(?<B>(?(<A>)b|((?(<B>)[e-g]|[h-j])))))/,
+     0 => [:group,       :capture,     '(',       0,  1, 0, 0, 0],
+     1 => [:group,       :named,       '(?<A>',   1,  6, 1, 0, 0],
+     5 => [:conditional, :open,        '(?',     13, 15, 2, 0, 0],
+     6 => [:conditional, :condition,   '(<A>)',  15, 20, 2, 0, 1],
+     8 => [:conditional, :separator,   '|',      21, 22, 2, 0, 1],
+    10 => [:conditional, :open,        '(?',     23, 25, 3, 0, 1],
+    11 => [:conditional, :condition,   '(<B>)',  25, 30, 3, 0, 2],
+    12 => [:set,         :open,        '[',      30, 31, 3, 0, 2],
+    13 => [:literal,     :literal,     'e',      31, 32, 3, 1, 2],
+    14 => [:set,         :range,       '-',      32, 33, 3, 1, 2],
+    15 => [:literal,     :literal,     'g',      33, 34, 3, 1, 2],
+    16 => [:set,         :close,       ']',      34, 35, 3, 0, 2],
+    17 => [:conditional, :separator,   '|',      35, 36, 3, 0, 2],
+    23 => [:conditional, :close,       ')',      41, 42, 3, 0, 1],
+    25 => [:conditional, :close,       ')',      43, 44, 2, 0, 0],
+    26 => [:group,       :close,       ')',      44, 45, 1, 0, 0],
+    27 => [:group,       :close,       ')',      45, 46, 0, 0, 0]
+
+  include_examples 'lex', /(a(b(c)))(?(1)(?(2)(?(3)d|e))|(?(3)(?(2)f|g)|(?(1)f|g)))/,
+     9 => [:conditional, :open,       '(?',    9, 11, 0, 0, 0],
+    10 => [:conditional, :condition,  '(1)',  11, 14, 0, 0, 1],
+    11 => [:conditional, :open,       '(?',   14, 16, 0, 0, 1],
+    12 => [:conditional, :condition,  '(2)',  16, 19, 0, 0, 2],
+    13 => [:conditional, :open,       '(?',   19, 21, 0, 0, 2],
+    14 => [:conditional, :condition,  '(3)',  21, 24, 0, 0, 3],
+    16 => [:conditional, :separator,  '|',    25, 26, 0, 0, 3],
+    18 => [:conditional, :close,      ')',    27, 28, 0, 0, 2],
+    19 => [:conditional, :close,      ')',    28, 29, 0, 0, 1],
+    20 => [:conditional, :separator,  '|',    29, 30, 0, 0, 1],
+    21 => [:conditional, :open,       '(?',   30, 32, 0, 0, 1],
+    22 => [:conditional, :condition,  '(3)',  32, 35, 0, 0, 2],
+    23 => [:conditional, :open,       '(?',   35, 37, 0, 0, 2],
+    24 => [:conditional, :condition,  '(2)',  37, 40, 0, 0, 3],
+    26 => [:conditional, :separator,  '|',    41, 42, 0, 0, 3],
+    28 => [:conditional, :close,      ')',    43, 44, 0, 0, 2],
+    29 => [:conditional, :separator,  '|',    44, 45, 0, 0, 2],
+    30 => [:conditional, :open,       '(?',   45, 47, 0, 0, 2],
+    31 => [:conditional, :condition,  '(1)',  47, 50, 0, 0, 3],
+    33 => [:conditional, :separator,  '|',    51, 52, 0, 0, 3],
+    35 => [:conditional, :close,      ')',    53, 54, 0, 0, 2],
+    36 => [:conditional, :close,      ')',    54, 55, 0, 0, 1],
+    37 => [:conditional, :close,      ')',    55, 56, 0, 0, 0]
 end