mumukit-content-type 1.8.1 → 1.11.1

data/vendor/bundle/ruby/2.6.0/gems/racc-1.5.2/test/assets/opt.y

@@ -0,0 +1,123 @@
+#
+# check options working
+#
+
+class Calcp
+
+  prechigh
+    left '*' '/'
+    left '+' '-'
+  preclow
+
+  convert
+    NUMBER 'Number'
+  end
+
+  options no_omit_action_call no_result_var
+
+rule
+
+  target : exp | /* none */ { 0 } ;
+
+  exp    : exp '+' exp { chk(val[0] + val[2]) }
+         | exp '-' exp { chk(val[0] - val[2]) }
+         | exp '*' exp { chk(val[0] * val[2]) }
+         | exp '/' exp { chk(val[0] / val[2]) }
+         | '(' { $emb = true } exp ')'
+             {
+               raise 'must not happen' unless $emb
+               val[2]
+             }
+         | '-' NUMBER  { -val[1] }
+         | NUMBER
+         ;
+
+end
+
+----header
+
+class Number; end
+
+----inner
+
+  def parse( src )
+    @src = src
+    do_parse
+  end
+
+  def next_token
+    @src.shift
+  end
+
+  def initialize
+    @yydebug = true
+  end
+
+  def chk( i )
+    # p i
+    i
+  end
+
+----footer
+
+$parser = Calcp.new
+$test_number = 1
+
+def chk( src, ans )
+  result = $parser.parse(src)
+  raise "test #{$test_number} failed" unless result == ans
+  $test_number += 1
+end
+
+chk(
+  [ [Number, 9],
+    [false, false],
+    [false, false] ], 9
+)
+
+chk(
+  [ [Number, 5],
+    ['*', nil],
+    [Number, 1],
+    ['-', nil],
+    [Number, 1],
+    ['*', nil],
+    [Number, 8],
+    [false, false],
+    [false, false] ], -3
+)
+
+chk(
+  [ [Number, 5],
+    ['+', nil],
+    [Number, 2],
+    ['-', nil],
+    [Number, 5],
+    ['+', nil],
+    [Number, 2],
+    ['-', nil],
+    [Number, 5],
+    [false, false],
+    [false, false] ], -1
+)
+
+chk(
+  [ ['-', nil],
+    [Number, 4],
+    [false, false],
+    [false, false] ], -4
+)
+
+chk(
+  [ [Number, 7],
+    ['*', nil],
+    ['(', nil],
+    [Number, 4],
+    ['+', nil],
+    [Number, 3],
+    [')', nil],
+    ['-', nil],
+    [Number, 9],
+    [false, false],
+    [false, false] ], 40
+)

data/vendor/bundle/ruby/2.6.0/gems/racc-1.5.2/test/assets/percent.y

@@ -0,0 +1,35 @@
+class ScannerChecker
+rule
+  target: A
+      {
+        i = 7
+        i %= 4
+	raise 'assert failed' unless i == 3
+        tmp = %-This is percent string.-
+	raise 'assert failed' unless tmp == 'This is percent string.'
+        a = 5; b = 3
+        assert_equal(2,(a%b))    #A
+      # assert_equal(2,(a %b))   # is %-string
+        assert_equal(2,(a% b))   #B
+        assert_equal(2,(a % b))  #C
+      }
+end
+
+---- inner ----
+
+  def parse
+    @q = [[:A, 'A'], [false, '$']]
+    do_parse
+  end
+
+  def next_token
+    @q.shift
+  end
+
+  def assert_equal( expect, real )
+    raise "expect #{expect.inspect} but #{real.inspect}" unless expect == real
+  end
+
+---- footer ----
+
+parser = ScannerChecker.new.parse

data/vendor/bundle/ruby/2.6.0/gems/racc-1.5.2/test/assets/php_serialization.y

