minjs 0.1.10 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc081d9afd40b166f51a4c5644c9de92885717c8
-  data.tar.gz: 36f9da0d2cc3b20cfc15665f78e9a7cfe9021d7b
+  metadata.gz: c3d1d9049c22ff483762abe2eb89d9cbcfdde1bd
+  data.tar.gz: 9780d815f256edea332b814d84c7c299c870d8d2
 SHA512:
-  metadata.gz: 56bdd17c30497dfe92cc8d2e53e5e8685814032acf69f2d0b31dae8f59e49739769297e4efe175f75f615f97f1ed662031d713b54330d7f2806107fe5d41e826
-  data.tar.gz: 40424bea0a9de0995419e53bf100d9ce7f8d42f08f32782e118c72023508897129c4aa338e671d44edde40c459aa1b772ca3aed35dd0dd45bfcffedb925a11cf
+  metadata.gz: dae0218ef56cdef8ca1fd8a602cedd6f36b23a328f1da3d9e17e19eab851b22bebe7b857ec72c223e04729a891eb2bb2b6ca4f1a24b099ccf5dd7bb166616594
+  data.tar.gz: 164cbde79345dcf7175af658571af6b5cef96b08ef4bc89d9600f21b6f91b310d369a53e0924355f0a16d94461899113a27b45f349a22bbbe721c011067bdab9

data/lib/minjs/compressor.rb

@@ -53,60 +53,44 @@ module Minjs
       @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
-
-      @logger.info '* reduce_if'
-      reduce_if
-
-      @logger.info '* block_to_statement'
-      block_to_statement
-
-      @logger.info '* if_to_cond'
-      if_to_cond
-
-      @logger.info '* optimize_if_return'
-      optimize_if_return
-
-      @logger.info '* compress_var'
-      compress_var(@prog, :longer => true)
-      compress_var
-
-      @logger.info '* reduce_exp'
-      reduce_exp
-
-      grouping_statement
-      block_to_statement
-      if_to_cond
-
-      #feature
-      optimize_if_return2
+      if options[:only_parse]
+        return
+      end
 
-      @logger.info '* remove_paren'
-      remove_paren
+      algo = [
+        :reorder_function_decl,
+        :simple_replacement,
+        :reorder_var,
+        :assignment_after_var,
+        :grouping_statement,
+        :reduce_if,
+        :block_to_statement,
+        :if_to_cond,
+        :optimize_if_return,
+        :compress_var,
+        :reduce_exp,
+        :grouping_statement,
+        :block_to_statement,
+        :if_to_cond,
+        :optimize_if_return2,
+        :remove_paren,
+      ]
+      algo.each do |a|
+        if (options.empty? || options[:all] || options[a]) && !options[("no_" + a.to_s).to_sym]
+          @logger.info "* #{a}"
+          __send__(a, @prog)
+        end
+      end
 
       @heading_comments.reverse.each do |c|
         @prog.source_elements.source_elements.unshift(c)
       end
-      to_js(options)
+      self
     end
 
     def parse(data)
       @lex = Minjs::Lex.new(data, :logger => @logger)
       @global_context = ECMA262::Context.new
-
       @heading_comments = []
       @lex.eval_lit{
         while a = @lex.ws_lit
@@ -116,11 +100,7 @@ module Minjs
       }
       @prog = source_elements(@lex, @global_context)
 
-      #a = @prog.deep_dup
-      #a == @prog
-
       remove_empty_statement
-      #@prog
       self
     end
 
@@ -191,14 +171,18 @@ module Minjs
     end
 
     def reorder_function_decl(node = @prog)
+      flist = []
       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)
+            flist.push([st, parent])
           end
         end
       }
+      flist.reverse.each do |st, parent|
+        parent.remove(st)
+        parent.statement_list.unshift(st)
+      end
       self
     end
 
@@ -254,13 +238,18 @@ module Minjs
 
             idx = 0
             elems.each do |e|
+              next if e.kind_of? ECMA262::StFunc and e.decl?
               found = false
