opal-cj 0.7.0.beta1

data/lib/opal/nodes/if.rb

@@ -0,0 +1,67 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class IfNode < Base
+      handle :if
+
+      children :test, :true_body, :false_body
+
+      RUBY_ENGINE_CHECK = [:call, [:const, :RUBY_ENGINE],
+                              :==, [:arglist, [:str, "opal"]]]
+
+      RUBY_PLATFORM_CHECK = [:call, [:const, :RUBY_PLATFORM],
+                              :==, [:arglist, [:str, "opal"]]]
+
+      def compile
+        truthy, falsy = self.truthy, self.falsy
+
+        if skip_check_present?
+          falsy = nil
+        end
+
+        push "if (", js_truthy(test), ") {"
+
+        # skip if-body if no truthy sexp
+        indent { line stmt(truthy) } if truthy
+
+        if falsy
+          if falsy.type == :if
+            line "} else ", stmt(falsy)
+          else
+            indent do
+              line "} else {"
+              line stmt(falsy)
+            end
+
+            line "}"
+          end
+        else
+          push "}"
+        end
+
+        wrap "(function() {", "; return nil; })()" if needs_wrapper?
+      end
+
+      # pre-processing only effects falsy blocks. If engine is
+      # opal, then falsy block gets generated as normal. Unless
+      # engine is opal then that code gets generated as the
+      # falsy block
+      def skip_check_present?
+        test == RUBY_ENGINE_CHECK or test == RUBY_PLATFORM_CHECK
+      end
+
+      def truthy
+        needs_wrapper? ? compiler.returns(true_body || s(:nil)) : true_body
+      end
+
+      def falsy
+        needs_wrapper? ? compiler.returns(false_body || s(:nil)) : false_body
+      end
+
+      def needs_wrapper?
+        expr? or recv?
+      end
+    end
+  end
+end

data/lib/opal/nodes/iter.rb

@@ -0,0 +1,131 @@
+require 'opal/nodes/scope'
+
+module Opal
+  module Nodes
+    class IterNode < ScopeNode
+      handle :iter
+
+      children :args_sexp, :body_sexp
+
+      def compile
+        opt_args  = extract_opt_args
+        block_arg = extract_block_arg
+
+        # find any splat args
+        if args.last.is_a?(Sexp) and args.last.type == :splat
+          splat = args.last[1][1]
+          args.pop
+          len = args.length
+        end
+
+        params = args_to_params(args[1..-1])
+        params << splat if splat
+
+        to_vars = identity = body_code = nil
+
+        in_scope do
+          identity = scope.identify!
+          add_temp "self = #{identity}.$$s || this"
+
+          compile_args(args[1..-1], opt_args, params)
+
+          if splat
+            scope.add_arg splat
+            push "#{splat} = $slice.call(arguments, #{len - 1});"
+          end
+
+          if block_arg
+            scope.block_name = block_arg
+            scope.add_temp block_arg
+            scope_name = scope.identify!
+
+            line "#{block_arg} = #{scope_name}.$$p || nil, #{scope_name}.$$p = null;"
+          end
+
+          body_code = stmt(body)
+          to_vars = scope.to_vars
+        end
+
+        line body_code
+
+        unshift to_vars
+
+        unshift "(#{identity} = function(#{params.join ', '}){"
+        push "}, #{identity}.$$s = self, #{identity})"
+      end
+
+      def compile_args(args, opt_args, params)
+        args.each_with_index do |arg, idx|
+          if arg.type == :lasgn
+            arg = variable(arg[1])
+
+            if opt_args and current_opt = opt_args.find { |s| s[1] == arg.to_sym }
+              push "if (#{arg} == null) #{arg} = ", expr(current_opt[2]), ";"
+            else
+              push "if (#{arg} == null) #{arg} = nil;"
+            end
+          elsif arg.type == :array
+            arg[1..-1].each_with_index do |_arg, _idx|
+              _arg = variable(_arg[1])
+              push "#{_arg} = #{params[idx]}[#{_idx}];"
+            end
+          else
+            raise "Bad block arg type"
+          end
+        end
+      end
+
+      # opt args are last (if present) and are a s(:block)
+      def extract_opt_args
+        if args.last.is_a?(Sexp) and args.last.type == :block
+          opt_args = args.pop
+          opt_args.shift
+          opt_args
+        end
+      end
+
+      # does this iter define a block_pass
+      def extract_block_arg
+        if args.last.is_a?(Sexp) and args.last.type == :block_pass
+          block_arg = args.pop
+          block_arg = block_arg[1][1].to_sym
+        end
+      end
+
+      def args
+        if Fixnum === args_sexp or args_sexp.nil?
+          s(:array)
+        elsif args_sexp.type == :lasgn
+          s(:array, args_sexp)
+        else
+          args_sexp[1]
+        end
+      end
+
+      def body
+        compiler.returns(body_sexp || s(:nil))
+      end
+
+      # Maps block args into array of jsid. Adds $ suffix to invalid js
+      # identifiers.
+      #
+      # s(:args, parts...) => ["a", "b", "break$"]
+      def args_to_params(sexp)
+        result = []
+        sexp.each do |arg|
+          if arg[0] == :lasgn
+            ref = variable(arg[1])
+            scope.add_arg ref
+            result << ref
+          elsif arg[0] == :array
+            result << scope.next_temp
+          else
+            raise "Bad js_block_arg: #{arg[0]}"
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/opal/nodes/literal.rb

