red 3.5.0 → 4.0.0

data/lib/red/nodes/control_nodes.rb

@@ -0,0 +1,126 @@
+module Red
+  class ControlNode < String # :nodoc:
+    class Begin < ControlNode # :nodoc:
+      # [:begin, {expression | :block}]
+      def initialize(body_sexp, options)
+        body = body_sexp.red!(:force_return => options[:as_assignment] || options[:as_receiver] || options[:as_argument] || options[:force_return])
+        self << "%s" % [body]
+      end
+    end
+    
+    class Ensure < ControlNode # :nodoc:
+      # [:ensure, {expression | :block}, {expression | :block}]
+      def initialize(attempted_sexp, ensure_body_sexp, options)
+        #string = (options[:as_argument] || options[:force_return] ? "function(){%s;}()" : "%s") % [string]
+        
+        attempted   = (attempted_sexp.is_sexp?(:block, :rescue) ? attempted_sexp : [:block, attempted_sexp]).red!(:force_return => options[:force_return])
+        ensure_body = (ensure_body_sexp.is_sexp?(:block) ? ensure_body_sexp : [:block, ensure_body_sexp]).red!(:force_return => options[:force_return])
+        string      = attempted_sexp.is_sexp?(:rescue) ? "%sfinally{%s;}" : "try{%s;}finally{%s;}"
+        
+        self << string % [attempted, ensure_body]
+      end
+    end
+    
+    class Rescue < ControlNode # :nodoc:
+      # [:rescue, (expression | :block), {:resbody}]
+      def initialize(attempted_sexp, rescue_body_sexp, options = {})
+        (options = rescue_body_sexp) && (rescue_body_sexp = attempted_sexp) && (attempted_sexp = [:nil]) if rescue_body_sexp.is_a?(Hash)
+        
+        string      = "try{%s;}catch(_e){_eRescued=false;%s;if(!_eRescued){throw(_e);};}"
+        if options[:as_argument] || options[:as_assignment]
+          string = "function(){%s;}.m$(this)()" % string
+          options[:force_return] = true
+        end
+        attempted   = (attempted_sexp.is_sexp?(:block) ? attempted_sexp : [:block, attempted_sexp]).red!(:force_return => options[:force_return])
+        rescue_body = rescue_body_sexp.red!(:force_return => options[:force_return])
+        
+        self << "try{%s;}catch(_e){_eRescued=false;%s;if(!_eRescued){throw(_e);};}" % [attempted, rescue_body]
+      end
+    end
+    
+    class RescueBody < ControlNode # :nodoc:
+      # [:resbody, {nil | [:array, {expression}, {expression}, ...]}, (expression | :block), (:resbody)]
+      def initialize(exception_types_array_sexp, block_sexp, rescue_body_sexp = nil, options = {})
+        (options = block_sexp) && (block_sexp = nil) if block_sexp.is_a?(Hash)
+        (options = rescue_body_sexp) && (block_sexp.first==:resbody ? (rescue_body_sexp = block_sexp && block_sexp = nil) : (rescue_body_sexp = nil)) if rescue_body_sexp.is_a?(Hash)
+        
+        if block_sexp.is_sexp?(:block) && block_sexp[1].is_sexp?(:lasgn) && block_sexp[1].last == [:gvar, %s($!)]
+          exception_variable  = "var %s=_e;" % block_sexp.delete(block_sexp.assoc(:lasgn))[1].red!
+        elsif block_sexp.is_sexp?(:lasgn) && block_sexp.last == [:gvar, %s($!)]
+          exception_variable  = "var %s=_e;" % block_sexp[1].red!
+          block_sexp          = [:nil]
+        end
+        
+        exception_types_array = (exception_types_array_sexp || [:array, [:const, :Exception]]).red!
+        block                 = (block_sexp.is_sexp?(:block) ? block_sexp : [:block, block_sexp]).red!(:force_return => options[:force_return])
+        rescue_body           = "else{%s;}" % rescue_body_sexp.red!(:force_return => options[:force_return]) if rescue_body_sexp
+        
+        self << "%sif($eType(_e,%s)){_eRescued=true;%s;}%s" % [exception_variable, exception_types_array, block, rescue_body]
+      end
+    end
+    
+    class For < ControlNode # :nodoc:
+      # [:for, {expression}, {expression}, {expression | :block}]
+      def initialize(source_sexp, iterator_assignment_sexp, body_sexp, options)
+        body = body_sexp.red!
+        unless source_sexp.is_sexp?(:xstr, :dxstr)
+          source   = source_sexp.red!(:as_argument => true)
+          iterator = iterator_assignment_sexp.last.red!
+          self << "for(var %s in %s){%s;}" % [iterator, source, body]
+        else
+          loop_statement = source_sexp.red!
+          self << "for(%s){%s;}" % [loop_statement, body]
+        end
+      end
+    end
+    
+    class Keyword < ControlNode # :nodoc:
+      # [:break, (expression)]
+      # [:next, (expression)]
+      def initialize(*arguments_array_sexp)
+        options = arguments_array_sexp.pop
+        arguments = arguments_array_sexp.map {|arg| arg.red!(:as_argument => true) }.join(",")
+        keyword = self.class.to_s.split('::').last.downcase
+        self << "$%s(%s)" % [keyword, arguments]
+      end
+      
+      class Break < Keyword # :nodoc:
+      end
+      
+      class Next < Keyword # :nodoc:
+      end
+      
+      class Redo < Keyword # :nodoc:
+      end
+    end
+    
+    class Loop < ControlNode # :nodoc:
+      # [:until, {expression}, {expression | :block}, true | false]
+      # [:while, {expression}, {expression | :block}, true | false]
+      def initialize(condition_sexp, body_sexp, run_only_if_condition_met, options)
+        condition = (self.is_a?(Until) ? "!$T(%s)" : "$T(%s)") % [condition_sexp.red!(:as_argument => true)]
+        body      = body_sexp.red!
+        if run_only_if_condition_met
+          self << "while(%s){%s;}"   % [condition, body]
+        else
+          self << "do{%s;}while(%s)" % [body, condition]
+        end
+      end
+      
+      class Until < Loop # :nodoc:
+      end
+      
+      class While < Loop # :nodoc:
+      end
+    end
+    
+    class Return < ControlNode # :nodoc:
+      # [:return, (expression)]
+      def initialize(expression_sexp = nil, options = {})
+        (options = expression_sexp) && (expression_sexp = [:nil]) if expression_sexp.is_a?(Hash)
+        expression = expression_sexp.red!(:as_argument => true)
+        self << "return(%s)" % [expression]
+      end
+    end
+  end
+end

