minjs 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf7918e2d61056e016f1903050b7866612ab4dc0
-  data.tar.gz: 0576989a9e9705cb43a696d10532d848ee83d27c
+  metadata.gz: f2378eb52a7085927e5c4068a9396d656e14dcf0
+  data.tar.gz: b3a936cdae1ebc77424d0a2330ee78bdf4b56922
 SHA512:
-  metadata.gz: ccf02697889e825b9c5bb7fdb80d91e235980753d3f8aa1c8598cf1512e06b638e8365d23197fa774812d7d5efbcc8c66805872a34072cefc5c81645a2bbbcf9
-  data.tar.gz: 373dd8eed54811bfae0a1498224fb775e47075d00a5c71087f1644063a2d697241101418cffac5aa028e2829758c429f8acf584c1b33b32ad783aca0a1519cff
+  metadata.gz: 86114b8ef9ef2ca9eb0ec5b15b532b49b138f3052b1ef10aaa6fa9433cbbdaa1837905b1b59a816eed0b6ab6182270a165d7aeb8e93c150fc71bc0ab6ae72d96
+  data.tar.gz: 458383c20b91c43c8a64c9c70896d54cfdbe34cdeaea3e129393a2ba7a371236cc10ec0cce8d0e7f4d6d537e1c3aa5a3d0ea261c9d2eafa5d9f1b5607c5a54eb

data/lib/minjs/compressor/compressor.rb

@@ -88,7 +88,7 @@ module Minjs::Compressor
     # @return self
     def parse(data)
       @lex = Minjs::Lex::Parser.new(data, :logger => @logger)
-      @global_context = ECMA262::Context.new
+      @global_var_env = ECMA262::LexEnv.new(outer: nil)
       @heading_comments = []
 
       while a = (@lex.comment || @lex.line_terminator || @lex.white_space)
@@ -98,7 +98,8 @@ module Minjs::Compressor
             !(@heading_comments[-2].kind_of?(ECMA262::SingleLineComment))
         @heading_comments.pop
       end
-      @prog = @lex.program(@global_context)
+      @prog = @lex.program(@global_var_env)
+      @prog.exe_context = ECMA262::ExeContext.new
 
       remove_empty_statement
       @lex.clear_cache
