riml 0.1.3 → 0.1.5

data/bin/riml

@@ -1,12 +1,11 @@
 #!/usr/bin/env ruby
 # vim: syntax=ruby
 
-require File.expand_path("../../config/environment", __FILE__)
+require File.expand_path("../../lib/environment", __FILE__)
 
 module Riml
   include Environment
-  require File.join(ROOTDIR, 'version')
-  require File.join(LIBDIR, "helper")
+  require 'riml'
 
   require 'optparse'
   require 'ostruct'
@@ -16,32 +15,41 @@ module Riml
 
       # defaults
       options = OpenStruct.new
-      options.compile = []
-      options.riml_source_path = Dir.getwd
+      options.compile_files = []
 
       OptionParser.new do |opts|
         opts.banner = "Usage: riml [options]"
         opts.separator ""
         opts.separator "Specific options:"
 
-        opts.on("-c", "--compile FILE", "Compile riml file to VimL") do |file|
+        opts.on("-c", "--compile FILE", "Compile riml file to VimL.") do |file|
           if File.exists?(file)
-            options.compile << file
+            options.compile_files << file
           else
-            warn "Couldn't find file #{file.inspect}"
+            warn "Couldn't find file #{file.inspect}."
+            exit 1
           end
         end
 
-        opts.on("-s", "--stdio", "pipe in riml to STDIN and get back VimL on STDOUT") do
+        opts.on("-t", "--source-path PATH", "Path riml uses for `riml_source` to find files. Defaults to pwd.") do |path|
+          if Dir.exists?(path)
+            Riml.source_path = path
+          else
+            warn "Couldn't find directory #{path.inspect}."
+            exit 1
+          end
+        end
+
+        opts.on("-s", "--stdio", "Pipe in riml to STDIN and get back VimL on STDOUT.") do
           options.stdio = true
         end
 
-        opts.on_tail("-v", "--version", "Show riml version") do
+        opts.on_tail("-v", "--version", "Show riml version.") do
           puts VERSION.join('.')
           exit
         end
 
-        opts.on_tail("-h", "--help", "Show this message") do
+        opts.on_tail("-h", "--help", "Show this message.") do
           puts opts
           exit
         end
@@ -55,12 +63,11 @@ module Riml
     class << self
       def start
         options = Options.parse(ARGV)
+
         if options.stdio
           puts Riml.compile($stdin.gets)
-        elsif options.compile.any?
-          options.compile.each do |file|
-            Riml.compile_file(file)
-          end
+        elsif options.compile_files.any?
+          Riml.compile_files(*options.compile_files)
         end
       end
     end

data/lib/ast_rewriter.rb

@@ -6,8 +6,8 @@ module Riml
   class AST_Rewriter
     include Riml::Constants
 
-    attr_reader :ast
-    def initialize(ast)
+    attr_accessor :ast
+    def initialize(ast = nil)
       @ast = ast
     end
 
@@ -134,11 +134,12 @@ module Riml
         def replace(node)
           def_node = node.to_def_node
           node.parent_node = ast.expressions
+          def_node.parent_node = ast.expressions
           node.remove
           def_node.name.insert(0, "#{dict_name}.")
           def_node.parent_node = constructor.expressions
           constructor.expressions << def_node
-          reestablish_parents(node)
+          reestablish_parents(def_node)
         end
       end
 
@@ -259,8 +260,8 @@ module Riml
       end
 
       def replace(node)
-        node.replace_with(ExplicitCallNode.new(node[0], node[1], node[2]))
-        reestablish_parents(node)
+        explicit = node.replace_with(ExplicitCallNode.new(node[0], node[1], node[2]))
+        reestablish_parents(explicit)
       end
     end
 

data/lib/compiler.rb

@@ -14,7 +14,6 @@ module Riml
       end
 
       def visit(node)
-        node.compiled_output.clear
         @value = compile(node)
         @value << "\n" if node.force_newline and @value[-1] != "\n"
         propagate_up_tree(node, @value)
@@ -33,12 +32,11 @@ module Riml
       def compile(node)
         condition_visitor = visitor_for_node(node.condition)
         node.condition.parent_node = node
-        node.body.parent_node = node
-        node.compiled_output = "if ("
+        node.condition.force_newline = true
+        node.compiled_output = "if "
         node.compiled_output << "!" if UnlessNode === node
 
         node.condition.accept(condition_visitor)