@@ -0,0 +1,230 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class ValueNode < Base
+      handle :true, :false, :self, :nil
+
+      def compile
+        push type.to_s
+      end
+    end
+
+    class NumericNode < Base
+      handle :int, :float
+
+      children :value
+
+      def compile
+        push value.to_s
+        wrap '(', ')' if recv?
+      end
+    end
+
+    class StringNode < Base
+      handle :str
+
+      children :value
+
+      def compile
+        push value.inspect
+      end
+    end
+
+    class SymbolNode < Base
+      handle :sym
+
+      children :value
+
+      def compile
+        push value.to_s.inspect
+      end
+    end
+
+    class RegexpNode < Base
+      handle :regexp
+
+      children :value, :flags
+
+      def compile
+        case value
+        when ''
+          push('/^/')
+        when %r{\?\<\w+\>}
+          message = "named captures are not supported in javascript: #{value.inspect}"
+          raise SyntaxError, message
+        else
+          push "#{Regexp.new(value).inspect}#{flags}"
+        end
+      end
+    end
+
+    module XStringLineSplitter
+      def compile_split_lines(value, sexp)
+        idx = 0
+        value.each_line do |line|
+          if idx == 0
+            push line
+          else
+            line_sexp = s()
+            line_sexp.source = [sexp.line + idx, 0]
+            frag = Fragment.new(line, line_sexp)
+            push frag
+          end
+
+          idx += 1
+        end
+      end
+    end
+
+    class XStringNode < Base
+      include XStringLineSplitter
+
+      handle :xstr
+
+      children :value
+
+      def needs_semicolon?
+        stmt? and !value.to_s.include?(';')
+      end
+
+      def compile
+        compile_split_lines(value.to_s, @sexp)
+
+        push ';' if needs_semicolon?
+
+        wrap '(', ')' if recv?
+      end
+
+      def start_line
+        @sexp.line
+      end
+    end
+
+    class DynamicStringNode < Base
+      handle :dstr
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :evstr
+            push "("
+            push expr(part[1])
+            push ")"
+          elsif part.type == :str
+            push part[1].inspect
+          elsif part.type == :dstr
+            push "("
+            push expr(part)
+            push ")"
+          else
+            raise "Bad dstr part #{part.inspect}"
+          end
+
+          wrap '(', ')' if recv?
+        end
+      end
+    end
+
+    class DynamicSymbolNode < Base
+      handle :dsym
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :evstr
+            push expr(s(:call, part.last, :to_s, s(:arglist)))
+          elsif part.type == :str
+            push part.last.inspect
+          else
+            raise "Bad dsym part"
+          end
+        end
+
+        wrap '(', ')'
+      end
+    end
+
+    class DynamicXStringNode < Base
+      include XStringLineSplitter
+
+      handle :dxstr
+
+      def requires_semicolon(code)
+        stmt? and !code.include?(';')
+      end
+
+      def compile
+        needs_semicolon = false
+
+        children.each do |part|
+          if String === part
+            compile_split_lines(part.to_s, @sexp)
+
+            needs_semicolon = true if requires_semicolon(part.to_s)
+          elsif part.type == :evstr
+            push expr(part[1])
+          elsif part.type == :str
+            compile_split_lines(part.last.to_s, part)
+            needs_semicolon = true if requires_semicolon(part.last.to_s)
+          else
+            raise "Bad dxstr part"
+          end
+        end
+
+        push ';' if needs_semicolon
+        wrap '(', ')' if recv?
+      end
+    end
+
+    class DynamicRegexpNode < Base
+      handle :dregx
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :str
+            push part[1].inspect
+          else
+            push expr(part[1])
+          end
+        end
+
+        wrap '(new RegExp(', '))'
+      end
+    end
+
+    class InclusiveRangeNode < Base
+      handle :irange
+
+      children :start, :finish
+
+      def compile
+        helper :range
+
+        push '$range(', expr(start), ', ', expr(finish), ', false)'
+      end
+    end
+
+    class ExclusiveRangeNode < Base
+      handle :erange
+
+      children :start, :finish
+
+      def compile
+        helper :range
+
+        push '$range(', expr(start), ', ', expr(finish), ', true)'
+      end
+    end
+  end
+end

