/*
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Rhino code, released
* May 6, 1999.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1997-1999
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Alex Russell
* Richard Backhouse
*/
package org.dojotoolkit.shrinksafe;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.mozilla.javascript.ScriptOrFnNode;
import org.mozilla.javascript.ScriptRuntime;
import org.mozilla.javascript.Token;
public class TokenMapper {
private List functionBracePositions = new ArrayList();
/**
* Map of all replaced tokens
*/
private List replacedTokens = new ArrayList();
/**
* 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 List functionVarMappings = new ArrayList();
private Map debugDataList = new HashMap();
private int functionNum = 0;
private int parentScope = 0;
private int lastTokenCount = 0;
public TokenMapper(ScriptOrFnNode parseTree) {
collectFunctionMappings(parseTree);
}
public void incrementFunctionNumber() {
functionNum++;
}
/**
* 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;
Map 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))) {
newToken = new String("_" + Integer.toHexString(++lastTokenCount));
if (newToken.length() >= token.length() && token.charAt(0) != '_') {
newToken = token;
lastTokenCount--;
}
tokens = (Map) replacedTokens.get(hasNewMapping ? localScope : 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();
Map chainedScopeVars = (Map) 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) {
Map tokens = (Map) (replacedTokens.get(scope));
if (tokens.containsKey(token)) {
result = (String) tokens.get(token);
return result;
}
} else {
for (int i = scope; i > -1; i--) {
Map tokens = (Map) (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, null);
}
/**
* 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 void collectFuncNodes(ScriptOrFnNode parseTree, int level, ScriptOrFnNode parent) {
level++;
DebugData debugData = new DebugData();
debugData.start = parseTree.getBaseLineno();
debugData.end = parseTree.getEndLineno();
debugData.paramAndVarNames = parseTree.getParamAndVarNames();
debugDataList.put(new Integer(parseTree.getEncodedSourceStart()), debugData);
functionVarMappings.add(new HashMap());
Map bindingNames = (Map) functionVarMappings.get(functionVarMappings.size() - 1);
bindingNames.put(new Integer(level), parseTree.getParamAndVarNames());
if (parent != null) {
bindingNames.put(new Integer(level-1), parent.getParamAndVarNames());
}
int nestedCount = parseTree.getFunctionCount();
for (int i = 0; i != nestedCount; ++i) {
collectFuncNodes(parseTree.getFunctionNode(i), level, parseTree);
bindingNames = (Map) 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, ReplacedTokens replacedTokens) {
boolean hasNewMapping = false;
int length = encodedSource.charAt(offset);
++offset;
if ((0x8000 & length) != 0) {
length = ((0x7FFF & length) << 16) | encodedSource.charAt(offset);
++offset;
}
String str = encodedSource.substring(offset, offset + length);
if ((prevToken == Token.VAR) || (inArgsList)) {
hasNewMapping = true;
}
if (sb != null) {
String sourceStr = new String(str);
if (((functionBracePositions.size() > 0) &&
(currentLevel >= (((Integer) functionBracePositions.get(functionBracePositions.size() - 1)).intValue()))) ||
(inArgsList)) {
if (prevToken != Token.DOT) {
// Look for replacement token in provided lookup object.
str = replacedTokens.find(str);
}
}
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('"');
}
}
else if (((functionBracePositions.size() > 0) &&
(currentLevel >= (((Integer) functionBracePositions.get(functionBracePositions.size() - 1)).intValue()))) ||
(inArgsList)) {
if (prevToken != Token.DOT) {
getMappedToken(str, hasNewMapping);
}
}
return offset + length;
}
public void enterNestingLevel(int braceNesting) {
functionBracePositions.add(new Integer(braceNesting + 1));
replacedTokens.add(new HashMap());
}
public boolean leaveNestingLevel(int braceNesting) {
boolean tokensRemoved = false;
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);
tokensRemoved = true;
}
return tokensRemoved;
}
public Map getCurrentTokens() {
Map m = null;
if (replacedTokens.size() > 0) {
m = (Map)replacedTokens.get(replacedTokens.size() - 1);
}
return m;
}
public DebugData getDebugData(Integer functionPosition) {
return (DebugData)debugDataList.get(functionPosition);
}
public void reset() {
functionNum = 0;
parentScope = 0;
lastTokenCount = 0;
functionBracePositions = new ArrayList();
replacedTokens = new ArrayList();
}
}