data/lib/red/nodes/data_nodes.rb

@@ -0,0 +1,75 @@
+module Red
+  class DataNode < String # :nodoc:
+    class Error < DataNode # :nodoc:
+    end
+    
+    class Nil < DataNode # :nodoc:
+      # nil
+      def initialize(value_data, options)
+        self << ""
+      end
+    end
+    
+    class Numeric < DataNode # :nodoc:
+      # 1
+      def initialize(value_data, options)
+        value  = value_data.inspect
+        string = options[:as_receiver] ? "(%s)" : "%s"
+        self << string % [value]
+      end
+    end
+    
+    class Range < DataNode # :nodoc:
+      # 1..2
+      def initialize(value_data, options)
+        start     = value_data.begin
+        finish    = value_data.end
+        exclusive = value_data.exclude_end?.inspect
+        self << "c$Range.m$new(%s,%s,%s)" % [start, finish, exclusive]
+      end
+    end
+    
+    class Regexp < DataNode # :nodoc:
+      # /foo/mi
+      def initialize(value_data, options)
+        source  = value_data.source
+        options = 0
+        options += 1 if value_data.to_s.match(/\(\?[^-]*i.*-*/)
+        options += 2 if value_data.to_s.match(/\(\?[^-]*x.*-*/)
+        options += 4 if value_data.to_s.match(/\(\?[^-]*m.*-*/)
+        self << "'%s',%s" % [source.gsub('\\','\\\\\\\\'),options]
+      end
+    end
+    
+    class String < DataNode # :nodoc:
+      # 'foo'
+      def initialize(value_data, options)
+        value  = options[:no_escape] ? value_data : value_data.gsub(/'/, "\\\\'")
+        string = options[:unquoted] ? "%s" % [value] : "%s" % [value.inspect]
+        self << string
+      end
+    end
+    
+    class Symbol < DataNode # :nodoc:
+      # :foo
+      def initialize(value_data, options)
+        value  = self.camelize(value_data.to_s, options[:not_camelized])
+        string = options[:as_receiver] ? "$q('%s')" : options[:as_argument] ? "'%s'" : "%s"
+        self << string % [value]
+      end
+      
+      def camelize(string, disabled = false)
+        return string unless self.camelize?(string) && !disabled
+        words = string.gsub(/@/,'').gsub('?','_bool').gsub('!','_bang').gsub('=','_eql').split(/_/)
+        underscore = words.shift if words.first.empty?
+        return (underscore ? '_' : '') + words[0] + words[1..-1].map {|word| word == word.upcase ? word : word.capitalize }.join
+      end
+      
+      def camelize?(string)
+        is_not_a_constant_name        = string != string.upcase || string =~ (/@|\$/)
+        is_not_a_js_special_attribute = string[0..1] != '__'
+        return is_not_a_constant_name && is_not_a_js_special_attribute
+      end
+    end
+  end
+end

data/lib/red/nodes/definition_nodes.rb

@@ -0,0 +1,191 @@
+module Red
+  class DefinitionNode < String # :nodoc:
+    class Alias < DefinitionNode # :nodoc:
+      def initialize(new_method_name_sexp, old_method_name_sexp, options)
+        new_method_name = new_method_name_sexp.last.red!
+        old_method_name = old_method_name_sexp.last.red!
+        self << "_.m$%s=_.m$%s" % [new_method_name, old_method_name]
+        @@red_methods |= [old_method_name_sexp.last] unless @@red_import
+      end
+    end
+    
+    class Class < DefinitionNode # :nodoc:
+      # [:class, :Foo, (expression), [:scope, (expression | :block)]] => superclass doesn't show up sometimes when namespaced a certain way; I forgot what the pattern is though
+      def initialize(class_name_sexp, superclass_sexp, scope_sexp, options = {})
+        (options = scope_sexp) && (scope_sexp = superclass_sexp) && (superclass_sexp = nil) if scope_sexp.is_a?(Hash)
+        superclass = (superclass_sexp || [:const, :Object]).red!
+        class_name = "%s" % class_name_sexp.red!
+        
+        if class_name_sexp.is_sexp?(:colon3)
+          old_namespace_stack = @@namespace_stack
+          namespaced_class    = class_name
+          @@namespace_stack   = [namespaced_class]
+        elsif class_name_sexp.is_sexp?(:colon2)
+          @@namespace_stack.push(class_name)
+          namespaced_class    = class_name
+          class_name          = class_name_sexp.last.red!
+        else
+          class_name = "c$%s" % class_name_sexp.red!
+          @@namespace_stack.push(class_name)
+          namespaced_class    = @@namespace_stack.join(".")
+        end
+        @@red_constants |= [namespaced_class]
+        
+        scope = scope_sexp.red!(:as_class_eval => true)
+        
+        self << "\n\n$class('%s',%s,function(){ var _=%s.prototype;\n  %s;\n})" % [namespaced_class.gsub("c$",""), superclass, namespaced_class, scope]
+        
+        old_namespace_stack.nil? ? @@namespace_stack.pop : @@namespace_stack = old_namespace_stack
+      end
+    end
+    
+    class Module < DefinitionNode # :nodoc:
+      # [:module, :Foo, [:scope, (expression | :block)]]
+      def initialize(module_name_sexp, scope_sexp, options)
+        module_name = "%s" % module_name_sexp.red!
+        
+        if module_name_sexp.is_sexp?(:colon3)
+          old_namespace_stack = @@namespace_stack
+          namespaced_module   = module_name
+          @@namespace_stack   = [namespaced_module]
+        elsif module_name_sexp.is_sexp?(:colon2)
+          namespaced_module   = module_name
+          module_name         = module_name_sexp.last.red!
+          @@namespace_stack.push(module_name)
+        else
+          module_name = "c$%s" % module_name_sexp.red!
+          @@namespace_stack.push(module_name)
+          namespaced_module   = @@namespace_stack.join(".")
+        end
+        @@red_constants |= [namespaced_module]
+        
+        scope = scope_sexp.red!(:as_class_eval => true)
+        
+        self << "\n\n$module('%s',function(){ var _=%s.prototype;\n  %s;\n})" % [namespaced_module.gsub("c$",""), namespaced_module, scope]
+        
+        @@namespace_stack.pop
+      end
+    end
+    
+    class Method < DefinitionNode # :nodoc:
+      # def args_and_contents_from(scope, function)
+      #   block = scope.assoc(:block) || scope
+      #   block_arg = block.delete(block.assoc(:block_arg)) || ([:block_arg, :block] if block.flatten.include?(:yield))
+      #   arguments = block.assoc(:args) ? block.assoc(:args)[1..-1] || [] : []
+      #   defaults = arguments.delete(arguments.assoc(:block))
+      #   splat_arg = arguments.pop.to_s[1..-1] if arguments.last && arguments.last.to_s.include?('*')
+      #   arguments = (block_arg ? arguments << block_arg.last : arguments).map {|arg| arg.red!}
+      #   block_given = "var blockGivenBool=(typeof(arguments[arguments.length-1])=='function')" if block_arg
+      #   args_array = "var blockGivenBool;var l=(blockGivenBool?arguments.length-1:arguments.length);#{splat_arg}=[];for(var i=#{block_arg ? arguments.size - 1 : arguments.size};i<l;++i){#{splat_arg}.push(arguments[i]);};var block=(blockGivenBool?arguments[arguments.length-1]:nil)" if splat_arg
+      #   contents = [block_given, args_array, defaults.red!(:as_argument_default => true), scope.red!(:force_return => function != 'initialize')].compact.reject {|x| x.empty? }
+      #   return [arguments, contents]
+      # end
+      
+      class Instance < Method # :nodoc:
+        # [:defn, :foo, [:scope, [:block, [:args, (:my_arg1, :my_arg2, ..., :'*my_args', (:block))], (:block_arg, :my_block), {expression}, {expression}, ...]]
+        def initialize(function_name_sexp, scope_sexp, options)
+          return if @@red_import && !@@red_methods.include?(function_name_sexp)
+          function        = (METHOD_ESCAPE[function_name_sexp] || function_name_sexp).red!
+          @@red_function  = function
+          block_sexp      = scope_sexp.assoc(:block)
+          block_arg_sexp  = block_sexp.delete(block_sexp.assoc(:block_arg)) || ([:block_arg, :_block] if block_sexp.flatten.include?(:yield))
+          @@red_block_arg = block_arg_sexp.last if block_arg_sexp
+          argument_sexps  = block_sexp.assoc(:args)[1..-1] || []
+          defaults_sexp   = argument_sexps.delete(argument_sexps.assoc(:block))
+          splat_arg       = argument_sexps.pop.to_s[1..-1] if argument_sexps.last && argument_sexps.last.to_s.include?('*')
+          argument_sexps += [block_arg_sexp.last] if block_arg_sexp
+          args_array      = argument_sexps.map {|argument| argument.red! }
+          splatten_args   = "for(var bg=m$blockGivenBool(arguments[arguments.length-1]),l=bg?arguments.length-1:arguments.length,i=#{block_arg_sexp ? argument_sexps.size - 1 : argument_sexps.size},#{splat_arg}=[];i<l;++i){#{splat_arg}.push(arguments[i]);};var #{block_arg_sexp.last rescue :_block}=(bg?c$Proc.m$new(arguments[arguments.length-1]):nil)" if splat_arg
+          block_arg       = "var #{block_arg_sexp.last rescue :_block}=(m$blockGivenBool(arguments[arguments.length-1])?c$Proc.m$new(arguments[arguments.length-1]):nil)" if block_arg_sexp && !splat_arg
+          defaults        = defaults_sexp.red!(:as_argument_default => true) if defaults_sexp
+          arguments       = args_array.join(",")
+          scope           = scope_sexp.red!(:force_return => function != 'initialize')
+          contents        = [splatten_args, block_arg, defaults, scope].compact.join(";")
+          if options[:as_class_eval]
+            string = "_.m$%s=function(%s){%s;}"
+          else
+            string = "m$%s=function(%s){%s;}"
+          end
+          self << string % [function, arguments, contents]
+          @@red_block_arg = nil
+          @@red_function  = nil
+        end
+      end
+      
+      class Singleton < Method # :nodoc:
+        # [:defs, {expression}, :foo, [:scope, (:block, [:args, (:my_arg1, :my_arg2, ..., :'*my_args', (:block))], (:block_arg, :my_block), {expression}, {expression}, ...)]
+        def initialize(object_sexp, function_name_sexp, scope_sexp, options)
+          return if @@red_import && !@@red_methods.include?(function_name_sexp)
+          function        = (METHOD_ESCAPE[function_name_sexp] || function_name_sexp).red!
+          @@red_function  = function
+          object          = object_sexp.is_sexp?(:self) ? @@namespace_stack.join(".") : object_sexp.red!
+          singleton       = "%s.m$%s" % [object, function]
+          block_sexp      = scope_sexp.assoc(:args) ? (scope_sexp << [:block, scope_sexp.delete(scope_sexp.assoc(:args)), [:nil]]).assoc(:block) : scope_sexp.assoc(:block)
+          block_arg_sexp  = block_sexp.delete(block_sexp.assoc(:block_arg)) || ([:block_arg, :_block] if block_sexp.flatten.include?(:yield))
+          @@red_block_arg = block_arg_sexp.last if block_arg_sexp
+          block_sexp      = [[:nil]] if block_sexp.empty?
+          argument_sexps  = block_sexp.assoc(:args)[1..-1] || []
+          defaults_sexp   = argument_sexps.delete(argument_sexps.assoc(:block))
+          splat_arg       = argument_sexps.pop.to_s[1..-1] if argument_sexps.last && argument_sexps.last.to_s.include?('*')
+          argument_sexps += [block_arg_sexp.last] if block_arg_sexp
+          args_array      = argument_sexps.map {|argument| argument.red! }
+          splatten_args   = "for(var bg=m$blockGivenBool(arguments[arguments.length-1]),l=bg?arguments.length-1:arguments.length,i=#{block_arg_sexp ? argument_sexps.size - 1 : argument_sexps.size},#{splat_arg}=[];i<l;++i){#{splat_arg}.push(arguments[i]);};var #{block_arg_sexp.last rescue :_block}=(bg?c$Proc.m$new(arguments[arguments.length-1]):nil)" if splat_arg
+          block_arg       = "var #{block_arg_sexp.last rescue :_block}=(m$blockGivenBool(arguments[arguments.length-1])?c$Proc.m$new(arguments[arguments.length-1]):nil)" if block_arg_sexp && !splat_arg
+          defaults        = defaults_sexp.red!(:as_argument_default => true) if defaults_sexp
+          arguments       = args_array.join(",")
+          scope           = scope_sexp.red!(:force_return => function != 'initialize')
+          contents        = [splatten_args, block_arg, defaults, scope].compact.join(";")
+          self << "%s=function(%s){%s;}" % [singleton, arguments, contents]
+          @@red_block_arg = nil
+          @@red_function  = nil
+        end
+      end
+    end
+    
+    class Scope < DefinitionNode # :nodoc:
+      # [:scope,  (expression | :block)]
+      def initialize(contents_sexp = nil, options = {})
+        (options = contents_sexp) && (contents_sexp = [:block]) if contents_sexp.is_a?(::Hash)
+        variables  = []
+        contents_sexp.flatten.each_with_index do |x,i|
+          variables.push(contents_sexp.flatten[i + 1]) if [:lasgn,:vcall].include?(x)
+        end
+        variables -= (contents_sexp.delete(contents_sexp.assoc(:args)) || [])[1..-1] || [] # don't want to undefine the arguments in a method definition
+        declare    = "var %s" % variables.map {|x| "%s=$u" % x.red! }.uniq.join(",") unless variables.empty?
+        contents   = [declare, contents_sexp.red!(options)].compact.join(";#{options[:as_class_eval] ? "\n  " : ''}")
+        self << "%s" % contents
+      end
+    end
+    
+    class SingletonClass < DefinitionNode # :nodoc:
+      # [:sclass, {expression}, [:scope, (expression | :block)]]
+      #def initialize(receiver, scope)
+      #  old_class = @@red_class
+      #  @@red_class = @class = receiver.build_node.compile_node
+      #  block_node = scope.assoc(:block) || scope
+      #  properties = block_node.select {|node| (node.first == :cvdecl) rescue false }
+      #  functions = block_node.select {|node| ![:block, :scope].include?(node) }
+      #  @slots = (properties | functions).build_nodes
+      #  @@red_class = old_class
+      #end
+      #
+      #def compile_node(options = {})
+      #  old_class = @@red_class
+      #  @@red_class = @class
+      #  slots = @slots.compile_nodes(:as_property => true).compact.join(', ')
+      #  @@red_class = old_class
+      #  return "{ %s }" % [slots]
+      #end
+    end
+    
+    class Undef < DefinitionNode # :nodoc:
+      # [:undef, {expression}]
+      def initialize(function_name_sexp, options)
+        return if @@red_import && !@@red_methods.include?(function_name_sexp)
+        function_sexp = function_name_sexp.last.red!
+        namespaced_function = @@namespace_stack.empty? ? function_sexp : (@@namespace_stack + ['prototype', "m$%s" % function_sexp]).join('.')
+        self << "delete %s" % [namespaced_function]
+      end
+    end
+  end
+end

data/lib/red/nodes/illegal_nodes.rb

@@ -0,0 +1,33 @@
+module Red
+  class IllegalNode # :nodoc:
+    class FlipflopNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoFlipflops, "Flip-flop operators are not supported")
+      end
+    end
+    
+    class MatchNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoArbitraryMatch, "Boolean matching is not supported")
+      end
+    end
+    
+    class PostexeNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoBEGINorEND, "BEGIN and END blocks are not supported")
+      end
+    end
+    
+    class RegexEvaluationNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoRegexEvaluation, "Construction of regular expressions with evaluated content is not supported")
+      end
+    end
+    
+    class RetryNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoRetry, "Retry is not supported")
+      end
+    end
+  end
+end

