minjs 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a1f04643d50c1beca0d24712ec63604fd2f0cd8
-  data.tar.gz: 95e7f5fe15dcf50dbc08e2428ef4d9b1d7735a06
+  metadata.gz: dd046433e1cdd1a40960158f44872ced89f083f2
+  data.tar.gz: 1482ef6536af057e27c05a4c448e4c74f953b9f7
 SHA512:
-  metadata.gz: 86c244ba18493772c481a2242758a589634e7799c7da5e545c22b3c2366908c2281dadf16a0f074bcb8c60ecccb2bac5137e379d2f245cf4c8694abb3a23f2c9
-  data.tar.gz: 0e84e49b46819f3991fde8a2821121eead7a29373e4e1dc23c7a41e6a35fb72eaf6a108bf9881256ba36bcb722b58ee91d8feedc25cd833794f89e807f6d9cea
+  metadata.gz: 37778bbbc0b9dc971d5b9c82b0136dc13ab2266408653bbf59d57eecf22367645bff60acad24ac95814a046308c668b6cc5debe7d46eafc60abbfae4486c98b1
+  data.tar.gz: 4435d429c220f49996ebf69d2bef7406102fa1c78099b9328c342f30e2a70dee4ffda51a801f17442e78165f1300e122f09318f4b3b807207becb95f26bff145

data/lib/minjs/compressor.rb

@@ -8,6 +8,7 @@ require 'minjs/expression'
 require 'minjs/func'
 require 'minjs/program'
 require 'minjs/exceptions'
+require 'minjs/version'
 require 'logger'
 
 module Minjs
@@ -17,6 +18,7 @@ module Minjs
     include Exp
     include Func
     include Program
+    include Ctype
 
     attr_reader :prog
 
@@ -63,8 +65,8 @@ module Minjs
         :reorder_var,
         :assignment_after_var,
         :grouping_statement,
-        :reduce_if,
         :block_to_statement,
+        :reduce_if,
         :if_to_cond,
         :optimize_if_return,
         :compress_var,
@@ -73,8 +75,8 @@ module Minjs
         :block_to_statement,
         :if_to_cond,
         :optimize_if_return2,
-        :optimize_if_return3,
-        :remove_paren,
+        :block_to_statement,
+        :add_remove_paren,
       ]
       algo.each do |a|
         if (options.empty? || options[:all] || options[a]) && !options[("no_" + a.to_s).to_sym]
@@ -167,7 +169,7 @@ module Minjs
           st.grouping
         end
       }
-      remove_paren
+      add_remove_paren
       self
     end
 
@@ -274,7 +276,7 @@ module Minjs
       self
     end
 
-    def remove_paren(node = @prog)
+    def add_remove_paren(node = @prog)
       node.traverse(nil) {|st, parent|
         if st.respond_to? :remove_paren
           st.remove_paren
@@ -284,41 +286,15 @@ module Minjs
       self
     end
 
-    def remove_block_in_block(node = @prog)
-      while true
-        _retry = false
-        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
-            break
-          elsif st.kind_of? ECMA262::StBlock
-            ;
-          end
-        }
-        break if !_retry
-      end
-      self
-    end
-
-    def block_to_statement(node = @prog)
-      node.traverse(nil) {|st, parent|
-        if st.kind_of? ECMA262::StBlock and !parent.kind_of?(ECMA262::StTry) and !parent.kind_of?(ECMA262::StIf)
-            if st.to_statement?
-              parent.replace(st, st.to_statement)
-            end
-        end
-      }
-      if_block_to_statement
+    def remove_paren(node = @prog)
+      add_remove_paren(node)
     end
 
     #
-    # To determine removing "if block" is available or not is difficult.
-    # For example, next codes block must not be removed, because
+    # To determine removing "block" is available or not is difficult.
+    # For example, next code's if-block must not be removed, because
     # "else" cluase combined to second "if" statement.
     #
-    #
     #  if(a){ //<= this block must not be removed
     #    while(true)
     #      if(b){
@@ -328,7 +304,49 @@ module Minjs
     #  else{
     #   ;
     #  }
+    #
+    # The next code's while-block must not be removed, because
+    # "else" cluase combined to second "if" statement.
+    #
+    #  if(a)
+    #    while(true){ //<= this block must not be removed
+    #      if(b){
+    #        ;
+    #      }
+    #    }
+    #  else{
+    #   ;
+    #  }
+    #
+    # To solve this problem, first, every then-clause without block
+    # converts to block statement. After converted, all blocks 
+    # except then-clause can be removed safety.
+    #
+    def then_to_block(node = @prog)
+      node.traverse(nil) {|st, parent|
+        if st.kind_of? ECMA262::StIf
+          if !st.then_st.kind_of?(ECMA262::StBlock)
+            st.replace(st.then_st, ECMA262::StBlock.new([st.then_st]))
+          end
+        end
+      }
+    end
+
+    def block_to_statement(node = @prog)
+      remove_empty_statement
+      then_to_block
+      node.traverse(nil) {|st, parent|
+        if st.kind_of? ECMA262::StBlock and !parent.kind_of?(ECMA262::StTry) and !parent.kind_of?(ECMA262::StIf)
+            if st.to_statement?
+              parent.replace(st, st.to_statement)
+            end
+        end
+      }
+      if_block_to_statement
+    end
+
     def if_block_to_statement(node = @prog)
