opal 0.2.2 → 0.3.0

data/lib/opal/builders/ruby/generate.rb

@@ -1,1851 +0,0 @@
-# 
-# generate.rb
-# vienna
-# 
-# Created by Adam Beynon.
-# Copyright 2009 Adam Beynon.
-#
-# 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.
-#
-
-require File.join(File.dirname(__FILE__), 'ruby_parser.rb')
-
-module Vienna
-  
-  class RubyParser < ::Racc::Parser
-    
-      
-      # ISEQ types
-      ISEQ_TYPE_TOP    = 1
-      ISEQ_TYPE_METHOD = 2
-      ISEQ_TYPE_BLOCK  = 3
-      ISEQ_TYPE_CLASS  = 4
-      ISEQ_TYPE_RESCUE = 5
-      ISEQ_TYPE_ENSURE = 6
-      ISEQ_TYPE_EVAL   = 7
-      ISEQ_TYPE_MAIN   = 8
-      # opt args etc use this
-      ISEQ_TYPE_TEMP = 9
-    
-
-    
-    # Generate any type of statement with the given options
-    # 
-    def generate_stmt stmt, context
-      return if stmt.is_a?(Array)
-      # puts stmt
-      case stmt.node
-      when :klass
-        generate_class stmt, context
-      when :module
-        generate_module stmt, context
-      when :class_shift
-        generate_class_shift stmt, context
-      when :def
-        generate_def stmt, context
-      when :numeric
-        generate_numeric stmt, context
-      when :call
-        generate_call stmt, context
-      when :super
-        generate_super stmt, context
-      when :identifier
-        generate_identifier stmt, context
-      when :ivar
-        generate_ivar stmt, context
-      when :cvar
-        generate_cvar stmt, context
-      when :constant
-        generate_constant stmt, context
-      when :symbol
-        generate_symbol stmt, context
-      when :self
-        generate_self stmt, context
-      when :true
-        generate_true stmt, context
-      when :false
-        generate_false stmt, context
-      when :nil
-        generate_nil stmt, context
-      when :if
-        generate_if stmt, context
-      when :unless
-        generate_if stmt, context
-      # when :if_mod
-      #        generate_if_mod stmt, context
-      #      when :unless_mod
-      #        generate_if_mod stmt, context  
-      when :string
-        generate_string stmt, context
-      when :xstring
-        generate_xstring stmt, context
-      when :array
-        generate_array stmt, context
-      when :assign
-        generate_assign stmt, context
-      when :assoc_list
-        generate_assoc_list stmt, context
-      when :op_asgn
-        generate_op_asgn stmt, context
-      when :lparen
-        generate_lparen stmt, context
-      when :return
-        generate_return stmt, context
-      when :break
-        generate_break stmt, context
-      when :colon2
-        generate_colon2 stmt, context
-      when :colon3
-        generate_colon3 stmt, context
-      when :case
-        generate_case stmt, context
-      when :yield
-        generate_yield stmt, context
-      when :orop
-        generate_orop stmt, context
-      when :andop
-        generate_andop stmt, context
-      when :not
-        generate_not stmt, context
-      when :tertiary
-        generate_tertiary stmt, context
-      when :dot2
-        generate_dot2 stmt, context
-      when :dot3
-        generate_dot3 stmt, context
-      when :__FILE__
-        generate__FILE__ stmt, context
-      when :__LINE__
-        generate__LINE__ stmt, context
-      when :opt_plus
-        generate_opt_plus stmt, context
-      when :opt_minus
-        generate_opt_minus stmt, context
-      when :opt_mult
-        generate_opt_mult stmt, context
-      when :opt_div
-        generate_opt_div stmt, context
-      when :opt_mod
-        generate_opt_mod stmt, context
-      when :block_given
-        generate_block_given stmt, context
-      when :regexp
-        generate_regexp stmt, context
-      when :alias
-        generate_alias stmt, context
-      when :begin
-        generate_begin stmt, context
-      when :aset_op_asgn
-        generate_aset_op_asgn stmt, context
-      when :gvar
-        generate_gvar stmt, context
-      when :while
-        generate_while stmt, context
-      when :until
-        generate_while stmt, context
-      when :lambda
-        generate_lambda stmt, context
-      when :words
-        generate_words stmt, context
-      when :next
-        generate_next stmt, context
-      when :redo
-        generate_redo stmt, context
-      else
-        write "\n[Unknown type for generate_stmt: #{stmt.inspect}]\n"
-      end
-    end
-    
-    class Iseq
-      
-      attr_accessor :type, :local_current
-            
-      def initialize(type)
-        @type = type
-        # names => minimized names
-        @locals = { } 
-        # arg name => minimized arg names
-        @args = { }
-        # arg types/names - these are all ordered
-        @norm_arg_names = []
-        @opt_arg_names = []
-        @rest_arg_name = nil
-        @post_arg_names = []
-        @block_arg_name = nil
-        
-        @parent_iseq = nil
-        
-        @opt_arg_str = {}
-        
-        @local_current = "a"
-        
-        @code = []
-        
-        
-        @should_handle_return = false
-      end
-      
-      def method_id=(method_id)
-        @method_id = method_id
-      end
-      
-      def method_id
-        if @method_id
-          @method_id
-        elsif @parent_iseq
-          @parent_iseq.method_id
-        else
-          nil
-        end
-      end
-      
-      def new_temp_variable
-        id = "$#{@local_current}"
-        @local_current = @local_current.next
-        @locals[id] = id
-        id
-      end
-      
-      # push "normal" arg name
-      def push_arg_name(name)
-        # id = @local_current
-        # @local_current = @local_current.next
-        # @args[name] = "_#{id}"
-        # @norm_arg_names.push name
-        # "_#{id}"
-        @args[name] = name
-        @norm_arg_names.push name
-        name
-      end
-      
-      # push optional arg name, with the node for its default value
-      # 
-      #  ['a', ""] <- for example
-      def push_opt_arg(name, str)
-        # name = arg[0]
-        @args[name] = name
-        @opt_arg_names.push name
-        @opt_arg_str[name] = str
-        name
-      end
-      
-      # push rest arg name
-      def push_rest_arg_name(name)
-        # id = @local_current
-        # @local_current = @local_current.next
-        @args[name] = name
-        @rest_arg_name = name
-        name
-      end
-      
-      # post (notmal args at end) names
-      def push_post_arg_name(name)
-        
-      end
-      
-      # block.. not actually added to function
-      def push_block_arg_name(name)
-        @block_arg_name = name
-      end
-      
-      def block_arg_name
-        @block_arg_name ||= '__block__'
-      end
-      
-      def push_local_name(name)
-        # id = @local_current
-        # @local_current = @local_current.next
-        # @locals[name] = "_#{id}"
-        # "_#{id}"
-        @locals[name] = name
-        name
-      end
-      
-      def lookup_local(name)
-        return nil if name == nil
-        if @locals.has_key?(name)
-          @locals[name]
-        elsif @args.has_key?(name)
-          @args[name]
-        elsif @block_arg_name == name
-          "__block__"
-        elsif @type == RubyParser::ISEQ_TYPE_BLOCK
-          @parent_iseq.lookup_local(name)
-        else
-          nil
-        end
-      end
-      
-      def parent_iseq=(other)
-        @parent_iseq = other
-
-        if @type == RubyParser::ISEQ_TYPE_BLOCK
-          # @local_current = other.local_current
-        end
-      end
-      
-      def tell_method_to_handle_return
-        if @type == RubyParser::ISEQ_TYPE_METHOD
-          @should_handle_return = true
-        elsif @parent_iseq
-          @parent_iseq.tell_method_to_handle_return
-        else
-          # should we throw error? return isnt in right place..?
-        end
-      end
-      
-      def parent_iseq
-        @parent_iseq
-      end
-
-      def finalize
-        if @type == RubyParser::ISEQ_TYPE_BLOCK
-          # @parent_iseq.local_current =  @local_current
-        end
-      end
-      
-      def write(str)
-        @code << str
-      end
-      
-      # r is array to append strings for outputting
-      def deal_with_method_args(r)
-        r << "function("
-        
-        norm = @norm_arg_names.length
-        opt = @opt_arg_names.length
-        post = @post_arg_names.length
-        rest = @rest_arg_name
-        
-        # Case 1: no args at all (block is dealt with seperately) - def a()
-        if norm == 0 && opt == 0 && post == 0 && rest.nil?
-          r << "){"
-          
-          if RubyParser::ISEQ_TYPE_METHOD === @type || RubyParser::ISEQ_TYPE_BLOCK === @type
-            # r << "var self = this;"
-          end
-          # block..
-          if @block_arg_name != nil
-            r << "if (arguments.length > 0 && arguments[0].info & this.TP) {"
-            r << "  var __block__ = arguments[0];"
-            r << "}"
-          end
-          
-        # Case 2: just splat args - def a(*args)
-        elsif norm == 0 && opt == 0 && post == 0 && rest
-          r << "#{@args[@rest_arg_name]}"
-          r << "){"
-          if RubyParser::ISEQ_TYPE_METHOD === @type || RubyParser::ISEQ_TYPE_BLOCK === @type
-            # r << "var self = this;"
-          end
-          # block..
-          if @block_arg_name
-            r << %Q|
-            if (arguments.length > 0 && arguments[0].info & this.TP) {
-              var __block__ = arguments[arguments.length - 1];
-              #{@args[@rest_arg_name]} =                 Array.prototype.slice.call(arguments, arguments.length -1);
-            }
-            else {
-              #{@args[@rest_arg_name]} =                 Array.prototype.slice.call(arguments);
-            }|
-          else
-            r << %{#{@args[@rest_arg_name]}=Array.prototype.slice.call(arguments);}
-          end
-        
-        # Case: one norm arg, rest splat args - def a(name, *args)
-        elsif norm == 1 && opt == 0 && post == 0 && rest
-          r << "#{@args[@norm_arg_names.first]}"
-          r << ",#{@args[@rest_arg_name]}"
-          r << "){"
-          if RubyParser::ISEQ_TYPE_METHOD === @type || RubyParser::ISEQ_TYPE_BLOCK === @type
-            # r << "var self = this;"
-          end
-          r << "#{@args[@norm_arg_names.first]}=arguments[0];"
-          r << %{#{@args[@rest_arg_name]}=Array.prototype.slice.call(arguments,1);}
-          
-        # Case 3: just normal args (any number) - def a(l,m,n,o,p)
-        elsif norm > 0 && opt == 0 && post == 0 && rest.nil?
-          @norm_arg_names.each do |a|
-            r << "," unless a == @norm_arg_names.first
-            r << "#{@args[a]}"
-          end
-          r << "){"
-          if RubyParser::ISEQ_TYPE_METHOD === @type || RubyParser::ISEQ_TYPE_BLOCK === @type
-            # r << "var self = this;"
-          end
-          # block..
-          if @block_arg_name
-            length = @norm_arg_names.length
-            r << %Q|var __block__ = 
-              (arguments[#{length}] && arguments[#{length}].info & this.TP)
-              ? arguments[#{length}] : this.n;|
-          end
-        
-        # Case: optional args, nothing else; def (a=1); end
-        elsif norm == 0 && opt > 0 && post == 0 && rest.nil?
-          @opt_arg_names.each do |arg|
-            r << arg
-            r << ", " unless @opt_arg_names.last == arg
-          end
-          r << "){"
-          @opt_arg_names.each do |arg|
-            r << "if (#{arg} == undefined) {"
-            r << "  #{arg} = #{@opt_arg_str[arg]};"
-            r << "}"
-          end
-          
-          if @block_arg_name
-            length = @opt_arg_names.length
-            r << %Q|var __block__ = 
-              (arguments[#{length}] && arguments[#{length}].info & this.TP)
-              ? arguments[#{length}] : this.n;|
-          end
-        
-        # Case: some normal args, some optional, nothing else
-        elsif norm > 0 && opt > 0 && post == 0 && rest.nil?
-          @norm_arg_names.each do |a|
-            r << ', ' unless a == @norm_arg_names.first
-            r << @args[a]
-          end
-          
-          @opt_arg_names.each do |arg|
-            r << ", "
-            r << arg
-            # write ", " unless
-          end
-          r << "){"
-          @opt_arg_names.each do |arg|
-            r << "if (#{arg} == undefined) {"
-            r << "  #{arg} = #{@opt_arg_str[arg]};"
-            r << "}"
-          end
-          
-        end
-      end
-      
-      def to_s
-        r = ""
-        
-        case @type
-        when RubyParser::ISEQ_TYPE_TOP
-          r << "(function(__FILE__){"
-          # locals
-          if @locals.length > 0
-            r << "var #{@locals.each_value.to_a.join(" = this.n,")} = this.n;"
-          end
-          r << @code.join("")
-          r << "})"
-          
-        when RubyParser::ISEQ_TYPE_CLASS
-          r << "function(){"
-          
-          # locals
-          if @locals.length > 0
-            r << "var #{@locals.each_value.to_a.join(" = this.n,")} = this.n;"
-          end
-          # code
-          r << @code.join("")
-          
-          r << "}"
-          
-        when RubyParser::ISEQ_TYPE_METHOD
-          
-          deal_with_method_args(r)
-          
-          # block arg name
-          if @block_arg_name != nil
-            # r << "var _ = opal_block; opal_block = nil;"
-          end
-          
-          # see below
-          if @should_handle_return
-            r << "try {"
-          end
-          
-          # locals
-          if @locals.length > 0
-            r << "var #{@locals.each_value.to_a.join(" = this.n,")} = this.n;"
-          end
-          # code
-          r << @code.join("")
-          
-          # if we are a method, we might need to handle a block returning. In 
-          # that case we will get it here in our method, and we simply need to
-          # return the return value...happy days. (rethrow error if its not what  
-          # we need)
-          if @should_handle_return
-            r << "} catch(e) {"
-            r << "if (e.__keyword__ == 'return') {"
-            r << "  return e.opal_value;"
-            r << "}"
-            r << "throw e;"
-            r << "}"
-            
-          end
-          
-          # always return nil as worst case scenario (should never get here?)
-          # r << "return #{NIL};"
-          r << "}"
-          
-        when RubyParser::ISEQ_TYPE_BLOCK
-          r << "this.P("
-          deal_with_method_args(r)
-          
-          # r << "if (arguments.callee.opal_self) {"
-          # r << "  var __old_self__ = self;"
-          # r << "  self = this;"
-          # r << "}"
-          
-          # r << "var res = (function() {"
-
-          # locals
-          if @locals.length > 0
-            r << "var #{@locals.each_value.to_a.join(" = this.n,")} = this.n;"
-          end
-          # WTF? this should take "var $=$$;" but we get errors...huh!?!?
-          # r << "if($$!=nil){var$=$$;}"
-          # this seems to be the easiest way to do it, but its hela ugly 
-          # r << "with({$:($$==nil?$:$$),_:(__==nil?_:__)}){"
-          r << @code.join("")
-          
-          # r << "})();"
-          
-          # r << "if (arguments.callee.opal_self) {"
-          # r << "  self = __old_self__;"
-          # r << "}"
-          
-          # r << "return res;"
-          
-          r << "})"
-        
-        when RubyParser::ISEQ_TYPE_TEMP
-          r << @code.join("")
-        end
-        r
-      end
-      
-    end
-    
-    # An optional argument iseq used for generating just the code for an optioan
-    # argument. This code is stored, then later used as/if needed. Basically,
-    # has a write method that self contains the code.
-    # 
-    class OptionalArgumentIseq
-      
-    end
-    
-    def write(str)
-      @iseq_current.write str
-    end
-    
-    
-    # Convert ruby style id to js property id - everything is prepended a '$'
-    # This method is used also for generating call method strings. For this 
-    # reason, the method looks at the method name for any non a-z characters
-    # which will mean that we cannot use a safe js name. For example, setter
-    # methods need to be wrapped =>
-    # 
-    #     self.something = 10
-    #     # => self['$something='](10).
-    # 
-    # We no longer just replace '=' with '$e' etc as this slows down the runtime
-    # when looking through methods, and using __send__() etc. 
-    # 
-    def mid_to_jsid(mid)
-      # everything needs to be prepended with '$'
-      mid = "$#{mid}"
-      
-      if /[\!\=\?\+\-\*\/\^\&\%\@\|\[\]\<\>\~]/.match mid
-        # special characters, so we must wrap in []
-        "['#{mid}']"
-      else
-        # no special characters, so we can just return .mid
-        ".#{mid}"
-      end
-      # "$#{mid}".
-      # gsub(/\!/, "$b").
-      # gsub(/\=/, "$e").
-      # gsub(/\?/, "$q").
-      # gsub(/\+/, "$p").
-      # gsub(/\-/, "$m").
-      # gsub(/\|/, '$r').
-      # gsub(/\&/, "$a").
-      # gsub(/\</, "$l").
-      # gsub(/\>/, "$g").
-      # gsub(/\[/, "$z").
-      # gsub(/\]/, "$x").
-      # gsub(/\//, "$d").
-      # gsub(/\*/, "$t").
-      # gsub(/\@/, "$a").
-      # gsub(/\^/, "$o")
-    end
-    
-    def generate_tree(tree)
-      top_iseq = iseq_stack_push(ISEQ_TYPE_TOP)
-      tree.each do |stmt|
-        generate_stmt stmt, :full_stmt => true, :last_stmt => tree.last == stmt
-      end
-      iseq_stack_pop
-    end
-    
-    def iseq_stack_push type
-      @iseq_current = Iseq.new type
-      @iseq_stack << @iseq_current
-      @iseq_current
-    end
-
-    def iseq_stack_pop
-      iseq = @iseq_stack.last
-      @iseq_stack.pop
-      @iseq_current = @iseq_stack.last
-      # finalize (var locals etc)
-      iseq.finalize
-      iseq.to_s
-    end
-    
-    def generate_class(cls, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      
-      current_iseq = @iseq_current
-      class_iseq = iseq_stack_push(ISEQ_TYPE_CLASS)
-      class_iseq.parent_iseq = current_iseq
-      
-      # do each bodystmt
-      cls.bodystmt[:compstmt].each do |b|
-        generate_stmt b, :full_stmt => true, :last_stmt => b == cls.bodystmt[:compstmt].last
-      end
-      
-      write "return nil;" if cls.bodystmt.length == 0
-      
-      iseq_stack_pop
-      
-      write "#{SELF}.define_class("
-      # superclass
-      if cls.super_klass
-        generate_stmt cls.super_klass[:expr], :full_stmt => false
-      else
-        write "#{NIL}"
-      end
-      write %{,"#{cls.klass_name}",#{class_iseq},0)}
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_module(cls, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      
-      current_iseq = @iseq_current
-      class_iseq = iseq_stack_push(ISEQ_TYPE_CLASS)
-      class_iseq.parent_iseq = current_iseq
-      
-      # do each bodystmt
-      cls.bodystmt[:compstmt].each do |b|
-        generate_stmt b, :full_stmt => true, :last_stmt => b == cls.bodystmt[:compstmt].last
-      end
-      
-      write "return nil;" if cls.bodystmt.length == 0
-      
-      iseq_stack_pop
-      
-      write "#{SELF}.define_class(#{NIL},'#{cls.klass_name}',#{class_iseq},2)"
-      
-      # write "vm$e($,"
-      # superclass - always nil for module
-      # write "nil"
-      # write %{,"#{cls.klass_name}",#{class_iseq},2)}
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_class_shift(cls, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      
-      current_iseq = @iseq_current
-      class_iseq = iseq_stack_push(ISEQ_TYPE_CLASS)
-      class_iseq.parent_iseq = current_iseq
-      
-      # each bodystmt
-      cls[:bodystmt][:compstmt].each do |b|
-        generate_stmt b, :full_stmt => true, :last_stmt => b == cls[:bodystmt][:compstmt].last
-      end
-      
-      write "return nil" if cls[:bodystmt][:compstmt].length == 0
-      
-      iseq_stack_pop
-      
-      write "#{SELF}.define_class(#{NIL},"
-
-      generate_stmt cls[:expr], :full_stmt => false
-      write ",#{class_iseq},1)"
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_def(stmt, context)
-      # if stmt[:bodystmt][:opt_rescue]
-        # puts "a"
-      # end
-      # if stmt[:fname] == "execute"
-        # pp stmt[:bodystmt]
-      # end
-      # if stmt[:bodystmt].vn_opt_rescue
-        # puts stmt[:bodystmt].vn_opt_rescue
-      # end
-      # puts stmt
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      
-      is_singleton = stmt[:singleton] ? 'true' : 'false'
-      
-      current_iseq = @iseq_current
-      def_iseq = iseq_stack_push(ISEQ_TYPE_METHOD)
-      def_iseq.parent_iseq = current_iseq
-      def_iseq.method_id = stmt[:fname]
-      
-      # normal args
-      if stmt[:arglist].arg
-        stmt[:arglist].arg.each do |arg|
-          @iseq_current.push_arg_name arg[:value]
-        end
-      end
-      
-      # opt args
-      if stmt[:arglist].opt
-        stmt[:arglist].opt.each do |opt|
-          opt_current_iseq = @iseq_current
-          opt_iseq = iseq_stack_push(ISEQ_TYPE_TEMP)
-          generate_stmt opt[1], {}
-          iseq_stack_pop
-          # puts "need to generate op: #{opt}"
-          @iseq_current.push_opt_arg opt[0], opt_iseq.to_s
-        end
-        # puts "opt args:"
-        # puts stmt[:arglist].opt
-        # puts "---------"
-      end
-      
-      # rest args
-      if stmt[:arglist].rest
-        @iseq_current.push_rest_arg_name stmt[:arglist].rest
-      end
-      
-      # block name..
-      if stmt[:arglist].block
-        @iseq_current.push_block_arg_name(stmt[:arglist].block)
-      end
-      
-      
-      # body statements
-      if stmt[:bodystmt][:compstmt].length > 0
-        stmt[:bodystmt][:compstmt].each do |s|
-          generate_stmt s, :full_stmt => true, :last_stmt => stmt[:bodystmt][:compstmt].last == s
-        end
-      else
-        # no bodystmts, return nil be default
-        write "return #{NIL};"
-      end
-      iseq_stack_pop
-      
-      # define method
-          
-      # base.. singleton or self
-      if stmt[:singleton]
-        generate_stmt stmt[:singleton], :full_stmt => false, :last_stmt => false
-        write ".dm("
-      else
-        write "#{SELF}.dm("
-      end
-      
-      # FIXME: only write line in debug mode!
-      write %{"#{stmt[:fname]}",#{def_iseq},#{is_singleton}, #{stmt[:line_number]})}
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_identifier(stmt, context)
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      local = @iseq_current.lookup_local(stmt[:name])
-      if local
-        write local
-      else
-        # write %{vm$a($,"#{stmt[:name]}",[],nil,8)}
-        write "#{SELF}#{mid_to_jsid(stmt[:name])}()"
-      end
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_call(call, context)
-      used_param = false
-      
-      if context[:full_stmt] and context[:last_stmt]
-        # go all the way back to original recv
-        original_recv = call
-        
-        while original_recv[:recv]
-          original_recv = original_recv[:recv] 
-        end
-        
-        # should we "donate" the return statement (need to for case, if, unless)
-        
-        if [:case, :if, :unless].include? original_recv.node
-          original_recv[:donate_recv] = true
-        else
-          write "return "
-        end
-      end
-      
-      # write "vm$a("
-      # receiver
-      if call[:recv]
-        call_bit = 0
-        generate_stmt call[:recv], :recv => true
-      else
-        call_bit = 8
-        # self as recv
-        write "#{SELF}"
-      end
-      
-      # method id
-      write %{#{mid_to_jsid(call[:meth])}(}
-      
-      # normal args - need to check for splats
-      is_splat = false
-      unless call[:call_args].nil? or call[:call_args][:args].nil?
-        call[:call_args][:args].each do |arg|
-          is_splat = true if arg.node == :splat
-        end
-      end
-      
-      if is_splat
-        write "(function(){"
-        write "var a=[],b=nil;"
-        call[:call_args][:args].each do |arg|
-          # puts arg
-          if arg.node == :splat
-            write "b = "
-            generate_stmt arg[:val], :full_stmt => false
-            write ";"
-            write "for(var i = 0; i < b.length; i++){"
-            write "a.push(b[i]);"
-            write "};"
-          else
-            write "a.push("
-            generate_stmt arg, :full_stmt => false
-            write ");"
-          end
-        end
-        write "return a;})()"
-      else
-        # write "["
-        unless call[:call_args].nil? or call[:call_args][:args].nil?
-          call[:call_args][:args].each do |arg|
-            used_param = true
-            write "," unless call[:call_args][:args].first == arg
-            generate_stmt arg, :full_stmt => false
-          end
-        end
-
-        # assocs
-        if call[:call_args] and call[:call_args][:assocs]
-        used_param = true
-        write "," unless call[:call_args].nil? or call[:call_args][:args].nil?
-        write "vnH("
-        call[:call_args][:assocs].each do |assoc|
-         write "," unless call[:call_args][:assocs].first == assoc
-         generate_stmt assoc[:key], :full_stmt => false, :last_stmt => false
-         write ","
-         generate_stmt assoc[:value], :full_stmt => false, :last_stmt => false
-        end
-        write ")"
-        end
-   
-        # write "]"
-      end
-      # write ","
-      
-      # block
-    if call[:brace_block]
-      write "," if used_param
-       current_iseq = @iseq_current
-       block_iseq = iseq_stack_push(ISEQ_TYPE_BLOCK)
-       block_iseq.parent_iseq = current_iseq
-
-       # block arg names
-       if call[:brace_block][:params]
-         call[:brace_block][:params].each do |p|
-           # puts p
-           block_iseq.push_arg_name(p[:value]) unless p.is_a?(String)
-         end
-       end
-
-       # block stmts
-       if call[:brace_block][:stmt]
-         call[:brace_block][:stmt].each do |a|
-           generate_stmt a, :full_stmt => true, :last_stmt => call[:brace_block][:stmt].last == a
-         end
-       end
-
-       iseq_stack_pop
-
-       write block_iseq.to_s
-       # map(&:name)
-     elsif call[:call_args][:block_arg]
-       if used_param
-         write ","
-        else
-          used_param = true
-        end
-       generate_stmt call[:call_args][:block_arg][:arg], :full_stmt => false
-       write "==#{SELF}.n ? #{SELF}.n : "
-
-       generate_stmt call[:call_args][:block_arg][:arg], :full_stmt => false
-       write %{.$to_proc()}
-     else
-       # write "nil"
-     end
-      # write ","
-
-      # op flag
-      # write "#{call_bit})"
-      
-      write ")"
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_string(str, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      
-      if str[:value].length == 0
-        write %{""}
-      elsif str[:value].length == 1
-        if str[:value][0].node == :string_content
-          write %{"#{str[:value][0][:value].gsub(/\"/, '\"')}"}
-        else
-          generate_stmt str[:value][0][:value][0], {}
-          write ".$to_s()"
-        end
-      else
-        write "["
-        str[:value].each do |s|
-          write "," unless str[:value].first == s
-          if s.node == :string_content
-            write %{"#{s[:value].gsub(/\"/, '\"')}"}
-          else
-            # write %{vm$a(}
-            generate_stmt s[:value][0], :full_stmt => false
-            write ".$to_s()"
-            # write %{,"to_s",[],nil,8)}
-          end
-        end
-        write "].join('')"
-      end
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_xstring(str, context)
-      # write "return " if context[:last_stmt] and context[:full_stmt]
-      
-      if str[:value].length == 0
-        write %{}
-      elsif str[:value].length == 1
-        write str[:value][0][:value]
-      else
-        str[:value].each do |s|
-          if s.node == :string_content
-            write s[:value]
-          else
-            generate_stmt s[:value][0], :full_stmt => false
-          end
-        end
-      end
-      
-      # write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_constant(cnst, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "#{SELF}.const_get('#{cnst[:name]}')"
-      # write %{vm$b($,"#{cnst[:name]}")}
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_assign(stmt, context)
-      should_return = context[:last_stmt] and context[:full_stmt]
-      param_seen = false
-      # LHS is a local identifier
-      if stmt[:lhs].node == :identifier
-        local = @iseq_current.lookup_local stmt[:lhs][:name]
-        unless local
-          local = @iseq_current.push_local_name(stmt[:lhs][:name])
-        end
-        
-        if stmt[:rhs].node == :if || stmt[:rhs].node == :unless
-          if_local_name = generate_stmt stmt[:rhs], {}
-          write "return " if should_return
-          write %{#{local}=#{if_local_name}}
-        else
-          write "return " if should_return
-          write %{#{local}=}
-          generate_stmt stmt[:rhs], {}
-        end
-      elsif stmt[:lhs].node == :ivar
-        write "return " if should_return
-        write %{#{SELF}.is("#{stmt[:lhs][:name]}",}
-        generate_stmt stmt[:rhs], :full_stmt => false, :last_stmt => false
-        write %{)}
-      elsif stmt[:lhs].node == :constant
-        write %{#{SELF}.const_set("#{stmt[:lhs][:name]}",}
-        generate_stmt stmt[:rhs], :full_stmt => false, :last_stmt => false
-        write %{)}
-      elsif stmt[:lhs].node == :call
-        write "return " if should_return
-        # puts stmt
-        # write %{vm$a(}
-        # recv
-        generate_stmt stmt[:lhs][:recv], :full_stmt => false
-        # id
-        write %{#{mid_to_jsid(stmt[:lhs][:meth] +'=')}(}
-        # args
-        if stmt[:lhs][:args] and stmt[:lhs][:args][:args]
-          stmt[:lhs][:args][:args].each do |arg|
-            param_seen = true
-            write "," unless stmt[:lhs][:args][:args].first == arg
-            generate_stmt arg, :full_stmt => false
-            # write ","
-          end
-        end
-        write "," if param_seen
-        generate_stmt stmt[:rhs], :full_stmt => false
-        write ")"
-        
-      else
-        puts stmt
-        abort "bad lhs type"
-      end
-      write ";\n" if context[:full_stmt]
-    end
-    
-    # how we replace "self/this"
-    SELF = "this"
-    # how we replace nil
-    NIL = "#{SELF}.n"
-    
-    def generate_self(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "#{SELF}"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_symbol(sym, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write %{#{SELF}.Y("#{sym[:name]}")}
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_numeric(num, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "(" if context[:recv]
-      write "#{num[:value]}"
-      write ")" if context[:recv]
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_ivar stmt, context
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      # write "vm_ivarget($, '#{stmt[:name]}')"
-      write "#{SELF}.ig('#{stmt[:name]}')"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_gvar(stmt, context)
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      write "rb_gvar_get('#{stmt[:name]}')"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_yield stmt, context
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      
-      # block_name = @iseq_current.block_arg_name
-      block_name = '__block__'
-      
-      # for now, normal args or a single *splat
-      if stmt[:call_args] and stmt[:call_args][:args][0].node == :splat
-        write "#{SELF}.rbYield(#{block_name},[])"
-      else
-        write "#{SELF}.rbYield(#{block_name},["
-
-        if stmt[:call_args] and stmt[:call_args][:args]
-          stmt[:call_args][:args].each do |a|
-            write "," unless stmt[:call_args][:args].first == a
-            generate_stmt a, :full_stmt => false, :last_stmt => false
-          end
-        end
-        write "])"
-      end
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_block_given stmt, context
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "((!__block__ || !__block__.r) ? #{SELF}.f : #{SELF}.t)"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    # def generate_if_mod(stmt, context)
-    #   # write "return "  if context[:full_stmt] and context[:last_stmt]
-    # 
-    #   # write "(function(){"
-    # 
-    #   # if/unless mod
-    #   if stmt.node == :if_mod
-    #     write "if("
-    #   else
-    #     write "if(!"
-    #   end
-    # 
-    #   generate_stmt stmt[:expr], :full_stmt => false, :last_stmt => false
-    #   write ".r){"
-    #   generate_stmt stmt[:stmt], :full_stmt => true, :last_stmt => false
-    #   write "}"
-    #   # return nil as safety value
-    #   # write "return #{NIL};})()"
-    #   write ";\n" if context[:full_stmt]
-    # end
-    
-    def generate_array(ary, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "["
-      if ary[:args]
-        ary[:args].each do |a|
-          write "," unless ary[:args].first == a
-          generate_stmt a, :full_stmt => false, :last_stmt => false
-        end
-      end
-      write "]"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_opt_plus(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      # write %{vm_optplus(}
-      generate_stmt stmt[:recv], :recv => true
-      write "#{mid_to_jsid('+')}("
-      generate_stmt stmt[:call_args][:args][0], :full_stmt => false
-      write ")"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_opt_minus(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      generate_stmt stmt[:recv], :last_stmt => false, :full_stmt => false
-      write "#{mid_to_jsid('-')}("
-      generate_stmt stmt[:call_args][:args][0], :full_stmt => false
-      write ")"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_opt_mult(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      generate_stmt stmt[:recv], :last_stmt => false, :full_stmt => false
-      write "#{mid_to_jsid('*')}("
-      generate_stmt stmt[:call_args][:args][0], :full_stmt => false
-      write ")"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_opt_div(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      generate_stmt stmt[:recv], :last_stmt => false, :full_stmt => false
-      write "#{mid_to_jsid('/')}("
-      generate_stmt stmt[:call_args][:args][0], :full_stmt => false
-      write ")"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_nil(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write NIL
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_true(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "#{SELF}.t"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_false(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "#{SELF}.f"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_regexp(stmt, context)
-      # puts stmt
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "/"
-      stmt[:value].each do |part|
-        write part[:value]
-      end
-      write "/"
-      # write %{/#{stmt[:value][0][:value]}/}
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_dot2(stmt, context)
-      # return #{self}.R(#{start}, #{ending}, #{exclusive}.r);
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "#{SELF}.R("
-      generate_stmt stmt[:start], :full_stmt => false
-      write ","
-      generate_stmt stmt[:ending], :full_stmt => false
-      write ",true)"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_dot3(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "#{SELF}.R("
-      generate_stmt stmt[:start], :full_stmt => false
-      write ","
-      generate_stmt stmt[:ending], :full_stmt => false
-      write ",false)"
-      write ";\n" if context[:full_stmt]        
-    end
-    
-    def generate_alias(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "vm_alias($,"
-      generate_stmt stmt[:lhs], :full_stmt => false
-      write ","
-      generate_stmt stmt[:rhs], :full_stmt => false
-      write ")"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate__FILE__ stmt, context
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write %{__FILE__}
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate__LINE__ stmt, context
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write %{0}
-      write ";\n" if context[:full_stmt]
-    end
-    # primay::CONST
-    def generate_colon2 stmt, context
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      # write %{vm$b(}
-      generate_stmt stmt[:lhs], :full_stmt => false
-      write %{.const_get("#{stmt[:rhs]}")}
-      write ";\n" if context[:full_stmt]
-    end
-
-    def generate_colon3 stmt, context
-
-    end
-    
-    def generate_if(stmt, context)
-      
-      # if we are not a full stmt, then we must return the last stmt's value.
-      # Each last stmt will save its value into this var name so it can be used
-      # again outside. nil is default and implies we dont need to do this. This
-      # method (generate_if) returns the temp variable name so the caller can
-      # decide what to do with it
-      return_value_name = nil
-      
-      # whether or not the last stmt for each stmt should be returned. This is
-      # only ever true when we are the last stmt, AND we are a full stmt
-      should_return_last = (context[:last_stmt] && context[:full_stmt] ? true : false)
-      
-      # keep track of if we did an else statement.. if we havent, then we might
-      # need to add one as a default response.. just return nil..
-      done_else_statement = false
-      
-      unless context[:full_stmt]
-        return_value_name = @iseq_current.new_temp_variable
-      end
-      
-      # if/unless clause
-      if stmt.node == :if
-        write "if("
-      else # must be unless
-        write "if(!"
-      end
-
-      generate_stmt stmt[:expr], :recv => true
-      write ".r){"
-      stmt[:stmt].each do |s|
-        is_last_stmt = false
-        if stmt[:stmt].last == s
-          if should_return_last
-            is_last_stmt = true
-          elsif return_value_name
-            write "#{return_value_name} = "
-          end
-        end
-        # alays return last stmt. we output inside a function context to capture
-        # the return value so that this will not return from the function itself
-        generate_stmt s, :full_stmt => true, :last_stmt => is_last_stmt
-      end
-      write "}"
-
-      # now onto the tail (elsif, else etc)
-      if stmt[:tail]
-        stmt[:tail].each do |t|
-          if t.node == :elsif
-            write "else if("
-            generate_stmt t[:expr], :recv => true
-            write ".r){"
-            t[:stmt].each do |s|
-              is_last_stmt = false
-              if t[:stmt].last == s
-                if should_return_last
-                  is_last_stmt = true
-                  # write "return "
-                elsif return_value_name
-                  write "#{return_value_name} = "
-                end
-              end
-              generate_stmt s, :full_stmt => true, :last_stmt => is_last_stmt
-            end
-            write "}"
-          else # else node
-            done_else_statement = true
-            write "else{"
-            t[:stmt].each do |s|
-              is_last_stmt = false
-              if t[:stmt].last == s
-                if should_return_last
-                  is_last_stmt = true
-                elsif return_value_name
-                  write "#{return_value_name} = "
-                end
-              end
-              generate_stmt s, :full_stmt => true, :last_stmt => is_last_stmt
-            end
-            write "}"
-          end
-        end
-      end
-      
-      # did we encounter an else statement? make sure..
-      unless done_else_statement
-        write "else{"
-        if should_return_last
-          write "return "
-        end
-        write "#{NIL};"
-        write "}"
-      end
-      
-      # so it can be used..
-      return_value_name
-    end
-    
-    def generate_op_asgn(stmt, context)
-      # resulting stmt
-      result = nil
-      # if || or &&, then treat differently... everything else is simply a call
-      # node :call, :recv => val[1], :meth => '-@', :call_args => { :args => []}
-      
-      if stmt[:lhs].node == :identifier
-        # adam += 20
-        # => adam = adam + 20
-        name = stmt[:lhs][:name]
-        recv = node(:identifier, :name => name)
-        lhs = node(:identifier, :name => name)
-      
-      elsif stmt[:lhs].node == :ivar
-        
-        name = stmt[:lhs][:name]
-        recv = node(:ivar, :name => name)
-        lhs = node(:ivar, :name => name)
-        
-      elsif stmt[:lhs].node == :call
-        
-        recv = stmt[:lhs]
-        lhs = stmt[:lhs]
-        
-      end
-      
-      if stmt[:op] == '||'
-        rhs = node(:assign, :lhs => lhs, :rhs => stmt[:rhs])
-        result = node(:orop, :lhs => lhs, :rhs => rhs)
-      else
-        # should be generic
-        rhs = node(:call, :recv => recv, :meth => stmt[:op], :call_args => { :args => [stmt[:rhs]]})
-        # rhs = node(:call, :recv => node(:identifier, :name => name), :meth => stmt[:op], :call_args => { :args => [stmt[:rhs]]})
-        result = node(:assign, :lhs => lhs, :rhs => rhs)
-      end
-      
-      
-      generate_stmt result, context
-      
-      
-      
-      # end new
-      
-      
-      
-      # puts result
-      # generate_stmt result, {}
-      
-      # if stmt[:lhs].node == :ivarpa
-      
-      # puts stmt
-      # write "return " if context[:full_stmt] and context[:last_stmt]
-      
-      # if stmt[:lhs].node == :ivar
-      #   if stmt[:op] == "||"
-      #     rhs = node(:assign, :lhs => stmt[:lhs], :rhs => stmt[:rhs])
-      #     generate_stmt(node(:orop, :lhs => stmt[:lhs], :rhs => rhs), {})
-      #     # write "(function(){var a;"
-      #     #          write "if(!RTEST(a = vm_ivarget($,'#{stmt[:lhs][:name]}'))){"
-      #     #          write "return vm_ivarset($,'#{stmt[:lhs][:name]}',"
-      #     #          generate_stmt stmt[:rhs], :full_stmt => false
-      #     #          write ");}"
-      #     #          write "return a;"
-      #     #          write "})()"
-      #   elsif stmt[:op] == "+"
-      #     write "vm_ivarset($,'#{stmt[:lhs][:name]}',vm_optplus("
-      #     write "vm_ivarget($,'#{stmt[:lhs][:name]}'),"
-      #     generate_stmt stmt[:rhs], :full_stmt => false
-      #     write "))"
-      #   elsif stmt[:op] == "-"
-      #     write "vm_ivarset($,'#{stmt[:lhs][:name]}',vm_optminus("
-      #     write "vm_ivarget($,'#{stmt[:lhs][:name]}'),"
-      #     generate_stmt stmt[:rhs], :full_stmt => false
-      #     write "))"
-      #   elsif stmt[:op] == "*"
-      #     write "vm_ivarset($,'#{stmt[:lhs][:name]}',vm_optmult("
-      #     write "vm_ivarget($,'#{stmt[:lhs][:name]}'),"
-      #     generate_stmt stmt[:rhs], :full_stmt => false
-      #     write "))"
-      #   elsif stmt[:op] == "/"
-      #     write "vm_ivarset($,'#{stmt[:lhs][:name]}',vm_optdiv("
-      #     write "vm_ivarget($,'#{stmt[:lhs][:name]}'),"
-      #     generate_stmt stmt[:rhs], :full_stmt => false
-      #     write "))"
-      #   else
-      #     abort "bas op type for op_asgn"
-      #   end
-      # else
-      #   abort "bad LHS for op_asgn"
-      # end
-      
-      # write ";\n" if context[:full_stmt]
-    end
-    
-    # yuck!
-    def generate_case stmt, context
-      # if stmt[:donate_recv]
-        # write "DONATABLE RECV"
-      # end
-      
-      # first get our case value (if method call, we dont want to call it for
-      # every comparison, so store it ina  temp variable for later use)
-      case_var_name = @iseq_current.new_temp_variable
-      
-      # if we are not a full stmt, then we might need to store return value
-      case_result = context[:full_stmt] ? nil : @iseq_current.new_temp_variable
-      
-      # if we simply return the last stmt..
-      is_last = context[:last_stmt] && context[:full_stmt]
-      
-      # make sure we do the else part
-      done_else = false
-      
-      write "#{case_var_name} = "
-      
-      if stmt[:expr]
-        generate_stmt stmt[:expr], :full_stmt => false, :last_stmt => false
-        write ";"
-      else
-        write "#{SELF}.t;"
-      end
-      
-      # write "(function($c){"
-      stmt[:body].each do |c|
-        if c.node == :when
-          # clauses
-          if stmt[:body].first == c
-            write "if"
-          else
-            write "else if"
-          end
-          write "("
-          c[:args].each do |a|
-            write " || " unless c[:args].first == a
-            
-            generate_stmt a, :recv => true
-            # ruby truthiness test to make sure result is truthy
-            write "#{mid_to_jsid('===')}(#{case_var_name}).r"
-            # write ",'===',[$c],nil,0)"
-          end
-          write") {"
-          c[:stmt].each do |s|
-            # assign to variable? (for non full stmts)
-            if c[:stmt].last == s && case_result
-              write "#{case_result} = "
-            end
-            
-            generate_stmt s, :full_stmt => true, :last_stmt => is_last && c[:stmt].last == s
-          end
-          write "}"
-        else # it is an else, so anything else goes
-          done_else = true
-          
-          write "else {"
-          c[:stmt].each do |s|
-            if c[:stmt].last == s && case_result
-              write "#{case_result} = "
-            end
-            generate_stmt s, :full_stmt => true, :last_stmt => is_last && c[:stmt].last == s
-          end
-          write "}"
-        end
-      end
-      
-      unless done_else
-        write "else {"
-        
-        if case_result
-          write "#{case_result} = "
-        else
-          write "return " if is_last
-        end
-        
-        write NIL
-        write ";"
-        write "}"
-      end
-      
-      # do we need to return for a call stmt later on?
-      write "return " if stmt[:donate_recv]
-      
-      # if we need to return our result...
-      if case_result
-        write case_result
-      end
-    end
-    
-    def generate_orop(stmt, context)
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      write "#{SELF}.o("
-      generate_stmt stmt[:lhs], :full_stmt => false
-      # write ".o("
-      write ",function(){"
-      generate_stmt stmt[:rhs], :full_stmt => true, :last_stmt => true
-      write "})"
-
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_andop(stmt, context)
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      write "#{SELF}.a("
-      generate_stmt stmt[:lhs], :full_stmt => false
-      # write ".o("
-      write ",function(){"
-      generate_stmt stmt[:rhs], :full_stmt => true, :last_stmt => true
-      write "})"
-
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_assoc_list stmt, context
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      write "vnH("
-      stmt[:list].each do |assoc|
-        write "," unless stmt[:list].first == assoc
-        generate_stmt assoc[:key], :full_stmt => false, :last_stmt => false
-        write ","
-        generate_stmt assoc[:value], :full_stmt => false, :last_stmt => false
-      end
-      write ")"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_begin(stmt, context)
-      if stmt[:stmt][:opt_rescue]
-        write "try{"
-        stmt[:stmt][:compstmt].each do |s|
-          generate_stmt s, :full_stmt => true, :last_stmt => (context[:last_stmt] && stmt[:stmt][:compstmt].last == s)
-        end
-        # puts stmt[:stmt][:opt_rescue]
-        write "}"
-        write "catch(e) {"
-        if stmt[:stmt][:opt_rescue][:var]
-          local = @iseq_current.lookup_local(stmt[:stmt][:opt_rescue][:var][:name])
-          unless local
-            local = @iseq_current.push_local_name(stmt[:stmt][:opt_rescue][:var][:name])
-          end
-          # write "#{local} = e;"
-          # make sure we are using a opal error
-          write %Q|
-            if (e.mid2jsid) {
-              #{local} = e;
-            } else {
-              #{local} = #{SELF}.rbNativeError(e);
-            }
-          |
-          # write "console.log('catch');console.log(e.klass);"
-          if stmt[:stmt][:opt_rescue][:stmt]
-            stmt[:stmt][:opt_rescue][:stmt].each do |s|
-              generate_stmt s, :full_stmt => true
-            end
-          end
-        end
-        write "}"
-      else
-        stmt[:stmt][:compstmt].each do |stmt|
-          generate_stmt stmt, :full_stmt => true, :last_stmt => false
-        end
-      end
-    end
-    
-    def generate_return(stmt, context)
-      
-      if @iseq_current.type == RubyParser::ISEQ_TYPE_BLOCK
-        # if we are inside a block, we must rbReturn (i.e. throw an error to 
-        # return to escape blocks etc, see opal.js). Also, we must tell the
-        # nearset method from iseq_current that it contains a block/proc so
-        # it can provide a simple try/catch statement to try and catch it if it
-        # returns.
-        
-        @iseq_current.tell_method_to_handle_return
-        
-        write "#{SELF}.rbReturn("
-        # puts stmt
-        if stmt[:call_args] and stmt[:call_args][:args]
-          if stmt[:call_args][:args].length == 1
-            generate_stmt stmt[:call_args][:args].first, :full_stmt => false
-          else
-            abort "generate_return multiple args not yet done"
-          end
-        else
-          write "#{NIL}"
-        end
-
-        write ");\n" if context[:full_stmt]
-      else
-        # assume we are in a method... if so, carry on as normal
-        write "return "
-        # puts stmt
-        if stmt[:call_args] and stmt[:call_args][:args]
-          if stmt[:call_args][:args].length == 1
-            generate_stmt stmt[:call_args][:args].first, :full_stmt => false
-          else
-            abort "generate_return multiple args not yet done"
-          end
-        else
-          write "#{NIL}"
-        end
-
-        write ";\n" if context[:full_stmt]
-      end
-    end
-    
-    def generate_lparen(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      write "("
-      if stmt[:stmt] and stmt[:stmt][0]
-        generate_stmt stmt[:stmt][0], :full_stmt => false
-      else
-        write "#{NIL}"
-      end
-      write ")"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_aset_op_asgn(stmt, context)
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      if stmt[:recv].node == :identifier
-        abort "unsupported. currently"
-      else
-        abort "bad recv node for aset_op_asgn (#{stmt[:recv]})"
-      end
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_not(stmt, context)
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      generate_stmt stmt[:expr], :full_stmt => false
-      write "#{mid_to_jsid('!')}()"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_super(stmt, context)
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      write %{#{SELF}.opal_super(arguments.callee, }
-      
-      # args, depends on is super has parens etc, simple for now: parens
-      if stmt[:call_args] and stmt[:call_args][:args]
-        write "["
-        stmt[:call_args][:args].each do |arg|
-          write "," unless arg == stmt[:call_args][:args].first
-          generate_stmt arg, :full_stmt => false
-        end
-        write "]"
-        
-      elsif stmt[:inherit]
-        write "Array.prototype.slice.call(arguments)"
-      else
-        write "[]"
-      end
-      
-      write ")"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_break(stmt, context)
-      write "#{SELF}.rbBreak("
-      if stmt[:call_args] and stmt[:call_args][:args]
-        stmt[:call_args][:args].each do |arg|
-          write "," unless stmt[:call_args][:args].first == arg
-          generate_stmt arg, :full_stmt => false
-        end
-      end
-      write ");"
-    end
-    
-    def generate_next(stmt, context)
-      write "#{SELF}.rbNext("
-      if stmt[:call_args] and stmt[:call_args][:args]
-        stmt[:call_args][:args].each do |arg|
-          write "," unless stmt[:call_args][:args].first == arg
-          generate_stmt arg, :full_stmt => false
-        end
-      end
-      write ")"
-      
-      write ";" if context[:full_stmt]
-    end
-    
-    def generate_tertiary(stmt, context)
-      write "return " if context[:full_stmt] and context[:last_stmt]
-      write "("
-      generate_stmt stmt[:expr], :full_stmt => false
-      write ").r ? "
-      generate_stmt stmt[:true], :full_stmt => false
-      write " : "
-      generate_stmt stmt[:false], :full_stmt => false
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_while(stmt, context)
-      
-    
-    
-      write "#{SELF}.rbWhile(function(){"
-      if stmt.node == :while
-        write "return ("
-      else
-        # until..
-        write "return (!("
-      end
-      
-      generate_stmt stmt[:expr], {}
-      
-      if stmt.node == :while
-        write ".r);"
-      else
-        # until..
-        write ".r));"
-      end
-      
-      # generate_stmt stmt[:expr], {}
-      
-      write "}, function() {"
-      
-      stmt[:stmt].each do |stmt|
-        generate_stmt stmt, :full_stmt => true
-      end
-      
-      # write "}"
-      
-      write "})"
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    
-    
-    
-    def generate_lambda(stmt, context)
-      write "return " if context[:last_stmt] && context[:full_stmt]
-      
-      write "#{SELF}.L(function() {"
-      
-      stmt[:body].each do |stmt|
-        generate_stmt stmt, :full_stmt => true
-      end
-      
-      write "})"
-      
-      write ";\n" if context[:full_stmt]
-    end
-    
-    def generate_words(stmt, context)
-      write "return " if context[:last_stmt] and context[:full_stmt]
-      
-      done_first = false
-      
-      write "["
-      stmt[:list].first.each do |list|
-        if list.node == :string_content
-          str = list[:value]
-          str = str.strip! || str
-          str.split(' ').each do |part|
-            if done_first
-              write ", '#{part}'"
-            else
-              done_first = true
-              write "'#{part}'"
-            end
-          end
-        else
-          if done_first
-            write ", "
-          else
-            done_first = true
-          end
-          # puts list
-          generate_stmt list[:value].first, {} 
-          write '.$to_s()'
-        end
-      end
-      
-      write "]"
-      write ";\n" if context[:full_stmt]
-    end
-    
-    
-    def generate_redo(stmt, context)
-      write "#{SELF}.rbRedo()"
-      write ";" if context[:full_stmt]
-    end
-  end
-end