-        node.compiled_output << ")\n"
         node.body.accept(NodesVisitor.new(:propagate_up_tree => false))
 
         node.body.compiled_output.each_line do |line|
@@ -69,12 +67,10 @@ module Riml
 
     class WhileNodeVisitor < Visitor
       def compile(node)
-        node.condition.parent_node = node
-        node.compiled_output = "while ("
+        node.condition.force_newline = true
+        node.compiled_output = "while "
         node.compiled_output << "!" if UntilNode === node
-
         node.condition.accept visitor_for_node(node.condition)
-        node.compiled_output << ")\n"
 
         node.body.accept NodesVisitor.new(:propagate_up_tree => false)
 
@@ -92,19 +88,18 @@ module Riml
     class ElseNodeVisitor < Visitor
       def compile(node)
         node.compiled_output = "else\n"
-        expressions_visitor = NodesVisitor.new
-        node.expressions.parent_node = node
-        node.expressions.accept(expressions_visitor)
+        node.expressions.parent = node
+        node.expressions.accept(visitor_for_node(node.expressions))
         node.compiled_output
       end
     end
 
     class ElseifNodeVisitor < Visitor
       def compile(node)
-        node.compiled_output = "elseif ("
+        node.compiled_output = "elseif "
         node.condition.parent_node = node
+        node.condition.force_newline = true
         node.condition.accept(visitor_for_node(node.condition))
-        node.compiled_output << ")\n"
         node.expressions.parent_node = node
         node.expressions.accept(visitor_for_node(node.expressions))
         node.force_newline = true
@@ -127,6 +122,8 @@ module Riml
       end
     end
 
+    SublistNodeVisitor = NodesVisitor
+
     class LiteralNodeVisitor < Visitor
       def compile(node)
         value = case node.value
@@ -208,6 +205,15 @@ module Riml
       end
     end
 
+    class WrapInParensNodeVisitor < Visitor
+      def compile(node)
+        node.compiled_output << "("
+        node.expression.parent_node = node
+        node.expression.accept(visitor_for_node(node.expression))
+        node.compiled_output << ")"
+      end
+    end
+
     # common visiting methods for nodes that are scope modified with variable
     # name prefixes
     class ScopedVisitor < Visitor
@@ -305,19 +311,15 @@ module Riml
     class BinaryOperatorNodeVisitor < Visitor
       def compile(node)
         op1, op2 = node.operand1, node.operand2
-        op1_visitor, op2_visitor = visitor_for_node(op1), visitor_for_node(op2)
-        node.operands.each {|n| n.parent_node = node}
-        op1.accept(op1_visitor)
-        op2_visitor.propagate_up_tree = false
-        op2.accept(op2_visitor)
+        [op1, op2].each {|n| n.parent = node}
+        op1.accept(visitor_for_node(op1))
         if node.ignorecase_capable_operator?(node.operator)
           operator_suffix = "# "
         else
           operator_suffix = " "
         end
         node.compiled_output << " #{node.operator}#{operator_suffix}"
-        op2_visitor.propagate_up_tree = true
-        op2.accept(op2_visitor)
+        op2.accept(visitor_for_node(op2))
         node.compiled_output
       end
     end
@@ -405,34 +407,40 @@ module Riml
 
     class CallNodeVisitor < ScopedVisitor
       def compile(node)
-        set_modifier(node) unless node.builtin_function?
+        set_modifier(node) if node.name && !node.builtin_function?
         node.compiled_output =
-        if node.name.respond_to?(:variable)
-          node.name.accept(visitor_for_node(node.name))
-          node.scope_modifier + node.name.compiled_output
-        elsif DictGetDotNode === node.name
-          node.name.accept(visitor_for_node(node.name))
-          node.name.compiled_output
-        else
-          "#{node.full_name}"
-        end
-        node.compiled_output << (node.no_parens_necessary? ? " " : "(")
+          if node.name.respond_to?(:variable)
+            node.name.accept(visitor_for_node(node.name))
+            node.scope_modifier + node.name.compiled_output
+          elsif DictGetDotNode === node.name
+            node.name.accept(visitor_for_node(node.name))
+            node.name.compiled_output
+          else
+            "#{node.full_name}"
+          end
+        compile_arguments(node)
+        node.compiled_output
+      end
+
+      def compile_arguments(node)
+        node.compiled_output << (node.builtin_command? ? " " : "(")
         node.arguments.each_with_index do |arg, i|
           arg.parent_node = node
           arg_visitor = visitor_for_node(arg)
           arg.accept(arg_visitor)
           node.compiled_output << ", " unless last_arg?(node.arguments, i)
         end