-              e.traverse(nil){|ee, pp|
-                if ee.kind_of? ECMA262::IdentifierName and var_vars[ee.val.to_sym]
-                  found = true
-                  break
-                end
-              }
+              if e.kind_of? ECMA262::StFunc and e.decl?
+                ;
+              else
+                e.traverse(nil){|ee, pp|
+                  if ee.kind_of? ECMA262::IdentifierName and var_vars[ee.val.to_sym]
+                    found = true
+                    break
+                  end
+                }
+              end
               break if found
               idx += 1
             end
@@ -275,35 +264,6 @@ module Minjs
         end
         self
       }
-=begin
-            st.traverse(parent) {|st2, parent2|
-              #
-              #if var statment has initializer,
-              #
-              #
-              if st2.kind_of? ECMA262::StVar and st2.context.var_env == @context.var_env
-                st2.instance_eval{
-                  blk = []
-                  @vars.each do |vl|
-                    if vl[1]
-                      blk.push(ECMA262::StExp.new(ECMA262::ExpAssign.new(vl[0], vl[1])))
-                    else
-                    end
-                  end
-                  parent2.replace(st2, ECMA262::StBlock.new(ECMA262::StatementList.new(blk)))
-                }
-              elsif st2.kind_of? ECMA262::StForVar and st2.context.var_env == @context.var_env
-                parent2.replace(st2, st2.to_st_for)
-              elsif st2.kind_of? ECMA262::StForInVar and st2.context.var_env == @context.var_env
-                parent2.replace(st2, st2.to_st_for_in)
-              end
-            }
-
-          }
-        end
-      }
-      remove_block_in_block
-=end
       self
     end
 
@@ -509,76 +469,93 @@ module Minjs
       self
     end
 
-    def compress_var(node = @prog, options = {})
-      if options[:longer]
-        var_sym = :aaaaaaaaaa
-      end
+    def compress_var(node = @prog)
+      #compress_var_sub(@prog, :longer => true)
+      compress_var_sub
+    end
 
+    def compress_var_sub(node = @prog, options = {})
       #
       #traverse all statemtns and expression
       #
       scopes = []
       node.traverse(nil) {|st, parent|
-        if st.kind_of? ECMA262::StTry and st.catch
-          _context = st.catch_context
-          _parent = st
-          _st = st.catch[1]
-        elsif st.kind_of? ECMA262::StFunc
+        if st.kind_of? ECMA262::StFunc
           _context = st.context
           _parent = parent
           _st = st
-        else
-          _parent = nil
-          _context = nil
-          _st = nil
-        end
-        if _parent and _context and _st
           scopes.push([st, parent, _parent, _context, _st])
         end
       }