data/lib/red/nodes/literal_nodes.rb

@@ -0,0 +1,148 @@
+module Red
+  class LiteralNode < String # :nodoc:
+    class Array < LiteralNode # :nodoc:
+      # [:zarray]
+      # [:to_ary, {expression}]
+      # [:array,  {expression}, {expression}, ...]
+      def initialize(*element_sexps)
+        options  = element_sexps.pop
+        elements = element_sexps.map {|element_sexp| element_sexp.red!(:as_argument => true)}.join(",")
+        self << "[%s]" % [elements]
+      end
+    end
+    
+    class Hash < LiteralNode # :nodoc:
+      # [:hash, ({expression->key}, {expression->value}, ...)]
+      def initialize(*element_sexps)
+        options  = element_sexps.pop
+        elements = element_sexps.map {|element_sexp| element_sexp.red!(:as_argument => true)}.join(",")
+        self << "c$Hash.m$_brkt(%s)" % [elements]
+      end
+    end
+    
+    class Multiline < LiteralNode # :nodoc:
+      # [:block, {expression}, {expression}, ...]
+      def initialize(*expression_sexps)
+        # force_return: changes final expression to "return <expression>",
+        #   unless there is already return anywhere inside <expression>.
+        # as_argument: duplicates :force_return and adds "function() {
+        #   <multiline block>; }()" wrapper to the entire block.
+        options = expression_sexps.pop
+        if options[:as_argument] || options[:as_assignment] || options[:force_return] && expression_sexps.last.is_a?(::Array) && !expression_sexps.last.is_sexp?(:rescue, :ensure, :begin) && (expression_sexps.last.first == :iter ? true : !expression_sexps.last.flatten.include?(:return))
+          returner = "return %s" % [expression_sexps.pop.red!(:as_argument => true)]
+        end
+        string = options[:as_argument] || options[:as_assignment] ? "function(){%s;}.m$(this)()" : "%s"
+        lines = (expression_sexps.map {|line| line.red!(options)} + [returner]).compact.reject {|x| x == '' }.join(";#{options[:as_class_eval] ? "\n  " : ''}")
+        self << string % [lines]
+      end
+    end
+    
+    class Namespace < LiteralNode # :nodoc:
+      # [:colon2, {expression}, :Foo]
+      def initialize(namespace_sexp, class_name_sexp, options)
+        namespace  = namespace_sexp.red!(:as_receiver => true)
+        class_name = class_name_sexp.red!
+        self << "%s.c$%s" % [namespace, class_name]
+      end
+      
+      # [:colon3, :Foo]
+      class TopLevel < LiteralNode # :nodoc:
+        def initialize(class_name_sexp, options)
+          class_name = class_name_sexp.red!
+          self << "c$%s" % [class_name]
+        end
+      end
+    end
+    
+    class Other < LiteralNode # :nodoc:
+      # [:lit,    {number | regexp | range}]
+      # [:svalue, [:array, {expression}, {expression}, ...]]
+      # [:to_ary, {expression}] => right side of :masgn when arguments are too few
+      def initialize(value_sexp = nil, options = {})
+        (options = value_sexp) && (value_sexp = nil) if value_sexp.is_a?(::Hash)
+        symbol_sexp = [:sym, value_sexp] if value_sexp.is_a?(::Symbol)
+        regexp_sexp = [:regex, value_sexp] if value_sexp.is_a?(::Regexp)
+        value = (regexp_sexp || symbol_sexp || value_sexp).red!(options)
+        self << "%s" % [value]
+      end
+    end
+    
+    class Range < LiteralNode # :nodoc:
+      # [:dot2, {expression}, {expression}]
+      def initialize(start_sexp, finish_sexp, options)
+        start  = start_sexp.red!(:as_argument => true)
+        finish = finish_sexp.red!(:as_argument => true)
+        self << "c$Range.m$new(%s,%s,false)" % [start, finish]
+      end
+      
+      class Exclusive < Range # :nodoc:
+        # [:dot3, {expression}, {expression}]
+        def initialize(start_sexp, finish_sexp, options)
+          start  = start_sexp.red!(:as_argument => true)
+          finish = finish_sexp.red!(:as_argument => true)
+          self << "c$Range.m$new(%s,%s,true)" % [start, finish]
+        end
+      end
+    end
+    
+    class Regexp < LiteralNode # :nodoc:
+      # [:lit, {regexp}]
+      # ### [:dregex,  "foo", {expression}, {expression}, ...]
+      def initialize(regexp_sexp, options)
+        regexp = regexp_sexp.red!(:as_argument => true)
+        self << "$r(%s)" % [regexp]
+      end
+    end
+    
+    class Splat < LiteralNode # :nodoc:
+      # [:splat, {expression}]
+      #def initialize(*args)
+      #  case @@red_library
+      #    when :Prototype : super(*args)
+      #    else              raise(BuildError::NoSplatConstructor, "Splat array constructor not supported for #{@@red_library} JavaScript library")
+      #  end
+      #end
+      #
+      #def compile_node(options = {})
+      #  initial = @initial.compile_node
+      #  case @@red_library
+      #    when :Prototype : return "$A(%s)" % [initial]
+      #    else              ""
+      #  end
+      #end
+    end
+    
+    class String < LiteralNode # :nodoc:
+      # [:str,   "foo"]
+      # [:dstr,  "foo", {expression}, {expression}, ...]
+      # [:evstr, {expression}]
+      def initialize(*element_sexps)
+        options  = element_sexps.pop
+        elements = element_sexps.map {|element_sexp| element_sexp.red!(options.merge(:as_argument => true, :as_string_element => true)) }.join(",")
+        string   = options[:unquoted] || options[:as_string_element] ? "%s" : element_sexps.size > 1 ? "$Q(%s)" : "$q(%s)"
+        self << string % [elements]
+      end
+    end
+    
+    class Symbol < LiteralNode # :nodoc:
+      # [:lit,   {symbol}]
+      # [:dsym,  "foo", {expression}, {expression}, ...]
+      def initialize(*element_sexps)
+        options  = element_sexps.pop
+        elements = element_sexps.map {|element_sexp| element_sexp.red!(options.merge(:as_argument => true, :as_string_element => true)) }.join(",")
+        string   = element_sexps.size > 1 ? "$S(%s)" : "$s(%s)"
+        self << string % [elements]
+      end
+    end
+    
+    class Uninterpreted < LiteralNode # :nodoc:
+      # [:xstr,  "foo"]
+      # [:dxstr, "foo", {expression}, {expression}, ...]
+      def initialize(*element_sexps)
+        options  = element_sexps.pop
+        elements = element_sexps.map {|element_sexp| element_sexp.red!(:unquoted => true, :no_escape => true) }.join
+        self << "%s" % [elements]
+      end
+    end
+  end
+end