+      remove_empty_statement
       # The "else" cluase's block can be removed always
       node.traverse(nil) {|st, parent|
         if st.kind_of? ECMA262::StIf
@@ -341,6 +359,47 @@ module Minjs
           end
         end
       }
+      node.traverse(nil) {|st, parent|
+        if st.kind_of? ECMA262::StIf
+          if st.then_st and st.then_st.kind_of? ECMA262::StBlock
+            st.then_st.remove_empty_statement
+          end
+          if !st.else_st and st.then_st.kind_of? ECMA262::StBlock and st.then_st.to_statement?
+            st.replace(st.then_st, st.then_st.to_statement)
+          elsif st.then_st.kind_of? ECMA262::StBlock and st.then_st.to_statement?
+            _st = st.then_st
+            st2 = st.then_st.to_statement
+            while true
+              if st2.kind_of? ECMA262::StVar or st2.kind_of? ECMA262::StEmpty or
+                st2.kind_of? ECMA262::StExp or st2.kind_of? ECMA262::StBlock or
+                st2.kind_of? ECMA262::StDoWhile or st2.kind_of? ECMA262::StSwitch or
+                st2.kind_of? ECMA262::StContinue or st2.kind_of? ECMA262::StBreak or
+                st2.kind_of? ECMA262::StReturn or st2.kind_of? ECMA262::StThrow or
+                st2.kind_of? ECMA262::StTry or st2.kind_of? ECMA262::StDebugger
+                st.replace(st.then_st, st.then_st.to_statement)
+                break;
+              elsif st2.kind_of? ECMA262::StWhile or
+                   st2.kind_of? ECMA262::StFor or
+                   st2.kind_of? ECMA262::StForIn or
+                   st2.kind_of? ECMA262::StForVar or
+                   st2.kind_of? ECMA262::StForInVar or
+                   st2.kind_of? ECMA262::StWith or
+                   st2.kind_of? ECMA262::StLabelled
+                st2 = st2.statement
+              elsif st2.kind_of? ECMA262::StIf
+                if st2.else_st
+                  st2 = st2.else_st
+                else
+                  break
+                end
+              else #?
+                break
+              end
+            end
+          end
+        end
+      }
+=begin
       node.traverse(nil) {|st0, parent|
         st = st0.deep_dup
         if st.kind_of? ECMA262::StIf
@@ -355,11 +414,22 @@ module Minjs
           _lex = Minjs::Lex.new(st.to_js)
           _context = ECMA262::Context.new
           _if = if_statement(_lex, _context)
+          reduce_exp(_if)
           if _if == st #
-            parent.replace(st0, st)
+            if st0.then_st and st0.then_st.kind_of? ECMA262::StBlock
+              st0.then_st.remove_empty_statement
+            end
+            if st0.then_st and st0.then_st.kind_of? ECMA262::StBlock and st0.then_st.to_statement?
+              st0.replace(st0.then_st, st0.then_st.to_statement)
+            end
+          else
+            p '!='
+            puts st.to_js
+            puts _if.to_js
           end
         end
       }
+=end
       self
     end
 
@@ -370,14 +440,25 @@ module Minjs
     #
     # if(a)b
     # =>
