rubyjs 0.7.0

data/src/rubyjs/compiler.rb

@@ -0,0 +1,2007 @@
+#
+# A Ruby to Javascript compiler.
+#
+# Copyright (c) 2007 by Michael Neumann (mneumann@ntecs.de).
+# All rights reserved.
+#
+
+require 'sexp_processor'
+require 'set'
+
+class MethodCompiler < SexpProcessor
+
+  def initialize(model, method_name)
+    super()
+    
+    # don't stop at unknown nodes
+    self.strict = true 
+
+    # remove the type from the sexp array
+    self.auto_shift_type = true
+
+    # warn whenever the default method is called, i.e.
+    # an unknown sexp is processed.
+    self.warn_on_default = true
+
+    # expected result class
+    self.expected = String
+
+    #
+    # Used to collect the dynamic variable declarations for
+    # an iterator. 
+    #
+    @current_iter_dvars = nil
+
+    # 
+    # The model object used for encoding and name generation of all
+    # kind of variables etc.
+    #
+    @model = model
+
+    #
+    # The (encoded) name of the method being compiled
+    #
+    @method_name = method_name
+
+    # 
+    # record all local variables (including arguments)
+    #
+    @local_variables = Set.new
+
+    #
+    # Those local variables that need not be initialized with "nil" are
+    # contained in this set (mostly temporary variables).
+    #
+    @local_variables_need_no_initialization = Set.new
+
+    #
+    # contains all argument variables except "*args"
+    #
+    @arguments_no_splat = []
+
+    #
+    # Contains the name of a splat argument "*args" 
+    # or nil if none has been specified.
+    #
+    @argument_splat = nil
+
+    #
+    # Include all arguments
+    #
+    @argument_variables = Set.new
+
+    #
+    # If the result should be an expression, this is set to true.
+    #
+    @want_expression = false
+
+    #
+    # Usually each method introduces a new local variable scope. 
+    # Make sure that there is no nested :scope.
+    # 
+    @scope_nesting = 0
+
+    #
+    # We collect all instance variable reads, because they might not be
+    # initialized yet and we want them to be initialized as "nil"!
+    #
+    @read_instance_variables = Set.new
+
+    #
+    # Use to reuse unused temporary variables
+    #
+    @temporary_variables_pool = []
+
+
+    #
+    # If a return value should be assigned or not. 
+    #
+    @want_result = false 
+
+
+    #
+    # contains the name of the block argument, e.g.
+    #
+    #   def a(&block)
+    #   end
+    #
+    # would contain the encoded name of "block".
+    #
+    @block_arg_name = nil
+
+    #
+    # Argument name used for the block argument: 
+    #
+    #   function (#{@block_name}, ...) { ... }
+    #
+    # Generated on demand with block_name().
+    #
+    @block_name = nil
+
+    #
+    # The name of the variable that contains the return value.
+    #
+    @result_name = nil
+
+    #
+    # For implementing +break+ and +next+ we
+    # have to keep track whether the +break+
+    # or +next+ statement occurs inside a
+    # +while+ loop or inside of a block. 
+    #
+    @block_whileloop_stack = []
+
+    #
+    # Whether the method body contains any code that
+    # makes use of iterators (e.g. yield, &block).
+    #
+    @iterators_used = false
+
+    # 
+    # Used in a zsuper call (super without arguments)
+    #
+    @arguments_name = nil
+
+    #
+    # Used in catch statements
+    #
+    @exception_name = nil
+
+
+
+    #
+    # Each method has a unique id assigned to it (a simple integer).
+    # This is used for returns that occur inside a code-block, which
+    # have to return the method in which the code-block is declared and
+    # NOT the method in which it is called". 
+    #
+    @unique_method_scope = nil
+  end
+
+  def compile_method(pt)
+    process(pt)
+  end
+
+  #
+  # 
+  #
+  def want_expression(wish=true)
+    old = @want_expression
+    @want_expression = wish
+    res = yield 
+    @want_expression = old
+    return res
+  end
+
+  #
+  # There exist a short cut in the node tree for simple getter and
+  # setter-methods:
+  # 
+  #   [:defn, :method_name, [:ivar, :variable_name]]
+  #
+  #   [:defn, :method_name, [:attrset, :variable_name]]
+  #
+  # We don't want to handle them differently, that's why we expand them
+  # into:
+  #
+  #   [:block, [:ivar, :variable_name]]
+  #
+  #   [:block, [:args, :v], [:iasgn, :variable_name, [:lvar, :v]]]
+  #
+  def process_defn(exp)
+    raise if @result_name
+    method_name = exp.shift || raise
+    exp = exp.shift || raise
+
+    method_body = want_result do
+      case exp.first
+      when :ivar
+        process(s(:block, exp))
+      when :attrset
+        process(s(:block, s(:args, :_), s(:iasgn, exp[1], s(:lvar, :_))))
+      when :scope, :block, :fbody
+        process(exp)
+      else
+        raise
+      end
+    end
+
+    str = ""
+
+    if @argument_variables.empty?
+      str << "function(){"
+    else
+      args_str = ([block_name()] + @arguments_no_splat).join(",")
+      str << "function(#{args_str}){"
+    end
+
+    raise if @local_variables.include?(@model.encode_self)
+    raise if @argument_variables.include?(@model.encode_self)
+
+    #
+    # Add "self" to the local variables
+    #
+    @local_variables.add(@model.encode_self)
+    @local_variables_need_no_initialization.add(@model.encode_self)
+
+    #
+    # declare local variables (except arguments)
+    #
+    to_declare = (@local_variables - @argument_variables).to_a
+    to_declare << @result_name if @result_name
+    unless to_declare.empty?
+      str << "var " + to_declare.join(",") + sep()
+    end
+
+    #
+    # initialize all local variables (that need initialization) to nil
+    #
+    to_initialize = (@local_variables - @argument_variables - @local_variables_need_no_initialization).to_a
+    to_initialize << @result_name if @result_name
+    unless to_initialize.empty?
+      str << to_initialize.join("=")
+      str << "=#{@model.encode_nil}#{sep()}"
+    end
+
+    #
+    # initialize "self"
+    #
+    str << "#{@model.encode_self}=this#{sep()}"
+
+    #
+    # If a block argument is given (&block) convert it to nil if it is
+    # undefined. 
+    #
+    if @block_arg_name
+      str << "#{@block_arg_name}=#{block_name()}==null?#{@model.encode_nil}:#{block_name()}#{sep()}"
+    end
+
+    #
+    # generate initialization code for each read instance variable
+    #
+    @read_instance_variables.each do |iv|
+      str << "if(#{@model.encode_self}.#{iv}==null)#{@model.encode_self}.#{iv}=#{@model.encode_nil}#{sep()}"
+    end
+
+    # 
+    # Used in a zsuper call to refer to the methods "arguments"
+    # "arguments" itself does not work due to iterators using functions.
+    if @arguments_name
+      str << "var #{@arguments_name}=arguments#{sep()}"
+    end
+
+    method_body << "#{sep()}return #{@result_name}" if @result_name
+
+    if @iterators_used
+      str << "try{" 
+      str << method_body 
+
+      #
+      # Declare variable x?
+      # No, catch introduced a new scope, so we don't have to
+      # use a local or temporary variable here! 
+      #
+      x = exception_name()
+      iter_jump = @model.encode_globalattr("iter_jump")
+      return_value = @model.encode_attr("return_value")
+      scope = @model.encode_attr("scope")
+      uid = unique_method_scope()
+
+      str << "}catch(#{x}){"
+      # scope == null or scope == uid
+      str << "if(#{x} instanceof #{iter_jump} && (!#{x}.#{scope} || #{x}.#{scope}==#{uid}))return #{x}.#{return_value}#{sep()}"
+      str << "throw(#{x})}"
+    else
+      str << method_body
+    end
+
+    str << "}"
+
+    return str
+  end
+
+  def sep
+    if $RUBYJS__OPTS.include?('PrettyPrint')
+      ";\n"
+    else
+      ";"
+    end
+  end
+
+  def unique_method_scope
+    @unique_method_scope ||= @model.next_unique_scope_id
+  end
+
+  def process_scope(exp)
+    raise "nested scope" if @scope_nesting > 0
+    @scope_nesting += 1
+    res = process(exp.shift)
+    @scope_nesting -= 1
+    return res
+  end
+
+  def process_fbody(exp)
+    process(exp.shift)
+  end
+
+  def process_block(exp)
+    raise "empty block" if exp.empty?
+
+    res = []
+
+    # all statements except the last don't want a result
+    without_result do 
+      exp[0..-2].each do |stmt|
+        res << process(stmt)
+      end
+    end
+    # last statement
+    res << process(exp[-1])
+
+    res = res.reject {|r| r.nil? || r.empty? || r == "" || r == ";"}
+
+    exp.clear
+
+    if @want_expression
+      "(" + res.join(",") + ")"
+    else
+      res.join(sep())
+    end
+  end
+
+  #
+  # STATEMENT
+  #
+  def process_block_arg(exp)
+    raise if @want_expression || @block_arg_name
+    block = exp.shift
+    block_name() # make sure that the function signature contains a block argument!
+    @block_arg_name = @model.encode_local_variable(block)
+    @local_variables.add(@block_arg_name)
+    @local_variables_need_no_initialization.add(@block_arg_name)
+    return ""
+  end
+
+  # 
+  # TODO?
+  #
+  def process_block_pass(exp)
+    block = exp.shift
+    call = exp.shift
+    without_result do 
+      want_expression do
+        put_iter(process(block))
+      end
+    end
+    process(call)
+  end
+
+  def throw_argument_error(n)
+    @model.add_method_call(m = @model.encode_method("new"))
+    "throw(" + @model.lookup_constant('::ArgumentError') + 
+    ".#{m}(#{@model.encode_nil},'wrong number of arguments ('+Math.max(0,arguments.length-1).toString()+' for #{n})'))"
+  end
+
+  #
+  # STATEMENT
+  #
+  # Method arguments.
+  #
+  # Generate arity checks and default argument assignment.
+  #
+  def process_args(exp)
+    raise if @want_expression
+
+    args = []
+    default_values = nil
+
+    loop do
+      arg = exp.shift
+      break if arg.nil?
+      if arg.is_a?(Symbol)
+        args << arg
+      else
+        raise unless exp.empty?
+        default_values = arg
+      end
+    end
+
+    args.each do |arg|
+      arg = arg.to_s
+      if arg[0,1] == '*'
+        raise if @argument_splat
+        @argument_splat = @model.encode_local_variable(arg[1..-1])
+        # argument_splat is not an argument in the function's argument list
+        @local_variables.add(@argument_splat) 
+      else
+        v = @model.encode_local_variable(arg)
+        @arguments_no_splat << v 
+        @local_variables.add(v)
+        @argument_variables.add(v)
+      end
+    end
+
+    # that's not the correct arity, but we decrease it by one for each
+    # optional argument.
+    min_arity = @arguments_no_splat.size
+    max_arity = @arguments_no_splat.size
+
+    str = ""
+
+    #
+    # Generate code for the default values of arguments. We check
+    # whether a argument has been assigned a value, if not (== null or == undefined), 
+    # then we assign the default value.
+    #
+    # NOTE: A check to ==null also returns true if the argument is undefined.
+    #
+    if default_values
+      raise unless default_values[0] == :block
+      default_values[1..-1].each do |dv|
+        min_arity -= 1
+        raise unless dv[0] == :lasgn
+        raise unless dv.size == 3
+        arg = @model.encode_local_variable(dv[1])
+        @local_variables.add(arg)
+        @argument_variables.add(arg)
+        value = dv[2]
+
+        str << "if(#{arg}==null)"
+        str << "#{arg}="
+        str << want_expression do process(value) end
+        str << sep()
+      end
+    end
+
+    # now as we know the min_arity, we prepend an arity check before the
+    # code generated above.
+    str2 = ""
+
+    if @argument_splat
+      # max_arity == infinity => no check
+
+      if min_arity == 0
+        # min_arity == infinity as well => we need no check
+      else
+        # +1 because we have a block argument anyway.
+        str2 << "if(arguments.length<#{min_arity+1})#{throw_argument_error(min_arity)}#{sep()}"
+      end
+    else
+      if min_arity == 0
+        # can't be less than 0 arguments anyway! => no check
+        str2 << "if(arguments.length>#{max_arity+1})#{throw_argument_error(max_arity)}#{sep()}"
+      else
+        if min_arity == max_arity
+          str2 << "if(arguments.length!=#{min_arity+1})#{throw_argument_error(min_arity)}#{sep()}"
+        else
+          str2 << "if(arguments.length<#{min_arity+1})#{throw_argument_error(min_arity)}#{sep()}"
+          str2 << "if(arguments.length>#{max_arity+1})#{throw_argument_error(max_arity)}#{sep()}"
+        end
+      end
+    end
+
+    # NoArgumentArityChecks disable argument arity checks
+    if $RUBYJS__OPTS.include?('NoArgumentArityChecks')
+    else
+      # prepend
+      str = str2 + str
+    end
+
+    if @argument_splat
+      # construct the code to initialize the splat argument. 
+      # unluckily the arguments object is not an array, instead it's a
+      # special object that has only the length() and [] methods. There
+      # is no way to convert it to an array, except looping over each
+      # value and pushing the value into a new array.
+      # FIXME: variable "i"
+      str << "#{@argument_splat}=[]#{sep()}"
+      @local_variables_need_no_initialization.add(@argument_splat)
+      with_temporary_variable do |i|
+        @local_variables_need_no_initialization.add(i)
+        str << "for(#{i}=#{@arguments_no_splat.size+1};#{i}<arguments.length;#{i}++)#{@argument_splat}.push(arguments[#{i}])#{sep()}"
+      end
+    end
+    
+    return str 
+  end
+
+
+  # 
+  # Same as generate_method_call, but where recv_exp is an sexp.
+  # We take care that it gets processed, and that in case of a
+  # numeric literal, it gets surrounded by parens.
+  #
+  def generate_method_call_receiver_exp(recv_exp, method, iter, args)
+    generate_method_call(receiver_exp(recv_exp), method, iter, args)
+  end
+
+  def receiver_exp(recv_exp)
+    is_num = is_numeric_literal(recv_exp)
+    receiver = want_expression do process(recv_exp) end 
+    receiver = "(" + receiver + ")" if is_num
+    return receiver
+  end
+
+  #
+  # Generates a method call. 
+  # 
+  def generate_method_call(receiver, method, iter, args)
+
+    method_name = @model.encode_method(method)
+    @model.add_method_call(method_name)
+
+    without_result do
+      want_expression do
+        if args.nil?
+          # no arguments
+          #
+          # NOTE: We don't have to encode an iter of "nil" as "nil".
+          # Instead we save us the space and check for undefined in the
+          # method definition.
+          "#{receiver}.#{method_name}(#{iter})"
+        elsif args.first == :array
+          # one or more arguments
+          args_string = args[1..-1].map{|a| process(a)}.join(",")
+          "#{receiver}.#{method_name}(#{iter || @model.encode_nil},#{args_string})"
+        elsif args.first == :splat or args.first == :argscat
+          #
+          # puts(*a)  # => [:fcall, :puts, [:splat, [:lvar, :a]]]]]]
+          #
+          # puts(1, *a) # => ... [:argscat, [:array, [:lit, 1]], [:lvar, :a]]
+          #
+          @model.add_method_call(__invoke = @model.encode_method('__invoke'))
+          "#{receiver}.#{__invoke}(#{iter || @model.encode_nil},'#{method_name}',#{ process(args) })"
+        else
+          raise
+        end
+      end
+    end
+  end
+  
+  #
+  # Generates a super call. 
+  # 
+  def generate_super_call(iter, args)
+    @model.add_method_call(@method_name)
+
+    args_str = without_result do
+      want_expression do
+        if args.nil?
+          # no arguments
+          #
+          # NOTE: We don't have to encode an iter of "nil" as "nil".
+          # Instead we save us the space and check for undefined in the
+          # method definition.
+          "[]"
+        else
+          process(args)
+        end
+      end
+    end
+
+    sc = @model.encode_globalattr('supercall')
+    "#{sc}(#{@model.encode_self},'#{@method_name}',#{iter || @model.encode_nil},#{args_str})"
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Super call.
+  #
+  def process_super(exp)
+    args = exp.shift
+    generate_super_call(get_iter(), args)
+  end
+
+  # 
+  # EXPRESSION
+  #
+  # Super call without arguments "super"
+  #
+  # We need to introduce a new variable instead of
+  # using "arguments" because "arguments" is not 
+  # available when called within an iterator, because
+  # an iterator introduces a new function.
+  #
+  def process_zsuper(exp)
+    @model.add_method_call(@method_name)
+    sc = @model.encode_globalattr('zsupercall')
+    "#{sc}(#{@model.encode_self},'#{@method_name}',#{arguments_name()})"
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Method call without receiver
+  #
+  def process_fcall(exp)
+    method = exp.shift
+    args = exp.shift
+
+    str = without_result do
+      generate_method_call(@model.encode_self, method, get_iter(), args)
+    end
+
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Attribute assignment: receiver.attr=(value)
+  #
+  # Same as a method call!
+  #
+  def process_attrasgn(exp)
+    process_call(exp)
+  end
+
+  #
+  # The ||= operator.
+  #
+  # For example:
+  #
+  #   a = a || "hallo"
+  #
+  #     [:lasgn, :a, [:or, [:lvar, :a], [:str, "hallo"]]],
+  #
+  #   a ||= "hallo" 
+  #
+  #     [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:str, "hallo"]]]]]]
+  #
+  # We rewrite the one to the other.
+  #
+  def process_op_asgn_or(exp)
+    ref = exp.shift
+    asgn = exp.shift
+    asgn[2] = [:or, ref, asgn[2]]
+    process(asgn)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Method call with receiver
+  #
+  def process_call(exp)
+    receiver = exp.shift
+    method = exp.shift
+    args = exp.shift
+
+    iter = get_iter()
+
+    #
+    # RubyJS::inline("str")
+    #
+    # A different form of Javascript inline. We have this form
+    # because ``-style Javascript-inline has a different esacping
+    # of \. Sometimes we want no escaping, so
+    #
+    #   RubyJS::inline %q(...) could be used.
+    #
+    if receiver == [:const, :RubyJS] and method == :inline and
+       args[0] == :array and args.size == 2 and args[1].size == 2 and args[1][0] == :str and iter.nil?
+      raise if @want_expression
+      return @model.interpolate(args[1][1])
+    end
+
+    str = 
+    if $RUBYJS__OPTS.include?('OptimizeArithOps') and %w(> >= < <= + - * /).include?(method.to_s) and
+          iter.nil? and args and args[0] == :array and args.size == 2
+      without_result do 
+        want_expression do
+          "(#{process(receiver)})#{method.to_s}(#{process(args[1])})"
+        end
+      end
+    else
+      without_result do 
+        generate_method_call_receiver_exp(receiver, method, iter, args)
+      end
+    end
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Virtual call. Either a method call or a variable, determined at
+  # runtime.
+  #
+  # Ruby cannot distinguish a local variable and a method called without
+  # parentheses and without receiver at parse time. Example:
+  #
+  #   def my_method
+  #     method_or_not.inspect
+  #   end
+  #
+  # If a local variable of that name exists, then it is used as
+  # receiver. Otherwise it is seen as a method and is called.
+  #
+  # NOTE: A vcall can never have an iterator! Because if an iterator is
+  # specified it is automatically no variable and as such a fcall or
+  # call is generated.
+  #
+  # NOTE: As RubyJS disallows to use eval(), a vcall can never be a
+  # local variable (FIXME: to be prooved).
+  #
+  def process_vcall(exp)
+    method = exp.shift
+
+    resultify(generate_method_call(@model.encode_self, method, nil, nil))
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Q: Always call with "nil" if no argument is given?
+  # A: No, because then we could not distinguish between
+  #    no arguments and "nil" as argument.
+  #
+  def process_yield(exp)
+    value = exp.shift
+
+    str = without_result do
+      want_expression do
+        block_name() + "(" + (value ? process(value) : '') + ")"
+      end
+    end
+    resultify(str)
+  end
+
+  #
+  # Constant lookup
+  # ===============
+  #
+  # Constant lookup in RubyJS is performed statically. This is possible
+  # because the whole class hierarchy is available at compile-time. 
+
+  #
+  # EXPRESSION
+  #
+  def process_const(exp)
+    resultify(@model.lookup_constant(constify(exp, :const)))
+  end
+
+  #
+  # helper methods
+  #
+
+  def constify(exp, type)
+    exp.unshift(type)
+    const_rec(exp).join("::")
+  end
+
+  def const_rec(exp)
+    case exp.shift
+    when :const
+      return [exp.shift]
+    when :colon2
+      const_rec(exp.shift) + [exp.shift]
+    when :colon3
+      [nil, exp.shift]
+    else
+      raise
+    end
+  end
+  
+  # 
+  # EXPRESSION
+  #
+  # A::B     # => [:colon2, [:const, :A], :B]
+  #
+  def process_colon2(exp)
+    resultify(@model.lookup_constant(constify(exp, :colon2)))
+  end
+
+  # 
+  # EXPRESSION
+  #
+  # ::A     # => [:colon3, :A]
+  #
+  def process_colon3(exp)
+    resultify(@model.lookup_constant(constify(exp, :colon3)))
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Implements the "&&" operator, which has short circuit behaviour.  
+  #
+  # a && b
+  #
+  #   is equivalent in Ruby to
+  #
+  # if a then b else a end 
+  #
+  def process_and(exp)
+    a = exp.shift
+    b = exp.shift
+
+    res = without_result do
+      want_expression do
+        with_temporary_variable do |tmp|
+          @local_variables_need_no_initialization.add(tmp)
+          "(#{tmp}=#{process(a)}, (#{tmp}!==false&&#{tmp}!==nil) ? (#{process(b)}) : #{tmp})"
+        end
+      end
+    end
+
+    return resultify(res)
+  end
+  
+  #
+  # EXPRESSION
+  #
+  # Implements the "||" operator, which has short circuit behaviour.  
+  #
+  # a || b
+  #
+  #   is equivalent in Ruby to
+  #
+  # if a then a else b end 
+  #
+  def process_or(exp)
+    a = exp.shift
+    b = exp.shift
+
+    res = without_result do
+      want_expression do
+        with_temporary_variable do |tmp|
+          @local_variables_need_no_initialization.add(tmp)
+          "(#{tmp}=#{process(a)}, (#{tmp}!==false&&#{tmp}!==nil) ? #{tmp} : (#{process(b)}))"
+        end
+      end
+    end
+
+    return resultify(res)
+  end
+
+  #
+  # EXPRESSION
+  #
+  def process_not(exp)
+    a = exp.shift
+
+    without_result do
+      want_expression do
+        a = conditionalize(a, true)
+      end
+    end
+
+    return resultify(a)
+  end
+
+  #
+  # STATEMENT/EXPRESSION
+  #
+  # unless is converted by the Ruby parser into an "if":
+  #
+  # unless X
+  #   block
+  # end
+  #
+  # =>
+  #
+  # if X
+  # else
+  #   block
+  # end
+  #
+  def process_if(exp)
+    cond = exp.shift
+    _then = exp.shift
+    _else = exp.shift
+
+    _then_processed = if _then
+                        process(_then)
+                      else
+                        nil
+                      end
+
+    _else_processed = if _else
+                        process(_else)
+                      else
+                        nil
+                      end
+
+    negate = false
+
+    if _then_processed.nil?
+      # no "then" block as in
+      #
+      # if X
+      # else
+      #   block
+      # end
+      #
+      # => convert into
+      #
+      # if not X
+      #   block
+      # end
+      #
+      # by swapping then and else blocks
+      # and negating the condition
+
+      _then_processed = _else_processed
+      _else_processed = nil
+      negate = true
+    end
+
+    cond_processed = without_result do
+      conditionalize(cond, negate)
+    end
+
+    str = ""
+
+    if @want_expression
+      _then_processed ||= resultify(@model.encode_nil)
+      _else_processes ||= resultify(@model.encode_nil)
+      str << "(#{cond_processed}?#{_then_processed}:#{_else_processed})"
+    else
+      str << "if(#{cond_processed}){"
+      str << (_then_processed || (@want_result ? resultify(@model.encode_nil) : ''))
+      str << "}"
+      if @want_result
+        _else_processed ||= resultify(@model.encode_nil) 
+      end
+      if _else_processed
+        str << "else{"
+        str << _else_processed
+        str << "}"
+      end
+    end
+
+    return str
+  end
+
+  #
+  # STATEMENT/EXPRESSION
+  #
+  # case obj
+  # when c1
+  #   block1
+  # when c2, c3
+  #   block23
+  # else
+  #   blockelse
+  # end
+  #
+  # [:case,
+  #  obj,
+  #  [:when, [:array, c1], block1],
+  #  [:when, [:array, c2, c3], block23],
+  #  blockelse or nil
+  # ]
+  #
+  # We are transforming the "case" into "if".
+  #
+  # _tmp = obj; 
+  # if c1 ===  _tmp
+  #   block1
+  # else 
+  #   if c2 === _tmp or c3 === _tmp then
+  #     block23
+  #   else
+  #     blockelse
+  #   end
+  # end
+  #
+  def process_case(exp)
+    obj = exp.shift  
+    
+    with_temporary_variable do |tmp|
+      @local_variables_need_no_initialization.add(tmp)
+      asgn = want_expression do
+        "#{tmp}=#{process(obj)}"
+      end
+
+      new_exp = current_exp = []
+
+      while not exp.empty?
+        _when = exp.shift
+        if _when.nil? or _when.first != :when
+          # last element
+          raise exp.inspect unless exp.empty?
+          current_exp << _when
+        else
+          conds = _when[1]
+          block = _when[2]
+          raise unless conds.first == :array
+
+          cond = multi_or(conds[1..-1].map {|c| [:call, c, :===, [:array, [:special_inline_js_value, tmp]]] })
+
+          my_exp = [:if, cond, block]
+
+          current_exp << my_exp
+          current_exp = my_exp
+        end
+      end
+
+      if_code = process(new_exp.first)
+
+      code = 
+      if @want_expression 
+        "(#{asgn}, #{if_code})"
+      else
+        "#{asgn}#{sep()}#{if_code}" 
+      end
+
+      code
+    end
+  end
+
+  def multi_or(exprs)
+    case exprs.size
+    when 0
+      raise
+    when 1
+      # multi_or([1]) => 1
+      exprs[0]
+    when 2
+      # multi_or([1, 2]) => [:or, 1, 2]
+      [:or, exprs[0], exprs[1]]
+    else
+      # multi_or([1, 2, 3]) => [:or, 1, multi_or([2,3])] == [:or, 1, [:or, 2, 3]]
+      [:or, exprs[0], multi_or(exprs[1..-1])]
+    end
+  end
+  
+  #
+  # STATEMENT
+  #
+  def process_begin(exp)
+    raise if @want_expression
+    block = exp.shift
+    process(block)
+  end
+  
+  #
+  # STATEMENT
+  #
+  def process_rescue(exp)
+    raise if @want_expression
+    block = exp.shift
+    handler = exp.shift
+    else_handler = exp.shift
+    raise unless handler.first == :resbody
+
+    x = exception_name() 
+
+    code = [:block, block] 
+    code << else_handler if else_handler
+
+    str = ""
+    str << "try{#{process(code)}}"
+    str << "catch(#{x}){"
+
+    # check whether it's an iterator break. if yes, pass it on
+    iter_jump = @model.encode_globalattr("iter_jump")
+    str << "if(#{x} instanceof #{iter_jump})throw(#{x})#{sep()}"
+    str << "#{process(handler)}"
+    str << "}"
+
+    str
+  end
+  
+  #
+  # STATEMENT
+  #
+  def process_resbody(exp)
+    raise if @want_expression
+    condition = exp.shift
+    if_body = exp.shift
+    else_body = exp.shift
+
+    x = exception_name()
+
+    # if only "rescue" is used (and not e.g. "rescue Exception")
+    condition ||= [:array, [:const, :StandardError]]
+    raise unless condition.first == :array
+
+    # if this is the last resbody (else_body is nil) then
+    # the exception couldn't be catched and we rethrow it! 
+    else_body ||= [:special_inline_js_value, "throw(#{x})"]
+
+    # build condition expression 
+    cond = 
+    multi_or(condition[1..-1].map do |c|
+      [:call, c, :===, [:array, [:special_inline_js_value, x]]]
+    end)
+
+    process([:if, cond, if_body, else_body])
+  end
+    
+  #
+  # STATEMENT
+  #
+  def process_ensure(exp)
+    raise if @want_expression
+    try_body = process(exp.shift)
+    ensure_body = without_result { process(exp.shift) }
+
+    "try{#{try_body}}finally{#{ensure_body}}"
+  end
+
+  #
+  # STATEMENT
+  #
+  def process_return(exp)
+    return_value =
+      if param = exp.shift
+        want_expression do
+          without_result do
+            process(param)
+          end
+        end
+      else
+        @model.encode_nil
+      end
+    if @block_whileloop_stack.last == :iter
+      # return from within an iterator 
+      throw_iter_jump(return_value, unique_method_scope())
+    elsif @want_expression
+      throw_iter_jump(return_value)
+    else
+      "return #{return_value}"
+    end
+  end
+
+  #
+  # STATEMENT
+  #
+  def process_while(exp)
+    raise if @want_expression
+
+    cond = exp.shift
+    block = exp.shift
+    flag = exp.shift
+    raise unless flag == true # FIXME: document
+
+    str = without_result do
+      c = conditionalize(cond)
+      @block_whileloop_stack.push(:while)
+      b = process(block)
+      @block_whileloop_stack.pop || raise
+
+      "while(#{c}){#{b}}" 
+    end
+
+    if @want_result
+      str << sep() + resultify(@model.encode_nil) + sep()
+    end
+
+    return str
+  end
+
+  #
+  # STATEMENT
+  #
+  def process_break(exp)
+    case @block_whileloop_stack.last
+    when :while
+      raise "break with arguments inside while not yet supported" unless exp.empty?
+      raise if @want_expression
+      "break"
+    when :iter
+      return_value =
+        if param = exp.shift
+          without_result do
+            process(param)
+          end
+        else
+          @model.encode_nil
+        end
+      throw_iter_jump(return_value)
+    when nil
+      raise("break not in loop/block scope")
+    else
+      raise "FATAL"
+    end
+  end
+
+  def throw_iter_jump(return_value, scope=nil)
+    @iterators_used = true # used to produce catch code in this method
+    iter_jump = @model.encode_globalattr('iter_jump')
+    scope ||= "null"
+    th = 
+      if @want_expression
+        @model.encode_globalattr("throw_expr")
+      else
+        "throw"
+      end
+
+    "#{th}(new #{iter_jump}(#{return_value},#{scope}))"
+  end
+
+  #
+  # STATEMENT
+  #
+  def process_next(exp)
+    case @block_whileloop_stack.last
+    when :while
+      raise "next with arguments inside while not yet supported" unless exp.empty?
+      raise if @want_expression
+      "continue"
+    when :iter
+      # next inside a code-block generates a "return" 
+      raise if @want_expression
+
+      return_value =
+        if param = exp.shift
+          want_expression do
+            without_result do
+              process(param)
+            end
+          end
+        else
+          @model.encode_nil
+        end
+
+      "return #{return_value}"
+    when nil
+      raise("next not in loop/block scope")
+    else
+      raise "FATAL"
+    end
+  end
+
+  #
+  # UNDEFINED
+  #
+  # Backtick strings: `inline javascript`
+  #
+  # We use them for inline Javascript.
+  #
+  # It's unclear whether it's a STATEMENT or EXPRESSION.
+  # It depends on the Javascript.
+  #
+  # NOTE: You have to take care to return a value yourself
+  # in case of @want_result, i.e. there is no automatic handling
+  # thereof.
+  #
+  def process_xstr(exp)
+    str = exp.shift
+    @model.interpolate(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # String interpolation
+  #
+  def process_dstr(exp)
+    pre_str = exp.shift
+    res = without_result do
+      want_expression do
+        # NOTE:
+        # We use +to_s+, and the + operator to
+        # build the interpolated string.
+        @model.add_method_call(to_s = @model.encode_method("to_s"))
+        "(" + ([pre_str.inspect] + exp.map {|e| "(" + process(e) + ").#{to_s}()"}).join(" + ") + ")"
+      end
+    end
+    exp.clear
+    resultify(res)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Process literals
+  #
+  def process_lit(exp)
+    lit = exp.shift
+    res = case lit
+    when Fixnum, Bignum, Float
+      lit.to_s
+    when String
+      lit.inspect
+    when Symbol
+      lit.to_s.inspect
+    when Regexp
+      lit.inspect
+    when Range
+      range = @model.lookup_constant('::Range') 
+      @model.add_method_call(m = @model.encode_method("new"))
+      "#{range}.#{m}(#{@model.encode_nil},#{lit.first},#{lit.last},#{lit.exclude_end?})"
+    else
+      raise
+    end
+
+    resultify(res)
+  end 
+
+  def is_numeric_literal(exp)
+    type = exp[0]
+    return false if exp[0] != :lit
+    case exp[1]
+    when Fixnum, Bignum, Float 
+      true
+    else
+      false
+    end
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Process string literal
+  #
+  def process_str(exp)
+    str = exp.shift
+    resultify(str.inspect)
+  end
+  
+  #
+  # EXPRESSION
+  #
+  def process_true(exp)
+    resultify("true")
+  end
+  
+  #
+  # EXPRESSION
+  #
+  def process_false(exp)
+    resultify("false")
+  end
+
+  #
+  # EXPRESSION
+  #
+  def process_nil(exp)
+    resultify(@model.encode_nil)
+  end
+  
+  #
+  # EXPRESSION
+  #
+  def process_self(exp)
+    resultify(@model.encode_self)
+  end
+ 
+  #
+  # EXPRESSION
+  #
+  def process_splat(exp)
+    value = exp.shift
+    to_splat = @model.encode_globalattr('to_splat')
+    str = without_result do
+      want_expression do
+        "#{to_splat}(#{ process(value) })"
+      end
+    end
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  def process_argscat(exp)
+    prefix = exp.shift
+    splat = exp.shift
+    raise unless prefix.first == :array
+    to_splat = @model.encode_globalattr('to_splat')
+    str = without_result do
+      want_expression do
+        "#{process(prefix)}.concat(#{to_splat}(#{ process(splat) }))"
+      end
+    end
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Array literal
+  #
+  def process_array(exp)
+    str = without_result do
+      want_expression do
+        "[" + exp.map{|e| process(e)}.compact.join(",") + "]"
+      end
+    end
+    exp.clear
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # We box the hash and use our own implementation, as Javascript's
+  # associative arrays are very different to Ruby hashes.
+  #
+  def process_hash(exp)
+    kv_list = exp
+    raise if kv_list.length % 2 != 0 
+
+    args = 
+    without_result do
+      want_expression do
+        kv_list.map {|i| process(i)}.join(",")
+      end
+    end
+
+    str = @model.lookup_constant('::Hash') + "."
+    if kv_list.empty?
+      # empty Hash
+      @model.add_method_call(m = @model.encode_method("new"))
+      str << "#{m}()" 
+    else
+      @model.add_method_call(m = @model.encode_method("new_from_key_value_list"))
+      str << "#{m}(#{@model.encode_nil},#{args})" 
+    end
+
+    exp.clear
+
+    return str
+  end
+
+  # 
+  # EXPRESSION
+  #
+  # Empty array.
+  #
+  def process_zarray(exp)
+    resultify("[]")
+  end
+
+
+  #
+  # EXPRESSION
+  #
+  # Local variable assignment
+  #
+  # We have to write down all local variables, because they have to be
+  # declared at the top of the method (otherwise they are seen as
+  # "global" variables :)
+  #
+  def process_lasgn(exp)
+    lvar   = exp.shift
+    value = exp.shift
+
+    lvar_name = @model.encode_local_variable(lvar)
+    @local_variables.add(lvar_name)
+    # local variables need not to be initialized, because they
+    # have to be asigned to before usage, otherwise they would
+    # not be local variables but methods instead.
+    @local_variables_need_no_initialization.add(lvar_name)
+
+    str = without_result do
+      want_expression do
+        "#{lvar_name}=#{process(value)}"
+      end
+    end
+
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Local variable lookup
+  #
+  def process_lvar(exp)
+    lvar = exp.shift
+
+    lvar_name = @model.encode_local_variable(lvar)
+    raise "variable not available" unless @local_variables.include?(lvar_name)
+
+    resultify("#{lvar_name}")
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Regular expression lookup $1 .. $9
+  #
+  def process_nth_ref(exp)
+    n = exp.shift
+    raise if n < 1 or n > 9
+    resultify("(RegExp.$#{n} || #{@model.encode_nil})")
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Global variable lookup
+  #
+  def process_gvar(exp)
+    gvar = exp.shift
+
+    res = 
+      case gvar.to_s
+      when "$!"
+        # this is a special variable which holds the current exception 
+        exception_name()  
+      else
+        gvar_name = @model.encode_global_variable(gvar)
+        "(typeof(#{gvar_name})=='undefined'?#{@model.encode_nil}:#{gvar_name})"
+      end
+
+    resultify(res)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Global variable assignment
+  #
+  def process_gasgn(exp)
+    gvar   = exp.shift
+    value = exp.shift
+
+    gvar_name = @model.encode_global_variable(gvar)
+
+    str = without_result do
+      want_expression do
+        "#{gvar_name}=#{process(value)}"
+      end
+    end
+
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Dynamic variable lookup
+  #
+  def process_dvar(exp)
+    dvar = exp.shift
+    dvar_name = @model.encode_local_variable(dvar)
+    raise "dynamic variable not available" unless @current_iter_dvars.include?(dvar_name)
+
+    resultify("#{dvar_name}")
+  end
+
+  # 
+  # EXPRESSION
+  #
+  # Dynamic variable assignment
+  #
+  def process_dasgn(exp)
+    dvar = exp.shift
+    value = exp.shift
+    dvar_name = @model.encode_local_variable(dvar)
+    raise "dynamic variable not available" unless @current_iter_dvars.include?(dvar_name)
+
+    str = without_result do
+      want_expression do
+        "#{dvar_name}=#{process(value)}"
+      end
+    end
+
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Dynamic variable declaration and assignment 
+  #
+  def process_dasgn_curr(exp)
+    dvar = exp.shift
+    value = exp.shift
+    dvar_name = @model.encode_local_variable(dvar)
+
+    @current_iter_dvars.add(dvar_name)
+
+    str = without_result do
+      want_expression do
+        if value
+          "#{dvar_name}=#{process(value)}"
+        else
+          # this should never happen, see process_iter()
+          raise "no declarations possible"
+        end
+      end
+    end
+
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Instance variable lookup
+  #
+  def process_ivar(exp)
+    ivar = exp.shift
+    ivar_name = @model.encode_instance_variable(ivar)
+    @read_instance_variables.add(ivar_name)
+    resultify("#{@model.encode_self}.#{ivar_name}")
+  end
+
+  def process_svalue
+    raise
+  end
+
+  def process_to_ary(exp)
+    value = exp.shift
+    str = without_result do
+      want_expression do
+        case value.first
+        when :lit
+          "[" + process(value) + "]"
+        when :array, :zarray
+          process(value)
+        when :special_to_ary
+          # this is used inside of process_iter to build the multiple
+          # assignment.
+          value[1]
+        else
+          generate_method_call_receiver_exp(value, "to_ary", nil, nil)
+        end
+      end
+    end
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION
+  #
+  # This is used to insert a pure inline JS string into the
+  # code. It is used for example in process_masgn.
+  #
+  # It is not part of the ParseTree returned node types!
+  #
+  def process_special_inline_js_value(exp)
+    return exp.shift
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Multiple assignment
+  #
+  # Simple case:
+  #
+  # a, b = 1, 2
+  #
+  # [:masgn,
+  #  [:array, [:lasgn, :a], [:lasgn, :b]],
+  #  [:array, [:lit, 1], [:lit, 2]]]]]]
+  #
+  # Case with splat argument:
+  #
+  # a, *b = 1, 2, 3
+  #
+  # [:masgn,
+  #  [:array, [:lasgn, :a]],
+  #  [:lasgn, :b],
+  #  [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]]]]
+  #
+  # Another case:
+  #
+  # a, b = 1
+  #
+  # [:masgn,
+  #  [:array, [:lasgn, :a], [:lasgn, :b]],
+  #  [:to_ary, [:lit, 1]]]
+  #
+  # We actually implement multiple assignment using a
+  # temporary array. Example:
+  #
+  #   a, b = b, a
+  #
+  # leads to the following javascript code 
+  #
+  #   (_t = [b,a],
+  #    a  = _t[0] == null ? nil : _t[0], 
+  #    b  = _t[1] == null ? nil : _t[1])
+  #
+  # When a splat argument is given, there's just an
+  # additional assignment which takes the rest of the
+  # array.
+  #
+  def process_masgn(exp)
+    lhs = exp.shift
+    rhs = exp.pop
+    splat = exp.shift 
+
+    raise unless lhs.first == :array
+    raise unless rhs.first == :array or rhs.first == :to_ary
+
+    want_expression do
+      with_temporary_variable do |tmp|
+        assgn = [] 
+        without_result do
+          assgn << "#{tmp}=#{process(rhs)}"
+
+          # lhs[0] == :array -> skip it
+          lhs[1..-1].each_with_index do |assignment, i|  # for example where assignment == [:lasgn, :a]
+            assignment << s(:special_inline_js_value, "#{tmp}[#{i}]==null?#{@model.encode_nil}:#{tmp}[#{i}]")
+            assgn << process(assignment)
+          end
+
+          if splat
+            # splat is for example [:lasgn, :a]
+            splat << s(:special_inline_js_value, "#{tmp}.slice(#{lhs.size-1})")
+            assgn << process(splat)
+          end
+        end
+
+        # return value of the expression is the array
+        assgn << resultify("#{tmp}")
+
+        "(" + assgn.join(",") + ")" 
+      end
+    end
+  end
+
+  #
+  # EXPRESSION
+  #
+  # Instance variable assignment
+  #
+  def process_iasgn(exp)
+    ivar  = exp.shift
+    value = exp.shift
+    ivar_name = @model.encode_instance_variable(ivar)
+
+    str = without_result do
+      want_expression do
+        "#{@model.encode_self}.#{ivar_name}=#{process(value)}"
+      end
+    end
+
+    resultify(str)
+  end
+
+  #
+  # EXPRESSION (doesn't generate any code directly!) 
+  #
+  # Iterator block.
+  #
+  # We process as follows:
+  #
+  #   1. Generate code for the arguments of the block (multiple
+  #   assignment etc.)
+  #
+  #   2. Generate code for the code block.
+  #
+  #   3. In 1 and 2 we also write down all dynamic variable assignments.
+  #      ("dasgn_curr" which introduces a new scope)
+  #
+  #   4. Generate code for variable declarations.
+  # 
+  # TODO: assign arity to function object!
+  #
+  def process_iter(exp)
+    call   = exp.shift # the method call to which the iterator is passed
+    params = exp.shift # arguments of the block
+    code   = exp.shift # the code block
+
+    old_iter_dvars = @current_iter_dvars
+    @current_iter_dvars = Set.new 
+    @block_whileloop_stack.push(:iter)
+   
+    # Get an argument name for the iterator function signature.
+    arg_name = @model.encode_fresh_local_variable()
+
+    fun_str = ""
+    asgn_str = ""
+   
+    if params.nil? 
+      # Case 1: {}: Any number of arguments may be passed
+      arity = -1
+      fun_str << "function(){"
+    elsif params == :zero_arguments
+      # Case 2: {||}: Zero arguments
+      arity = 0
+      fun_str << "function(){"
+    elsif params.first == :masgn
+      # Case 3: {|i,j|}: Multiple arguments (multiple assignment)
+      arity = nil # |arity| >= 2 
+      fun_str << "function(#{arg_name}){"
+
+      # TODO: remove masgn_iter and instead put the corresponding logic
+      # into yield!
+      masgn_iter = @model.encode_globalattr("masgn_iter")
+      params << [:to_ary, [:special_to_ary, "#{masgn_iter}(#{arg_name})"]]
+      want_expression(false) do
+        without_result do
+          asgn_str << process(params) 
+        end
+      end
+    else
+      # Case 4: {|i|}: Single argument
+      # TODO: warning if not exactly one argument is passed  
+      arity = 1
+      fun_str << "function(#{arg_name}){"
+
+      # we convert a single argument into a multiple assignment clause
+      # with one argument.
+
+      sasgn_iter = @model.encode_globalattr("sasgn_iter")
+      params << [:special_inline_js_value, "#{arg_name}==null?#{@model.encode_nil}:#{arg_name}"]
+
+      want_expression(false) do
+        without_result do
+          asgn_str << process(params) 
+        end
+      end
+    end
+
+    old_result_name = @result_name
+    @result_name = nil
+
+    block_str = ""
+    want_expression(false) do
+      want_result do
+        block_str << process(code) if code
+      end
+    end
+
+    # generate code for the variable declarations
+    var_str = ""
+    unless @current_iter_dvars.empty?
+      var_str << "var "
+      var_str << @current_iter_dvars.to_a.join(",")
+      var_str << sep()
+    end
+
+    # declare and initialize the return value
+    if @result_name
+      var_str << "var #{@result_name}=#{@model.encode_nil}#{sep()}"
+    end
+
+    # NOTE: we don't need to initialize any dvar to nil, as 
+    # they can't be used before being assigned to (because
+    # otherwise they are vcall's and not dynamic variables).   
+
+    str = fun_str + var_str + asgn_str + sep() + block_str
+    str << "#{sep()}return #{@result_name}" if @result_name
+    str << "}"
+
+    put_iter(str)
+
+    @result_name = old_result_name
+    @current_iter_dvars = old_iter_dvars
+    @block_whileloop_stack.pop || raise
+
+    return process(call)
+  end
+
+  # 
+  # a =~ /regexp/
+  #
+  # is converted to 
+  #
+  # [:match3, [:lit, /regexp/], [:lvar, :a]]
+  #
+  # We just convert it to:
+  #
+  # [:call, [:lvar, :a], :=~, [:array, [:lit, /regexp/]]]
+  #
+  def process_match3(exp)
+    right = exp.shift
+    left = exp.shift 
+    return process(s(:call, left, :=~, s(:array, right)))
+  end
+
+  # 
+  # if /regexp/ =~ a
+  #
+  # is converted to 
+  #
+  # [:match2, [:lit, /regexp/], [:lvar, :a]]
+  #
+  # We just convert it to:
+  #
+  # [:call, [:lit, /regexp/], :=~, [:array, [:lvar, :a]]]
+  #
+  def process_match2(exp)
+    left = exp.shift
+    right = exp.shift
+    return process(s(:call, left, :=~, s(:array, right)))
+  end
+
+  #######################################################################
+  
+  private
+
+  #######################################################################
+  
+  def without_result(&block)
+    want_result(false, &block)
+  end
+
+  def want_result(wish=true)
+    old_want_result = @want_result
+    begin
+      @want_result = wish
+      return yield
+    ensure
+      @want_result = old_want_result
+    end
+  end
+
+  def resultify(str)
+    if @want_result
+      # FIXME
+      result_name() + "=" + str
+    else
+      str
+    end
+  end
+
+  def result_name
+    @result_name ||= @model.encode_fresh_local_variable() 
+    #@local_variables.add(@result_name)
+    @result_name
+  end
+
+  # 
+  # Generate a name for @block_name (which is the argument for
+  # the block in the Javascript function signature).
+  #
+  def block_name
+    @block_name ||= @model.encode_fresh_local_variable()
+    @argument_variables.add(@block_name)
+    @iterators_used = true 
+    # FIXME: not true. passing an interator &block does not
+    # mean that iterators are used!
+    @block_name
+  end
+
+  def arguments_name()
+    @arguments_name ||= @model.encode_fresh_local_variable()
+  end
+
+  def exception_name()
+    @exception_name ||= @model.encode_fresh_local_variable()
+  end
+
+  def conditionalize(exp, negate=false)
+    # Optimize literals
+    case exp.first
+    when :true, :lit, :self, :str   # evaluate to true
+      return (negate ? "false" : "true")
+    when :false, :nil         # evaluate to false
+      return (negate ? "true" : "false")
+    end
+
+    want_expression do
+      with_temporary_variable do |tmp|
+        @local_variables_need_no_initialization.add(tmp)
+        if negate 
+          "(#{tmp}=#{process(exp)},#{tmp}===false||#{tmp}===nil)"
+        else
+          "(#{tmp}=#{process(exp)},#{tmp}!==false&&#{tmp}!==nil)"
+        end
+      end
+    end
+  end
+
+  def with_temporary_variable
+    var = get_temporary_variable()
+    begin
+      return (yield var)
+    ensure
+      put_temporary_variable(var)
+    end
+  end
+
+  def get_temporary_variable
+    tmp = @temporary_variables_pool.shift || @model.encode_fresh_local_variable
+    @local_variables.add(tmp)
+    return tmp
+  end
+
+  def put_temporary_variable(tmp)
+    @temporary_variables_pool.unshift(tmp)
+  end
+
+  def get_iter
+    res = @iter
+    @iter = nil
+    res
+  end
+
+  def put_iter(iter)
+    @iter = iter
+  end
+end