-      #node.traverse(nil) {|st, parent|
-      scopes.reverse.each {|st, parent, _parent, _context, _st|
-        #p "*#{st.name.to_js}"
-        if !options[:longer]
-          var_sym = :a
-        end
+      scopes.reverse!
+      scopes.each {|st, parent, _parent, _context, _st|
+        var_sym = :a
         if _parent and _context and _st
           #
           # collect and counting all variables under this function/catch
+          # collect and counting all var-variables under this function/catch
           #
-          vars = {}
-          if st.kind_of? ECMA262::StTry
-            vars[st.catch[0].val.to_sym] = 1
-          end
+          all_vars = {}
+          var_vars = {}
+          var_vars_list = []
+          outer_vars = {}
+          nesting_vars = {}
+          nesting_vars_list = []
+
           _st.traverse(_parent) {|st2|
+            #
+            # In this function,
+            #
+            # 1. outer_vars:
+            #    Variables which locate out of this function(or global variable)
+            #    Them name cannot be renamed
+            # 2. nesting_vars:
+            #    Variables which locate in the function of this function.
+            #    Them name cannot be renamed
+            # 3. var_vars:
+            #    Variables which have same scope in this function.
+            #    Them name can be renamed under the following conditions
+            #
+            #   a. If the new name is not used, the name can be renamed to it.
+            #   b. If the new name belongs to var_vars, the name cannot be renamed.
+            #   c. If the new name belongs to outer_vars the name cannot be renamed.
+            #   d. If the new name belongs to nesting_vars, the name can be rename
+            #      to it after rename nesting_vars's name to another name.
+            #
             if st2.kind_of? ECMA262::IdentifierName
-              vars[st2.val.to_sym] ||= 0
-              vars[st2.val.to_sym] += 1
+              var_name = st2.val.to_sym
+              st2_env = st2.binding_env
+              all_vars[var_name] ||= 0
+              all_vars[var_name] += 1
+              if st2_env == nil #global
+                outer_vars[var_name] ||= 0
+                outer_vars[var_name] += 1
+              elsif st2_env == @global_context.var_env #global
+                outer_vars[var_name] ||= 0
+                outer_vars[var_name] += 1
+              elsif st2_env == st.context.var_env
+                var_vars[var_name] ||= 0
+                var_vars[var_name] += 1
+                var_vars_list.push(st2)
+              else
+                e = st2.binding_env
+                while e
+                  e = e.outer
+                  if e == st.context.var_env
+                    nesting_vars[var_name] ||= 0
+                    nesting_vars[var_name] += 1
+                    nesting_vars_list.push(st2)
+                    break
+                  end
+                  if e.nil?
+                    outer_vars[var_name] ||= 0
+                    outer_vars[var_name] += 1
+                    break
+                  end
+                end
+              end
             end
           }
-          #
-          # collect all var variables under this function
-          #
-          var_vars = {}
-          if st.kind_of? ECMA262::StFunc
-            _context.var_env.record.binding.each do|k, v|
-              var_vars[k] = (vars[k] || 1)
-            end
-          end
-          #
-          # collect all lexical variables under this catch clause
-          #
-          # currently, only catch's args is lex_var
-          #
-          lex_vars = {}
-          if st.kind_of? ECMA262::StTry
-            _context.lex_env.record.binding.each do|k, v|
-              lex_vars[k] = (vars[k] || 1)
-            end
-          end
-          #
-          # check `eval' function is exist under this function/catch
-          #
           unless var_vars[:eval]
             eval_flag = false
             _st.traverse(_parent) {|st2|
@@ -594,97 +571,83 @@ module Minjs
           #
           # sort var_vars
           #
-          var_vars = var_vars.sort {|(k1,v1), (k2,v2)| v2 <=> v1}
-          #p var_vars
+          var_vars_array = var_vars.sort {|(k1,v1), (k2,v2)| v2 <=> v1}
           #
-          # check var_vars
+          # create renaming table
           #
-          var_vars.each {|name, count|
+          rename_table = {}
+          var_vars_array.each {|name, count|
             if name.nil?
-              next
+              next #bug?
             end
-            while(vars[var_sym])
+            while outer_vars[var_sym] or var_vars[var_sym]
               var_sym = next_sym(var_sym)
             end
-            if (!options[:longer] && name.to_s.bytesize >= var_sym.to_s.bytesize) or
-              (options[:longer] && name.to_s.bytesize <= var_sym.to_s.bytesize)
-              #
-              # rename `name' to `var_sym'
-              #
-              func_name = nil
-              if _st.kind_of? ECMA262::StFunc and _st.decl?
-                func_name = _st.name
+            #rename nesting_vars
+            if nesting_vars[var_sym]
+              nesting_vars_list.each do |x|
+                raise 'error' if x.binding_env(:var).nil?
+                raise 'error' if x.binding_env(:lex).nil?
               end
-              _st.traverse(_parent){|st2|
-                if st2.kind_of? ECMA262::IdentifierName and st2.context.nil?
-                  ;# this
-                elsif st2.kind_of? ECMA262::IdentifierName and st2.context.var_env.outer == nil # global scope
-                  ;
-                elsif st2.kind_of? ECMA262::IdentifierName and st2.val == name
-                  # scope of function's name is outer
-                  if st2.eql?(func_name)
-                  else
-                    st2.instance_eval{
-                      @val = var_sym
-                    }
-                  end
-                elsif st2.kind_of? ECMA262::StFunc
-                  if st2.context.var_env.record.binding[name]
-                    st2.context.var_env.record.binding[var_sym] = st2.context.var_env.record.binding[name]
-                    st2.context.var_env.record.binding.delete(name)
-                  end
-                elsif st2.kind_of? ECMA262::StTry
-                  if st2.catch_context.lex_env.record.binding[name]
-                    st2.catch_context.lex_env.record.binding[var_sym] = st2.catch_context.lex_env.record.binding[name]
-                    st2.catch_context.lex_env.record.binding.delete(name)
-                  end
+
+              var_sym2 = "abc#{var_sym.to_s}".to_sym
+              while all_vars[var_sym2]
+                var_sym2 = next_sym(var_sym2)
+              end
+              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)
+                  rl[_var_env] = true
+                  rl[_lex_env] = true
                 end
-              }
-            end
-            var_sym = next_sym(var_sym)
-          }
-          lex_vars.each {|name, count|
-            if name.nil?
-              next
-            end
-            while(vars[var_sym])
-              var_sym = next_sym(var_sym)
-            end
-            if name.to_s.bytesize > var_sym.to_s.bytesize
-              #
-              # rename `name' to `var_sym'
-              #
-              _st.traverse(_parent){|st2|
-                if st2.kind_of? ECMA262::IdentifierName and st2.context.nil?
-                  ;# TODO, currently special identifier such as 'this' has no context
-                elsif st2.kind_of? ECMA262::IdentifierName and st2.context.lex_env.outer == nil # global scope
-                  ;
-                elsif st2.kind_of? ECMA262::IdentifierName and st2.val == name
-                  st2.instance_eval{
-                    @val = var_sym
-                  }
+              end
+              rl.keys.each do |_env|
+                if _env && _env.record.binding[var_sym]
+                  _env.record.binding[var_sym2] = _env.record.binding[var_sym]
+                  _env.record.binding.delete var_sym
                 end
-              }
-              if st.kind_of? ECMA262::StTry
-                if st.catch[0].kind_of? ECMA262::IdentifierName
-                  st.catch[0].instance_eval{
-                    @val = var_sym
+              end
+
+              nesting_vars_list.each do |x|
+                if x.val.to_sym == var_sym
+                  x.instance_eval{
+                    @val = var_sym2
                   }
-                elsif st2.kind_of? ECMA262::StFunc
-                  if st2.context.var_env.record.binding[name]
-                    st2.context.var_env.record.binding[var_sym] = st2.context.var_env.record.binding[name]
-                    st2.context.var_env.record.binding.delete(name)
-                  end
-                elsif st2.kind_of? ECMA262::StTry
-                  if st2.catch_context.lex_env.record.binding[name]
-                    st2.catch_context.lex_env.record.binding[var_sym] = st2.catch_context.lex_env.record.binding[name]
-                    st2.catch_context.lex_env.record.binding.delete(name)
-                  end
                 end
+                raise 'error' if x.binding_env(:var).nil?
+                raise 'error' 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 'error' if st2.binding_env(:var).nil?
+            raise 'error' if st2.binding_env(:lex).nil?
+          }
+
+          rename_table.each do |name, new_name|
+            if name != new_name
+              if st.context.var_env.record.binding[name]
+                st.context.var_env.record.binding[new_name] = st.context.var_env.record.binding[name]
+                st.context.var_env.record.binding.delete(name)
+              end
+              if st.context.lex_env.record.binding[name]
+                st.context.lex_env.record.binding[new_name] = st.context.lex_env.record.binding[name]
+                st.context.lex_env.record.binding.delete(name)
+              end
+            end
+          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?
+          }
         end
       }
       self
@@ -700,6 +663,7 @@ module Minjs
     end
 
     def simple_replacement(node = @prog)
+      retry_flag = false
       node.traverse(nil) {|st, parent|
         #
         #true => !0
@@ -715,20 +679,7 @@ module Minjs
         #if(true){<then>}else{<else>} => then
         #
         elsif st.kind_of? ECMA262::StIf
-          #if(a)z;else;
-          #if(a)z;else{}
-          # => {if(a)z;}
-          if st.else_st and st.else_st.empty?
-            st.replace(st.else_st, nil)
-            parent.replace(st, ECMA262::StBlock.new([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))
-          elsif st.cond.respond_to? :to_ecma262_boolean
+          if st.cond.respond_to? :to_ecma262_boolean
             if st.cond.to_ecma262_boolean
               parent.replace(st, st.then_st)
             elsif st.else_st
@@ -747,6 +698,12 @@ module Minjs
           else
             parent.replace(st, ECMA262::StEmpty.new)
           end
+        #
+        # new A() => (new A)
+        #
+        elsif st.kind_of? ECMA262::ExpNew and st.args and st.args.length == 0
+          st.replace(st.args, nil)
+          parent.add_paren.remove_paren
         end
       }
       self
@@ -755,27 +712,54 @@ module Minjs
     #
     # reduce_if
     #
-    # 1) rewrite nested "if" statemet such as:
-    # if(a)
-    #   if(b) ...;
-    #
-    # to:
-    #
-    # if(a && b) ...;
-    #
-    # NOTE:
-    # both if must not have "else" clause
-    #
     def reduce_if(node = @prog)
-      node.traverse(nil) {|st, parent|
-        if st.kind_of? ECMA262::StIf
-          if st.else_st.nil? and
-            st.then_st.kind_of? ECMA262::StIf and st.then_st.else_st.nil?
-            st.replace(st.cond, ECMA262::ExpLogicalAnd.new(st.cond, st.then_st.cond))
-            st.replace(st.then_st, st.then_st.then_st)
+      retry_flag = true
+      while(retry_flag)
+        retry_flag = false
+        node.traverse(nil) {|st, parent|
+          if st.kind_of? ECMA262::StIf
+            # if(a)
+            #   if(b) ...;
+            # if(a && b) ...;
+            #
+            if st.else_st.nil? and
+              st.then_st.kind_of? ECMA262::StIf and st.then_st.else_st.nil?
+              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;}
+            if st.else_st and st.else_st.empty?
+              st.replace(st.else_st, nil)
+              parent.replace(st, ECMA262::StBlock.new([st]))
+              retry_flag = true
+            end
+
+            #if(a);else z;
+            #=>if(!a)z;
+            #if(a){}else 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
+              st.replace(st.else_st, nil)
+              st.replace(st.then_st, else_st)
+              parent.replace(st, ECMA262::StBlock.new([st]))
+              retry_flag = true
+            end
           end
-        end
-      }
+        }
+        block_to_statement if retry_flag
+      end
       self
     end
 
@@ -858,10 +842,16 @@ end
 if $0 == __FILE__
   argv = ARGV.dup
   f = []
+  options = {}
   argv.each do |x|
-    f.push(open(x.to_s).read())
+    if x.match(/^--?/)
+      opt = $'.gsub(/-/, '_').to_sym
+      options[opt] = true
+    else
+      f.push(open(x.to_s).read())
+    end
   end
   comp = Minjs::Compressor.new(:debug => false)
-  comp.compress(f.join("\n"))
-  puts comp.to_js({})
+  comp.compress(f.join("\n"), options)
+  puts comp.to_js(options)
 end

data/lib/minjs/ecma262/base.rb

@@ -39,10 +39,13 @@ module Minjs
           end
           #for debug
           unless options[:no_debug]
-            if @logger and @logger.debug?
+            if (@logger and @logger.debug?) || options[:debug]
               if js.match(/;\z/) and !options[:for_args]
                 nl = "\n"
               end
+              if js.match(/}\z/) and !options[:for_args]
+                nl = "\n"
+              end
             end
           end
           js = "#{sep}#{js}#{nl}";

data/lib/minjs/ecma262/env.rb

@@ -25,6 +25,12 @@ module Minjs
       end
     end
 
+    class DeclarativeEnvRecord < EnvRecord
+    end
+
+    class ObjectEnvRecord < EnvRecord
+    end
+
     class ExObject
       def initialize(options = {})
         @attr = options[:attr] || {}
@@ -35,14 +41,30 @@ module Minjs
     class LexEnv
       attr_reader :record
       attr_reader :outer
+      attr_reader :type
 
       def initialize(options = {})
         @outer = options[:outer]
-        @record = EnvRecord.new
+        if options[:type] == :object
+          @record = ObjectEnvRecord.new
+        else #if options[:type] == :declarative
+          @record = DeclarativeEnvRecord.new
+        end
       end
 
       def new_declarative_env(outer = nil)
-        LexEnv.new(outer: (outer || self))
+        e = LexEnv.new(outer: (outer || self), type: :declarative)
+      end
+
+      def new_object_env(object, outer = nil)#TODO
+        raise 'TODO'
+        e = LexEnv.new(outer: (outer || self), type: :object)
+        object.val.each do |k, v|
+          if k.id_name?
+            e.create_mutable_binding(k)
+            e.set_mutable_binding(k, v)
+          end
+        end
       end
 
       def debug
@@ -58,6 +80,7 @@ module Minjs
       def initialize(options = {})
         @var_env = LexEnv.new(options)
         @lex_env = LexEnv.new(options)
+        #TODO
         @this_binding = ExObject.new(
           {
             attr: {
@@ -73,9 +96,6 @@ module Minjs
         @var_env.debug
       end
 
-      def inspect
-        @var_env.record.binding.to_s
-      end
     end
   end
 end

data/lib/minjs/ecma262/exp.rb

@@ -427,7 +427,7 @@ module Minjs
       end
 
       def priority
-        PRIORITY_LEFT_HAND_SIDE + ((args && args.length == 0) ? 1 : 0)
+        PRIORITY_LEFT_HAND_SIDE + ((args == nil) ? 1 : 0)
       end
 
       def deep_dup
@@ -438,6 +438,8 @@ module Minjs
       def replace(from, to)
         if @name .eql? from
           @name = from
+        elsif @args .eql? from
+          @args = to
         elsif @args and (idx = @args.index(from))
           @args[idx] = to
         end
@@ -458,7 +460,8 @@ module Minjs
       end
 
       def to_js(options = {})
-        if @args and @args.length > 0
+        #TODO => simple_replacement
+        if @args# and @args.length > 0
           args = @args.collect{|x| x.to_js(options)}.join(",")
           concat options, :new, @name, '(', args, ')'
         else

data/lib/minjs/ecma262/lit.rb

@@ -199,12 +199,21 @@ module Minjs
       end
 
       def to_js(options = {})
-        t = "\""
+        dq = @val.to_s.each_codepoint.select{|x| x == 0x22}.length
+        sq = @val.to_s.each_codepoint.select{|x| x == 0x27}.length
+        if dq <= sq
+          t = "\""
+        else
+          t = "\'"
+        end
+
         @val.to_s.each_codepoint do |c|
           if c == 0x5c
             t << ('\\\\')
-          elsif c == 0x22
+          elsif c == 0x22 and dq <= sq
             t << ('\"')
+          elsif c == 0x27 and dq > sq
+            t << ('\\\'')
           elsif c >= 0x20 and c <= 0x7f
             t << ("%c" % c)
           elsif c == 8
@@ -227,7 +236,11 @@ module Minjs
             t << [c].pack("U*")
           end
         end
-        t << "\""
+        if dq <= sq
+          t << "\""
+        else
+          t << "\'"
+        end
       end
 
       def to_ecma262_boolean
@@ -454,7 +467,13 @@ module Minjs
 
     class ECMA262Object < Literal
       include Ctype
-      private
+      attr_reader :val
+
+      #val is tupple [[k,v],[k,v],...]
+      def initialize(val)
+        @val = val
+      end
+
       def idname?(name)
         return false if name.length == 0
         s = name.codepoints
@@ -466,13 +485,6 @@ module Minjs
         return true
       end
 
-      public
-      attr_reader :val
-
-      def initialize(val)
-        @val = val
-      end
-
       def deep_dup
         self.class.new(@val.collect{|x, y| [x.deep_dup, y ? y.deep_dup : y]})
       end
@@ -633,6 +645,24 @@ module Minjs
       def to_js(options = {})
         val.to_s
       end
+
+      def binding_env(type = :var)
+        return nil if context.nil?
+        if type == :var
+          v = context.var_env
+        else
+          v = context.lex_env
+        end
+
+        while v
+          if v.record.binding[val]
+            return v
+          else
+            v = v.outer
+          end
+        end
+        nil
+      end
     end
 
     ID_THIS = IdentifierName.get(nil, :this)

data/lib/minjs/ecma262/st.rb

@@ -1146,19 +1146,17 @@ module Minjs
     #12.14
     class StTry < St
       attr_reader :context
-      attr_reader :catch_context
       attr_reader :try, :catch, :finally
 
-      def initialize(context, catch_context, try, catch, finally)
+      def initialize(context, try, catch, finally)
         @context = context
-        @catch_context = catch_context
         @try = try
         @catch = catch
         @finally = finally
       end
 
       def deep_dup
-        self.class.new(@context, @catch_context, @try, @catch, @finally)
+        self.class.new(@context, @try, @catch, @finally)
       end
 
       def replace(from, to)

data/lib/minjs/expression.rb

@@ -31,7 +31,9 @@ module Minjs
       } || lex.eval_lit {
         object_literal(lex, context, options)
       }
-      @logger.debug "*** primary_exp => #{t ? t.to_js : t}"
+      @logger.debug {
+        "*** primary_exp => #{t ? t.to_js : t}"
+      }
       t
     end
 
@@ -162,7 +164,9 @@ module Minjs
       } || lex.eval_lit{
         new_exp(lex, context, options)
       }
-      @logger.debug "*** left_hand_side_exp => #{t ? t.to_js: t}"
+      @logger.debug{
+        "*** left_hand_side_exp => #{t ? t.to_js: t}"
+      }
       t
     end
 
@@ -696,7 +700,9 @@ module Minjs
             raise ParseError.new("unexpceted token", lex)
           end
         else
-          @logger.debug "*** assignment_exp => #{t ? t.to_js : t}"
+          @logger.debug {
+            "*** assignment_exp => #{t ? t.to_js : t}"
+          }
           t
         end
       }
@@ -716,7 +722,9 @@ module Minjs
             raise ParseError.new("unexpceted token", lex)
           end
         end
-        @logger.debug "*** expression => #{t ? t.to_js : t}"
+        @logger.debug{
+          "*** expression => #{t ? t.to_js : t}"
+        }
         t
       }
     end

