minjs 0.1.2

data/lib/minjs/ecma262/base.rb

@@ -0,0 +1,128 @@
+module Minjs
+  module ECMA262
+    class Base
+      def to_js(options = {})
+        self.class.to_s + "??"
+      end
+
+      def to_s
+        to_js({})
+      end
+
+      def concat(options, *args)
+        prev = nil
+        j = []
+        args.flatten.each do|x|
+          sep = ''
+          nl = ''
+          if x.kind_of? Base
+            js = x.to_js(options);
+          else
+            js = x.to_s
+          end
+          if prev
+            if prev.match(/[\w\$]\z/) and js.match(/^[\w\$]/)
+              sep = ' '
+            elsif prev.match(/;\z/) and js == "}"
+              prev.sub!(/;\z/, "")
+            elsif prev.match(/;\z/) and js == ";" and !options[:for_args]
+              prev.sub!(/;\z/, "")
+            elsif prev.match(/[\-]\z/) and js.match(/^\-/)
+              sep = ' '
+            elsif prev.match(/[\+]\z/) and js.match(/^\+/)
+              sep = ' '
+            end
+          end
+          #for debug
+          if false and js.match(/;\z/) and !options[:for_args]
+            nl = "\n"
+          end
+          js = "#{sep}#{js}#{nl}";
+          j.push(js)
+          prev = js
+        end
+        j.join("")
+      end
+    end
+
+    class Prog < Base
+      attr_reader :source_elements
+      attr_reader :context
+
+      def initialize(context, source_elements)
+        @source_elements = source_elements
+        @context = context
+      end
+
+      def traverse(parent, &block)
+        @source_elements.each do |s|
+          s.traverse(self, &block)
+        end
+        yield self, parent
+      end
+
+      def to_js(options = {})
+        tt = ''
+        vars = @context.var_env.record.binding.find_all {|k, v|
+          v and v[:_parameter_list].nil? and !v[:value].kind_of?(StFunc)
+        }.collect{|x|x[0]}
+
+        tt = concat(options, tt, @source_elements)
+      end
+
+      def grouping
+        sl = @source_elements
+        i = 0
+        while i < sl.length
+          st = sl[i]
+          i0 = i
+          prev = nil
+          t = nil
+          while st and st.to_exp?
+            if prev and prev.to_exp?
+              t = ECMA262::ExpComma.new(t, st.to_exp({}))
+            elsif prev.nil?
+              t = st.to_exp({})
+            else
+              break
+            end
+            prev = st
+            i += 1
+            st = sl[i]
+          end
+          if i0 != i and i - i0 >= 2
+            sl[i0...i] = StExp.new(t)
+            i = (i - i0 + 1)
+          else
+            i += 1
+          end
+        end
+      end
+
+      def replace(from, to)
+        idx = @source_elements.index(from)
+        if idx
+          @source_elements[idx] = to
+        end
+      end
+
+      def remove(st)
+        @source_elements.delete(st)
+      end
+
+      def each(&block)
+        @source_elements.each(&block)
+      end
+
+      def [](i)
+        @source_elements[i]
+      end
+
+      def index(st)
+        @source_elements.index(st)
+      end
+
+    end
+  end
+end
+

data/lib/minjs/ecma262/env.rb

@@ -0,0 +1,78 @@
+module Minjs
+  module ECMA262
+    class EnvRecord
+      attr_reader :binding
+      attr_reader :options
+
+      def initialize(options = {})
+        @binding = {}
+        @options = {}
+      end
+      def create_mutable_binding(n, d, options = {})
+        if n.kind_of? IdentifierName
+          n = n.val
+        end
+        @binding[n] = {:value => nil}
+      end
+      def set_mutable_binding(n, v, s, options = {})
+        if n.kind_of? IdentifierName
+          n = n.val
+        end
+        @binding[n][:value] = v
+        @binding[n].merge!(options)
+      end
+    end
+
+    class ExObject
+      def initialize(options = {})
+        @attr = options[:attr] || {}
+        @prop = options[:prop] || {}
+      end
+    end
+
+    class LexEnv
+      attr_reader :record
+      attr_reader :outer
+
+      def initialize(options = {})
+        @outer = options[:outer]
+        @record = EnvRecord.new
+      end
+
+      def new_declarative_env(outer = nil)
+        LexEnv.new(outer: (outer || self))
+      end
+
+      def debug
+        STDERR.puts @record.binding
+      end
+    end
+
+    class Context
+      attr_accessor :lex_env
+      attr_accessor :var_env
+      attr_accessor :this_binding
+
+      def initialize(options = {})
+        @var_env = @lex_env = LexEnv.new(options)
+        @this_binding = ExObject.new(
+          {
+            attr: {
+              writable: true,
+              enumerable: false,
+              configurable: true
+            }
+          }
+        )
+      end
+
+      def debug
+        @var_env.debug
+      end
+
+      def inspect
+        @var_env.record.binding.to_s
+      end
+    end
+  end
+end