data/lib/opal/nodes/logic.rb

@@ -0,0 +1,217 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class NextNode < Base
+      handle :next
+
+      children :value
+
+      def compile
+        return push "continue;" if in_while?
+
+        push expr_or_nil(value)
+        wrap "return ", ";"
+      end
+    end
+
+    class BreakNode < Base
+      handle :break
+
+      children :value
+
+      def compile
+        if in_while?
+          compile_while
+        elsif scope.iter?
+          compile_iter
+        else
+          error "void value expression: cannot use break outside of iter/while"
+        end
+      end
+
+      def compile_while
+        if while_loop[:closure]
+          push "return ", expr_or_nil(value)
+        else
+          push "break;"
+        end
+      end
+
+      def compile_iter
+        error "break must be used as a statement" unless stmt?
+        push expr_or_nil(value)
+        wrap "return ($breaker.$v = ", ", $breaker)"
+      end
+    end
+
+    class RedoNode < Base
+      handle :redo
+
+      def compile
+        if in_while?
+          compile_while
+        elsif scope.iter?
+          compile_iter
+        else
+          push "REDO()"
+        end
+      end
+
+      def compile_while
+        while_loop[:use_redo] = true
+        push "#{while_loop[:redo_var]} = true"
+      end
+
+      def compile_iter
+        push "return #{scope.identity}.apply(null, $slice.call(arguments))"
+      end
+    end
+
+    class NotNode < Base
+      handle :not
+
+      children :value
+
+      def compile
+        with_temp do |tmp|
+          push expr(value)
+          wrap "(#{tmp} = ", ", (#{tmp} === nil || #{tmp} === false))"
+        end
+      end
+    end
+
+    class SplatNode < Base
+      handle :splat
+
+      children :value
+
+      def empty_splat?
+        value == [:nil] or value == [:paren, [:nil]]
+      end
+
+      def compile
+        if empty_splat?
+          push '[]'
+        elsif value.type == :sym
+          push '[', expr(value), ']'
+        else
+          push recv(value)
+        end
+      end
+    end
+
+    class OrNode < Base
+      handle :or
+
+      children :lhs, :rhs
+
+      def compile
+        with_temp do |tmp|
+          push "(((#{tmp} = "
+          push expr(lhs)
+          push ") !== false && #{tmp} !== nil) ? #{tmp} : "
+          push expr(rhs)
+          push ")"
+        end
+      end
+    end
+
+    class AndNode < Base
+      handle :and
+
+      children :lhs, :rhs
+
+      def compile
+        truthy_opt = nil
+
+        with_temp do |tmp|
+          if truthy_opt = js_truthy_optimize(lhs)
+            push "((#{tmp} = ", truthy_opt
+            push ") ? "
+            push expr(rhs)
+            push " : #{tmp})"
+          else
+            push "(#{tmp} = "
+            push expr(lhs)
+            push ", #{tmp} !== false && #{tmp} !== nil ?"
+            push expr(rhs)
+            push " : #{tmp})"
+          end
+        end
+      end
+    end
+
+    class ReturnNode < Base
+      handle :return
+
+      children :value
+
+      def return_val
+        if value.nil?
+          expr(s(:nil))
+        elsif children.size > 1
+          expr(s(:array, *children))
+        else
+          expr(value)
+        end
+      end
+
+      def return_in_iter?
+        if scope.iter? and parent_def = scope.find_parent_def
+          parent_def
+        end
+      end
+
+      def return_expr_in_def?
+        return scope if expr? and scope.def?
+      end
+
+      def scope_to_catch_return
+        return_in_iter? or return_expr_in_def?
+      end
+
+      def compile
+        if def_scope = scope_to_catch_return
+          def_scope.catch_return = true
+          push '$opal.$return(', return_val, ')'
+        elsif stmt?
+          push 'return ', return_val
+        else
+          raise SyntaxError, "void value expression: cannot return as an expression"
+        end
+      end
+    end
+
+    class JSReturnNode < Base
+      handle :js_return
+
+      children :value
+
+      def compile
+        push "return "
+        push expr(value)
+      end
+    end
+
+    class JSTempNode < Base
+      handle :js_tmp
+
+      children :value
+
+      def compile
+        push value.to_s
+      end
+    end
+
+    class BlockPassNode < Base
+      handle :block_pass
+
+      children :value
+
+      def compile
+        push expr(s(:call, value, :to_proc, s(:arglist)))
+      end
+    end
+  end
+end