-    # a&&b;
+    # a&&b; or a?b:0;
+    #
+    # NOTE:
+    # Sometimes, "conditional operator" will be shorter than
+    # "logical and operator", because "conditional operator"'s
+    # priority is lower than almost all other expressions.
     #
     def if_to_cond(node = @prog)
       node.traverse(nil) {|st, parent|
         if st.kind_of? ECMA262::StIf
           if st.to_exp?
             t = ECMA262::StExp.new(st.to_exp({}))
-            remove_paren(t)
+            t2 = ECMA262::StExp.new(st.to_exp({cond: true}))
+            if t2.to_js.length < t.to_js.length
+              t = t2
+            end
+            add_remove_paren(t)
+            simple_replacement(t)
+
             if t.to_js.length <= st.to_js.length
               parent.replace(st, t)
             end
@@ -396,7 +477,8 @@ module Minjs
         if st.kind_of? ECMA262::StIf
           if st.to_return?
             t = st.to_return
-            remove_paren(t)
+            add_remove_paren(t)
+            simple_replacement(t)
             if t.to_js.length <= st.to_js.length
               parent.replace(st, t)
             end
@@ -410,49 +492,55 @@ module Minjs
     # if(a)return b;
     # return c;
     #
-    # => if(a)return b;else return c;
     # => return a?b:c;
     #
     def optimize_if_return(node = @prog)
-      retry_flag = true
-      while retry_flag
-        retry_flag = false
-        node.traverse(nil) {|st0, parent0|
-          if st0.kind_of? ECMA262::StIf and parent0.kind_of? ECMA262::StatementList
-            i = parent0.index(st0)
-            break if i.nil?
-            parent = parent0.deep_dup
-            st = parent[i]
-            #
-            if parent[i+1].nil? and !parent.kind_of?(ECMA262::SourceElements)
-              next
+      node.traverse(nil) {|st0, parent0|
+        if st0.kind_of? ECMA262::StatementList
+          st0.remove_empty_statement
+          st = st0.deep_dup
+          while true
+            #check last statement
+            ls = st.statement_list[-1]
+            ls2 = st.statement_list[-2]
+            if st.kind_of? ECMA262::SourceElements and !(ls.kind_of? ECMA262::StReturn)
+              ls2 = ls
+              ls = ECMA262::StReturn.new(ECMA262::ExpVoid.new(ECMA262::ECMA262Numeric.new(0)))
             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
-                if_to_cond(parent)
-                if parent.to_js(:no_debug => true).length <= parent0.to_js(:no_debug => true).length
-                  parent0.replace(st0, st)
-                  if parent[i+1]
-                    parent0.replace(parent0[i+1], ECMA262::StEmpty.new)
-                  end
-                  retry_flag = true
-                  node = parent0
-                end
-              end
+            break if ls.nil?
+            break if ls2.nil?
+            break if !ls.to_return?
+            break if !ls2.kind_of?(ECMA262::StIf)
+            break if ls2.else_st
+            break if !ls2.then_st.to_return?
+
+#            if !ls2.then_st.kind_of? ECMA262::StIf and !ls2.then_st.to_return?
+#              break
+#            end
+#            if ls2.then_st.kind_of? ECMA262::StIf and !ls2.then_to_return?
+#              break
+#            end
+
+            then_exp = ls2.then_st.to_return.exp
+            else_exp = ls.to_return.exp
+            then_exp = ECMA262::ExpVoid.new(ECMA262::ECMA262Numeric.new(0)) if then_exp.nil?
+            else_exp = ECMA262::ExpVoid.new(ECMA262::ECMA262Numeric.new(0)) if else_exp.nil?
+            if ls2.cond.kind_of? ECMA262::ExpLogicalNot
+              cond = ECMA262::ExpCond.new(ls2.cond.val, else_exp, then_exp)
+            else
+              cond = ECMA262::ExpCond.new(ls2.cond, then_exp, else_exp)
             end
+            ret = ECMA262::StReturn.new(cond)
+            #puts ret.to_js
+            #puts ls2.to_js
+            st.replace(ls2, ret)
+            st.remove(ls)
           end
-        }
-      end
+          if st0.to_js.length > st.to_js.length 
+            parent0.replace(st0, st)
+          end
+        end
+      }
       self
     end
 
@@ -470,23 +558,7 @@ module Minjs
             idx = parent.index(st)
             parent[idx+1..0] = st.else_st
             st.replace(st.else_st, nil)
-          end
-        end
-      }
-      self
-    end
-    #
-    # feature
-    #
-    # if(a)b;else return c;
-    # =>
-    # if(!a)return c;b;
-    #
-    def optimize_if_return3(node = @prog)
-      node.traverse(nil) {|st, parent|
-        if st.kind_of? ECMA262::StIf and st.else_st and parent.kind_of? ECMA262::StatementList
-          st.remove_empty_statement
-          if (st.else_st.kind_of? ECMA262::StBlock and st.else_st[-1].kind_of? ECMA262::StReturn) or
+          elsif (st.else_st.kind_of? ECMA262::StBlock and st.else_st[-1].kind_of? ECMA262::StReturn) or
              st.else_st.kind_of? ECMA262::StReturn
             idx = parent.index(st)
             parent[idx+1..0] = st.then_st
@@ -504,19 +576,64 @@ module Minjs
     def compress_var(node = @prog, options = {})
       func_scopes = []
       catch_scopes = []
+      with_scopes = []
+      #
+      # ECMA262 10.2:
+      #
+      #  Usually a Lexical Environment is associated with some
+      #  specific syntactic structure of ECMAScript code such as a
+      #  FunctionDeclaration, a WithStatement, or a Catch clause of a
+      #  TryStatement and a new Lexical Environment is created each
+      #  time such code is evaluated.
+      #
       node.traverse(nil) {|st, parent|
         if st.kind_of? ECMA262::StFunc
           func_scopes.push([st, parent])
         elsif st.kind_of? ECMA262::StTry
           catch_scopes.push([st, parent])
         elsif st.kind_of? ECMA262::StWith
-          #TODO
+          with_scopes.push([st, parent])
         end
       }
-      #10.2
       #
-      # Catch clause of a TryStatement and a new Lexical Environment is
-      # created each time such code is evaluated.
+      # 10.2, 12.14
+      #
+      #eee = 'global';
+      #function test()
+      #{
+      #  /*
+      #    "eee" is local variable(belongs to this function)
+      #    because var declaration is exist in this function.
+      #    (see also catch's scope comment)
+      #    So, global variable 'eee' is not changed.
+      #  */
+      #  eee = 'function';
+      #  try{
+      #    console.log(eee);	//=>function
+      #    throw "exception";
+      #  }
+      #  catch(eee){
+      #  /*
+      #    The catch's variable scope will be created at execution time.
+      #    so next var declaration should belong to "test" function.
+      #  */
+      #    var eee;
+      #  /*
+      #    In execution time, "eee" belongs to this 
+      #    catch-clause's scope.
+      #  */
+      #    console.log(eee);	//=>exception
+      #  /*
+      #    Next function has its own scope and 'eee' belongs to its.
+      #  */
+      #    (function(){
+      #      var eee;
+      #      console.log(eee);	//=>undefined
+      #    })();
+      #  }
+      #}
+      #console.log(eee); 	//=>global
+      #test();
       #
       catch_scopes.each{|st, parent|
         catch_context = ECMA262::Context.new
@@ -527,13 +644,24 @@ module Minjs
         st.catch[0].context = catch_context
 
         st.catch[1].traverse(parent){|st2|
-          if st2.kind_of? ECMA262::IdentifierName and st2 == st.catch[0] and
-            st2.binding_env == st.catch[0].binding_env
+          if st2.kind_of? ECMA262::IdentifierName and st2 == st.catch[0] and st2.binding_env == st.catch[0].binding_env
             st2.context = catch_context
           end
         }
         func_scopes.unshift([st, parent])
       }
+#      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 {|st, parent|
         if st.kind_of? ECMA262::StFunc
@@ -586,10 +714,6 @@ module Minjs
             elsif st2_lex_env == @global_context.lex_env #global
               outer_vars[var_name] ||= 0
               outer_vars[var_name] += 1
-#            elsif st2_lex_env == context.lex_env and st2_lex_env != context.lex_env
-#              nesting_vars[var_name] ||= 0
-#              nesting_vars[var_name] += 1
-#              nesting_vars_list.push(st2)
             elsif st2_lex_env == context.lex_env
               var_vars[var_name] ||= 0
               var_vars[var_name] += 1
@@ -620,6 +744,10 @@ module Minjs
               eval_flag = true
               break
             end
+            if st2.kind_of? ECMA262::StWith
+              eval_flag = true
+              break
+            end
           }
           if eval_flag
             next
