root / trunk / buildscripts / lib / custom_rhino.diff

src/org/mozilla/javascript/BaseFunction.java

@@ -373 +373 @@
         return sb.toString();
     }
 
+        String compress(int indent, int flags)
+        {
+            StringBuffer sb = new StringBuffer();
+                String FuncName = null;
+            boolean justbody = (0 != (flags & Decompiler.ONLY_BODY_FLAG));
+            if (!justbody) {
+                sb.append("function");
+                        FuncName = getFunctionName();
+                        if(FuncName.length()>0){
+                                sb.append(" "+FuncName);
+                        }
+                sb.append("(){");
+            }
+           sb.append("[native code, arity=");
+            sb.append(getArity());
+            sb.append("]");
+            if (!justbody) {
+                sb.append("}");
+            }
+            return sb.toString();
+        }
+    
     public int getArity() { return 0; }
 
     public int getLength() { return 0; }

src/org/mozilla/javascript/NativeFunction.java

@@ -70 +70 @@
         }
     }
 
+    /**
+     * Compress the script.
+     * <p>
+     * 
+     * @param parseTree Mapping for each function node and corresponding parameters & variables names
+     * @param indent How much to indent the decompiled result
+     * @param flags Flags specifying format of decompilation output
+     * @return compressed script
+     */
+    final String compress(ScriptOrFnNode parseTree, int indent, int flags)
+    {
+        String encodedSource = getEncodedSource();
+        if (encodedSource == null) {
+            return super.compress(indent, flags);
+        } else {
+            UintMap properties = new UintMap(1);
+            properties.put(Decompiler.INITIAL_INDENT_PROP, indent);
+            return Decompiler.compress(encodedSource, flags, properties, parseTree);
+        }
+    }
     public int getLength()
     {
         int paramCount = getParamCount();

src/org/mozilla/javascript/TokenStream.java

@@ -64 +64 @@
     private final static int
         EOF_CHAR = -1;
 
+    public StringBuffer lastComment;
+    
     TokenStream(Parser parser, Reader sourceReader, String sourceString,
                 int lineno)
     {
+        this.lastComment = new StringBuffer();
         this.parser = parser;
         this.lineno = lineno;
         if (sourceReader != null) {
@@ -736 +739 @@
 
             case '/':
                 // is it a // comment?
+                // FIXME: RAR: comment, need to set config to optionally keep
+                // instead of skipping!
                 if (matchChar('/')) {
                     skipLine();
                     continue retry;

src/org/mozilla/javascript/Context.java

@@ -1178 +1178 @@
         }
     }
 
+        public final String decompileReader(Scriptable scope, Reader in,
+                                                       String sourceName, int lineno,
+                                                       Object securityDomain)
+                        throws IOException
+                    {
+                        Script script = compileReader(scope, in, sourceName, lineno,
+                                                      securityDomain);
+                        if (script != null) {
+                                        // System.err.println(script);
+                            return decompileScript(script, 0);
+                        } else {
+                            return null;
+                        }
+                    }
+                
+        public final String compressReader(Scriptable scope, Script script, String source,
+                        String sourceName, int lineno, Object securityDomain){
+                
+                if (script != null) {
+                        // System.err.println(script);                          
+                        return compressScript(script, 0, source,lineno);                        
+                } else {
+                        return null;
+                }
+        }
+       
+                
     /**
      * Check whether a string is ready to be compiled.
      * <p>
@@ -1361 +1388 @@
     }
 
     /**
+     * Compress the script.
+     * <p>
+     * Compressed script is returned.
+     * 
+     * @param script the script object
+     * @param indent the number of spaces to indent the result
+     * @return a string representing the script source
+     */
+    public final String compressScript(Script script, int indent, String source,int lineno)
+    {
+        //Make sure to clear out the TokenMapper state before running.
+        //This allows for more than one script to be compressed.
+        //However, this is not a very clean way to do the reset.
+        TokenMapper.reset();
+        Decompiler.tm = new TokenMapper();
+
+        NativeFunction scriptImpl = (NativeFunction) script;
+        
+        CompilerEnvirons compilerEnv = new CompilerEnvirons();
+
+        Parser parser = new Parser(compilerEnv, compilerEnv.getErrorReporter());
+        
+        ScriptOrFnNode tree = parser.parse(source, null, lineno);
+ 
+        return scriptImpl.compress( tree,indent, 0);
+    }   
+    /**
      * Decompile a JavaScript Function.
      * <p>
      * Decompiles a previously compiled JavaScript function object to
@@ -2240 +2294 @@
                 sourceReader = null;
             }
         }
-
         Parser p = new Parser(compilerEnv, compilationErrorReporter);
         if (returnFunction) {
             p.calledByCompileFunction = true;
@@ -2251 +2304 @@
         } else {
             tree = p.parse(sourceReader, sourceName, lineno);
         }
+        
         if (returnFunction) {
             if (!(tree.getFunctionCount() == 1
                   && tree.getFirstChild() != null

src/org/mozilla/javascript/Decompiler.java

@@ -37 +37 @@
 
 package org.mozilla.javascript;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
 /**
  * The following class save decompilation information about the source.
  * Source information is returned from the parser as a String
@@ -70 +75 @@
  * the final constant pool entry from information available at parse
  * time.
  */
+
+class TokenMapper {
+        private ArrayList functionBracePositions = new ArrayList();
+
+        /**
+         * Map of all replaced tokens
+         */
+        private ArrayList replacedTokens = new ArrayList();
+
+        /**
+         * Collection of Function nodes
+         */
+        private static ObjArray funcObjects = new ObjArray();
+
+        /**
+         * Map of each Function node and all the variables in its current function
+         * scope, other variables found while traversing the prototype chain and
+         * variables found in the top-level scope.
+         */
+        private static ArrayList functionVarMappings = new ArrayList();
+
+        public int functionNum = 0;
+
+        private int parentScope = 0;
+
+        private int lastTokenCount = 0;
+
+        /**
+         * Reset the static members for the TokenMapper.
+         */
+        public static void reset() {
+                funcObjects = new ObjArray();
+                functionVarMappings = new ArrayList();
+        }
+
+        /**
+         * Generate new compressed tokens
+         * <p>
+         * 
+         * @param token
+         *            value of the string token
+         * @param hasNewMapping
+         *            boolean value indicating a new variable binding
+         * @return compressed token
+         */
+        private String getMappedToken(String token, boolean hasNewMapping) {
+                String newToken = null;
+                HashMap tokens = null;
+                String blank = new String("");
+                int localScope = functionBracePositions.size() - 1;
+
+                String oldToken = getPreviousTokenMapping(token, hasNewMapping);
+
+                if (!oldToken.equalsIgnoreCase(blank)) {
+                        return oldToken;
+                } else if ((hasNewMapping || isInScopeChain(token))) {
+                        lastTokenCount++;
+                        newToken = new String("_" + Integer.toHexString(lastTokenCount));
+                        if (newToken.length() >= token.length()) {
+                                newToken = token;
+                        }
+                        if (hasNewMapping) {
+                                tokens = (HashMap) replacedTokens.get(localScope);
+                        } else {
+                                tokens = (HashMap) replacedTokens.get(parentScope);
+                        }
+
+                        tokens.put(token, newToken);
+                        return newToken;
+                }
+                return token;
+        }
+
+        /**
+         * Checks for variable names in prototype chain
+         * <p>
+         * 
+         * @param token
+         *            value of the string token
+         * @return boolean value indicating if the token is present in the chained
+         *         scope
+         */
+        private boolean isInScopeChain(String token) {
+                int scope = functionBracePositions.size();
+                HashMap chainedScopeVars = (HashMap) functionVarMappings
+                                .get(functionNum);
+                if (!chainedScopeVars.isEmpty()) {
+                        for (int i = scope; i > 0; i--) {
+                                if (chainedScopeVars.containsKey(new Integer(i))) {
+                                        parentScope = i - 1;
+                                        List temp = Arrays.asList((String[]) chainedScopeVars
+                                                        .get(new Integer(i)));
+                                        if (temp.indexOf(token) != -1) {
+                                                return true;
+                                        }
+                                }
+                        }
+                }
+                return false;
+        }
+
+        /**
+         * Checks previous token mapping
+         * <p>
+         * 
+         * @param token
+         *            value of the string token
+         * @param hasNewMapping
+         *            boolean value indicating a new variable binding
+         * @return string value of the previous token or blank string
+         */
+        private String getPreviousTokenMapping(String token, boolean hasNewMapping) {
+                String result = new String("");
+                int scope = replacedTokens.size() - 1;
+
+                if (scope < 0) {
+                        return result;
+                }
+
+                if (hasNewMapping) {
+                        HashMap tokens = (HashMap) (replacedTokens.get(scope));
+                        if (tokens.containsKey(token)) {
+                                result = (String) tokens.get(token);
+                                return result;
+                        }
+                } else {
+                        for (int i = scope; i > -1; i--) {
+                                HashMap tokens = (HashMap) (replacedTokens.get(i));
+                                if (tokens.containsKey(token)) {
+                                        result = (String) tokens.get(token);
+                                        return result;
+                                }
+                        }
+                }
+                return result;
+        }
+
+        /**
+         * Generate mappings for each Function node and parameters and variables
+         * names associated with it.
+         * <p>
+         * 
+         * @param parseTree
+         *            Mapping for each function node and corresponding parameters &
+         *            variables names
+         */
+        private void collectFunctionMappings(ScriptOrFnNode parseTree) {
+                int level = -1;
+                collectFuncNodes(parseTree, level);
+        }
+
+        /**
+         * Recursive method to traverse all Function nodes
+         * <p>
+         * 
+         * @param parseTree
+         *            Mapping for each function node and corresponding parameters &
+         *            variables names
+         * @param level
+         *            scoping level
+         */
+        private static void collectFuncNodes(ScriptOrFnNode parseTree, int level) {
+                level++;
+                functionVarMappings.add(new HashMap());
+
+                HashMap bindingNames = (HashMap) functionVarMappings
+                                .get(functionVarMappings.size() - 1);
+                bindingNames.put(new Integer(level), parseTree.getParamAndVarNames());
+                funcObjects.add(parseTree);
+
+                int nestedCount = parseTree.getFunctionCount();
+                for (int i = 0; i != nestedCount; ++i) {
+                        collectFuncNodes(parseTree.getFunctionNode(i), level);
+                        bindingNames = (HashMap) functionVarMappings
+                                        .get(functionVarMappings.size() - 1);
+                        bindingNames.put(new Integer(level), parseTree
+                                        .getParamAndVarNames());
+                }
+        }
+
+        /**
+         * Compress the script
+         * <p>
+         * 
+         * @param encodedSource
+         *            encoded source string
+         * @param offset
+         *            position within the encoded source
+         * @param asQuotedString
+         *            boolean value indicating a quoted string
+         * @param sb
+         *            String buffer reference
+         * @param prevToken
+         *            Previous token in encoded source
+         * @param inArgsList
+         *            boolean value indicating position inside arguments list
+         * @param currentLevel
+         *            embeded function level
+         * @param parseTree
+         *            Mapping of each function node and corresponding parameters &
+         *            variables names
+         * @return compressed script
+         */
+        public int sourceCompress(String encodedSource, int offset,
+                        boolean asQuotedString, StringBuffer sb, int prevToken,
+                        boolean inArgsList, int currentLevel, ScriptOrFnNode parseTree) {
+
+                boolean hasNewMapping = false;
+
+                if (functionVarMappings.isEmpty())
+                        collectFunctionMappings(parseTree);
+
+                int length = encodedSource.charAt(offset);
+                ++offset;
+                if ((0x8000 & length) != 0) {
+                        length = ((0x7FFF & length) << 16) | encodedSource.charAt(offset);
+                        ++offset;
+                }
+                if (sb != null) {
+                        String str = encodedSource.substring(offset, offset + length);
+                        String sourceStr = new String(str);
+                        if ((prevToken == Token.VAR) || (inArgsList)) {
+                                hasNewMapping = true;
+                        }
+                        if (((functionBracePositions.size() > 0) && (currentLevel >= (((Integer) functionBracePositions
+                                        .get(functionBracePositions.size() - 1)).intValue())))
+                                        || (inArgsList)) {
+                                if (prevToken != Token.DOT) {
+                                        str = this.getMappedToken(str, hasNewMapping);
+                                }
+                        }
+                        if ((!inArgsList) && (asQuotedString)) {
+                                if ((prevToken == Token.LC) || (prevToken == Token.COMMA)) {
+                                        str = sourceStr;
+                                }
+                        }
+                        if (!asQuotedString) {
+                                sb.append(str);
+                        } else {
+                                sb.append('"');
+                                sb.append(ScriptRuntime.escapeString(str));
+                                sb.append('"');
+                        }
+                }
+                return offset + length;
+        }
+
+        public void enterNestingLevel(int braceNesting) {
+                functionBracePositions.add(new Integer(braceNesting + 1));
+                replacedTokens.add(new HashMap());
+        }
+
+        public void leaveNestingLevel(int braceNesting) {
+                Integer bn = new Integer(braceNesting);
+
+                if ((functionBracePositions.contains(bn))
+                                && (replacedTokens.size() > 0)) {
+                        // remove our mappings now!
+                        int scopedSize = replacedTokens.size();
+                        replacedTokens.remove(scopedSize - 1);
+                        functionBracePositions.remove(bn);
+                }
+        }
+}
+        
+        
 public class Decompiler
 {
     /**
@@ -266 +537 @@
         return new String(sourceBuffer, offset, sourceTop - offset);
     }
 
+    //Used to be private, but making it public so we
+    //can reset the token state between compression runs.
+    //Not very pretty.
+    public static TokenMapper tm = new TokenMapper();
+    
+    /**
+     * Compress the script
+     * <p>
+     * 
+     * @param encodedSource encoded source string
+     * @param flags Flags specifying format of decompilation output
+     * @param properties Decompilation properties
+     * @param parseTree Mapping for each function node and corresponding parameters & variables names
+     * @return compressed script
+     */
+    public static String compress(String encodedSource, int flags,
+            UintMap properties, ScriptOrFnNode parseTree){
+        
+         int length = encodedSource.length();
+         if (length == 0) { return ""; }
+         int indent = properties.getInt(INITIAL_INDENT_PROP, 0);
+         if (indent < 0) throw new IllegalArgumentException();
+         int indentGap = properties.getInt(INDENT_GAP_PROP, 4);
+         if (indentGap < 0) throw new IllegalArgumentException();
+         int caseGap = properties.getInt(CASE_GAP_PROP, 2);
+         if (caseGap < 0) throw new IllegalArgumentException();
+         StringBuffer result = new StringBuffer();
+         boolean justFunctionBody = (0 != (flags & Decompiler.ONLY_BODY_FLAG));
+         boolean toSource = (0 != (flags & Decompiler.TO_SOURCE_FLAG));
+         // Spew tokens in source, for debugging.
+         // as TYPE number char
+         if (printSource) {
+             System.err.println("length:" + length);
+             for (int i = 0; i < length; ++i) {
+                 // Note that tokenToName will fail unless Context.printTrees
+                 // is true.
+                 String tokenname = null;
+                 if (Token.printNames) {
+                     tokenname = Token.name(encodedSource.charAt(i));
+                 }
+                 if (tokenname == null) {
+                     tokenname = "---";
+                 }
+                 String pad = tokenname.length() > 7
+                     ? "\t"
+                     : "\t\t";
+                 System.err.println
+                     (tokenname
+                      + pad + (int)encodedSource.charAt(i)
+                      + "\t'" + ScriptRuntime.escapeString
+                      (encodedSource.substring(i, i+1))
+                      + "'");
+             }
+             System.err.println();
+         }
+         int braceNesting = 0;
+         boolean afterFirstEOL = false;
+         int i = 0;
+        int prevToken = 0;
+        boolean primeFunctionNesting = false;
+        boolean inArgsList = false;
+        boolean primeInArgsList = false;
+         int topFunctionType;
+         if (encodedSource.charAt(i) == Token.SCRIPT) {
+             ++i;
+             topFunctionType = -1;
+         } else {
+             topFunctionType = encodedSource.charAt(i + 1);
+         }
+         if (!toSource) {
+             // add an initial newline to exactly match js.
+             // result.append('\n');
+             for (int j = 0; j < indent; j++){
+                 // result.append(' ');
+                 result.append("");
+                }
+         } else {
+             if (topFunctionType == FunctionNode.FUNCTION_EXPRESSION) {
+                 result.append('(');
+             }
+         }
+         while (i < length) {
+                if(i>0){
+                        prevToken = encodedSource.charAt(i-1);
+                }
+                // System.out.println(Token.name(getNext(source, length, i)));
+             switch(encodedSource.charAt(i)) {
+             case Token.NAME:
+             case Token.REGEXP:  // re-wrapped in '/'s in parser...
+                        int jumpPos = getSourceStringEnd(encodedSource, i+1);
+                        if(Token.OBJECTLIT == encodedSource.charAt(jumpPos)){
+                                i = printSourceString(encodedSource, i + 1, false, result);
+                        }else{
+                                i = tm.sourceCompress(  encodedSource, i + 1, false, result, prevToken, 
+                                                                                inArgsList, braceNesting, parseTree);
+                        }
+                 continue;
+             case Token.STRING:
+                 i = printSourceString(encodedSource, i + 1, true, result);
+                 continue;
+             case Token.NUMBER:
+                 i = printSourceNumber(encodedSource, i + 1, result);
+                 continue;
+             case Token.TRUE:
+                 result.append("true");
+                 break;
+             case Token.FALSE:
+                 result.append("false");
+                 break;
+             case Token.NULL:
+                 result.append("null");
+                 break;
+             case Token.THIS:
+                 result.append("this");
+                 break;
+             case Token.FUNCTION:
+                 ++i; // skip function type
+                 tm.functionNum++;
+                        primeInArgsList = true;
+                        primeFunctionNesting = true;
+                 result.append("function");
+                 if (Token.LP != getNext(encodedSource, length, i)) {
+                     result.append(' ');
+                 }
+                 break;
+             case FUNCTION_END:
+                 // Do nothing
+                 break;
+             case Token.COMMA:
+                 result.append(",");
+                 break;
+             case Token.LC:
+                        ++braceNesting;
+                 if (Token.EOL == getNext(encodedSource, length, i)){
+                     indent += indentGap;
+                        }
+                 result.append('{');
+                 // // result.append('\n');
+                 break;
+             case Token.RC: {
+                        tm.leaveNestingLevel(braceNesting);
+                 --braceNesting;
+                 /* don't print the closing RC if it closes the
+                  * toplevel function and we're called from
+                  * decompileFunctionBody.
+                  */
+                 if(justFunctionBody && braceNesting == 0){
+                     break;
+                        }
+                 // // result.append('\n');
+                 result.append('}');
+                 // // result.append(' ');
+                 switch (getNext(encodedSource, length, i)) {
+                     case Token.EOL:
+                     case FUNCTION_END:
+                         indent -= indentGap;
+                         break;
+                     case Token.WHILE:
+                     case Token.ELSE:
+                         indent -= indentGap;
+                         // result.append(' ');
+                         result.append("");
+                         break;
+                 }
+                 break;
+             }
+             case Token.LP:
+                        if(primeInArgsList){
+                                inArgsList = true;
+                                primeInArgsList = false;
+                        }