public void EnterPseudoScope(ast.Node n)
{
SymbolScope currentScope = m_PseudoScopes.Peek();
n.PseudoScope = new SymbolScope(currentScope.Compiler, n, Accessibility.Private);
currentScope.InnerScopes.Add(n.PseudoScope);
n.PseudoScope.OuterScope = currentScope;
m_PseudoScopes.Push(n.PseudoScope);
}
public void EnterScope(SymbolScope Scope)
{
System.Diagnostics.Debug.Assert(Scope.OuterScope == m_CurrentScope);
m_CurrentScope = Scope;
m_SymbolAllocator.EnterScope();
m_MemberAllocator.EnterScope();
// Obfuscate symbols?
if (!Compiler.NoObfuscate)
{
Scope.ObfuscateSymbols(this);
}
}
public bool OnEnterNode(MiniME.ast.Node n)
{
// Descending into an inner scope
if (n.Scope != null)
{
System.Diagnostics.Debug.Assert(n.Scope.OuterScope == currentScope);
currentScope = n.Scope;
}
// Is is a "var <name>=<literal_int_or_double>", inside a function
if (currentScope.OuterScope!=null && n.GetType() == typeof(ast.StatementVariableDeclaration))
{
var vardecl = (ast.StatementVariableDeclaration)n;
foreach (var v in vardecl.Variables)
{
// Must have initial value
if (v.InitialValue == null)
continue;
// Must evaluate to a constant
object val = v.InitialValue.RootNode.EvalConstLiteral();
if (val==null)
continue;
// Must be a number
if (val.GetType() != typeof(long) && val.GetType() != typeof(DoubleLiteral))
continue;
// Find the symbol in the current scope
Symbol s = currentScope.Symbols.FindLocalSymbol(v.Name);
System.Diagnostics.Debug.Assert(s != null);
// Store the constant value for this symbol
if (s.ConstValue == null && s.ConstAllowed)
{
s.ConstValue = val;
}
else
{
s.ConstAllowed = false;
s.ConstValue = null;
}
}
}
return true;
}
public bool OnEnterNode(MiniME.ast.Node n)
{
if (n.Scope != null)
{
currentScope = n.Scope;
}
if (n.PseudoScope!=null)
{
currentPseudoScope=n.PseudoScope;
DetectMultipleDeclarations();
}
// Check 'if' statement
var ifStatement = n as ast.StatementIfElse;
if (ifStatement != null)
{
CheckControlCondition(ifStatement, ifStatement.Condition);
}
// Check 'while' statement
var whileStatement = n as ast.StatementWhile;
if (whileStatement != null)
{
CheckControlCondition(whileStatement, whileStatement.Condition);
}
// Check 'do' statement
var doStatement = n as ast.StatementDoWhile;
if (doStatement != null)
{
CheckControlCondition(doStatement, doStatement.Condition);
}
// Check 'for' statement
var forStatement = n as ast.StatementFor;
if (forStatement != null)
{
CheckControlCondition(forStatement, forStatement.Condition);
}
// Check for variable used outself declaring pseudo scope
var ident = n as ast.ExprNodeIdentifier;
if (ident!=null && ident.Lhs == null)
{
var symbol=currentScope.FindLocalSymbol(ident.Name);
if (symbol!=null)
{
// Now walk the pseudo scopes and make sure that it's defined in the current scope too
// (and not in a child scope)
var scope = currentPseudoScope;
bool bFound=false;
while (scope != null && !bFound)
{
// Check scope
if (scope.FindLocalSymbol(ident.Name) != null)
{
bFound = true;
break;
}
// Are we finished on the actual local scope
if (scope.Node!=null && scope.Node.Scope != null)
break;
// Get next outer scope
scope = scope.OuterScope;
}
if (!bFound)
{
currentScope.Compiler.RecordWarning(n.Bookmark, "symbol `{0}` used outside declaring pseudo scope", ident.Name);
foreach (var decl in symbol.Declarations)
{
currentScope.Compiler.RecordWarning(decl, n.Bookmark, "see also declaration of `{0}`", ident.Name);
}
}
}
}
return true;
}
// Constructor
public VisitorLint(SymbolScope rootScope, SymbolScope rootPseudoScope)
{
currentScope = rootScope;
currentPseudoScope = rootPseudoScope;
DetectMultipleDeclarations();
}
// Constructor
public VisitorScopeBuilder(SymbolScope rootScope, SymbolScope rootPseudoScope)
{
m_Scopes.Push(rootScope);
m_PseudoScopes.Push(rootPseudoScope);
}
public void OnLeaveNode(MiniME.ast.Node n)
{
if (n.Scope != null)
{
currentScope = n.Scope.OuterScope;
}
}
public VisitorConstDetectorPass1(SymbolScope rootScope)
{
currentScope = rootScope;
}
public bool OnEnterNode(MiniME.ast.Node n)
{
// Descending into an inner scope
if (n.Scope != null)
{
System.Diagnostics.Debug.Assert(n.Scope.OuterScope == currentScope);
currentScope = n.Scope;
}
// Look for assignments to property
if (n.GetType() == typeof(ast.ExprNodeAssignment))
{
// Is it an assignment
var assignOp = (ast.ExprNodeAssignment)n;
RejectConstVariable(assignOp.Lhs);
}
// Look for increment/decrement operators
if (n.GetType() == typeof(ast.ExprNodeUnary))
{
var oneOp = (ast.ExprNodeUnary)n;
if (oneOp.Op == Token.increment || oneOp.Op == Token.decrement)
{
RejectConstVariable(oneOp.Rhs);
}
}
// Postfix too
if (n.GetType() == typeof(ast.ExprNodePostfix))
{
var oneOp = (ast.ExprNodePostfix)n;
if (oneOp.Op == Token.increment || oneOp.Op == Token.decrement)
{
RejectConstVariable(oneOp.Lhs);
}
}
return true;
}
// Constructor
public VisitorSymbolDeclaration(SymbolScope rootScope, SymbolScope rootPseudoScope)
{
currentScope = rootScope;
currentPseudoScope = rootPseudoScope;
}
public void EnterScope(SymbolScope Scope)
{
System.Diagnostics.Debug.Assert(Scope.OuterScope == m_CurrentScope);
m_CurrentScope = Scope;
m_SymbolAllocator.EnterScope();
m_MemberAllocator.EnterScope();
// Obfuscate symbols?
if (!Compiler.NoObfuscate)
Scope.ObfuscateSymbols(this);
}
// Constructor
public VisitorLint(SymbolScope rootScope, SymbolScope rootPseudoScope)
{
currentScope = rootScope;
currentPseudoScope = rootPseudoScope;
DetectMultipleDeclarations();
}
public VisitorConstDetectorPass1(SymbolScope rootScope)
{
currentScope = rootScope;
}
public VisitorCombineVarDecl(SymbolScope rootScope)
{
}
public bool OnEnterNode(ast.Node n)
{
// New actual scope (function body or catch clause)
if (n.GetType() == typeof(ast.ExprNodeFunction) || n.GetType() == typeof(ast.CatchClause))
{
SymbolScope currentScope = m_Scopes.Peek();
n.Scope = new SymbolScope(currentScope.Compiler, n, Accessibility.Private);
// Add this function to the parent function's list of nested functions
currentScope.InnerScopes.Add(n.Scope);
n.Scope.OuterScope = currentScope;
// Enter scope
m_Scopes.Push(n.Scope);
// Also create a pseudo scope
EnterPseudoScope(n);
return(true);
}
// New pseudo scope (statement body or braced code block)
if (n.GetType() == typeof(ast.CodeBlock) || n.GetType() == typeof(ast.StatementBlock) || n.GetType() == typeof(ast.StatementFor) || n.GetType() == typeof(ast.StatementForIn))
{
// Create pseudo scope
EnterPseudoScope(n);
return(true);
}
// Is it an evil?
if (n.GetType() == typeof(ast.StatementWith))
{
m_Scopes.Peek().Compiler.RecordWarning(n.Bookmark, "use of `with` statement prevents local symbol obfuscation of all containing scopes");
m_Scopes.Peek().DefaultAccessibility = Accessibility.Public;
return(true);
}
// More evil
if (n.GetType() == typeof(ast.ExprNodeIdentifier))
{
var m = (ast.ExprNodeIdentifier)n;
if (m.Lhs == null && m.Name == "eval")
{
m_Scopes.Peek().Compiler.RecordWarning(n.Bookmark, "use of `eval` prevents local symbol obfuscation of all containing scopes");
m_Scopes.Peek().DefaultAccessibility = Accessibility.Public;
}
return(true);
}
// Private member declaration?
if (n.GetType() == typeof(ast.StatementAccessibility))
{
var p = (ast.StatementAccessibility)n;
foreach (var s in p.Specs)
{
m_Scopes.Peek().AddAccessibilitySpec(p.Bookmark, s);
}
}
// Try to guess name of function by assignment in variable declaration
var decl = n as ast.StatementVariableDeclaration;
if (decl != null)
{
foreach (var i in decl.Variables)
{
if (i.InitialValue != null)
{
var fn = i.InitialValue.RootNode as ast.ExprNodeFunction;
if (fn != null)
{
fn.AssignedToName = i.Name;
}
}
}
}
// Try to guess name of function by assignment
var assignment = n as ast.ExprNodeAssignment;
if (assignment != null)
{
var fn = assignment.Rhs as ast.ExprNodeFunction;
if (fn != null)
{
var id = assignment.Lhs as ast.ExprNodeIdentifier;
if (id != null)
{
fn.AssignedToName = id.Name;
}
}
}
// Try to guess name of function in object literal
var objLiteral = n as ast.ExprNodeObjectLiteral;
if (objLiteral != null)
{
foreach (var i in objLiteral.Values)
{
var fn = i.Value as ast.ExprNodeFunction;
if (fn != null)
{
var id = i.Key as ast.ExprNodeIdentifier;
if (id != null)
{
fn.AssignedToName = id.Name;
}
}
}
}
return(true);
}
// Constructor
public VisitorSymbolDeclaration(SymbolScope rootScope, SymbolScope rootPseudoScope)
{
currentScope = rootScope;
currentPseudoScope = rootPseudoScope;
}
public bool OnEnterNode(MiniME.ast.Node n)
{
// Define name of function in outer scope, before descending
if (n.GetType() == typeof(ast.ExprNodeFunction))
{
var fn = (ast.ExprNodeFunction)n;
// Define a symbol for the new function
if (!String.IsNullOrEmpty(fn.Name))
{
DefineLocalSymbol(fn.Name, fn.Bookmark);
currentScope.ProcessAccessibilitySpecs(fn.Name, fn.Bookmark);
}
}
// Descending into an inner scope
if (n.Scope != null)
{
System.Diagnostics.Debug.Assert(n.Scope.OuterScope == currentScope);
currentScope = n.Scope;
}
// Descending into an inner pseudo scope
if (n.PseudoScope != null)
{
System.Diagnostics.Debug.Assert(n.PseudoScope.OuterScope == currentPseudoScope);
currentPseudoScope = n.PseudoScope;
}
// Define catch clause exception variables in the inner scope
if (n.GetType() == typeof(ast.CatchClause))
{
var cc = (ast.CatchClause)n;
DefineLocalSymbol(cc.ExceptionVariable, n.Bookmark);
return true;
}
// Define variables in the current scope
if (n.GetType() == typeof(ast.StatementVariableDeclaration))
{
var vardecl = (ast.StatementVariableDeclaration)n;
foreach (var v in vardecl.Variables)
{
DefineLocalSymbol(v.Name, v.Bookmark);
currentScope.ProcessAccessibilitySpecs(v.Name, v.Bookmark);
if (v.InitialValue!=null && v.InitialValue.RootNode.GetType()==typeof(ast.ExprNodeObjectLiteral))
{
// Get the object literal
var literal=(ast.ExprNodeObjectLiteral)v.InitialValue.RootNode;
// Create a fake/temp identifier node while we process accessibility specs
var target = new ast.ExprNodeIdentifier(null, v.Name);
// Process all keys that are identifiers
foreach (var x in literal.Values)
{
var identifierKey=x.Key as ast.ExprNodeIdentifier;
if (identifierKey!=null && identifierKey.Lhs==null)
{
currentScope.ProcessAccessibilitySpecs(target, identifierKey.Name, identifierKey.Bookmark);
}
}
}
}
return true;
}
// Define parameters in the current scope
if (n.GetType() == typeof(ast.Parameter))
{
var p = (ast.Parameter)n;
DefineLocalSymbol(p.Name, p.Bookmark);
currentScope.ProcessAccessibilitySpecs(p.Name, p.Bookmark);
return true;
}
// Automatic declaration of private member?
// We're looking for an assignment to a matching private spec
if (n.GetType() == typeof(ast.StatementExpression))
{
var exprstmt = (ast.StatementExpression)n;
if (exprstmt.Expression.RootNode.GetType()==typeof(ast.ExprNodeAssignment))
{
var assignOp = (ast.ExprNodeAssignment)exprstmt.Expression.RootNode;
if (assignOp.Op == Token.assign)
{
// Lhs must be an identifier member
// eg: target.member=<expr>
if (assignOp.Lhs.GetType()==typeof(ast.ExprNodeIdentifier))
{
var identifier=(ast.ExprNodeIdentifier)assignOp.Lhs;
if (identifier.Lhs!=null)
{
// For member specs, the identifier must have a lhs
if (identifier.Lhs.GetType() != typeof(ast.ExprNodeIdentifier))
return false;
currentScope.ProcessAccessibilitySpecs((ast.ExprNodeIdentifier)identifier.Lhs, identifier.Name, identifier.Bookmark);
}
}
// Assignment of an object literal
// eg: target={member:value,member:value};
if (assignOp.Lhs.GetType() == typeof(ast.ExprNodeIdentifier) &&
assignOp.Rhs.GetType() == typeof(ast.ExprNodeObjectLiteral))
{
var target = (ast.ExprNodeIdentifier)assignOp.Lhs;
var literal=(ast.ExprNodeObjectLiteral)assignOp.Rhs;
if (target.Lhs == null)
{
foreach (var x in literal.Values)
{
var identifierKey=x.Key as ast.ExprNodeIdentifier;
if (identifierKey!=null && identifierKey.Lhs==null)
{
currentScope.ProcessAccessibilitySpecs(target, identifierKey.Name, identifierKey.Bookmark);
}
}
}
}
/*
if (assignOp.Rhs.GetType() == typeof(ast.ExprNodeObjectLiteral))
{
var literal=ast.ExprNode
}
*/
}
}
}
// Normally accessibility specs are already processed in the scope builder, but this
// is a special case for declaring external symbols. We need to pick up the explicit
// symbol declaration and add it to the pseudo scope to avoid incorrect warnings.
// Use case is declaring `x` as an external global var by:
//
// // public:x
//
if (n.GetType() == typeof(ast.StatementAccessibility))
{
var p = (ast.StatementAccessibility)n;
foreach (var s in p.Specs)
{
if (!s.IsWildcard() && !s.IsMemberSpec())
currentPseudoScope.Symbols.DefineSymbol(s.GetExplicitName(), n.Bookmark);
}
}
return true;
}
public void LeaveScope()
{
m_SymbolAllocator.LeaveScope();
m_MemberAllocator.LeaveScope();
m_CurrentScope = m_CurrentScope.OuterScope;
}
// Constructor
public VisitorSymbolUsage(SymbolScope rootScope)
{
currentScope = rootScope;
}
/// <summary>
/// Parses all loaded scripts as javascript and compiles them to a string.
/// </summary>
/// <returns>A string containing the minified javascript.</returns>
public string CompileJavascriptToString()
{
// Create a symbol allocator
SymbolAllocator SymbolAllocator = new SymbolAllocator(this);
// Don't let the symbol allocator use any reserved words or common Javascript bits
// We only go up to three letters - symbol allocation of more than 3 letters is
// highly unlikely.
// (based on list here: http://www.quackit.com/javascript/javascript_reserved_words.cfm)
string[] words = new string[] { "if", "in", "do", "for", "new", "var", "int", "try", "NaN", "ref", "sun", "top" };
foreach (var s in words)
{
SymbolAllocator.ClaimSymbol(s);
}
// Create a member allocator
SymbolAllocator MemberAllocator = new SymbolAllocator(this);
// Render
RenderContext r = new RenderContext(this, SymbolAllocator, MemberAllocator);
// Process all files
bool bNeedSemicolon = false;
foreach (var file in m_files)
{
Console.WriteLine("Processing {0}...", System.IO.Path.GetFileName(file.filename));
// Create a tokenizer and parser
Warnings = new List<Warning>();
WarningsEnabledStack = new Stack<bool>();
Tokenizer t = new Tokenizer(this, file.content, file.filename, file.warnings);
Parser p = new Parser(t);
// Create the global statement block
var code = new ast.CodeBlock(null, TriState.No);
// Parse the file into a namespace
p.ParseStatements(code);
// Ensure everything processed
if (t.more)
{
throw new CompileError("Unexpected end of file", t);
}
// Dump the abstract syntax tree
if (DumpAST)
code.Dump(0);
// Create the root symbol scope and build scopes for all
// constained function scopes
SymbolScope rootScope = new SymbolScope(this, null, Accessibility.Public);
SymbolScope rootPseudoScope = new SymbolScope(this, null, Accessibility.Public);
code.Visit(new VisitorScopeBuilder(rootScope, rootPseudoScope));
// Combine consecutive var declarations into a single one
code.Visit(new VisitorCombineVarDecl(rootScope));
// Find all variable declarations
code.Visit(new VisitorSymbolDeclaration(rootScope, rootPseudoScope));
// Do lint stuff
code.Visit(new VisitorLint(rootScope, rootPseudoScope));
// Try to eliminate const declarations
if (DetectConsts && !NoObfuscate)
{
code.Visit(new VisitorConstDetectorPass1(rootScope));
code.Visit(new VisitorConstDetectorPass2(rootScope));
code.Visit(new VisitorConstDetectorPass3(rootScope));
}
// Simplify expressions
code.Visit(new VisitorSimplifyExpressions());
// If obfuscation is allowed, find all in-scope symbols and then
// count the frequency of their use.
if (!NoObfuscate)
{
code.Visit(new VisitorSymbolUsage(rootScope));
}
// Process all symbol scopes, applying default accessibility levels
// and determining the "rank" of each symbol
rootScope.Prepare();
// Dump scopes to stdout
if (DumpScopes)
rootScope.Dump(0);
// Tell the global scope to claim all locally defined symbols
// so they're not re-used (and therefore hidden) by the
// symbol allocation
rootScope.ClaimSymbols(SymbolAllocator);
// Create a credit comment on the first file
if (!NoCredit && file==m_files[0])
{
int iInsertPos = 0;
while (iInsertPos < code.Content.Count && code.Content[iInsertPos].GetType() == typeof(ast.StatementComment))
iInsertPos++;
code.Content.Insert(iInsertPos, new ast.StatementComment(null, "// Minified by MiniME from toptensoftware.com"));
}
if (bNeedSemicolon)
{
r.Append(";");
}
// Render it
r.EnterScope(rootScope);
bNeedSemicolon=code.Render(r);
r.LeaveScope();
// Display warnings
Warnings.Sort(delegate(Warning w1, Warning w2)
{
int Compare = w1.Order.file.FileName.CompareTo(w2.Order.file.FileName);
if (Compare == 0)
Compare = w1.Order.position - w2.Order.position;
if (Compare == 0)
Compare = w1.OriginalOrder - w2.OriginalOrder;
return Compare;
});
foreach (var w in Warnings)
{
Console.WriteLine("{0}: {1}", w.Bookmark, w.Message);
}
}
// return the final script
string strResult = r.GetGeneratedOutput();
return strResult;
}
public bool OnEnterNode(MiniME.ast.Node n)
{
// Descending into an inner scope
if (n.Scope != null)
{
System.Diagnostics.Debug.Assert(n.Scope.OuterScope == currentScope);
currentScope = n.Scope;
}
// Is it a variable declaration
if (n.GetType() == typeof(ast.StatementVariableDeclaration))
{
var vardecl = (ast.StatementVariableDeclaration)n;
for (int i = vardecl.Variables.Count - 1; i >= 0; i-- )
{
var v = vardecl.Variables[i];
// Find the symbol (must exist in current scope)
var s = currentScope.Symbols.FindLocalSymbol(v.Name);
System.Diagnostics.Debug.Assert(s != null);
// Is it a const?
if (s.ConstValue != null)
{
// Yes! Remove it
vardecl.Variables.RemoveAt(i);
}
}
}
return true;
}
// Constructor
public VisitorSymbolUsage(SymbolScope rootScope)
{
currentScope = rootScope;
}
public bool OnEnterNode(MiniME.ast.Node n)
{
// Define name of function in outer scope, before descending
if (n.GetType() == typeof(ast.ExprNodeFunction))
{
var fn = (ast.ExprNodeFunction)n;
// Define a symbol for the new function
if (!String.IsNullOrEmpty(fn.Name))
{
currentScope.Symbols.UseSymbol(fn.Name);
}
}
// Descending into an inner scope
if (n.Scope != null)
{
System.Diagnostics.Debug.Assert(n.Scope.OuterScope == currentScope);
currentScope = n.Scope;
}
// Identifier?
if (n.GetType() == typeof(ast.ExprNodeIdentifier))
{
var m = (ast.ExprNodeIdentifier)n;
if (m.Lhs == null)
{
currentScope.Symbols.UseSymbol(m.Name);
}
else
{
currentScope.Members.UseSymbol(m.Name);
}
}
// Use catch clause exception variables in the inner scope
if (n.GetType() == typeof(ast.CatchClause))
{
var cc = (ast.CatchClause)n;
currentScope.Symbols.UseSymbol(cc.ExceptionVariable);
return true;
}
// Use variables in the current scope
if (n.GetType() == typeof(ast.StatementVariableDeclaration))
{
var vardecl = (ast.StatementVariableDeclaration)n;
foreach (var v in vardecl.Variables)
{
currentScope.Symbols.UseSymbol(v.Name);
}
return true;
}
// Use parameters in the current scope
if (n.GetType() == typeof(ast.Parameter))
{
var p = (ast.Parameter)n;
currentScope.Symbols.UseSymbol(p.Name);
return true;
}
// Look for assignment to undefined variable
if (n.GetType() == typeof(ast.ExprNodeAssignment))
{
var rtlOp = (ast.ExprNodeAssignment)n;
if (rtlOp.Op == Token.assign)
{
if (rtlOp.Lhs.GetType() == typeof(ast.ExprNodeIdentifier))
{
var identifier = (ast.ExprNodeIdentifier)rtlOp.Lhs;
if (identifier.Lhs == null)
{
// Assignment to an identifier
if (currentScope.FindSymbol(identifier.Name) == null)
{
currentScope.Compiler.RecordWarning(identifier.Bookmark, "assignment to undeclared variable `{0}` introduces new global variable", identifier.Name);
}
}
}
}
}
return true;
}
// Compile all loaded script to a string
public string CompileJavascriptToString()
{
// Create a symbol allocator
SymbolAllocator SymbolAllocator = new SymbolAllocator(this);
// Don't let the symbol allocator use any reserved words or common Javascript bits
// We only go up to three letters - symbol allocation of more than 3 letters is
// highly unlikely.
// (based on list here: http://www.quackit.com/javascript/javascript_reserved_words.cfm)
string[] words = new string[] { "if", "in", "do", "for", "new", "var", "int", "try", "NaN", "ref", "sun", "top" };
foreach (var s in words)
{
SymbolAllocator.ClaimSymbol(s);
}
// Create a member allocator
SymbolAllocator MemberAllocator = new SymbolAllocator(this);
// Render
RenderContext r = new RenderContext(this, SymbolAllocator, MemberAllocator);
// Process all files
bool bNeedSemicolon = false;
foreach (var file in m_files)
{
Console.WriteLine("Processing {0}...", System.IO.Path.GetFileName(file.filename));
// Create a tokenizer and parser
Warnings = new List <Warning>();
WarningsEnabledStack = new Stack <bool>();
Tokenizer t = new Tokenizer(this, file.content, file.filename, file.warnings);
Parser p = new Parser(t);
// Create the global statement block
var code = new ast.CodeBlock(null, TriState.No);
// Parse the file into a namespace
p.ParseStatements(code);
// Ensure everything processed
if (t.more)
{
throw new CompileError("Unexpected end of file", t);
}
// Dump the abstract syntax tree
if (DumpAST)
{
code.Dump(0);
}
// Create the root symbol scope and build scopes for all
// constained function scopes
SymbolScope rootScope = new SymbolScope(this, null, Accessibility.Public);
SymbolScope rootPseudoScope = new SymbolScope(this, null, Accessibility.Public);
code.Visit(new VisitorScopeBuilder(rootScope, rootPseudoScope));
// Combine consecutive var declarations into a single one
code.Visit(new VisitorCombineVarDecl(rootScope));
// Find all variable declarations
code.Visit(new VisitorSymbolDeclaration(rootScope, rootPseudoScope));
// Do lint stuff
code.Visit(new VisitorLint(rootScope, rootPseudoScope));
// Try to eliminate const declarations
if (DetectConsts && !NoObfuscate)
{
code.Visit(new VisitorConstDetectorPass1(rootScope));
code.Visit(new VisitorConstDetectorPass2(rootScope));
code.Visit(new VisitorConstDetectorPass3(rootScope));
}
// Simplify expressions
code.Visit(new VisitorSimplifyExpressions());
// If obfuscation is allowed, find all in-scope symbols and then
// count the frequency of their use.
if (!NoObfuscate)
{
code.Visit(new VisitorSymbolUsage(rootScope));
}
// Process all symbol scopes, applying default accessibility levels
// and determining the "rank" of each symbol
rootScope.Prepare();
// Dump scopes to stdout
if (DumpScopes)
{
rootScope.Dump(0);
}
// Tell the global scope to claim all locally defined symbols
// so they're not re-used (and therefore hidden) by the
// symbol allocation
rootScope.ClaimSymbols(SymbolAllocator);
// Create a credit comment on the first file
if (!NoCredit && file == m_files[0])
{
int iInsertPos = 0;
while (iInsertPos < code.Content.Count && code.Content[iInsertPos].GetType() == typeof(ast.StatementComment))
{
iInsertPos++;
}
code.Content.Insert(iInsertPos, new ast.StatementComment(null, "// Minified by MiniME from toptensoftware.com"));
}
if (bNeedSemicolon)
{
r.Append(";");
}
// Render it
r.EnterScope(rootScope);
bNeedSemicolon = code.Render(r);
r.LeaveScope();
// Display warnings
Warnings.Sort(delegate(Warning w1, Warning w2)
{
int Compare = w1.Order.file.FileName.CompareTo(w2.Order.file.FileName);
if (Compare == 0)
{
Compare = w1.Order.position - w2.Order.position;
}
if (Compare == 0)
{
Compare = w1.OriginalOrder - w2.OriginalOrder;
}
return(Compare);
});
foreach (var w in Warnings)
{
Console.WriteLine("{0}: {1}", w.Bookmark, w.Message);
}
}
// return the final script
string strResult = r.GetGeneratedOutput();
return(strResult);
}
public VisitorCombineVarDecl(SymbolScope rootScope)
{
}
// Constructor
public VisitorScopeBuilder(SymbolScope rootScope, SymbolScope rootPseudoScope)
{
m_Scopes.Push(rootScope);
m_PseudoScopes.Push(rootPseudoScope);
}