@@ -637,14 +765,18 @@ module Minjs
           if name.nil?
             next #bug?
           end
-          #STDERR.puts "trying to rename #{name}"
+          if name.length == 1
+            #STDERR.puts "#{name}=>#{count}"
+            next
+          end
+          #STDERR.puts "trying to rename #{name}(#{count})"
           while true
             #condition b
-            if var_vars[var_sym]
-              #STDERR.puts "var_vars has #{var_sym}"
-            #condigion c
-            elsif outer_vars[var_sym]
+            if outer_vars[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
             else #condition a&d
               #STDERR.puts "->#{var_sym}"
               break
@@ -687,7 +819,7 @@ module Minjs
                 }
               end
               #raise 'error' if x.binding_env(:var).nil?
-              raise 'error' if x.binding_env(:lex).nil?
+              raise x.to_js if x.binding_env(:lex).nil?
             end
           end
           rename_table[name] = var_sym
@@ -711,11 +843,13 @@ module Minjs
         end
 
         var_vars_list.each {|st2|
-          st2.instance_eval{
-            @val = rename_table[@val]
-          }
-          #raise 'error' if st2.binding_env(:var).nil?
-          raise 'error' if st2.binding_env(:lex).nil?
+            st2.instance_eval{
+              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?
+              end
+            }
         }
       }
       self
@@ -731,7 +865,6 @@ module Minjs
     end
 
     def simple_replacement(node = @prog)