@@ -0,0 +1,98 @@
+# MIT License
+# See https://github.com/divoxx/ruby-php-serialization/blob/master/LICENSE.txt
+
+class PhpSerialization::Unserializer
+rule
+
+  data            : null    ';'  { @object = val[0] }
+                  | bool    ';'  { @object = val[0] }
+                  | integer ';'  { @object = val[0] }
+                  | double  ';'  { @object = val[0] }
+                  | string  ';'  { @object = val[0] }
+                  | assoc_array  { @object = val[0] }
+                  | object       { @object = val[0] }
+                  ;
+
+  null            : 'N' { result = nil }
+                  ;
+
+  bool            : 'b' ':' NUMBER { result = Integer(val[2]) > 0 }
+                  ;
+
+  integer         : 'i' ':' NUMBER { result = Integer(val[2]) }
+                  ;
+
+  double          : 'd' ':' NUMBER { result = Float(val[2]) }
+                  ;
+
+  string          : 's' ':' NUMBER ':' STRING { result = val[4] }
+                  ;
+
+  object          : 'O' ':' NUMBER ':' STRING ':' NUMBER ':' '{' attribute_list '}'
+                    {
+                      if eval("defined?(#{val[4]})")
+                        result = Object.const_get(val[4]).new
+
+                        val[9].each do |(attr_name, value)|
+                          # Protected and private attributes will have a \0..\0 prefix
+                          attr_name = attr_name.gsub(/\A\\0[^\\]+\\0/, '')
+                          result.instance_variable_set("@#{attr_name}", value)
+                        end
+                      else
+                        klass_name = val[4].gsub(/^Struct::/, '')
+                        attr_names, values = [], []
+
+                        val[9].each do |(attr_name, value)|
+                          # Protected and private attributes will have a \0..\0 prefix
+                          attr_names << attr_name.gsub(/\A\\0[^\\]+\\0/, '')
+                          values << value
+                        end
+
+                        result = Struct.new(klass_name, *attr_names).new(*values)
+                        result.instance_variable_set("@_php_class", klass_name)
+                      end
+                    }
+                  ;
+
+  attribute_list  : attribute_list attribute { result = val[0] << val[1] }
+                  |                          { result = [] }
+                  ;
+
+  attribute       : data data { result = val }
+                  ;
+
+  assoc_array     : 'a' ':' NUMBER ':' '{' attribute_list '}'
+                    {
+                      # Checks if the keys are a sequence of integers
+                      idx = -1
+                      arr = val[5].all? { |(k,v)| k == (idx += 1) }
+
+                      if arr
+                        result = val[5].map { |(k,v)| v }
+                      else
+                        result = Hash[val[5]]
+                      end
+                    }
+                  ;
+
+end
+
+---- header ----
+require 'php_serialization/tokenizer'
+
+---- inner ----
+  def initialize(tokenizer_klass = Tokenizer)
+    @tokenizer_klass = tokenizer_klass
+  end
+
+  def run(string)
+    @tokenizer = @tokenizer_klass.new(string)
+    yyparse(@tokenizer, :each)
+    return @object
+  ensure
+    @tokenizer = nil
+  end
+
+  def next_token
+    @tokenizer.next_token
+  end

data/vendor/bundle/ruby/2.6.0/gems/racc-1.5.2/test/assets/recv.y

@@ -0,0 +1,97 @@
+# s/r 5, r/r 10
+class A
+rule
+
+  content: RecvH         received
+    ;
+
+  datetime: day
+    ;
+
+  msgid: '<' spec '>';
+
+  day:
+    | ATOM ','
+    ;
+
+  received: recvitem_list recvdatetime
+    ;
+
+  recvitem_list:
+    | recvitem_list recvitem
+    ;
+
+  recvitem: by | via | with | for ;
+
+  by:
+    | BY domain
+    ;
+
+  via:
+    | VIA ATOM
+    ;
+
+  with: WITH ATOM
+    ;
+
+  for:
+    | FOR addr
+    ;
+
+  recvdatetime:
+    | ';' datetime
+    ;
+
+  addr: mbox | group ;
+
+  mboxes: mbox
+    | mboxes ',' mbox
+    ;
+
+  mbox: spec
+    | routeaddr
+    | phrase routeaddr
+    ;
+
+  group: phrase ':' mboxes ';'
+    ;
+
+  routeaddr: '<' route spec '>'
+    | '<' spec '>'
+    ;
+
+  route: at_domains ':' ;
+
+  at_domains: '@' domain
+    | at_domains ',' '@' domain
+    ;
+
+  spec: local '@' domain
+    | local
+    ;
+
+  local: word
+    | local '.' word
+    ;
+
+  domain: domword
+    | domain '.' domword
+    ;
+
+  domword: atom
+    | DOMLIT
+    | DIGIT
+    ;
+
+  phrase: word
+    | phrase word
+    ;
+
+  word: atom
+    | QUOTED
+    | DIGIT
+    ;
+
+  atom: ATOM | FROM | BY | VIA | WITH | ID | FOR ;
+
+end

data/vendor/bundle/ruby/2.6.0/gems/racc-1.5.2/test/assets/riml.y