data/lib/red/nodes/logic_nodes.rb

@@ -0,0 +1,89 @@
+module Red
+  class LogicNode < String # :nodoc:
+    class Boolean < LogicNode # :nodoc:
+      # [:false]
+      # [:true]
+      def initialize(options)
+        string = case self when False : "false" when True : "true" end
+        self << string
+      end
+      
+      class False < Boolean # :nodoc:
+      end
+      
+      class True < Boolean # :nodoc:
+      end
+    end
+    
+    class Case < LogicNode # :nodoc:
+      # [:case, {expression}, {:when}, {:when}, ..., {expression | :block}]
+      def initialize(switch_sexp, *case_sexps)
+        options     = case_sexps.pop
+        switch      = switch_sexp.red!(:as_argument => true)
+        else_case   = case_sexps.pop.red!(:as_argument => options[:as_argument])
+        string      = "var _switch=(%s);%s" % [switch, '%s']
+        case_string = case_sexps.inject(string) do |cases,case_sexp|
+          cases %= case_sexp.red!(:as_argument => options[:as_argument])
+        end
+        self << case_string % [else_case]
+      end
+      
+      class When < Case # :nodoc:
+        # [:when, [:array, {expression}, {expression}, ...], {expression | :block}]
+        def initialize(condition_sexps, expression_sexp, options)
+          conditions = condition_sexps[1..-1].map {|condition_sexp| "%s.m$_eql3(_switch)" % [condition_sexp.red!(:as_receiver => true)] }.join("||")
+          expression = expression_sexp.red!(:as_argument => options[:as_argument])
+          string     = options[:as_argument] ? "(%s?%s:%s)" : "if(%s){%s;}else{%s;}"
+          self << string % [conditions, expression, '%s']
+        end
+      end
+    end
+    
+    class Conjunction < LogicNode # :nodoc:
+      # [:and, {expression}, {expression}]
+      # [:or,  {expression}, {expression}]
+      def initialize(expression_a_sexp, expression_b_sexp, options)
+        a = expression_a_sexp.red!(:as_argument => true)
+        b = expression_b_sexp.red!(:as_argument => true)
+        string = self.class::STRING
+        self << string % [a,b]
+      end
+      
+      class And < Conjunction # :nodoc:
+        # FIX: nil && obj produces false instead of nil
+        STRING = "(_a=$T(%s)?(_c=$T(_b=%s)?_b:_c):_a)"
+      end
+      
+      class Or < Conjunction # :nodoc:
+        STRING = "($T(_a=%s)?_a:%s)"
+      end
+    end
+    
+    class If < LogicNode # :nodoc:
+      # [:if, {expression}, {expression | :block}, {expression | :block}]
+      def initialize(condition_sexp, true_case_sexp, else_case_sexp, options)
+        # ... each_with_index {|x,i| b << a.flatten[i+1] if x == :lasgn}
+        if options[:as_argument] || options[:as_receiver] || options[:as_assignment]
+          condition = condition_sexp.red!(:as_argument => true)
+          true_case = true_case_sexp.nil? ? "nil" : true_case_sexp.red!(:as_argument => true)
+          else_case = else_case_sexp.nil? ? "nil" : else_case_sexp.red!(:as_argument => true)
+          self << "($T(%s)?%s:%s)" % [condition, true_case, else_case]
+        else
+          condition = (true_case_sexp.nil? ? "!$T(%s)" : "$T(%s)") % [condition_sexp.red!(:as_argument => true)]
+          true_case = "{%s;}" % [true_case_sexp.red!] unless true_case_sexp.nil?
+          join      = "else"                          unless true_case_sexp.nil? || else_case_sexp.nil?
+          else_case = "{%s;}" % [else_case_sexp.red!] unless else_case_sexp.nil?
+          self << "if(%s)%s%s%s" % [condition, true_case, join, else_case]
+        end
+      end
+    end
+    
+    class Not < LogicNode # :nodoc:
+      # [:not, {expression}]
+      def initialize(expression_sexp, options)
+        expression = expression_sexp.red!(:as_argument => true)
+        self << "!$T(%s)" % [expression]
+      end
+    end
+  end
+end