-      retry_flag = false
       node.traverse(nil) {|st, parent|
         #
         #true => !0
@@ -777,6 +910,40 @@ module Minjs
         elsif st.kind_of? ECMA262::ExpNew and st.args and st.args.length == 0
           st.replace(st.args, nil)
           parent.add_paren.remove_paren
+        #
+        # !c?a:b => c?b:a
+        # true?a:b => a
+        # false?a:b => b
+        #
+        elsif st.kind_of? ECMA262::ExpCond
+          if st.val.kind_of? ECMA262::ExpLogicalNot
+            st.instance_eval{
+              @val = @val.val
+              t = @val2
+              @val2 = @val3
+              @val3 = t
+            }
+            simple_replacement(st)
+          end
+
+          if st.val.respond_to? :to_ecma262_boolean
+            if st.val.to_ecma262_boolean.nil?
+              ;
+            elsif st.val.to_ecma262_boolean
+              parent.replace(st, st.val2)
+            else
+              parent.replace(st, st.val3)
+            end
+          end
+        #
+        # A["B"] => A.N
+        #
+        elsif st.kind_of? ECMA262::ExpPropBrac and st.val2.kind_of? ECMA262::ECMA262String
+          if idname?(st.val2.val)
+            parent.replace(st, ECMA262::ExpProp.new(st.val, st.val2))
+          elsif !st.val2.to_ecma262_number.nil? and (v=ECMA262::ECMA262Numeric.new(st.val2.to_ecma262_number)).to_ecma262_string == st.val2.to_ecma262_string
+            st.replace(st.val2, v)
+          end
         end
       }
       self
@@ -787,7 +954,7 @@ module Minjs
     #
     def reduce_if(node = @prog)
       retry_flag = true
-      while(retry_flag)
+      while retry_flag
         retry_flag = false
         node.traverse(nil) {|st, parent|
           if st.kind_of? ECMA262::StIf
@@ -800,14 +967,6 @@ module Minjs
               st.replace(st.cond, ECMA262::ExpLogicalAnd.new(st.cond, st.then_st.cond))
               st.replace(st.then_st, st.then_st.then_st)
             end
-            #if(a);
-            # => a
-            #if(a){}
-            # => a
-            if st.then_st.empty? and st.else_st.nil?
-              parent.replace(st, ECMA262::StExp.new(st.cond))
-              retry_flag = true
-            end
             #if(a)z;else;
             #if(a)z;else{}
             # => {if(a)z;}
@@ -815,12 +974,12 @@ module Minjs
               st.replace(st.else_st, nil)
               parent.replace(st, ECMA262::StBlock.new([st]))
               retry_flag = true
+              break
             end
-
             #if(a);else z;
-            #=>if(!a)z;
+            #=>{if(!a)z};
             #if(a){}else z;
-            #=>if(!a)z;
+            #=>{if(!a)z};
             if st.then_st.empty? and st.else_st
               st.replace(st.cond, ECMA262::ExpLogicalNot.new(st.cond));
               else_st = st.else_st
@@ -828,40 +987,53 @@ module Minjs
               st.replace(st.then_st, else_st)
               parent.replace(st, ECMA262::StBlock.new([st]))
               retry_flag = true
+              break
+            end
+            #if(a);
+            # => a
+            #if(a){}
+            # => a
+            if st.then_st.empty? and st.else_st.nil?
+              parent.replace(st, ECMA262::StExp.new(st.cond))
             end
 =begin
-#feature
-            #
             #if(!(a&&b))
             #=>
             #if(!a||!b)
-            #
-            #if(!(a||b))
-            #=>
-            #if(!a&&!b)
-            #
             if st.cond.kind_of? ECMA262::ExpLogicalNot and st.cond.val.kind_of? ECMA262::ExpParen and
               st.cond.val.val.kind_of? ECMA262::ExpLogicalAnd
               a = ECMA262::ExpLogicalNot.new(st.cond.val.val.val)
               b = ECMA262::ExpLogicalNot.new(st.cond.val.val.val2)
-              r = ECMA262::ExpLogicalOr.new(a,b).add_paren.remove_paren
-              if r.to_js.length < st.cond.to_js.length
+              r = ECMA262::ExpLogicalOr.new(a,b).add_remove_paren
+              if r.to_js.length <= st.cond.to_js.length
                 st.replace(st.cond, r)
               end
-            elsif st.cond.kind_of? ECMA262::ExpLogicalNot and st.cond.val.kind_of? ECMA262::ExpParen and
+            end
+            #if(!(a||b))
+            #=>
+            #if(!a&&!b)
+            if st.cond.kind_of? ECMA262::ExpLogicalNot and st.cond.val.kind_of? ECMA262::ExpParen and
               st.cond.val.val.kind_of? ECMA262::ExpLogicalOr
               a = ECMA262::ExpLogicalNot.new(st.cond.val.val.val)
               b = ECMA262::ExpLogicalNot.new(st.cond.val.val.val2)
-              r = ECMA262::ExpLogicalAnd.new(a,b).add_paren.remove_paren
-              if r.to_js.length < st.cond.to_js.length
+              r = ECMA262::ExpLogicalAnd.new(a,b).add_remove_paren
+              if r.to_js.length <= st.cond.to_js.length
                 st.replace(st.cond, r)
               end
             end
 =end
+            #if((a))
+            if st.cond.kind_of? ECMA262::ExpParen
+              st.replace(st.cond, st.cond.val)
+            end
+            #if(!!a)
+            if st.cond.kind_of? ECMA262::ExpLogicalNot and st.cond.val.kind_of? ECMA262::ExpLogicalNot
+              st.replace(st.cond, st.cond.val.val)
+            end
           end
         }