@@ -203,12 +204,12 @@ module Minjs::Compressor
       node.traverse(nil) {|parent, st|
         if st.kind_of? ECMA262::Prog
           vars = nil
-          context = st.context
+          var_env = st.var_env
           #
           # collect all of var variable in this function
           #
           var_vars = {}
-          context.var_env.record.binding.each do|k, v|
+          var_env.record.binding.each do|k, v|
             if v and v[:_parameter_list].nil? and !v[:value].kind_of?(ECMA262::StFunc)
               var_vars[k] = true
             end
@@ -218,7 +219,7 @@ module Minjs::Compressor
           # if variable has initializer
           #
           st.traverse(parent){|parent2, st2|
-            if st2.kind_of? ECMA262::StVar and st2.context.var_env == context.var_env
+            if st2.kind_of? ECMA262::StVar and st2.var_env == var_env
               exp = nil
               st2.vars.each do |name, initializer|
                 if initializer
@@ -234,18 +235,18 @@ module Minjs::Compressor
               else
                 parent2.replace(st2, ECMA262::StEmpty.new())
               end
-            elsif st2.kind_of? ECMA262::StForVar and st2.context.var_env == context.var_env
+            elsif st2.kind_of? ECMA262::StForVar and st2.var_env == var_env
               parent2.replace(st2, st2.to_st_for)
-            elsif st2.kind_of? ECMA262::StForInVar and st2.context.var_env == context.var_env
+            elsif st2.kind_of? ECMA262::StForInVar and st2.var_env == var_env
               parent2.replace(st2, st2.to_st_for_in)
             end
           }
           if var_vars.length > 0
             elems = st.source_elements.source_elements
             v = ECMA262::StVar.new(
-              context,
+              var_env,
               var_vars.collect do |k, v|
-                [ECMA262::IdentifierName.get(context, k)]
+                [ECMA262::IdentifierName.get(k)]
               end
             )
 
@@ -341,7 +342,7 @@ module Minjs::Compressor
       remove_empty_statement
       then_to_block
       node.traverse(nil) {|parent, st|
-        if st.kind_of? ECMA262::StBlock and !parent.kind_of?(ECMA262::StTry) and !parent.kind_of?(ECMA262::StIf)
+        if st.kind_of? ECMA262::StBlock and !parent.kind_of?(ECMA262::StTry) and !parent.kind_of?(ECMA262::StIf) and !parent.kind_of?(ECMA262::StTryCatch)
             if st.to_statement?
               parent.replace(st, st.to_statement)
             end
@@ -569,20 +570,20 @@ module Minjs::Compressor
 
     # Compresses variable name as short as possible.
     #
-    # This method collects and counts all variables under this function,
+    # This method collects and counts all variables under the function/catch,
     # then trying to rename var_vars(see bellow) to
     # new name.
     #
     # outer_vars::
-    #    Variables which locate out of this function(or global variable)
+    #    Variables which locate out of this function/catch(or global variable)
     #    Them name cannot be renamed
     # nesting_vars::
-    #    Variables which locate in the function of this function.
+    #    Variables which locate in the function/catch of this function/catch.
     #    Them name cannot be renamed
     # var_vars::
-    #    Variables which have same scope in this function.
+    #    Variables which have same scope in this function/catch.
     # all_vars::
-    #    All variables under this function.
+    #    All variables under this function/catch.
     #
     # 1. If the new name is not in all_vars, the name can be renamed to it.
     # 2. If the new name belongs to var_vars, the name cannot be renamed.
@@ -592,9 +593,15 @@ module Minjs::Compressor
     #
     #
     def compress_var(node = @prog)
+      scopes = []
       func_scopes = []
       catch_scopes = []
       with_scopes = []
+
+      node.traverse(nil) {|parent, st|
+        st.parent = parent
+      }
+
       #
       # ECMA262 10.2:
       #
@@ -607,8 +614,10 @@ module Minjs::Compressor
       node.traverse(nil) {|parent, st|
         if st.kind_of? ECMA262::StFunc
           func_scopes.push([parent, st])
-        elsif st.kind_of? ECMA262::StTry
+          scopes.push([parent, st])
+        elsif st.kind_of? ECMA262::StTryCatch
           catch_scopes.push([parent, st])
+          scopes.push([parent, st])
         elsif st.kind_of? ECMA262::StWith
           with_scopes.push([parent, st])
         end
@@ -653,42 +662,53 @@ module Minjs::Compressor
       #console.log(eee); 	//=>global
       #test();
       #
-      catch_scopes.each{|parent, st|
-        if st.catch
-          catch_context = ECMA262::Context.new
-          catch_context.lex_env = st.context.lex_env.new_declarative_env()
-          catch_context.var_env = st.context.var_env
-          catch_context.lex_env.record.create_mutable_binding(st.catch[0], nil)
-          catch_context.lex_env.record.set_mutable_binding(st.catch[0], :undefined, nil)
-          st.catch[0].context = catch_context
+      scopes.reverse!
 
-          st.catch[1].traverse(parent){|parent2, st2|
-            if st2.kind_of? ECMA262::IdentifierName and st2 == st.catch[0] and st2.binding_env == st.catch[0].binding_env
-              st2.context = catch_context
+      # outer
+      scopes = scopes.collect {|parent, st|
+        if st.kind_of? ECMA262::StFunc or st.kind_of? ECMA262::StTryCatch
+          outer = st.parent
+          while outer
+            if outer.kind_of? ECMA262::StFunc or outer.kind_of? ECMA262::StTryCatch
+              break
             end
-          }
-          func_scopes.unshift([parent, st])
+            outer = outer.parent
+          end
         end
+        if outer.nil?
+          outer = @prog
+        end
+        [parent, st, outer]
       }
-#      with_scopes.each{|st, parent|
-#        with_context = ECMA262::Context.new
-#        with_context.lex_env = st.context.lex_env.new_declarative_env()
-#        with_context.var_env = st.context.var_env
-#        st.statement.traverse(st) {|st2|
-#          if st2.kind_of? ECMA262::IdentifierName and st2.binding_env == st.context.var_env
-#            st2.context = with_context
-#            with_context.lex_env.record.create_mutable_binding(st2, nil)
-#            with_context.lex_env.record.set_mutable_binding(st2, :undefined, nil)
-#          end
-#        }
-#      }
-      func_scopes.reverse!
-      func_scopes.each {|parent, st|
+
+      # exe_context
+      scopes.each {|parent, st, outer|
         if st.kind_of? ECMA262::StFunc
-          context = st.context
-        elsif st.kind_of? ECMA262::StTry
-          context = st.catch[0].context
+          st.exe_context = st.enter(outer.exe_context)
+          st.traverse(nil) {|parent2, st2|
+            if st2.kind_of? ECMA262::IdentifierName
+              if st.decl? and st2 .eql? st.name
+                ;
+              elsif st.var_env.record.binding[st2.to_s.to_sym]
+                st2.exe_context = st.exe_context
+              end
+            end
+          }
+        elsif st.kind_of? ECMA262::StTryCatch
+          st.exe_context = st.enter(outer.exe_context)
+          st.traverse(nil) {|parent2, st2|
+            if st2.kind_of? ECMA262::IdentifierName
+              if st2 == st.arg
+                st2.exe_context = st.exe_context
+              end
+            end
+          }
         end
+      }
+
+      scopes.each {|parent, st|
+        exe_context = st.exe_context
+
         var_sym = :a
         all_vars = {}
         var_vars = {}
@@ -700,30 +720,28 @@ module Minjs::Compressor
         st.traverse(parent) {|parent2, st2|
           if st2.kind_of? ECMA262::IdentifierName
             var_name = st2.val.to_sym
-            #st2_var_env = st2.binding_env
-            st2_lex_env = st2.binding_env(:lex)
             all_vars[var_name] ||= 0
             all_vars[var_name] += 1
-            if st2_lex_env == nil #global
+            if st2.exe_context == nil #global
               outer_vars[var_name] ||= 0
               outer_vars[var_name] += 1
-            elsif st2_lex_env == @global_context.lex_env #global
+            elsif st2.exe_context.lex_env == @prog.exe_context.lex_env
               outer_vars[var_name] ||= 0
               outer_vars[var_name] += 1
-            elsif st2_lex_env == context.lex_env
+            elsif st2.exe_context.lex_env == exe_context.lex_env
               var_vars[var_name] ||= 0
               var_vars[var_name] += 1
               var_vars_list.push(st2)
             else
-              e = st2.binding_env(:lex)
+              e = st2.exe_context.lex_env
               while e
-                e = e.outer
-                if e == context.lex_env
+                if e == exe_context.lex_env
                   nesting_vars[var_name] ||= 0
                   nesting_vars[var_name] += 1
                   nesting_vars_list.push(st2)
                   break
                 end
+                e = e.outer
                 if e.nil?
                   outer_vars[var_name] ||= 0
                   outer_vars[var_name] += 1
@@ -733,6 +751,19 @@ module Minjs::Compressor
             end
           end
         }
+
+#        puts "*" * 30
+#        puts st.to_js
+#        puts "*" * 30
+#        puts "all_vars"
+#        puts all_vars
+#        puts "outer_vars"
+#        puts outer_vars
+#        puts "var_vars"
+#        puts var_vars
+#        puts "nesting_vars"
+#        puts nesting_vars
+
         unless var_vars[:eval]
           eval_flag = false
           st.traverse(parent) {|parent2, st2|
@@ -769,7 +800,7 @@ module Minjs::Compressor
           while true
             #condition b
             if outer_vars[var_sym]
-              #STDERR.puts "outer_vars has #{var_sym}"
+            #STDERR.puts "outer_vars has #{var_sym}"
             elsif var_vars[var_sym]
               #STDERR.puts "var_vars has #{var_sym}(#{var_vars[var_sym]})"
             #condigion c
@@ -783,8 +814,7 @@ module Minjs::Compressor
           if nesting_vars[var_sym]
             #STDERR.puts "nesting_vars has #{var_sym}"
             nesting_vars_list.each do |x|
-              #raise 'error' if x.binding_env(:var).nil?
-              raise 'error' if x.binding_env(:lex).nil?
+              #raise 'error' if x.binding_env(x.exe_context.var_env).nil?
             end
 
             var_sym2 = "XXX#{var_sym.to_s}".to_sym
@@ -792,13 +822,12 @@ module Minjs::Compressor
               var_sym2 = next_sym(var_sym2)
             end
             #STDERR.puts "#{var_sym}->#{var_sym2}"
+
             rl = {}
             nesting_vars_list.each do |x|
               if x.val.to_sym == var_sym
-                _var_env = x.binding_env(:var)
-                _lex_env = x.binding_env(:lex)
+                _var_env = x.binding_env(x.exe_context.var_env)
                 rl[_var_env] = true
-                rl[_lex_env] = true
               end
             end
             rl.keys.each do |_env|
@@ -814,26 +843,24 @@ module Minjs::Compressor
                   @val = var_sym2
                 }
               end
-              #raise 'error' if x.binding_env(:var).nil?
-              raise x.to_js if x.binding_env(:lex).nil?
             end
           end
           rename_table[name] = var_sym
           var_sym = next_sym(var_sym)
         }
         var_vars_list.each {|st2|
-          raise st2.to_js if st2.binding_env(:lex).nil?
+          #raise 'error' if st2.binding_env(st2.exe_context.var_env).nil?
         }
 
         rename_table.each do |name, new_name|
           if name != new_name
-            if context.var_env.record.binding[name]
-              context.var_env.record.binding[new_name] = context.var_env.record.binding[name]
-              context.var_env.record.binding.delete(name)
+            if exe_context.var_env.record.binding[name]
+              exe_context.var_env.record.binding[new_name] = exe_context.var_env.record.binding[name]
+              exe_context.var_env.record.binding.delete(name)
             end
-            if context.lex_env.record.binding[name]
-              context.lex_env.record.binding[new_name] = context.lex_env.record.binding[name]
-              context.lex_env.record.binding.delete(name)
+            if exe_context.lex_env.record.binding[name]
+              exe_context.lex_env.record.binding[new_name] = exe_context.lex_env.record.binding[name]
+              exe_context.lex_env.record.binding.delete(name)
             end
           end
         end
@@ -843,11 +870,14 @@ module Minjs::Compressor
               if rename_table[@val]
                 @val = rename_table[@val]
                 #raise 'error' if st2.binding_env(:var).nil?
-                raise st2.to_js if st2.binding_env(:lex).nil?
+                #raise st2.to_js if st2.binding_env(:lex).nil?
               end
             }
         }
       }
+      node.traverse(nil) {|parent, st|
+        st.parent = nil
+      }
       self
     end
 

data/lib/minjs/ecma262/base.rb

@@ -2,6 +2,8 @@ module Minjs
   module ECMA262
     #ECMA262 Elements
     class Base
+      attr_accessor :parent
+
       # Returns a ECMAScript string containg the representation of element.
       # @param options [Hash] options for Base#concat
       # @return [String] ECMAScript string.
@@ -9,11 +11,6 @@ module Minjs
         self.class.to_s + "??"
       end
 
-      # to string
-      def to_s
-        to_js({})
-      end
-
       # concatenate some of ECMA262 elements and convert it to ECMAScript
       #
       # @param args ECMA262 element
@@ -321,17 +318,18 @@ module Minjs
     # @see http://www.ecma-international.org/ecma-262 ECMA262 14
     class Prog < Base
       attr_reader :source_elements
-      attr_reader :context
+      attr_reader :var_env
+      attr_accessor :exe_context
 
-      def initialize(context, source_elements)
+      def initialize(var_env, source_elements)
         @source_elements = source_elements
-        @context = context
+        @var_env = var_env
       end
 
       # duplicate object
       # @see Base#deep_dup
       def deep_dup
-        self.class.new(context, source_elements.deep_dup)
+        self.class.new(var_env, source_elements.deep_dup)
       end
 
       # Replaces children object

data/lib/minjs/ecma262/env.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 module Minjs
   module ECMA262
     # class of Environment Record
@@ -30,7 +31,7 @@ module Minjs
           n = n.val
         end
         @binding[n][:value] = v
-        @binding[n].merge!(options)
+        @binding[n].merge!(options || {})
       end
     end
 
@@ -50,16 +51,19 @@ module Minjs
     #
     # @see http://www.ecma-international.org/ecma-262 ECMA262 10.2
     class LexEnv
-      attr_reader :record
+      attr_accessor :record
       attr_reader :outer
       attr_reader :type
 
       def initialize(options = {})
         @outer = options[:outer]
-        if options[:type] == :object
+        @type = (options[:type] || :declarative)
+        if options[:record]
           @record = ObjectEnvRecord.new
-        else #if options[:type] == :declarative
+        elsif options[:type] == :declarative
           @record = DeclarativeEnvRecord.new
+        elsif options[:type] == :object or true
+          @record = ObjectEnvRecord.new
         end
       end
 
@@ -70,6 +74,13 @@ module Minjs
         e = LexEnv.new(outer: (outer || self), type: :declarative)
       end
 
+      # NewDeclarativeEnvironment(E)
+      #
+      # @see http://www.ecma-international.org/ecma-262 ECMA262 10.2.2.2
+      def self.new_declarative_env(e)
+        env = LexEnv.new(outer: e, type: :declarative)
+      end
+
       # NewObjectEnvironment(O, E)
       #
       # @see http://www.ecma-international.org/ecma-262 ECMA262 10.2.2.3
@@ -93,32 +104,15 @@ module Minjs
     # Class of Execution Contexts
     #
     # @see http://www.ecma-international.org/ecma-262 ECMA262 10.3
-    class Context
+    class ExeContext
       attr_accessor :lex_env
       attr_accessor :var_env
       attr_accessor :this_binding
-
       def initialize(options = {})
         @var_env = LexEnv.new(options)
         @lex_env = LexEnv.new(options)
-        #TODO
         @this_binding = nil
-#        ExObject.new(
-#          {
-#            attr: {
-#              writable: true,
-#              enumerable: false,
-#              configurable: true
-#            }
-#          }
-#        )
-      end
-
-      # debug
-      def debug
-        @var_env.debug
       end
-
     end
   end
 end