-        node.compiled_output << ")" unless node.no_parens_necessary?
+        node.compiled_output << ")" unless node.builtin_command?
 
         unless node.descendant_of_control_structure? ||
                node.descendant_of_call_node? ||
                node.descendant_of_list_node? ||
                node.descendant_of_list_or_dict_get_node? ||
-               node.descendant_of_operator_node?
+               node.descendant_of_operator_node? ||
+               node.descendant_of_wrap_in_parens_node? ||
+               node.descendant_of_sublist_node?
           node.force_newline = true
         end
-        node.compiled_output
       end
 
       private
@@ -443,9 +451,36 @@ module Riml
 
     class ExplicitCallNodeVisitor < CallNodeVisitor
       def compile(node)
-        pre = "call "
-        post = super
-        node.compiled_output = pre << post
+        if node.scope_modifier || node.name
+          node.compiled_output = "call " << super
+        else
+          node.compiled_output = "call"
+          compile_arguments(node)
+        end
+        node.compiled_output
+      end
+    end
+
+    class RimlCommandNodeVisitor < CallNodeVisitor
+      def compile(node)
+        if node.name == 'riml_source'
+          node.arguments.map(&:value).each do |file|
+            unless File.exists?(File.join(Riml.source_path, file))
+              raise Riml::FileNotFound, "#{file.inspect} could not be found in " \
+                "source path (#{Riml.source_path.inspect})"
+            end
+
+            root_node(node).current_compiler.compile_queue << file
+          end
+          node.compiled_output << 'source'
+          compile_arguments(node)
+          node.compiled_output.gsub(/['"]/, '').gsub('.riml', '.vim')
+        end
+      end
+
+      def root_node(node)
+        node = node.parent until node.parent.nil?
+        node
       end
     end
 
@@ -568,10 +603,21 @@ module Riml
       end
     end
 
+    module CompilerAccessible
+      attr_accessor :current_compiler
+    end
+
+    def compile_queue
+      @compile_queue ||= []
+    end
+
     # compiles nodes into output code
     def compile(root_node)
-      root_visitor = NodesVisitor.new
-      root_node.accept(root_visitor)
+      # so we can compile concurrently, as some nodes have access to the
+      # compiler instance itself
+      root_node.extend CompilerAccessible
+      root_node.current_compiler = self
+      root_node.accept(NodesVisitor.new)
       root_node.compiled_output
     end
 

data/lib/constants.rb

@@ -11,10 +11,14 @@ module Riml
          class new)
     DEFINE_KEYWORDS = %w(def def! defm defm! function function!)
     KEYWORDS = VIML_KEYWORDS + VIML_END_KEYWORDS + RIML_KEYWORDS
+
     SPECIAL_VARIABLE_PREFIXES =
       %w(& @ $)
     BUILTIN_COMMANDS  =
       %w(echo echon echohl execute sleep)
+    RIML_COMMANDS =
+      %w(riml_source)
+
     IGNORECASE_CAPABLE_OPERATORS =
       %w(== != >= > <= < =~ !~)
     COMPARISON_OPERATORS = IGNORECASE_CAPABLE_OPERATORS.map do |o|

data/{config → lib}/environment.rb

@@ -1,9 +1,10 @@
 module Riml
   module Environment
     ROOTDIR = File.expand_path('../../', __FILE__)
+    require File.join(ROOTDIR, 'version')
 
-    LIBDIR = File.join(ROOTDIR, "lib")
-    BINDIR = File.join(ROOTDIR, "bin")
+    LIBDIR = File.join(ROOTDIR, 'lib')
+    BINDIR = File.join(ROOTDIR, 'bin')
 
     $:.unshift(LIBDIR) unless $:.include? LIBDIR
   end

data/lib/errors.rb

@@ -1,4 +1,9 @@
 module Riml
-  class ParseError < StandardError; end
-  class SyntaxError < ::SyntaxError; end
+  RimlError = Class.new(StandardError)
+
+  SyntaxError  = Class.new(RimlError)
+  ParseError   = Class.new(RimlError)
+  CompileError = Class.new(RimlError)
+
+  FileNotFound = Class.new(RimlError)
 end

data/lib/grammar.y

@@ -5,7 +5,7 @@ token WHILE UNTIL BREAK CONTINUE
 token TRY CATCH ENSURE
 token FOR IN
 token DEF DEF_BANG SPLAT CALL BUILTIN_COMMAND # such as echo "hi"
-token CLASS NEW DEFM DEFM_BANG SUPER
+token CLASS NEW DEFM DEFM_BANG SUPER RIML_COMMAND
 token RETURN
 token NEWLINE
 token NUMBER
@@ -21,14 +21,14 @@ token FINISH
 prechigh
   right '!'
   left '*' '/' '%'
-  left '+' '+=' '-' '-=' '.'
+  left '+' '-' '.'
   left '>' '>#' '>?' '<' '<#' '<?' '>=' '>=#' '>=?'  '<=' '<=#' '<=?'
   left '==' '==?' '==#' '=~' '=~?' '=~#' '!~' '!~?' '!~#' '!=' '!=?' '!=#'
   left IS ISNOT
   left '&&'
   left '||'
   right '?'
-  right '='
+  right '=' '+=' '-=' '.='
   left ','
   left IF UNLESS
 preclow
@@ -43,40 +43,47 @@ rule
 
   # any list of expressions
   Expressions:
-    Expression                            { result = Nodes.new([ val[0] ]) }
-  | Expressions Terminator Expression     { result = val[0] << val[2] }
+    AnyExpression                         { result = Nodes.new([ val[0] ]) }
+  | Expressions Terminator AnyExpression  { result = val[0] << val[2] }
   | Expressions Terminator                { result = val[0] }
   | Terminator                            { result = Nodes.new([]) }
   ;
 
   # All types of expressions in Riml
-  Expression:
-    BinaryOperator                        { result = val[0] }
-  | UnaryOperator                         { result = val[0] }
-  | Call                                  { result = val[0] }
-  | Assign                                { result = val[0] }
-  | DictGet                               { result = val[0] }
-  | ListOrDictGet                         { result = val[0] }
+  AnyExpression:
+    ExplicitCall                          { result = val[0] }
   | Def                                   { result = val[0] }
   | Return                                { result = val[0] }
-  | VariableRetrieval                     { result = val[0] }
   | UnletVariable                         { result = val[0] }
-  | Literal                               { result = val[0] }
   | ExLiteral                             { result = val[0] }
-  | Heredoc                               { result = val[0] }
   | If                                    { result = val[0] }
   | Unless                                { result = val[0] }
-  | Ternary                               { result = val[0] }
+  | For                                   { result = val[0] }
   | While                                 { result = val[0] }
   | Until                                 { result = val[0] }
-  | For                                   { result = val[0] }
   | Try                                   { result = val[0] }
   | ClassDefinition                       { result = val[0] }
-  | ObjectInstantiation                   { result = val[0] }
   | Super                                 { result = val[0] }
   | LoopKeyword                           { result = val[0] }
   | EndScript                             { result = val[0] }
-  | '(' Expression ')'                    { result = val[1] }
+  | ValueExpression                       { result = val[0] }
+  | RimlCommand                           { result = val[0] }
+  ;
+
+  # Expressions that evaluate to a value
+  ValueExpression:
+    UnaryOperator                         { result = val[0] }
+  | Assign                                { result = val[0] }
+  | DictGet                               { result = val[0] }
+  | ListOrDictGet                         { result = val[0] }
+  | VariableRetrieval                     { result = val[0] }
+  | Literal                               { result = val[0] }
+  | Call                                  { result = val[0] }
+  | Heredoc                               { result = val[0] }
+  | Ternary                               { result = val[0] }
+  | ObjectInstantiation                   { result = val[0] }
+  | BinaryOperator                        { result = val[0] }
+  | '(' ValueExpression ')'               { result = WrapInParensNode.new(val[1]) }
   ;
 
   Terminator:
@@ -100,8 +107,6 @@ rule
 
   Number:
     NUMBER                                { result = NumberNode.new(val[0]) }
-  | '-' NUMBER                            { result = NumberNode.new(val[1].insert(0, val[0])) }
-  | '+' NUMBER                            { result = NumberNode.new(val[1].insert(0, val[0])) }
   ;
 
   String:
@@ -132,8 +137,8 @@ rule
 
   ListItems:
     /* nothing */                         { result = [] }
-  | Expression                            { result = [val[0]] }
-  | ListItems ',' Expression              { result = val[0] << val[2] }
+  | ValueExpression                       { result = [val[0]] }
+  | ListItems ',' ValueExpression         { result = val[0] << val[2] }
   ;
 
   Dictionary:
@@ -159,30 +164,27 @@ rule
   ;
 
   DictGet:
-    Dictionary ListOrDictGetWithBrackets         { result = DictGetBracketNode.new(val[0], val[1]) }
-  | Dictionary DictGetWithDotLiteral             { result = DictGetDotNode.new(val[0], val[1]) }
+    Dictionary DictGetWithDotLiteral             { result = DictGetDotNode.new(val[0], val[1]) }
   | VariableRetrieval DictGetWithDot             { result = DictGetDotNode.new(val[0], val[1]) }
   | ListOrDictGet DictGetWithDot                 { result = DictGetDotNode.new(val[0], val[1]) }
   ;
 
   ListOrDictGet:
-    VariableRetrieval ListOrDictGetWithBrackets    { result = ListOrDictGetNode.new(val[0], val[1]) }
-  | DictGet ListOrDictGetWithBrackets              { result = ListOrDictGetNode.new(val[0], val[1]) }
-  | Call ListOrDictGetWithBrackets                 { result = ListOrDictGetNode.new(val[0], val[1]) }
+    ValueExpression ListOrDictGetWithBrackets    { result = ListOrDictGetNode.new(val[0], val[1]) }
   ;
 
   ListOrDictGetWithBrackets:
-    '['  Expression ']'                          { result = [val[1]] }
-  | '['  SubList    ']'                          { result = [val[1]] }
-  | ListOrDictGetWithBrackets '[' Expression ']' { result = val[0] << val[2] }
-  | ListOrDictGetWithBrackets '[' SubList    ']' { result = val[0] << val[2] }
+    '['  ValueExpression ']'                          { result = [val[1]] }
+  | '['  SubList    ']'                               { result = [val[1]] }
+  | ListOrDictGetWithBrackets '[' ValueExpression ']' { result = val[0] << val[2] }
+  | ListOrDictGetWithBrackets '[' SubList    ']'      { result = val[0] << val[2] }
   ;
 
   SubList:
-    Expression ':' Expression                    { result = Nodes.new([val[0], LiteralNode.new(' : '), val[2]]) }
-  | Expression ':'                               { result = Nodes.new([val[0], LiteralNode.new(' :')]) }
-  | ':' Expression                               { result = Nodes.new([LiteralNode.new(': '), val[1]]) }
-  | ':'                                          { result = Nodes.new([LiteralNode.new(':')]) }
+    ValueExpression ':' ValueExpression          { result = SublistNode.new([val[0], LiteralNode.new(' : '), val[2]]) }
+  | ValueExpression ':'                          { result = SublistNode.new([val[0], LiteralNode.new(' :')]) }
+  | ':' ValueExpression                          { result = SublistNode.new([LiteralNode.new(': '), val[1]]) }
+  | ':'                                          { result = SublistNode.new([LiteralNode.new(':')]) }
   ;
 
   DictGetWithDot:
@@ -198,10 +200,19 @@ rule
   Call:
     Scope DefCallIdentifier '(' ArgList ')'       { result = CallNode.new(val[0], val[1], val[3]) }
   | DictGet '(' ArgList ')'                       { result = CallNode.new(nil, val[0], val[2]) }
-  | CALL Scope DefCallIdentifier '(' ArgList ')'  { result = ExplicitCallNode.new(val[1], val[2], val[4]) }
-  | CALL DictGet '(' ArgList ')'                  { result = ExplicitCallNode.new(nil, val[1], val[3]) }
   | BUILTIN_COMMAND '(' ArgList ')'               { result = CallNode.new(nil, val[0], val[2]) }
   | BUILTIN_COMMAND ArgList                       { result = CallNode.new(nil, val[0], val[1]) }
+  | CALL '(' ArgList ')'                          { result = ExplicitCallNode.new(nil, nil, val[2]) }
+  ;
+
+  RimlCommand:
+    RIML_COMMAND '(' ArgList ')'                  { result = RimlCommandNode.new(nil, val[0], val[2]) }
+  | RIML_COMMAND ArgList                          { result = RimlCommandNode.new(nil, val[0], val[1]) }
+  ;
+
+  ExplicitCall:
+    CALL Scope DefCallIdentifier '(' ArgList ')'  { result = ExplicitCallNode.new(val[1], val[2], val[4]) }
+  | CALL DictGet '(' ArgList ')'                  { result = ExplicitCallNode.new(nil, val[1], val[3]) }
   ;
 
   Scope:
@@ -211,101 +222,103 @@ rule
 
   ArgList:
     /* nothing */                         { result = [] }
-  | Expression                            { result = val }
-  | ArgList "," Expression                { result = val[0] << val[2] }
+  | ValueExpression                       { result = val }
+  | ArgList "," ValueExpression           { result = val[0] << val[2] }
   ;
 
   BinaryOperator:
-    Expression '||' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '&&' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+    ValueExpression '||' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '&&' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '==' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '==#' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '==?' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '==' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '==#' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '==?' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
   # added by riml
-  | Expression '===' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '===' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '!=' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '!=#' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '!=?' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '!=' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '!=#' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '!=?' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '=~' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '=~#' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '=~?' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '=~' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '=~#' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '=~?' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '!~' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '!~#' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '!~?' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '!~' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '!~#' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '!~?' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '>' Expression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '>#' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '>?' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '>' ValueExpression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '>#' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '>?' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '>=' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '>=#' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '>=?' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '>=' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '>=#' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '>=?' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '<' Expression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '<#' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '<?' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '<' ValueExpression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '<#' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '<?' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '<=' Expression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '<=#' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '<=?' Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '<=' ValueExpression            { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '<=#' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '<=?' ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression '+' Expression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '-' Expression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '*' Expression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '/' Expression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression '.' Expression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '+' ValueExpression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '-' ValueExpression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '*' ValueExpression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '/' ValueExpression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression '.' ValueExpression             { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | Expression IS    Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | Expression ISNOT Expression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression IS    ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | ValueExpression ISNOT ValueExpression           { result = BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
   ;
 
   UnaryOperator:
-    '!' Expression                        { result = UnaryOperatorNode.new(val[0], val[1]) }
+    '!' ValueExpression                        { result = UnaryOperatorNode.new(val[0], val[1]) }
+  | '+' ValueExpression                        { result = UnaryOperatorNode.new(val[0], val[1]) }
+  | '-' ValueExpression                        { result = UnaryOperatorNode.new(val[0], val[1]) }
   ;
 
   # ['=', LHS, RHS]
   Assign:
-    LET AssignExpression                  { result = AssignNode.new(val[1][0], val[1][1], val[1][2]) }
-  | AssignExpression                      { result = AssignNode.new(val[0][0], val[0][1], val[0][2]) }
+    LET AssignExpression                       { result = AssignNode.new(val[1][0], val[1][1], val[1][2]) }
+  | AssignExpression                           { result = AssignNode.new(val[0][0], val[0][1], val[0][2]) }
   ;
 
   # ['=', 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 '='  ValueExpression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '+=' ValueExpression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '-=' ValueExpression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '.=' ValueExpression             { result = [val[1], val[0], val[2]] }
   ;
 
   AssignLHS:
-    VariableRetrieval                     { result = val[0] }
-  | DictGet                               { result = val[0] }
-  | List                                  { result = val[0] }
-  | ListOrDictGet                         { result = val[0] }
+    VariableRetrieval                          { result = val[0] }
+  | DictGet                                    { result = val[0] }
+  | List                                       { result = val[0] }
+  | ListOrDictGet                              { result = val[0] }
   ;
 
   # retrieving the value of a variable
   VariableRetrieval:
-    Scope IDENTIFIER                            { result = GetVariableNode.new(val[0], val[1]) }
-  | SPECIAL_VAR_PREFIX IDENTIFIER               { result = GetSpecialVariableNode.new(val[0], val[1]) }
-  | Scope CurlyBraceName                        { result = GetCurlyBraceNameNode.new(val[0], val[1])}
+    Scope IDENTIFIER                           { result = GetVariableNode.new(val[0], val[1]) }
+  | SPECIAL_VAR_PREFIX IDENTIFIER              { result = GetSpecialVariableNode.new(val[0], val[1]) }
+  | Scope CurlyBraceName                       { result = GetCurlyBraceNameNode.new(val[0], val[1]) }
   ;
 
   UnletVariable:
-    UNLET VariableRetrieval                               { result = UnletVariableNode.new('!', [ val[1] ]) }
-  | UNLET_BANG VariableRetrieval                          { result = UnletVariableNode.new('!', [ val[1] ]) }
-  | UnletVariable VariableRetrieval                       { result = val[0] << val[1] }
+    UNLET VariableRetrieval                    { result = UnletVariableNode.new('!', [ val[1] ]) }
+  | UNLET_BANG VariableRetrieval               { result = UnletVariableNode.new('!', [ val[1] ]) }
+  | UnletVariable VariableRetrieval            { result = val[0] << val[1] }
   ;
 
   CurlyBraceName:
-    IDENTIFIER '{' VariableRetrieval '}'               { result = CurlyBraceVariable.new([ CurlyBracePart.new(val[0]), CurlyBracePart.new(val[2]) ]) }
-  | '{' VariableRetrieval '}' IDENTIFIER               { result = CurlyBraceVariable.new([ CurlyBracePart.new(val[1]), CurlyBracePart.new(val[3]) ]) }
-  | CurlyBraceName IDENTIFIER                          { result = val[0] << CurlyBracePart.new(val[1]) }
+    IDENTIFIER '{' VariableRetrieval '}'       { result = CurlyBraceVariable.new([ CurlyBracePart.new(val[0]), CurlyBracePart.new(val[2]) ]) }
+  | '{' VariableRetrieval '}' IDENTIFIER       { result = CurlyBraceVariable.new([ CurlyBracePart.new(val[1]), CurlyBracePart.new(val[3]) ]) }
+  | CurlyBraceName IDENTIFIER                  { result = val[0] << CurlyBracePart.new(val[1]) }
   ;
 
   # Method definition
@@ -325,11 +338,11 @@ rule
 
   DefCallIdentifier:
     # use '' for first argument instead of nil in order to avoid a double scope-modifier
-    CurlyBraceName          { result = GetCurlyBraceNameNode.new('', val[0])}
+    CurlyBraceName          { result = GetCurlyBraceNameNode.new('', val[0]) }
   | IDENTIFIER              { result = val[0] }
   ;
 
-  # Example: 'range' or 'dict' after function definition
+  # Example: 'range', 'dict' or 'abort' after function definition
   Keyword:
     IDENTIFIER            { result = val[0] }
   | /* nothing */         { result = nil }
@@ -342,7 +355,7 @@ rule
   ;
 
   Return:
-    RETURN Expression                     { result = ReturnNode.new(val[1]) }
+    RETURN ValueExpression                { result = ReturnNode.new(val[1]) }
   | RETURN Terminator                     { result = ReturnNode.new(nil)    }
   ;
 
@@ -352,23 +365,23 @@ rule
 
   # [expression, expressions]
   If:
-    IF Expression IfBlock END               { result = IfNode.new(val[1], val[2]) }
-  | IF Expression THEN Expression END       { result = IfNode.new(val[1], Nodes.new([val[3]])) }
-  | Expression IF Expression                { result = IfNode.new(val[2], Nodes.new([val[0]])) }
+    IF ValueExpression IfBlock END                    { result = IfNode.new(val[1], val[2]) }
+  | IF ValueExpression THEN ValueExpression END       { result = IfNode.new(val[1], Nodes.new([val[3]])) }
+  | ValueExpression IF ValueExpression                { result = IfNode.new(val[2], Nodes.new([val[0]])) }
   ;
 
   Unless:
-    UNLESS Expression IfBlock END           { result = UnlessNode.new(val[1], val[2]) }
-  | UNLESS Expression THEN Expression END   { result = UnlessNode.new(val[1], Nodes.new([val[3]])) }
-  | Expression UNLESS Expression            { result = UnlessNode.new(val[2], Nodes.new([val[0]])) }
+    UNLESS ValueExpression IfBlock END                { result = UnlessNode.new(val[1], val[2]) }
+  | UNLESS ValueExpression THEN ValueExpression END   { result = UnlessNode.new(val[1], Nodes.new([val[3]])) }
+  | ValueExpression UNLESS ValueExpression            { result = UnlessNode.new(val[2], Nodes.new([val[0]])) }
   ;
 
   Ternary:
-    Expression '?' Expression ':' Expression   { result = TernaryOperatorNode.new([val[0], val[2], val[4]]) }
+    ValueExpression '?' ValueExpression ':' ValueExpression   { result = TernaryOperatorNode.new([val[0], val[2], val[4]]) }
   ;
 
   While:
-    WHILE Expression Block END                 { result = WhileNode.new(val[1], val[2]) }
+    WHILE ValueExpression Block END                 { result = WhileNode.new(val[1], val[2]) }
   ;
 
   LoopKeyword:
@@ -377,12 +390,12 @@ rule
   ;
 
   Until:
-    UNTIL Expression Block END                 { result = UntilNode.new(val[1], val[2]) }
+    UNTIL ValueExpression Block END                 { result = UntilNode.new(val[1], val[2]) }
   ;
 
   For:
-    FOR IDENTIFIER IN Expression Block END     { result = ForNode.new(val[1], val[3], val[4]) }
-  | FOR List IN Expression Block END           { result = ForNode.new(val[1], val[3], val[4]) }
+    FOR IDENTIFIER IN ValueExpression Block END     { result = ForNode.new(val[1], val[3], val[4]) }
+  | FOR List IN ValueExpression Block END           { result = ForNode.new(val[1], val[3], val[4]) }
   ;
 
   Try:
@@ -409,17 +422,18 @@ rule
 
   IfBlock:
     Block                                      { result = val[0] }
-  | NEWLINE Expressions ElseBlock              { result = val[1].concat(val[2]) }
+  | NEWLINE Expressions ElseBlock              { result = val[1] << val[2] }
+  | NEWLINE Expressions ElseifBlock            { result = val[1] << val[2] }
+  | NEWLINE Expressions ElseifBlock ElseBlock  { result = val[1] << val[2] << val[3] }
   ;
 
   ElseBlock:
-    ElseifBlock ELSE NEWLINE Expressions       { result = [val[0], ElseNode.new(val[3])].compact }
+    ELSE NEWLINE Expressions                   { result = ElseNode.new(val[2]) }
   ;
 
   ElseifBlock:
-    ELSEIF Expression NEWLINE Expressions                   { result = Nodes.new([ElseifNode.new(val[1], val[3])]) }
-  | ElseifBlock ELSEIF Expression NEWLINE Expressions       { result = val[0] << ElseifNode.new(val[2], val[4]) }
-  | /* nothing */                                           { result = nil }
+    ELSEIF ValueExpression NEWLINE Expressions                   { result = Nodes.new([ElseifNode.new(val[1], val[3])]) }
+  | ElseifBlock ELSEIF ValueExpression NEWLINE Expressions       { result = val[0] << ElseifNode.new(val[2], val[4]) }
   ;
 
   ClassDefinition:
@@ -449,27 +463,31 @@ end
 ---- inner
   # This code will be put as-is in the parser class
 
+  attr_accessor :ast_rewriter
+
   # parses tokens or code into output nodes
-  def parse(object, rewrite_ast = true)
+  def parse(object, ast_rewriter = AST_Rewriter.new)
     if tokens?(object)
       @tokens = object
     elsif code?(object)
       @lexer = Riml::Lexer.new(object)
     end
-    ast = do_parse
-    return ast if rewrite_ast == false
-    AST_Rewriter.new(ast).rewrite
-  end
 
-  alias do_parse_without_error_handling do_parse
-  def do_parse_with_error_handling
-    do_parse_without_error_handling
-  rescue Racc::ParseError => e
-    raise unless @lexer
-    raise Riml::ParseError,  "line #{@lexer.lineno}: #{e.message}"
+    begin
+      ast = do_parse
+    rescue Racc::ParseError => e
+      raise unless @lexer
+      raise Riml::ParseError,  "line #{@lexer.lineno}: #{e.message}"
+    end
+
+    @ast_rewriter = ast_rewriter
+    return ast unless @ast_rewriter
+    @ast_rewriter.ast = ast
+    @ast_rewriter.rewrite
   end
-  alias do_parse do_parse_with_error_handling
 
+  # 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
     @lexer.next_token