-        block_to_statement if retry_flag
       end
+      block_to_statement
       self
     end
 
@@ -946,14 +1118,24 @@ if $0 == __FILE__
   f = []
   options = {}
   argv.each do |x|
-    if x.match(/^--?/)
+    if x.match(/^--?version/)
+      puts Minjs::VERSION
+      exit(0)
+    elsif x.match(/^--?/)
       opt = $'.gsub(/-/, '_').to_sym
       options[opt] = true
     else
       f.push(open(x.to_s).read())
     end
   end
+
+  js = f.join("\n")
+
   comp = Minjs::Compressor.new(:debug => false)
-  comp.compress(f.join("\n"), options)
-  puts comp.to_js(options)
+  comp.compress(js, options)
+  comp_js = comp.to_js(options)
+  #p comp_js.length
+  js = comp_js
+  puts js
+
 end

data/lib/minjs/ctype.rb

@@ -863,5 +863,16 @@ module Minjs
         return true
       end
     end
+
+    def idname?(name)
+      return false if name.length == 0
+      s = name.codepoints
+      return false unless identifier_start?(s[0])
+      s.unshift
+      s.each do |code|
+        return false unless identifier_part?(code)
+      end
+      return true
+    end
   end
 end

data/lib/minjs/ecma262/base.rb

@@ -67,6 +67,16 @@ module Minjs
         puts "warning: #{self.class}: == not implement"
         raise "warning: #{self.class}: == not implement"
       end
+
+      def add_remove_paren(node = self)
+        node.traverse(nil) {|st, parent|
+          if st.respond_to? :remove_paren
+            st.add_paren
+            st.remove_paren
+          end
+        }
+        node
+      end
     end
 
     class StatementList < Base
@@ -111,8 +121,16 @@ module Minjs
         end
 
         if idx = new_sl.index{|x| x.class == StReturn}
-          while idx < new_sl.length - 1
-            new_sl.pop
+          idx += 1
+          while idx < new_sl.length
+            if new_sl[idx].kind_of? StVar
+              ;
+            elsif new_sl[idx].kind_of? StFunc
+              ;
+            else
+              new_sl[idx] = StEmpty.new
+            end
+            idx += 1
           end
         end
 
@@ -153,6 +171,7 @@ module Minjs
       end
 
       def traverse(parent, &block)
+        _self = self
         @statement_list.each do|st|
           st.traverse(self, &block)
         end
@@ -240,6 +259,13 @@ module Minjs
       def deep_dup
         self.class.new(context, source_elements.deep_dup)
       end
+
+      def replace(from, to)
+        if from == @source_elements
+          @source_elements = to
+        end
+      end
+
       def traverse(parent, &block)
         @source_elements.traverse(self, &block)
         yield self, parent

data/lib/minjs/ecma262/exp.rb

@@ -360,11 +360,15 @@ module Minjs
       end
 
       def replace(from, to)
-        @args.each_index do |i|
-          arg = @args[i]
-          if arg .eql? from
-            @args[i] = to
-            break
+        if @name .eql? from
+          @name = to
+        else
+          @args.each_index do |i|
+            arg = @args[i]
+            if arg .eql? from
+              @args[i] = to
+              break
+            end
           end
         end
       end
@@ -466,8 +470,7 @@ module Minjs
       end
 
       def to_js(options = {})
-        #TODO => simple_replacement
-        if @args# and @args.length > 0
+        if @args
           args = @args.collect{|x| x.to_js(options)}.join(",")
           concat options, :new, @name, '(', args, ')'
         else
@@ -1194,16 +1197,13 @@ module Minjs
       end
 
       def to_ecma262_boolean