@@ -0,0 +1,665 @@
+# Copyright (c) 2012-2014 by Luke Gruber
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class Riml::Parser
+
+token IF ELSE ELSEIF THEN UNLESS END
+token WHILE UNTIL BREAK CONTINUE
+token TRY CATCH FINALLY
+token FOR IN
+token DEF DEF_BANG SPLAT_PARAM SPLAT_ARG CALL BUILTIN_COMMAND # such as echo "hi"
+token CLASS NEW DEFM DEFM_BANG SUPER
+token RIML_FILE_COMMAND RIML_CLASS_COMMAND
+token RETURN
+token NEWLINE
+token NUMBER
+token STRING_D STRING_S # single- and double-quoted
+token EX_LITERAL
+token REGEXP
+token TRUE FALSE
+token LET UNLET UNLET_BANG IDENTIFIER
+token DICT_VAL # like dict.key, 'key' is a DICT_VAL
+token SCOPE_MODIFIER SCOPE_MODIFIER_LITERAL SPECIAL_VAR_PREFIX
+token FINISH
+
+prechigh
+  right '!'
+  left '*' '/' '%'
+  left '+' '-' '.'
+  left '>' '>#' '>?' '<' '<#' '<?' '>=' '>=#' '>=?'  '<=' '<=#' '<=?'
+  left '==' '==?' '==#' '=~' '=~?' '=~#' '!~' '!~?' '!~#' '!=' '!=?' '!=#'
+  left IS ISNOT
+  left '&&'
+  left '||'
+  right '?'
+  right '=' '+=' '-=' '.='
+  left ','
+  left IF UNLESS
+preclow
+
+# All rules
+rule
+
+  Root:
+    /* nothing */                        { result = make_node(val) { |_| Riml::Nodes.new([]) } }
+  | Terminator                           { result = make_node(val) { |_| Riml::Nodes.new([]) } }
+  | Statements                           { result = val[0] }
+  ;
+
+  # any list of expressions
+  Statements:
+    Statement                            { result = make_node(val) { |v| Riml::Nodes.new([ v[0] ]) } }
+  | Statements Terminator Statement      { result = val[0] << val[2] }
+  | Statements Terminator                { result = val[0] }
+  | Terminator Statements                { result = make_node(val) { |v| Riml::Nodes.new(v[1]) } }
+  ;
+
+  # All types of expressions in Riml
+  Statement:
+    ExplicitCall                          { result = val[0] }
+  | Def                                   { result = val[0] }
+  | Return                                { result = val[0] }
+  | UnletVariable                         { result = val[0] }
+  | ExLiteral                             { result = val[0] }
+  | For                                   { result = val[0] }
+  | While                                 { result = val[0] }
+  | Until                                 { result = val[0] }
+  | Try                                   { result = val[0] }
+  | ClassDefinition                       { result = val[0] }
+  | LoopKeyword                           { result = val[0] }
+  | EndScript                             { result = val[0] }
+  | RimlFileCommand                       { result = val[0] }
+  | RimlClassCommand                      { result = val[0] }
+  | MultiAssign                           { result = val[0] }
+  | If                                    { result = val[0] }
+  | Unless                                { result = val[0] }
+  | Expression                            { result = val[0] }
+  ;
+
+  Expression:
+    ExpressionWithoutDictLiteral          { result = val[0] }
+  | Dictionary                            { result = val[0] }
+  | Dictionary DictGetWithDotLiteral      { result = make_node(val) { |v| Riml::DictGetDotNode.new(v[0], v[1]) } }
+  | BinaryOperator                        { result = val[0] }
+  | Ternary                               { result = val[0] }
+  | Assign                                { result = val[0] }
+  | Super                                 { result = val[0] }
+  | '(' Expression ')'                    { result = make_node(val) { |v| Riml::WrapInParensNode.new(v[1]) } }
+  ;
+
+  ExpressionWithoutDictLiteral:
+    UnaryOperator                         { result = val[0] }
+  | DictGet                               { result = val[0] }
+  | ListOrDictGet                         { result = val[0] }
+  | AllVariableRetrieval                  { result = val[0] }
+  | LiteralWithoutDictLiteral             { result = val[0] }
+  | Call                                  { result = val[0] }
+  | ObjectInstantiation                   { result = val[0] }
+  | '(' ExpressionWithoutDictLiteral ')'  { result = make_node(val) { |v| Riml::WrapInParensNode.new(v[1]) } }
+  ;
+
+  # for inside curly-brace variable names
+  PossibleStringValue:
+    String                                { result = val[0] }
+  | DictGet                               { result = val[0] }
+  | ListOrDictGet                         { result = val[0] }
+  | AllVariableRetrieval                  { result = val[0] }
+  | BinaryOperator                        { result = val[0] }
+  | Ternary                               { result = val[0] }
+  | Call                                  { result = val[0] }
+  ;
+
+  Terminator:
+    NEWLINE                               { result = nil }
+  | ';'                                   { result = nil }
+  ;
+
+  LiteralWithoutDictLiteral:
+    Number                                { result = val[0] }
+  | String                                { result = val[0] }
+  | Regexp                                { result = val[0] }
+  | List                                  { result = val[0] }
+  | ScopeModifierLiteral                  { result = val[0] }
+  | TRUE                                  { result = make_node(val) { |_| Riml::TrueNode.new } }
+  | FALSE                                 { result = make_node(val) { |_| Riml::FalseNode.new } }
+  ;
+
+  Number:
+    NUMBER                                { result = make_node(val) { |v| Riml::NumberNode.new(v[0]) } }
+  ;
+
+  String:
+    STRING_S                              { result = make_node(val) { |v| Riml::StringNode.new(v[0], :s) } }
+  | STRING_D                              { result = make_node(val) { |v| Riml::StringNode.new(v[0], :d) } }
+  | String STRING_S                       { result = make_node(val) { |v| Riml::StringLiteralConcatNode.new(v[0], Riml::StringNode.new(v[1], :s)) } }
+  | String STRING_D                       { result = make_node(val) { |v| Riml::StringLiteralConcatNode.new(v[0], Riml::StringNode.new(v[1], :d)) } }
+  ;
+
+  Regexp:
+    REGEXP                                { result = make_node(val) { |v| Riml::RegexpNode.new(v[0]) } }
+  ;
+
+  ScopeModifierLiteral:
+    SCOPE_MODIFIER_LITERAL                { result = make_node(val) { |v| Riml::ScopeModifierLiteralNode.new(v[0]) } }
+  ;
+
+  List:
+    ListLiteral                           { result = make_node(val) { |v| Riml::ListNode.new(v[0]) } }
+  ;
+
+  ListUnpack:
+    '[' ListItems ';' Expression ']'      { result = make_node(val) { |v| Riml::ListUnpackNode.new(v[1] << v[3]) } }
+  ;
+
+  ListLiteral:
+    '[' ListItems ']'                     { result = val[1] }
+  | '[' ListItems ',' ']'                 { result = val[1] }
+  ;
+
+  ListItems:
+    /* nothing */                         { result = [] }
+  | Expression                            { result = [val[0]] }
+  | ListItems ',' Expression              { result = val[0] << val[2] }
+  ;
+
+  Dictionary:
+    DictionaryLiteral                     { result = make_node(val) { |v| Riml::DictionaryNode.new(v[0]) } }
+  ;
+
+  # {'key': 'value', 'key2': 'value2'}
+  # Save as [['key', 'value'], ['key2', 'value2']] because ruby-1.8.7 offers
+  # no guarantee for key-value pair ordering.
+  DictionaryLiteral:
+    '{' DictItems '}'                     { result = val[1] }
+  | '{' DictItems ',' '}'                 { result = val[1] }
+  ;
+
+  # [[key, value], [key, value]]
+  DictItems:
+    /* nothing */                         { result = [] }
+  | DictItem                              { result = val }
+  | DictItems ',' DictItem                { result = val[0] << val[2] }
+  ;
+
+  # [key, value]
+  DictItem:
+    Expression ':' Expression                   { result = [val[0], val[2]] }
+  ;
+
+  DictGet:
+    AllVariableRetrieval DictGetWithDot          { result = make_node(val) { |v| Riml::DictGetDotNode.new(v[0], v[1]) } }
+  | ListOrDictGet DictGetWithDot                 { result = make_node(val) { |v| Riml::DictGetDotNode.new(v[0], v[1]) } }
+  | Call DictGetWithDot                          { result = make_node(val) { |v| Riml::DictGetDotNode.new(v[0], v[1]) } }
+  | '(' Expression ')' DictGetWithDot            { result = make_node(val) { |v| Riml::DictGetDotNode.new(Riml::WrapInParensNode.new(v[1]), v[3]) } }
+  ;
+
+  ListOrDictGet:
+    ExpressionWithoutDictLiteral ListOrDictGetWithBrackets  { result = make_node(val) { |v| Riml::ListOrDictGetNode.new(v[0], v[1]) } }
+  | '(' Expression ')' ListOrDictGetWithBrackets            { result = make_node(val) { |v| Riml::ListOrDictGetNode.new(Riml::WrapInParensNode.new(v[1]), v[3]) } }
+  ;
+
+  ListOrDictGetAssign:
+    ExpressionWithoutDictLiteral ListOrDictGetWithBrackets  { result = make_node(val) { |v| Riml::ListOrDictGetNode.new(v[0], v[1]) } }
+  ;
+
+  ListOrDictGetWithBrackets:
+    '['  Expression ']'                           { result = [val[1]] }
+  | '['  SubList    ']'                           { result = [val[1]] }
+  | ListOrDictGetWithBrackets '[' Expression ']'  { result = val[0] << val[2] }
+  | ListOrDictGetWithBrackets '[' SubList    ']'  { result = val[0] << val[2] }
+  ;
+
+  SubList:
+    Expression ':' Expression          { result = make_node(val) { |v| Riml::SublistNode.new([v[0], Riml::LiteralNode.new(' : '), v[2]]) } }
+  | Expression ':'                     { result = make_node(val) { |v| Riml::SublistNode.new([v[0], Riml::LiteralNode.new(' :')]) } }
+  | ':' Expression                     { result = make_node(val) { |v| Riml::SublistNode.new([Riml::LiteralNode.new(': '), v[1]]) } }
+  | ':'                                { result = make_node(val) { |_| Riml::SublistNode.new([Riml::LiteralNode.new(':')]) } }
+  ;
+
+  DictGetWithDot:
+    DICT_VAL                        { result = [val[0]] }
+  | DictGetWithDot DICT_VAL         { result = val[0] << val[1] }
+  ;
+
+  DictGetWithDotLiteral:
+    '.' IDENTIFIER                  { result = [val[1]] }
+  | DictGetWithDotLiteral DICT_VAL  { result = val[0] << val[1] }
+  ;
+
+  Call:
+    Scope DefCallIdentifier '(' ArgList ')'       { result = make_node(val) { |v| Riml::CallNode.new(v[0], v[1], v[3]) } }
+  | DictGet '(' ArgList ')'                       { result = make_node(val) { |v| Riml::CallNode.new(nil, v[0], v[2]) } }
+  | BUILTIN_COMMAND '(' ArgList ')'               { result = make_node(val) { |v| Riml::CallNode.new(nil, v[0], v[2]) } }
+  | BUILTIN_COMMAND ArgListWithoutNothing         { result = make_node(val) { |v| Riml::CallNode.new(nil, v[0], v[1]) } }
+  | BUILTIN_COMMAND NEWLINE                       { result = make_node(val) { |v| Riml::CallNode.new(nil, v[0], []) } }
+  | CALL '(' ArgList ')'                          { result = make_node(val) { |v| Riml::ExplicitCallNode.new(nil, nil, v[2]) } }
+  ;
+
+  ObjectInstantiationCall:
+    Scope DefCallIdentifier '(' ArgList ')'       { result = make_node(val) { |v| Riml::CallNode.new(v[0], v[1], v[3]) } }
+  | Scope DefCallIdentifier                       { result = make_node(val) { |v| Riml::CallNode.new(v[0], v[1], []) } }
+  ;
+
+  RimlFileCommand:
+    RIML_FILE_COMMAND '(' ArgList ')'             { result = make_node(val) { |v| Riml::RimlFileCommandNode.new(nil, v[0], v[2]) } }
+  | RIML_FILE_COMMAND ArgList                     { result = make_node(val) { |v| Riml::RimlFileCommandNode.new(nil, v[0], v[1]) } }
+  ;
+
+  RimlClassCommand:
+    RIML_CLASS_COMMAND '(' ClassArgList ')'       { result = make_node(val) { |v| Riml::RimlClassCommandNode.new(nil, v[0], v[2]) } }
+  | RIML_CLASS_COMMAND ClassArgList               { result = make_node(val) { |v| Riml::RimlClassCommandNode.new(nil, v[0], v[1]) } }
+  ;
+
+  ClassArgList:
+    Scope IDENTIFIER                              { result = ["#{val[0]}#{val[1]}"] }
+  | String                                        { result = val }
+  | ClassArgList ',' Scope IDENTIFIER             { result = val[0].concat ["#{val[2]}#{val[3]}"] }
+  ;
+
+  ExplicitCall:
+    CALL Scope DefCallIdentifier '(' ArgList ')'  { result = make_node(val) { |v| Riml::ExplicitCallNode.new(v[1], v[2], v[4]) } }
+  | CALL DictGet '(' ArgList ')'                  { result = make_node(val) { |v| Riml::ExplicitCallNode.new(nil, v[1], v[3]) } }
+  ;
+
+  Scope:
+    SCOPE_MODIFIER         { result = val[0] }
+  | /* nothing */          { result = nil }
+  ;
+
+  # [SID, scope_modifier]
+  SIDAndScope:
+    Scope                       { result = [ nil, val[0] ] }
+  | '<' IDENTIFIER '>' Scope    { result = [ make_node(val) { |v| Riml::SIDNode.new(v[1]) }, val[3] ] }
+  ;
+
+  ArgList:
+    /* nothing */                                  { result = [] }
+  | ArgListWithoutNothingWithSplat                 { result = val[0] }
+  ;
+
+  ArgListWithSplat:
+    /* nothing */                         { result = [] }
+  | ArgListWithoutNothingWithSplat        { result = val[0] }
+  ;
+
+  ArgListWithoutNothingWithSplat:
+    Expression                                                   { result = val }
+  | SPLAT_ARG Expression                                         { result = [ make_node(val) { |v| Riml::SplatNode.new(v[1]) } ] }
+  | ArgListWithoutNothingWithSplat "," Expression                { result = val[0] << val[2] }
+  | ArgListWithoutNothingWithSplat "," SPLAT_ARG Expression      { result = val[0] << make_node(val) { |v| Riml::SplatNode.new(v[3]) } }
+  ;
+
+  ArgListWithoutNothing:
+    Expression                               { result = val }
+  | ArgListWithoutNothing "," Expression     { result = val[0] << val[2] }
+  ;
+
+  BinaryOperator:
+    Expression '||' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '&&' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '==' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '==#' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '==?' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  # added by riml
+  | Expression '===' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '!=' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '!=#' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '!=?' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '=~' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '=~#' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '=~?' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '!~' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '!~#' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '!~?' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '>' Expression             { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '>#' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '>?' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '>=' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '>=#' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '>=?' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '<' Expression             { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '<#' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '<?' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '<=' Expression            { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '<=#' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '<=?' Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression '+' Expression             { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '-' Expression             { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '*' Expression             { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '/' Expression             { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '.' Expression             { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression '%' Expression             { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+
+  | Expression IS    Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  | Expression ISNOT Expression           { result = make_node(val) { |v| Riml::BinaryOperatorNode.new(v[1], [v[0], v[2]]) } }
+  ;
+
+  UnaryOperator:
+    '!' Expression                        { result = make_node(val) { |v| Riml::UnaryOperatorNode.new(val[0], [val[1]]) } }
+  | '+' Expression                        { result = make_node(val) { |v| Riml::UnaryOperatorNode.new(val[0], [val[1]]) } }
+  | '-' Expression                        { result = make_node(val) { |v| Riml::UnaryOperatorNode.new(val[0], [val[1]]) } }
+  ;
+
+  # ['=', LHS, RHS]
+  Assign:
+    LET AssignExpression                  { result = make_node(val) { |v| Riml::AssignNode.new(v[1][0], v[1][1], v[1][2]) } }
+  | AssignExpression                      { result = make_node(val) { |v| Riml::AssignNode.new(v[0][0], v[0][1], v[0][2]) } }
+  ;
+
+  MultiAssign:
+    Assign ',' Assign                     { result = make_node(val) { |v| Riml::MultiAssignNode.new([v[0], v[2]]) } }
+  | MultiAssign ',' Assign                { val[0].assigns << val[2]; result = val[0] }
+  ;
+
+  # ['=', AssignLHS, Expression]
+  AssignExpression:
+    AssignLHS '='  Expression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '+=' Expression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '-=' Expression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '.=' Expression             { result = [val[1], val[0], val[2]] }
+  ;
+
+  AssignLHS:
+    AllVariableRetrieval                  { result = val[0] }
+  | List                                  { result = val[0] }
+  | ListUnpack                            { result = val[0] }
+  | DictGet                               { result = val[0] }
+  | ListOrDictGetAssign                   { result = val[0] }
+  ;
+
+  # retrieving the value of a variable
+  VariableRetrieval:
+    SimpleVariableRetrieval                        { result = val[0] }
+  | SPECIAL_VAR_PREFIX IDENTIFIER                  { result = make_node(val) { |v| Riml::GetSpecialVariableNode.new(v[0], v[1]) } }
+  | ScopeModifierLiteral ListOrDictGetWithBrackets { result = make_node(val) { |v| Riml::GetVariableByScopeAndDictNameNode.new(v[0], v[1]) } }
+  ;
+
+  SimpleVariableRetrieval:
+    Scope IDENTIFIER                               { result = make_node(val) { |v| Riml::GetVariableNode.new(v[0], v[1]) } }
+  ;
+
+  AllVariableRetrieval:
+    VariableRetrieval                          { result = val[0] }
+  | Scope CurlyBraceName                       { result = make_node(val) { |v| Riml::GetCurlyBraceNameNode.new(v[0], v[1]) } }
+  ;
+
+  UnletVariable:
+    UNLET VariableRetrieval                    { result = make_node(val) { |v| Riml::UnletVariableNode.new('!', [ v[1] ]) } }
+  | UNLET_BANG VariableRetrieval               { result = make_node(val) { |v| Riml::UnletVariableNode.new('!', [ v[1] ]) } }
+  | UnletVariable VariableRetrieval            { result = val[0] << val[1] }
+  ;
+
+  CurlyBraceName:
+    CurlyBraceVarPart                          { result = make_node(val) { |v| Riml::CurlyBraceVariable.new([ v[0] ]) } }
+  | IDENTIFIER CurlyBraceName                  { result = make_node(val) { |v| Riml::CurlyBraceVariable.new([ Riml::CurlyBracePart.new(v[0]), v[1] ]) } }
+  | CurlyBraceName IDENTIFIER                  { result = val[0] << make_node(val) { |v| Riml::CurlyBracePart.new(v[1]) } }
+  | CurlyBraceName CurlyBraceVarPart           { result = val[0] << val[1] }
+  ;
+
+  CurlyBraceVarPart:
+    '{' PossibleStringValue '}'                     { result = make_node(val) { |v| Riml::CurlyBracePart.new(v[1]) } }
+  | '{' PossibleStringValue CurlyBraceVarPart '}'   { result = make_node(val) { |v| Riml::CurlyBracePart.new([v[1], v[2]]) } }
+  | '{' CurlyBraceVarPart PossibleStringValue '}'   { result = make_node(val) { |v| Riml::CurlyBracePart.new([v[1], v[2]]) } }
+  ;
+
+  # Method definition
+  # [SID, scope_modifier, name, parameters, keyword, expressions]
+  Def:
+    FunctionType SIDAndScope DefCallIdentifier DefKeywords Block END                                     { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], [], v[3], v[4]) } }
+  | FunctionType SIDAndScope DefCallIdentifier '(' ParamList ')' DefKeywords Block END                   { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], v[4], v[6], v[7]) } }
+  | FunctionType SIDAndScope DefCallIdentifier '(' SPLAT_PARAM     ')' DefKeywords Block END             { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], [v[4]], v[6], v[7]) } }
+  | FunctionType SIDAndScope DefCallIdentifier '(' ParamList ',' SPLAT_PARAM ')' DefKeywords Block END   { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], v[4] << v[6], v[8], v[9]) } }
+  ;
+
+  FunctionType:
+    DEF           { result = "DefNode" }
+  | DEF_BANG      { result = "DefNode" }
+  | DEFM          { result = "DefMethodNode" }
+  ;
+
+  DefCallIdentifier:
+    # use '' for first argument instead of nil in order to avoid a double scope-modifier
+    CurlyBraceName          { result = make_node(val) { |v| Riml::GetCurlyBraceNameNode.new('', v[0]) } }
+  | IDENTIFIER              { result = val[0] }
+  ;
+
+  # Example: 'range', 'dict' or 'abort' after function definition
+  DefKeywords:
+    IDENTIFIER             { result = [val[0]] }
+  | DefKeywords IDENTIFIER { result = val[0] << val[1] }
+  | /* nothing */          { result = nil }
+  ;
+
+  ParamList:
+    /* nothing */                         { result = [] }
+  | IDENTIFIER                            { result = val }
+  | DefaultParam                          { result = val }
+  | ParamList ',' IDENTIFIER              { result = val[0] << val[2] }
+  | ParamList ',' DefaultParam            { result = val[0] << val[2] }
+  ;
+
+  DefaultParam:
+    IDENTIFIER '=' Expression                { result = make_node(val) { |v| Riml::DefaultParamNode.new(v[0], v[2]) } }
+  ;
+
+  Return:
+    RETURN Returnable                        { result = make_node(val) { |v| Riml::ReturnNode.new(v[1]) } }
+  | RETURN Returnable IF Expression          { result = make_node(val) { |v| Riml::IfNode.new(v[3], Nodes.new([ReturnNode.new(v[1])])) } }
+  | RETURN Returnable UNLESS Expression      { result = make_node(val) { |v| Riml::UnlessNode.new(v[3], Nodes.new([ReturnNode.new(v[1])])) } }
+  ;
+
+  Returnable:
+    /* nothing */     { result = nil }
+  | Expression        { result = val[0] }
+  ;
+
+  EndScript:
+    FINISH                                  { result = make_node(val) { |_| Riml::FinishNode.new } }
+  ;
+
+  # [expression, expressions]
+  If:
+    IF Expression IfBlock END               { result = make_node(val) { |v| Riml::IfNode.new(v[1], v[2]) } }
+  | IF Expression THEN Expression END       { result = make_node(val) { |v| Riml::IfNode.new(v[1], Riml::Nodes.new([v[3]])) } }
+  | Expression IF Expression                { result = make_node(val) { |v| Riml::IfNode.new(v[2], Riml::Nodes.new([v[0]])) } }
+  ;
+
+  Unless:
+    UNLESS Expression IfBlock END           { result = make_node(val) { |v| Riml::UnlessNode.new(v[1], v[2]) } }
+  | UNLESS Expression THEN Expression END   { result = make_node(val) { |v| Riml::UnlessNode.new(v[1], Riml::Nodes.new([v[3]])) } }
+  | Expression UNLESS Expression            { result = make_node(val) { |v| Riml::UnlessNode.new(v[2], Riml::Nodes.new([v[0]])) } }
+  ;
+
+  Ternary:
+    Expression '?' Expression ':' Expression   { result = make_node(val) { |v| Riml::TernaryOperatorNode.new([v[0], v[2], v[4]]) } }
+  ;
+
+  While:
+    WHILE Expression Block END                 { result = make_node(val) { |v| Riml::WhileNode.new(v[1], v[2]) } }
+  ;
+
+  LoopKeyword:
+    BREAK                                      { result = make_node(val) { |_| Riml::BreakNode.new } }
+  | CONTINUE                                   { result = make_node(val) { |_| Riml::ContinueNode.new } }
+  ;
+
+  Until:
+    UNTIL Expression Block END                 { result = make_node(val) { |v| Riml::UntilNode.new(v[1], v[2]) } }
+  ;
+
+  For:
+    FOR SimpleVariableRetrieval IN Expression Block END     { result = make_node(val) { |v| Riml::ForNode.new(v[1], v[3], v[4]) } }
+  | FOR List IN Expression Block END                        { result = make_node(val) { |v| Riml::ForNode.new(v[1], v[3], v[4]) } }
+  | FOR ListUnpack IN Expression Block END                  { result = make_node(val) { |v| Riml::ForNode.new(v[1], v[3], v[4]) } }
+  ;
+
+  Try:
+    TRY Block END                              { result = make_node(val) { |v| Riml::TryNode.new(v[1], nil, nil) } }
+  | TRY Block Catch END                        { result = make_node(val) { |v| Riml::TryNode.new(v[1], v[2], nil) } }
+  | TRY Block Catch FINALLY Block END          { result = make_node(val) { |v| Riml::TryNode.new(v[1], v[2], v[4]) } }
+  ;
+
+  Catch:
+    /* nothing */                              { result = nil }
+  | CATCH Block                                { result = [ make_node(val) { |v| Riml::CatchNode.new(nil, v[1]) } ] }
+  | CATCH Catchable Block                      { result = [ make_node(val) { |v| Riml::CatchNode.new(v[1], v[2]) } ] }
+  | Catch CATCH Block                          { result = val[0] << make_node(val) { |v| Riml::CatchNode.new(nil, v[2]) } }
+  | Catch CATCH Catchable Block                { result = val[0] << make_node(val) { |v| Riml::CatchNode.new(v[2], v[3]) } }
+  ;
+
+  Catchable:
+    Regexp                                      { result = val[0] }
+  | String                                      { result = val[0] }
+  ;
+
+  # [expressions]
+  # expressions list could contain an ElseNode, which contains expressions
+  # itself
+  Block:
+    NEWLINE Statements                        { result = val[1] }
+  | NEWLINE                                   { result = make_node(val) { |_| Riml::Nodes.new([]) } }
+  ;
+
+  IfBlock:
+    Block                                     { result = val[0] }
+  | NEWLINE Statements ElseBlock              { result = val[1] << val[2] }
+  | NEWLINE Statements ElseifBlock            { result = val[1] << val[2] }
+  | NEWLINE Statements ElseifBlock ElseBlock  { result = val[1] << val[2] << val[3] }
+  ;
+
+  ElseBlock:
+    ELSE NEWLINE Statements                   { result = make_node(val) { |v| Riml::ElseNode.new(v[2]) } }
+  ;
+
+  ElseifBlock:
+    ELSEIF Expression NEWLINE Statements                   { result = make_node(val) { |v| Riml::Nodes.new([Riml::ElseifNode.new(v[1], v[3])]) } }
+  | ElseifBlock ELSEIF Expression NEWLINE Statements       { result = val[0] << make_node(val) { |v| Riml::ElseifNode.new(v[2], v[4]) } }
+  ;
+
+  ClassDefinition:
+    CLASS Scope IDENTIFIER Block END                         { result = make_node(val) { |v| Riml::ClassDefinitionNode.new(v[1], v[2], nil, v[3]) } }
+  | CLASS Scope IDENTIFIER '<' Scope IDENTIFIER Block END    { result = make_node(val) { |v| Riml::ClassDefinitionNode.new(v[1], v[2], (v[4] || ClassDefinitionNode::DEFAULT_SCOPE_MODIFIER) + v[5], v[6]) } }
+  ;
+
+  ObjectInstantiation:
+    NEW ObjectInstantiationCall                              { result = make_node(val) { |v| Riml::ObjectInstantiationNode.new(v[1]) } }
+  ;
+
+  Super:
+    SUPER '(' ArgListWithSplat ')'     { result = make_node(val) { |v| Riml::SuperNode.new(v[2], true) } }
+  | SUPER                              { result = make_node(val) { |_| Riml::SuperNode.new([], false) } }
+  ;
+
+  ExLiteral:
+    EX_LITERAL                { result = make_node(val) { |v| Riml::ExLiteralNode.new(v[0]) } }
+  ;
+end
+
+---- header
+  require File.expand_path("../lexer", __FILE__)
+  require File.expand_path("../nodes", __FILE__)
+  require File.expand_path("../errors", __FILE__)
+  require File.expand_path("../ast_rewriter", __FILE__)
+---- inner
+  # This code will be put as-is in the parser class
+
+  attr_accessor :ast_rewriter
+  attr_writer :options
+
+  # The Parser and AST_Rewriter share this same hash of options
+  def options
+    @options ||= {}
+  end
+
+  def self.ast_cache
+    @ast_cache
+  end
+  @ast_cache = {}
+
+  # parses tokens or code into output nodes
+  def parse(object, ast_rewriter = Riml::AST_Rewriter.new, filename = nil, included = false)
+    if (ast = self.class.ast_cache[filename])
+    else
+      if tokens?(object)
+        @tokens = object
+      elsif code?(object)
+        @lexer = Riml::Lexer.new(object, filename, true)
+      end
+
+      begin
+        ast = do_parse
+      rescue Racc::ParseError => e
+        raise unless @lexer
+        if (invalid_token = @lexer.prev_token_is_keyword?)
+          warning = "#{invalid_token.inspect} is a keyword, and cannot " \
+            "be used as a variable name"
+        end
+        error_msg = e.message
+        error_msg << "\nWARNING: #{warning}" if warning
+        error = Riml::ParseError.new(error_msg, @lexer.filename, @lexer.lineno)
+        raise error
+      end
+      self.class.ast_cache[filename] = ast if filename
+    end
+    @ast_rewriter ||= ast_rewriter
+    return ast unless @ast_rewriter
+    @ast_rewriter.ast = ast.dup
+    @ast_rewriter.options ||= options
+    @ast_rewriter.rewrite(filename, included)
+    @ast_rewriter.ast
+  end
+
+  # get the next token from either the list of tokens provided, or
+  # the lexer getting the next token
+  def next_token
+    return @tokens.shift unless @lexer
+    token = @lexer.next_token
+    if token && @lexer.parser_info
+      @current_parser_info = token.pop
+    end
+    token
+  end
+
+  private
+
+  def tokens?(object)
+    Array === object
+  end
+
+  def code?(object)
+    String === object
+  end
+
+  def make_node(racc_val)
+    node = yield racc_val
+    node.parser_info = @current_parser_info
+    node
+  end