data/lib/minjs/func.rb

@@ -6,10 +6,9 @@ module Minjs
     def func_declaration(lex, context)
       return nil if lex.match_lit(ECMA262::ID_FUNCTION).nil?
       lex.eval_lit {
-        new_env = context.lex_env.new_declarative_env()
         new_context = ECMA262::Context.new
-        new_context.lex_env = new_env
-        new_context.var_env = new_env
+        new_context.lex_env = context.lex_env.new_declarative_env()
+        new_context.var_env = context.var_env.new_declarative_env()
 
         if id=identifier(lex, context) and
           lex.match_lit(ECMA262::PUNC_LPARENTHESIS) and
@@ -39,11 +38,10 @@ module Minjs
       @logger.debug "*** func_exp"
 
       lex.eval_lit {
-         id_opt = identifier(lex, context)
-         new_env = context.lex_env.new_declarative_env()
-         new_context = ECMA262::Context.new
-         new_context.lex_env = new_env
-         new_context.var_env = new_env
+        id_opt = identifier(lex, context)
+        new_context = ECMA262::Context.new
+        new_context.lex_env = context.lex_env.new_declarative_env()
+        new_context.var_env = context.var_env.new_declarative_env()
 
          if lex.match_lit(ECMA262::PUNC_LPARENTHESIS) and
            args = formal_parameter_list(lex, new_context) and

data/lib/minjs/lex.rb

@@ -618,15 +618,18 @@ module Minjs
         @pos += 4
         t
       else
-        #
+        # line continuation
+        if line_terminator?(@codes[@pos])
+          ""
         # octal
         # Annex B
-        if octal?(@codes[@pos])
-          oct = 0
-          while octal?(@codes[@pos])
+        elsif octal?(@codes[@pos])
+          oct = (@codes[@pos] - 0x30)
+          2.times do
+            break unless octal?(@codes[@pos+1])
+            @pos += 1
             oct *= 8
             oct += (@codes[@pos] - 0x30)
-            @pos += 1
           end
           [oct].pack("U*")
         else
@@ -728,8 +731,8 @@ module Minjs
         pos0 = pos
         pos = 0
       end
-      if col and col > 2
-        pos0 = col - 2;
+      if col and col >= 1
+        pos0 = col - 1;
       end
       t = ''
       t << @codes[pos..(pos+80)].pack("U*")
@@ -782,13 +785,13 @@ module Minjs
         break if _pos >= pos
         if line_terminator?(code)
           row += 1
-          row = 0
+          col = 0
         else
           col += 1
         end
         _pos += 1
       end
-      return [row+1, col]
+      return [row+1, col+1]
     end
   end
 end

data/lib/minjs/minjs_compressor.rb

@@ -33,7 +33,7 @@ module Minjs
           tmp.close
         end
         #TODO
-        t = Minjs::Compressor.new(:logger => logger).compress(data)
+        t = Minjs::Compressor.new(:logger => logger).compress(data).to_js
         if logger.info?
           tmp = open(output, "w")
           tmp.write(t)

data/lib/minjs/statement.rb

@@ -101,6 +101,8 @@ module Minjs
             dn = v[0]
             context.var_env.record.create_mutable_binding(dn, nil)
             context.var_env.record.set_mutable_binding(dn, :undefined, nil)
+            context.lex_env.record.create_mutable_binding(dn, nil)
+            context.lex_env.record.set_mutable_binding(dn, :undefined, nil)
           end
           ECMA262::StVar.new(context, vl)
         else
@@ -146,17 +148,22 @@ module Minjs
     #
     def empty_statement(lex, context)
       lex.eval_lit{
-        a = lex.fwd_lit(:nolt => true)
+        a = lex.fwd_lit
         if a == ECMA262::PUNC_SEMICOLON
           ECMA262::StEmpty.new
-        elsif a == ECMA262::LIT_LINE_FEED
-          ECMA262::StEmpty.new
-        elsif a.lt?
-          ECMA262::StEmpty.new
         else
           nil
         end
-      }
+      }# || lex.eval_lit {
+#        a = lex.fwd_lit(:nolt => true)
+#        if a == ECMA262::LIT_LINE_FEED
+#          ECMA262::StEmpty.new
+#        elsif a.lt?
+#          ECMA262::StEmpty.new
+#        else
+#          nil
+#        end
+#      }
     end
     #
     #12.4
@@ -226,6 +233,8 @@ module Minjs
           #10.5
           context.var_env.record.create_mutable_binding(v[0], nil)
           context.var_env.record.set_mutable_binding(v[0], :undefined, nil)
+          context.lex_env.record.create_mutable_binding(v[0], nil)
+          context.lex_env.record.set_mutable_binding(v[0], :undefined, nil)
           ECMA262::StForInVar.new(context, v, e, s)
         else
           nil
@@ -241,6 +250,8 @@ module Minjs
             dn = v[0]
             context.var_env.record.create_mutable_binding(dn, nil)
             context.var_env.record.set_mutable_binding(dn, :undefined, nil)
+            context.lex_env.record.create_mutable_binding(dn, nil)
+            context.lex_env.record.set_mutable_binding(dn, :undefined, nil)
           end
           ECMA262::StForVar.new(context, vl, e, e2, s)
         else
@@ -404,7 +415,10 @@ module Minjs
       return nil unless lex.match_lit(ECMA262::ID_TRY)
       lex.eval_lit {
         catch_context = ECMA262::Context.new
-        catch_env = context.lex_env.new_declarative_env()
+        #
+        # catch context must be executable lexical environment
+        #
+        catch_env = context.var_env.new_declarative_env()
         catch_context.lex_env = catch_env
         catch_context.var_env = context.var_env
 
@@ -416,11 +430,11 @@ module Minjs
           break nil unless c
 
           f = try_finally(lex, context)
-          ECMA262::StTry.new(context, catch_context, t, c, f)
+          ECMA262::StTry.new(context, t, c, f)
         } || lex.eval_lit{
           f = try_finally(lex, context)
           break nil unless f
-          ECMA262::StTry.new(context, catch_context, t, nil, f)
+          ECMA262::StTry.new(context, t, nil, f)
         }
       }
     end
@@ -429,7 +443,11 @@ module Minjs
 
       if lex.match_lit(ECMA262::PUNC_LPARENTHESIS) and i=identifier(lex, catch_context) and lex.match_lit(ECMA262::PUNC_RPARENTHESIS) and b=block(lex, catch_context)
         catch_context.lex_env.record.create_mutable_binding(i, nil)
-        catch_context.lex_env.record.set_mutable_binding(i, :undefined, nil)
+        catch_context.lex_env.record.set_mutable_binding(i, :undefined, nil, {:_parameter_list => true})
+        catch_context.var_env.record.create_mutable_binding(i, nil)
+        catch_context.var_env.record.set_mutable_binding(i, :undefined, nil, {:_parameter_list => true})
+        catch_context.var_env.record.binding.each do|k, v|
+        end
         [i, b]
       else
         nil

data/lib/minjs/version.rb

@@ -1,3 +1,3 @@
 module Minjs
-  VERSION = "0.1.10"
+  VERSION = "0.2.0"
 end

metadata

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