-        if @val.respond_to? :to_ecma262_boolean and @val2.respond_to? :to_ecma262_boolean
-          return nil if @val.to_ecma262_boolean == nil or @val2.to_ecma262_boolean == nil
-          if @val.to_ecma262_boolean and @val2.to_ecma262_boolean
-            true
-          else
-            false
-          end
-        else
-          nil
-        end
+        return nil if !(@val.respond_to? :to_ecma262_boolean)
+        return nil if @val.to_ecma262_boolean == nil
+        return false if @val.to_ecma262_boolean == false
+        return nil if !(@val2.respond_to? :to_ecma262_boolean)
+        return nil if @val2.to_ecma262_boolean == nil
+        return false if @val2.to_ecma262_boolean == false
+        true
       end
 
       def ecma262_typeof
@@ -1227,16 +1227,13 @@ module Minjs
       end
 
       def to_ecma262_boolean
-        if @val.respond_to? :to_ecma262_boolean and @val2.respond_to? :to_ecma262_boolean
-          return nil if @val.to_ecma262_boolean == nil or @val2.to_ecma262_boolean == nil
-          if @val.to_ecma262_boolean or @val2.to_ecma262_boolean
-            true
-          else
-            false
-          end
-        else
-          nil
-        end
+        return nil if !(@val.respond_to? :to_ecma262_boolean)
+        return nil if @val.to_ecma262_boolean == nil
+        return true if @val.to_ecma262_boolean == true
+        return nil if !(@val2.respond_to? :to_ecma262_boolean)
+        return nil if @val2.to_ecma262_boolean == nil
+        return true if @val2.to_ecma262_boolean == true
+        false
       end
 
       def ecma262_typeof
@@ -1255,6 +1252,7 @@ module Minjs
     #
     class ExpCond < Exp
       attr_reader :val, :val2, :val3
+      alias :cond :val
 
       def initialize(val, val2, val3)
         @val = val

data/lib/minjs/ecma262/lit.rb

@@ -693,16 +693,17 @@ module Minjs
         @val = val
       end
 
-      def idname?(name)
-        return false if name.length == 0
-        s = name.codepoints
-        return false unless identifier_start?(s[0])
-        s.unshift
-        s.each do |code|
-          return false unless identifier_part?(code)
-        end
-        return true
-      end
+#=>Ctype
+#      def idname?(name)
+#        return false if name.length == 0
+#        s = name.codepoints
+#        return false unless identifier_start?(s[0])
+#        s.unshift
+#        s.each do |code|
+#          return false unless identifier_part?(code)
+#        end
+#        return true
+#      end
 
       def deep_dup
         self.class.new(@val.collect{|x, y| [x.deep_dup, y ? y.deep_dup : y]})

data/lib/minjs/ecma262/st.rb

@@ -37,6 +37,12 @@ module Minjs
         self.class.new(@statement_list.deep_dup)
       end
 
+      def replace(from, to)
+        if from == @statement_list
+          @statement_list = to
+        end
+      end
+
       def traverse(parent, &block)
         @statement_list.traverse(self, &block)
         yield self, parent
@@ -84,6 +90,14 @@ module Minjs
         end
       end
 
