opal 0.0.1 → 0.1.0

data/lib/opal/builders/base.rb

@@ -0,0 +1,50 @@
+# 
+# base.rb
+# vienna
+# 
+# Created by Adam Beynon.
+# Copyright 2010 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.
+#
+
+module Vienna
+  
+  module Builders
+    
+    class Base
+      
+      attr_reader :build_item
+      
+      def initialize(build_item, dst)
+        @build_item = build_item
+        @dst_path = dst
+      end
+      
+      # build the item
+      def build
+      end
+      
+      def self.build(build_item, dst)
+        new(build_item, dst).build
+      end
+      
+    end
+  end
+end

data/lib/opal/builders/css.rb

@@ -0,0 +1,46 @@
+# 
+# css.rb
+# vienna
+# 
+# Created by Adam Beynon.
+# Copyright 2010 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__), 'base')
+
+module Vienna
+  
+  module Builders
+    
+    class CSS < Base
+      
+      def build
+        FileUtils.mkdir_p(File.dirname(@dst_path))
+        
+        # puts "building to #{@dst_path}"
+        
+        File.open(@dst_path, 'w') do |out|
+          out.write File.read(@build_item.source_path)
+        end
+      end
+    end
+  end
+end

data/lib/opal/builders/javascript.rb

@@ -0,0 +1,44 @@
+# 
+# javascript.rb
+# vienna
+# 
+# Created by Adam Beynon.
+# Copyright 2010 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__), 'base')
+
+module Vienna
+  
+  module Builders
+    
+    class Javascript < Base
+      
+      def build
+        FileUtils.mkdir_p(File.dirname(@dst_path))
+
+        File.open(@dst_path, 'w') do |out|
+          out.write File.read(@build_item.source_path)
+        end
+      end
+    end
+  end
+end

data/lib/opal/builders/opal.rb

@@ -0,0 +1,79 @@
+# 
+# opal.rb
+# vienna
+# 
+# Created by Adam Beynon.
+# Copyright 2010 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__), 'base')
+
+module Vienna
+  
+  module Builders
+    
+    class Opal < Base
+      
+      def build
+        # puts "building opal to #{@build_item.build_path}"
+        source_items = @build_item.source_items
+        build_path = @build_item.build_path
+        
+        FileUtils.mkdir_p File.dirname(build_path)
+        
+        exec_sources = source_items.select do |item|
+          item.ext == 'rb' || item.ext == 'js'
+        end
+
+        File.open(build_path, 'w') do |out|
+          # opal definition and required attributes
+          out.puts %Q|opal.register({|
+          out.puts %Q|  "name": "#{@build_item.target.target_name}",|
+          # executable sources
+          out.puts %Q|  "files": {|
+          exec_sources.each_with_index do |item, index|
+            out.puts(",") if index > 0
+            contents = File.read(item.stage!.staging_path)
+            if item.ext == "rb"
+              out.write %Q|    "#{item.filename}": #{contents}|
+            else
+              # must wrap javascript in function closure
+              out.write %Q|    "#{item.filename}": function() {#{contents}}|
+            end
+          end
+          out.puts "\n  }"
+          
+          
+          # 
+          out.puts "});"
+        end
+        
+        # source_items.each do |item|
+        #   staged_path = item.stage!.staging_path
+        #   
+        #   puts staged_path
+        #   puts item.ext
+        # end
+      end
+      
+    end
+  end
+end

data/lib/opal/builders/ruby.rb

@@ -0,0 +1,50 @@
+# 
+# ruby.rb
+# vienna
+# 
+# Created by Adam Beynon.
+# Copyright 2010 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__), 'base')
+
+module Vienna
+  
+  module Builders
+    
+    class Ruby < Base
+      
+      # Build the ruby file.. here we actually cheat and use a completely
+      # differently parser/compiler
+      def build
+        # puts "building to #{@build_item.source_path}"
+        # Vienna::RubyParser.new(@build_item.source_path, @dst_path, "").build!
+        res = Vienna::RubyParser.new(@build_item.source_path, File.read(@build_item.source_path)).build!
+        
+        FileUtils.mkdir_p(File.dirname(@dst_path))
+        File.open(@dst_path, 'w') do |out|
+          out.write res
+        end
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,1851 @@
+# 
+# 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