minjs 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dff56ddbe102f06b6d07d67ca3cbb7076dec2bc2
-  data.tar.gz: 2bf1104e9aeda92155019cd2784e4313614fc958
+  metadata.gz: 82f88a2a64ab93ccafd2abd3e699e8d5fa7682d0
+  data.tar.gz: 3e9aec62b059e22695c0111169b75c5bd3fc1141
 SHA512:
-  metadata.gz: 546ff6b86865bc79856e034b4bba733093170ccc4f514de33f390b597bb9cd0cf6608e2c00c8619ccfe2cd3e3ab3977df50fb3f022def02982b06a99f4dcee80
-  data.tar.gz: 4ce28cc2d02368b99335fd1fe5bd69a7d03ccd72b4399fb775782e3186bf42d839df584f30468b83e6be4b9040a3c6054722ff266b79a96a177fee53c25ae9e4
+  metadata.gz: b58b34b47810cec665a86a8d831f7a222a558eb0ed21996de5332caddd13a3e15000544bc9a7867ed0a3341535eb55bebe8af4092e73dc9d0b8f34e143cf2b88
+  data.tar.gz: 93c25a509a9bf2c6864433f4ef955b64887bb35471be4d4fe1b68fdcaf736341e9c04634150adf8136097a2ada5d2f6815298ac1257b62a8192512d716f0754b

data/lib/minjs/compressor.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# coding: utf-8
 require 'minjs/lex'
 require 'minjs/ecma262'
 require 'minjs/literal'
@@ -7,6 +8,7 @@ require 'minjs/expression'
 require 'minjs/func'
 require 'minjs/program'
 require 'minjs/exceptions'
+require 'logger'
 
 module Minjs
   class Compressor
@@ -19,14 +21,17 @@ module Minjs
     attr_reader :prog
 
     def initialize(options = {})
-      @debug = false
-      if options[:debug]
-        @debug = true
+      @logger = options[:logger]
+      if !@logger
+        @logger = Logger.new(STDERR)
+        @logger.level = (options[:debug_level] || Logger::WARN)
+        @logger.formatter = proc{|severity, datetime, progname, message|
+          "#{message}\n"
+        }
       end
     end
 
     def debug
-      #@global_context.debug
       puts @prog.to_js()
     end
 
@@ -35,29 +40,50 @@ module Minjs
     end
 
     def compress(data, options = {})
+      @logger.info '* parse'
       parse(data)
 
+      @logger.info '* reorder_function_decl'
       reorder_function_decl
+
+      @logger.info '* simple_replacement'
       simple_replacement
+
+      @logger.info '* reorder_var'
       reorder_var
+
+      @logger.info '* assignment_after_var'
       assignment_after_var
+
+      @logger.info '* grouping_statement'
       grouping_statement
-      block_to_exp
+
+      @logger.info '* block_to_statement'
+      block_to_statement
+
+      @logger.info '* if_to_cond'
       if_to_cond
+
+      @logger.info '* compress_var'
       compress_var
+
+      @logger.info '* reduce_exp'
       reduce_exp
+
+      @logger.info '* remove_paren'
       remove_paren
-      #feature
-      #return_to_exp
+
+      @logger.info '* return_to_exp'
+      return_to_exp
+
       @heading_comments.reverse.each do |c|
-        @prog.source_elements.unshift(c)
+        @prog.source_elements.source_elements.unshift(c)
       end
-
       to_js(options)
     end
 
     def parse(data)
-      @lex = Minjs::Lex.new(data)
+      @lex = Minjs::Lex.new(data, :logger => @logger)
       @global_context = ECMA262::Context.new
 
       @heading_comments = []
@@ -71,9 +97,9 @@ module Minjs
       @prog
     end
 
-    def traverse(&block)
-      @prog.traverse(nil, &block)
-    end
+#    def traverse(&block)
+#      @prog.traverse(nil, &block)
+#    end
 
     def next_sym(s)
       def c2i(c)
@@ -131,34 +157,37 @@ module Minjs
 
     end
 
-    def grouping_statement
-      self.traverse {|st, parent|
-        if st.kind_of? ECMA262::Prog
-          st.grouping
-        elsif st.kind_of? ECMA262::StList
+    def grouping_statement(node = @prog)
+      node.traverse(nil) {|st, parent|
+        if st.kind_of? ECMA262::StatementList
           st.grouping
         end
       }
+      remove_paren
+      self
     end
 
-    def reorder_function_decl
-      self.traverse {|st, parent|
-        if st.kind_of? ECMA262::StFunc and parent.kind_of? ECMA262::Prog and st.decl?
+    def reorder_function_decl(node = @prog)
+      node.traverse(nil) {|st, parent|
+        if st.kind_of? ECMA262::StFunc and parent.kind_of? ECMA262::StatementList and st.decl?
           if parent.index(st)
             parent.remove(st)
             parent.source_elements.unshift(st)
           end
         end
       }
+      self
     end
 
-    def reorder_var
-      #traverse all statemtns and expression
-      self.traverse {|st, parent|
+    def reorder_var(node = @prog)
+      node.traverse(nil) {|st, parent|
         if st.kind_of? ECMA262::Prog
           vars = nil
           context = nil
           st.instance_eval{
+            #
+            # collect all of var variable in this function
+            #
             vars = @context.var_env.record.binding.find_all {|k, v|
               v and v[:_parameter_list].nil? and !v[:value].kind_of?(ECMA262::StFunc)
             }.collect{|x|
@@ -173,12 +202,10 @@ module Minjs
                   @vars.each do |vl|
                     if vl[1]
                       blk.push(ECMA262::StExp.new(ECMA262::ExpAssign.new(vl[0], vl[1])))
-                      #parent2.replace(st2, ECMA262::StExp.new(ECMA262::ExpAssign.new(vl[0], vl[1])))
                     else
-                      #parent2.replace(st2, ECMA262::StEmpty.new())
                     end
                   end
-                  parent2.replace(st2, ECMA262::StBlock.new(ECMA262::StList.new(blk)))
+                  parent2.replace(st2, ECMA262::StBlock.new(ECMA262::StatementList.new(blk)))
                 }
               elsif st2.kind_of? ECMA262::StForVar and st2.context == @context
                 parent2.replace(st2, st2.to_st_for)
@@ -187,7 +214,7 @@ module Minjs
               end
             }
             if vars.length > 0
-              @source_elements.unshift ECMA262::StVar.new(@context, vars)
+              @source_elements.source_elements.unshift ECMA262::StVar.new(@context, vars)
             end
           }
         end
@@ -195,38 +222,20 @@ module Minjs
       remove_block_in_block
     end
 
-    #feature
-    def remove_paren
-      self.traverse {|st, parent|
-        if st.kind_of? ECMA262::ExpParen
-          #
-          # ECMA262 say:
-          # expression statement cannot start with "function"
-          #
-          if parent.priority(st) > st.val.priority(nil)
-            if st.val.to_js.match(/^function/)
-              ;
-            elsif st.val.to_js.match(/^{/)
-              ;
-            else
-              parent.replace(st, st.val)
-            end
-          end
+    def remove_paren(node = @prog)
+      node.traverse(nil) {|st, parent|
+        if st.respond_to? :remove_paren
+          st.remove_paren
         end
       }
       self
     end
 
-    def remove_block_in_block
+    def remove_block_in_block(node = @prog)
       while true
         _retry = false
-        self.traverse {|st, parent|
-          if parent.kind_of? ECMA262::Prog and st.kind_of? ECMA262::StBlock
-            idx = parent.index(st)
-            parent.source_elements[idx..idx] = st.statement_list.statement_list
-            _retry = true
-            break
-          elsif parent.kind_of? ECMA262::StList and st.kind_of? ECMA262::StBlock
+        node.traverse(nil) {|st, parent|
+          if parent.kind_of? ECMA262::StatementList and st.kind_of? ECMA262::StBlock
             idx = parent.index(st)
             parent.statement_list[idx..idx] = st.statement_list.statement_list
             _retry = true
@@ -239,66 +248,69 @@ module Minjs
       end
     end
 
-    def block_to_exp
-      self.traverse {|st, parent|
-        if st.kind_of? ECMA262::StBlock and st.to_exp?
-          if parent.kind_of? ECMA262::StTry
-          else
-            t = st.to_exp({})
-            parent.replace(st, ECMA262::StExp.new(t))
+    def block_to_statement(node = @prog)
+      node.traverse(nil) {|st, parent|
+        if st.kind_of? ECMA262::StBlock and !parent.kind_of?(ECMA262::StTry)
+          if st.to_statement?
+            parent.replace(st, st.to_statement)
           end
         end
       }
+      self
     end
 
-    def block_to_statement
-      self.traverse {|st, parent|
-        if st.kind_of? ECMA262::StBlock and st.to_statement?
-          if parent.kind_of? ECMA262::StTry
-          else
-            parent.replace(st, st.to_statement)
+    def if_to_cond(node = nil)
+      node = @prog if node.nil?
+      node.traverse(nil) {|st, parent|
+        #
+        #feature
+        #
+        # if(a)return a;
+        # return b;
+        # => if(a)return a;else return b;
+        #
+
+        if st.kind_of? ECMA262::StIf and parent.kind_of? ECMA262::StatementList
+          i = parent.index(st)
+          if parent[i+1].nil? and !parent.kind_of?(ECMA262::SourceElements)
+            next
+          end
+          if parent[i+1].nil? or parent[i+1].to_return?
+            s = st
+            while s.kind_of? ECMA262::StIf and s.else_st and s.then_st.to_return?
+              s = s.else_st
+            end
+            if s and s.kind_of? ECMA262::StIf and s.then_st.to_return?
+              if parent[i+1]
+                s.replace(s.else_st, parent[i+1])
+                parent.replace(parent[i+1], ECMA262::StEmpty.new)
+              else
+                s.replace(s.else_st, ECMA262::StReturn.new(ECMA262::ExpVoid.new(ECMA262::ECMA262Numeric.new(0))))
+              end
+            end
           end
         end
       }
-    end
-
-    def if_to_cond
-      self.traverse {|st, parent|
+      node.traverse(nil) {|st, parent|
         if st.kind_of? ECMA262::StIf and st.to_exp?
           if t = ECMA262::StExp.new(st.to_exp({}))
             parent.replace(st, t)
           end
-          # feature...
-=begin
         elsif st.kind_of? ECMA262::StIf and st.to_return?
-          #
-          # if(...)
-          #   return a;
-          # return b;
-          #
-          # => if(...)return a;else return b;
-          #
-          if parent.kind_of? ECMA262::StList and st.else_st.nil? and (nxt = parent[parent.index(st) + 1]).kind_of? ECMA262::StReturn
-            st.replace(st.else_st, nxt)
-            parent.replace(nxt, ECMA262::StEmpty.new())
-            parent.replace(st, st.to_return)
-          #
-          # if(...)
-          # return a;
-          # else
-          # return b;
-          #
-          else
+          t = st.to_return
+          if t.to_js().length < st.to_js().length
             parent.replace(st, st.to_return)
           end
-=end
         end
       }
+      remove_paren
     end
 
-    def compress_var
+    def compress_var(node = @prog)
+      #
       #traverse all statemtns and expression
-      self.traverse {|st, parent|
+      #
+      node.traverse(nil) {|st, parent|
         if st.kind_of? ECMA262::StFunc and st.context.var_env.outer
           var_sym = :a
           #
@@ -307,7 +319,8 @@ module Minjs
           vars = {}
           st.traverse(parent) {|st2|
             if st2.kind_of? ECMA262::IdentifierName
-              vars[st2.val.to_sym] = true
+              vars[st2.val.to_sym] ||= 0
+              vars[st2.val.to_sym] += 1
             end
           }
           #
@@ -315,12 +328,12 @@ module Minjs
           #
           var_vars = {}
           st.context.var_env.record.binding.each do|k, v|
-            var_vars[k] = true
+            var_vars[k] = vars[k]
           end
           st.traverse(parent) {|st2|
             if st2.kind_of? ECMA262::StFunc
               st2.context.var_env.record.binding.each do|k, v|
-                var_vars[k] = true
+                var_vars[k] = vars[k]
               end
             end
           }
@@ -340,9 +353,13 @@ module Minjs
             end
           end
           #
+          # sort var_vars
+          #
+          var_vars = var_vars.sort {|(k1,v1), (k2,v2)| v2 <=> v1}
+          #
           # check var_vars
           #
-          var_vars.each {|name, v|
+          var_vars.each {|name, count|
             if name.nil?
               next
             end
@@ -357,7 +374,9 @@ module Minjs
                 if st2.kind_of? ECMA262::IdentifierName and st2.context and st2.context.var_env == st.context.var_env.outer
                   ;
                 elsif st2.kind_of? ECMA262::IdentifierName and st2.val == name
-                  st2.val = var_sym
+                  st2.instance_eval{
+                    @val = var_sym
+                  }
                 elsif st2.kind_of? ECMA262::StFunc
                   st2.context.var_env.record.binding[var_sym] = st2.context.var_env.record.binding[name]
                   st2.context.var_env.record.binding.delete(name)
@@ -368,18 +387,19 @@ module Minjs
           }
         end
       }
+      self
     end
 
-    def reduce_exp
-      self.traverse {|st, parent|
+    def reduce_exp(node = @prog)
+      node.traverse(nil) {|st, parent|
         if st.kind_of? ECMA262::Exp
           st.reduce(parent)
         end
       }
     end
 
-    def simple_replacement
-      self.traverse {|st, parent|
+    def simple_replacement(node = @prog)
+      node.traverse(nil) {|st, parent|
         #true => !0
         #false => !1
         if st.kind_of? ECMA262::Boolean
@@ -403,23 +423,10 @@ module Minjs
       }
     end
 
-    def return_to_exp
-      self.traverse {|st, parent|
+    def return_to_exp(node = @prog)
+      node.traverse(nil) {|st, parent|
         if st.kind_of? ECMA262::StReturn
-          if parent.kind_of? ECMA262::Prog
-            parent.remove_empty_statement
-            #
-            # a=1;return b; => return a=1,b;
-            #
-            # check statement:
-            # last one is return and its previous is expression or not
-            if parent.source_elements[-1] == st and (prev=parent.source_elements[-2]).class == ECMA262::StExp
-              if st.exp
-                st.replace(st.exp, ECMA262::ExpComma.new(prev.exp, st.exp))
-                parent.replace(prev, ECMA262::StEmpty.new())
-              end
-            end
-          elsif parent.kind_of? ECMA262::StList
+          if parent.kind_of? ECMA262::StatementList
             parent.remove_empty_statement
             if parent.statement_list[-1] == st and (prev=parent.statement_list[-2]).class == ECMA262::StExp
               if st.exp
@@ -427,19 +434,21 @@ module Minjs
                 parent.replace(prev, ECMA262::StEmpty.new())
               end
             end
+            parent.remove_empty_statement
           end
         end
       }
       block_to_statement
       if_to_cond
+      self
     end
     #
     # var a; a=1
     # => var a=1
     #
-    def assignment_after_var
-      self.traverse {|st, parent|
-        if st.kind_of? ECMA262::StExp and parent.kind_of? ECMA262::Prog
+    def assignment_after_var(node = @prog)
+      node.traverse(nil) {|st, parent|
+        if st.kind_of? ECMA262::StExp and parent.kind_of? ECMA262::SourceElements
           if st.exp.kind_of? ECMA262::ExpAssign
             idx = parent.index(st)
             while idx > 0

data/lib/minjs/ctype.rb

@@ -14,6 +14,7 @@ module Minjs
     end
 
     def identifier_start?(c)
+      return false if c.nil?
         c == 0x24 || c == 0x5f ||
         (c >= 0x41 && c <= 0x5a) ||
         (c >= 0x61 && c <= 0x7a) ||
@@ -563,6 +564,7 @@ module Minjs
     end
 
     def identifier_part?(c)
+      return false if c.nil?
       identifier_start?(c) ||
         (c >= 0x30 && c <= 0x39) ||
         (c >= 0x5f && c <= 0x5f) ||