+      def to_return?
+        to_statement? and to_statement.to_return?
+      end
+
+      def to_return
+        to_statement.to_return
+      end
+
       def empty?
         @statement_list.statement_list.select{|s|
           s.class != StEmpty
@@ -181,6 +195,7 @@ module Minjs
             x[1] = x[1].val
           end
         end
+        self
       end
 
       def add_paren
@@ -262,6 +277,7 @@ module Minjs
         if @exp.kind_of? ExpParen
           @exp = @exp.val if @exp.remove_paren?
         end
+        self
       end
 
       def add_paren
@@ -327,24 +343,22 @@ module Minjs
 
       def to_return
         then_exp = then_st.exp;
-        else_exp = else_st.exp;
+        if @else_st
+          else_exp = else_st.exp;
+        end
 
         if then_exp.nil?
           then_exp = ExpVoid.new(ECMA262Numeric.new(0))
         end
-        if else_exp.nil?
+        if @else_st and else_exp.nil?
           else_exp = ExpVoid.new(ECMA262Numeric.new(0))
         end
         if @else_st
-          ret = StReturn.new(ExpCond.new(@cond, then_exp, else_exp).add_paren)
-        else
-          ret = StReturn.new(ExpLogicalAnd.new(@cond, then_exp).add_paren)
-        end
-        if ret.to_js.length <= to_js.length
-          ret
+          ret = add_remove_paren StReturn.new(ExpCond.new(@cond, then_exp, else_exp))
         else
-          self
+          ret = add_remove_paren StReturn.new(ExpLogicalAnd.new(@cond, then_exp))
         end
+        ret
       end
 
       def to_exp?
@@ -361,20 +375,28 @@ module Minjs
         cond = @cond.deep_dup
         if !@else_st
           then_exp = @then_st.to_exp(options)
-          if cond.kind_of? ExpLogicalNot
-            return ExpParen.new(ExpLogicalOr.new(ExpParen.new(cond.val), ExpParen.new(then_exp)))
+          if(options[:cond])
+            if cond.kind_of? ExpLogicalNot
+              add_remove_paren ExpCond.new(cond.val, ECMA262Numeric.new(0), then_exp)
+            else
+              add_remove_paren ExpCond.new(cond, then_exp, ECMA262Numeric.new(0))
+            end
           else
-            return ExpParen.new(ExpLogicalAnd.new(ExpParen.new(cond), ExpParen.new(then_exp)))
+            if cond.kind_of? ExpLogicalNot
+              add_remove_paren ExpLogicalOr.new(cond.val, then_exp)
+            else
+              add_remove_paren ExpLogicalAnd.new(cond, then_exp)
+            end
           end
         else
-          then_exp = ExpParen.new(@then_st.to_exp(options))
-          else_exp = ExpParen.new(@else_st.to_exp(options))
-        end
+          then_exp = @then_st.to_exp(options)
+          else_exp = @else_st.to_exp(options)
 
-        if cond.kind_of? ExpLogicalNot
-          ExpCond.new(ExpParen.new(cond.val), else_exp, then_exp)
-        else
-          ExpCond.new(ExpParen.new(cond), then_exp, else_exp)
+          if cond.kind_of? ExpLogicalNot
+            add_remove_paren ExpCond.new(cond.val, else_exp, then_exp)
+          else
+            add_remove_paren ExpCond.new(cond, then_exp, else_exp)
+          end
         end
       end
 
@@ -842,7 +864,7 @@ module Minjs
       end
 
       def deep_dup
-        self.class.new(@exp)
+        self.class.new(@exp ? @exp.deep_dup : nil)
       end
 
       def traverse(parent, &block)
@@ -873,7 +895,7 @@ module Minjs
       end
 
       def deep_dup
-        self.class.new(@exp)
+        self.class.new(@exp ? @exp.deep_dup : nil)
       end
 
       def traverse(parent, &block)
@@ -903,10 +925,6 @@ module Minjs
         @exp = exp
       end
 
-      def deep_dup
-        self.class.new(@exp)
-      end
-
       def deep_dup
         self.class.new(exp ? exp.deep_dup : nil)
       end
@@ -955,15 +973,16 @@ module Minjs
     end
     #12.10
     class StWith < St
-      attr_reader :exp, :statement
+      attr_reader :exp, :statement, :context
 
-      def initialize(exp, statement)
+      def initialize(context, exp, statement)
+        @context = context
         @exp = exp
         @statement = statement
       end
 
       def deep_dup
-        self.class.new(@exp, @statement)
+        self.class.new(@context, @exp.deep_dup, @statement.deep_dup)
       end
 
       def replace(from, to)
@@ -1014,7 +1033,7 @@ module Minjs
       end
 
       def deep_dup
-        self.class.new(@exp,
+        self.class.new(@exp.deep_dup,
                        @blocks.collect{|x, y|
                          [
                            x ? x.deep_dup : nil,
@@ -1085,7 +1104,7 @@ module Minjs
       end
 
       def deep_dup
-        self.class.new(@label, @statement)
+        self.class.new(@label.deep_dup, @statement.deep_dup)
       end
 
       def replace(from, to)
@@ -1121,7 +1140,7 @@ module Minjs
       end
 
       def deep_dup
-        self.class.new(@exp)
+        self.class.new(@exp.deep_dup)
       end
 
       def traverse(parent, &block)
@@ -1152,7 +1171,10 @@ module Minjs
       end
 
       def deep_dup
-        self.class.new(@context, @try, @catch, @finally)
+        self.class.new(@context,
+                       @try.deep_dup,
+                       @catch ? [@catch[0].deep_dup, @catch[1].deep_dup] : nil,
+                       @finally ? @finally.deep_dup : nil)
       end
 
       def replace(from, to)

data/lib/minjs/statement.rb

@@ -338,7 +338,7 @@ module Minjs
       return nil unless lex.match_lit(ECMA262::ID_WITH)
       lex.eval_lit {
         if lex.match_lit(ECMA262::PUNC_LPARENTHESIS) and e=exp(lex, context, {}) and lex.match_lit(ECMA262::PUNC_RPARENTHESIS) and s=statement(lex, context)
-          ECMA262::StWith.new(e, s)
+          ECMA262::StWith.new(context, e, s)
         else
           raise ParseError.new("switch_statement", lex)
         end

data/lib/minjs/version.rb

@@ -1,3 +1,3 @@
 module Minjs
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minjs
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Issei Numata
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-26 00:00:00.000000000 Z
+date: 2015-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler