public override bool Render(RenderContext dest)
{
dest.Append("with(");
Expression.Render(dest);
dest.Append(")");
return Code.RenderIndented(dest);
}
public override bool Render(RenderContext dest)
{
dest.Append("with(");
Expression.Render(dest);
dest.Append(")");
return(Code.RenderIndented(dest));
}
public override bool Render(RenderContext dest)
{
dest.Append("(");
Inner.Render(dest);
dest.Append(")");
return(true);
}
public override bool Render(RenderContext dest)
{
dest.Append("while(");
Condition.Render(dest);
dest.Append(")");
return(Code.RenderIndented(dest));
}
public override bool Render(RenderContext dest)
{
// LHS
WrapAndRender(dest, Lhs, false);
foreach (var t in Terms)
{
// Operator
switch (t.Op)
{
case Token.add:
dest.Append("+");
// Prevent `lhs + ++rhs` from becoming `lhs+++rhs` (which would incorrectly be interpreted as `lhs++ + rhs`)
dest.NeedSpaceIf('+');
break;
case Token.subtract:
dest.Append("-");
// Prevent `lhs - --rhs` from becoming `lhs---rhs` (which would incorrectly be interpreted as `lhs-- - rhs`)
// Also prevent `lhs- -rhs` from become `lhs--rhs` (which would incorrectly be interpreted as `lhs-- rhs`)
dest.NeedSpaceIf('-');
break;
case Token.multiply:
case Token.divide:
case Token.modulus:
case Token.shl:
case Token.shr:
case Token.shrz:
case Token.compareEQ:
case Token.compareNE:
case Token.compareLT:
case Token.compareLE:
case Token.compareGT:
case Token.compareGE:
case Token.compareEQStrict:
case Token.compareNEStrict:
case Token.bitwiseXor:
case Token.bitwiseOr:
case Token.bitwiseAnd:
case Token.logicalOr:
case Token.logicalAnd:
case Token.kw_in:
case Token.kw_instanceof:
dest.Append(Tokenizer.FormatToken(t.Op));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
// RHS
WrapAndRender(dest, t.Rhs, true);
}
return(true);
}
public override bool Render(RenderContext dest)
{
dest.Append("while(");
Condition.Render(dest);
dest.Append(")");
return Code.RenderIndented(dest);
}
public override bool Render(RenderContext dest)
{
switch (Op)
{
case Token.kw_typeof:
case Token.kw_void:
case Token.kw_delete:
dest.Append(Op.ToString().Substring(3));
break;
case Token.add:
break;
case Token.subtract:
dest.Append('-');
dest.NeedSpaceIf('-');
break;
case Token.bitwiseNot:
case Token.logicalNot:
case Token.increment:
case Token.decrement:
dest.Append(Tokenizer.FormatToken(Op));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
// RHS
WrapAndRender(dest, Rhs, false);
return(true);
}
public override bool Render(RenderContext dest)
{
dest.Append("(");
Inner.Render(dest);
dest.Append(")");
return true;
}
public override bool Render(RenderContext dest)
{
dest.DisableLineBreaks();
dest.Append(Label);
dest.Append(':');
dest.EnableLineBreaks();
return(false);
}
public override bool Render(RenderContext dest)
{
dest.DisableLineBreaks();
dest.Append(Label);
dest.Append(':');
dest.EnableLineBreaks();
return false;
}
public override bool Render(RenderContext dest)
{
WrapAndRender(dest, Condition, false);
dest.Append('?');
WrapAndRender(dest, TrueResult, false);
dest.Append(':');
WrapAndRender(dest, FalseResult, false);
return(true);
}
public override bool Render(RenderContext dest)
{
WrapAndRender(dest, Condition, false);
dest.Append('?');
WrapAndRender(dest, TrueResult, false);
dest.Append(':');
WrapAndRender(dest, FalseResult, false);
return true;
}
public override bool Render(RenderContext dest)
{
// Render the statement, need special handling to insert
// a space if don't have a braced statement block
dest.Append("do");
if (Code.RenderIndented(dest))
dest.Append(';');
dest.StartLine();
dest.Append("while(");
Condition.Render(dest);
dest.Append(')');
return false;
}
public override bool Render(RenderContext dest)
{
if (Value == null)
{
dest.Append(Op.ToString().Substring(3));
return true;
}
dest.DisableLineBreaks();
dest.Append(Op.ToString().Substring(3));
dest.EnableLineBreaksAfterNextWrite();
Value.Render(dest);
return true;
}
public override bool Render(RenderContext dest)
{
if (Op == Token.kw_fallthrough)
return false;
dest.DisableLineBreaks();
dest.Append(Op.ToString().Substring(3));
if (Label != null)
{
dest.Append(Label);
}
dest.EnableLineBreaks();
return true;
}
public override bool Render(RenderContext dest)
{
WrapAndRender(dest, Lhs, false);
dest.Append("(");
bool first = true;
foreach (var a in Arguments)
{
if (!first)
dest.Append(",");
a.Render(dest);
first = false;
}
dest.Append(")");
return true;
}
public override bool Render(RenderContext dest)
{
if (Value == null)
{
dest.Append(Op.ToString().Substring(3));
return(true);
}
dest.DisableLineBreaks();
dest.Append(Op.ToString().Substring(3));
dest.EnableLineBreaksAfterNextWrite();
Value.Render(dest);
return(true);
}
public override bool Render(RenderContext dest)
{
// Render the statement, need special handling to insert
// a space if don't have a braced statement block
dest.Append("do");
if (Code.RenderIndented(dest))
{
dest.Append(';');
}
dest.StartLine();
dest.Append("while(");
Condition.Render(dest);
dest.Append(')');
return(false);
}
public override bool Render(RenderContext dest)
{
if (Op == Token.kw_fallthrough)
{
return(false);
}
dest.DisableLineBreaks();
dest.Append(Op.ToString().Substring(3));
if (Label != null)
{
dest.Append(Label);
}
dest.EnableLineBreaks();
return(true);
}
public override bool Render(RenderContext dest)
{
dest.ForceLineBreak();
dest.Append(Comment);
dest.ForceLineBreak();
return(false);
}
public override bool Render(RenderContext dest)
{
dest.Append('[');
bool bFirst = true;
foreach (var e in Values)
{
if (!bFirst)
dest.Append(",");
else
bFirst = false;
if (e!=null)
WrapAndRender(dest, e, false);
}
dest.Append(']');
return true;
}
public override bool Render(RenderContext dest)
{
dest.Append("for(");
if (VariableDeclaration != null)
{
VariableDeclaration.Render(dest);
}
else
{
Iterator.Render(dest);
}
dest.Append("in");
Collection.Render(dest);
dest.Append(")");
return(Code.RenderIndented(dest));
}
// Render an child node, wrapping it in parentheses if necessary
public void WrapAndRender(RenderContext dest, ExprNode other, bool bWrapEqualPrecedence)
{
var precOther = other.GetPrecedence();
var precThis = this.GetPrecedence();
if (precOther < precThis || (precOther == precThis && bWrapEqualPrecedence))
{
dest.Append("(");
other.Render(dest);
dest.Append(")");
}
else
{
other.Render(dest);
}
}
public override bool Render(RenderContext dest)
{
dest.ForceLineBreak();
dest.Append(Comment);
dest.ForceLineBreak();
return false;
}
public override bool Render(RenderContext dest)
{
// LHS
WrapAndRender(dest, Lhs, false);
// Operator
switch (Op)
{
case Token.assign:
case Token.addAssign:
case Token.subtractAssign:
case Token.multiplyAssign:
case Token.divideAssign:
case Token.modulusAssign:
case Token.shlAssign:
case Token.shrAssign:
case Token.shrzAssign:
case Token.bitwiseXorAssign:
case Token.bitwiseOrAssign:
case Token.bitwiseAndAssign:
dest.Append(Tokenizer.FormatToken(Op));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
// RHS
WrapAndRender(dest, Rhs, true);
return(true);
}
public override bool Render(RenderContext dest)
{
// Check for new Object and new Array
var id = ObjectType as ast.ExprNodeIdentifier;
if (id != null && id.Lhs == null)
{
if (id.Name == "Object" && Arguments.Count == 0)
{
dest.Append("{}");
return(true);
}
if (id.Name == "Array")
{
if (Arguments.Count != 1)
{
dest.Append("[");
bool first = true;
foreach (var a in Arguments)
{
if (!first)
{
dest.Append(",");
}
a.Render(dest);
first = false;
}
dest.Append("]");
return(true);
}
else
{
dest.Compiler.RecordWarning(Bookmark, "use of `new Array()` with one argument creates a sized array - are you sure?");
}
}
}
dest.Append("new");
WrapAndRender(dest, ObjectType, false);
dest.Append("(");
bool bFirst = true;
foreach (var a in Arguments)
{
if (!bFirst)
{
dest.Append(",");
}
a.Render(dest);
bFirst = false;
}
dest.Append(")");
return(true);
}
public override bool Render(RenderContext dest)
{
WrapAndRender(dest, Lhs, false);
dest.Append("(");
bool first = true;
foreach (var a in Arguments)
{
if (!first)
{
dest.Append(",");
}
a.Render(dest);
first = false;
}
dest.Append(")");
return(true);
}
public override bool Render(RenderContext dest)
{
WrapAndRender(dest, Lhs, false);
string str = GetIdentifier();
if (str != null)
{
dest.Append('.');
dest.Append(str);
}
else
{
dest.Append("[");
Index.Render(dest);
dest.Append("]");
}
return true;
}
public override bool Render(RenderContext dest)
{
WrapAndRender(dest, Lhs, false);
string str = GetIdentifier();
if (str != null)
{
dest.Append('.');
dest.Append(str);
}
else
{
dest.Append("[");
Index.Render(dest);
dest.Append("]");
}
return true;
}
public override bool Render(RenderContext dest)
{
dest.Append("for(");
if (Initialize != null)
{
Initialize.Render(dest);
}
dest.Append(";");
if (Condition != null)
{
Condition.Render(dest);
}
dest.Append(";");
if (Increment != null)
{
Increment.Render(dest);
}
dest.Append(")");
return(Code.RenderIndented(dest));
}
public override bool Render(RenderContext dest)
{
for (int i = 0; i < Expressions.Count; i++)
{
if (i > 0)
dest.Append(',');
WrapAndRender(dest, Expressions[i], false);
}
return true;
}
public override bool Render(RenderContext dest)
{
// Statement
dest.Append("try");
Code.Render(dest);
// Catch clauses
foreach (var cc in CatchClauses)
{
cc.Render(dest);
}
// Finally clause
if (FinallyClause != null)
{
dest.Append("finally");
FinallyClause.RenderIndented(dest);
}
return(false);
}
public override bool Render(RenderContext dest)
{
if (Values.Count == 0)
{
dest.Append("{}");
return true;
}
dest.Append('{');
dest.Indent();
for (var i = 0; i < Values.Count; i++)
{
if (i > 0)
dest.Append(',');
dest.StartLine();
// Key - if key is a valid identifier, don't quote it
var kp = Values[i];
if (kp.Key.GetType() == typeof(ast.ExprNodeIdentifier))
{
dest.Append(dest.Members.GetObfuscatedSymbol(((ast.ExprNodeIdentifier)kp.Key).Name));
}
else if (kp.Key.GetType() == typeof(String) && Tokenizer.IsIdentifier((string)kp.Key) && !Tokenizer.IsKeyword((string)kp.Key))
{
dest.Append((string)kp.Key);
}
else
{
ExprNodeLiteral.RenderValue(dest, kp.Key);
}
// Value
dest.Append(':');
kp.Value.Render(dest);
}
dest.Unindent();
dest.StartLine();
dest.Append('}');
return true;
}
public override bool Render(RenderContext dest)
{
dest.Append("for(");
if (VariableDeclaration!=null)
VariableDeclaration.Render(dest);
else
Iterator.Render(dest);
dest.Append("in");
Collection.Render(dest);
dest.Append(")");
return Code.RenderIndented(dest);
}
public override bool Render(RenderContext dest)
{
for (int i = 0; i < Expressions.Count; i++)
{
if (i > 0)
{
dest.Append(',');
}
WrapAndRender(dest, Expressions[i], false);
}
return(true);
}
public override bool Render(RenderContext dest)
{
if (Lhs != null)
{
WrapAndRender(dest, Lhs, false);
dest.Append(".");
dest.Append(dest.Members.GetObfuscatedSymbol(Name));
}
else
{
// Find the symbol and check if it's a constant
var s = dest.CurrentScope.FindSymbol(Name);
if (s != null && s.ConstValue != null)
{
ExprNodeLiteral.RenderValue(dest, s.ConstValue);
}
else
{
dest.Append(dest.Symbols.GetObfuscatedSymbol(Name));
}
}
return(true);
}
public override bool Render(RenderContext dest)
{
dest.Append('[');
bool bFirst = true;
foreach (var e in Values)
{
if (!bFirst)
{
dest.Append(",");
}
else
{
bFirst = false;
}
if (e != null)
{
WrapAndRender(dest, e, false);
}
}
dest.Append(']');
return(true);
}
public override bool Render(RenderContext dest)
{
// Quit if all variables have been eliminated
if (Variables.Count == 0)
{
return(false);
}
// Statement
dest.Append("var");
// Comma separated variables
bool bFirst = true;
foreach (var v in Variables)
{
if (!bFirst)
{
dest.Append(',');
}
else
{
bFirst = false;
}
// Variable name, possibly obfuscated
dest.Append(dest.Symbols.GetObfuscatedSymbol(v.Name));
// Optional initial value
if (v.InitialValue != null)
{
dest.Append("=");
v.InitialValue.Render(dest);
}
}
return(true);
}
public override bool Render(RenderContext dest)
{
// Get obfuscated name before we enter our own scope
string strObfuscatedName = dest.Symbols.GetObfuscatedSymbol(Name);
// Enter a new symbol scope and tell symbol allocator
// about our local symbols
dest.EnterScope(Scope);
// `function`
dest.Append("function");
// Function name not present for anonymous functions
if (Name != null)
{
dest.Append(strObfuscatedName);
}
// Parameters
dest.Append('(');
for (int i = 0; i < Parameters.Count; i++)
{
if (i > 0)
{
dest.Append(',');
}
Parameters[i].Render(dest);
}
dest.Append(")");
// Body of the function
Code.Render(dest);
// Clean up scope and we're finished
dest.LeaveScope();
return(false);
}
public override bool Render(RenderContext dest)
{
// Enter a new symbol scope since the exception variable
// can be obfuscated
dest.EnterScope(Scope);
// Catch clause
dest.StartLine();
dest.Append("catch(");
dest.Append(dest.Symbols.GetObfuscatedSymbol(ExceptionVariable));
if (Condition != null)
{
dest.Append("if");
Condition.Render(dest);
}
dest.Append(')');
// Associated code
Code.Render(dest);
// Done
dest.LeaveScope();
return false;
}
public override bool Render(RenderContext dest)
{
// Enter a new symbol scope since the exception variable
// can be obfuscated
dest.EnterScope(Scope);
// Catch clause
dest.StartLine();
dest.Append("catch(");
dest.Append(dest.Symbols.GetObfuscatedSymbol(ExceptionVariable));
if (Condition != null)
{
dest.Append("if");
Condition.Render(dest);
}
dest.Append(')');
// Associated code
Code.Render(dest);
// Done
dest.LeaveScope();
return(false);
}
public override bool Render(RenderContext dest)
{
// Check for new Object and new Array
var id = ObjectType as ast.ExprNodeIdentifier;
if (id != null && id.Lhs == null)
{
if (id.Name == "Object" && Arguments.Count==0)
{
dest.Append("{}");
return true;
}
if (id.Name == "Array")
{
if (Arguments.Count!=1)
{
dest.Append("[");
bool first = true;
foreach (var a in Arguments)
{
if (!first)
dest.Append(",");
a.Render(dest);
first = false;
}
dest.Append("]");
return true;
}
else
{
dest.Compiler.RecordWarning(Bookmark, "use of `new Array()` with one argument creates a sized array - are you sure?");
}
}
}
dest.Append("new");
WrapAndRender(dest, ObjectType, false);
dest.Append("(");
bool bFirst = true;
foreach (var a in Arguments)
{
if (!bFirst)
dest.Append(",");
a.Render(dest);
bFirst = false;
}
dest.Append(")");
return true;
}
public override bool Render(RenderContext dest)
{
dest.DisableLineBreaks();
WrapAndRender(dest, Lhs, false);
switch (Op)
{
case Token.increment:
case Token.decrement:
dest.Append(Tokenizer.FormatToken(Op));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
dest.EnableLineBreaks();
return true;
}
public override bool Render(RenderContext dest)
{
dest.DisableLineBreaks();
WrapAndRender(dest, Lhs, false);
switch (Op)
{
case Token.increment:
case Token.decrement:
dest.Append(Tokenizer.FormatToken(Op));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
dest.EnableLineBreaks();
return(true);
}
public override bool Render(RenderContext dest)
{
if (Values.Count == 0)
{
dest.Append("{}");
return(true);
}
dest.Append('{');
dest.Indent();
for (var i = 0; i < Values.Count; i++)
{
if (i > 0)
{
dest.Append(',');
}
dest.StartLine();
// Key - if key is a valid identifier, don't quote it
var kp = Values[i];
if (kp.Key.GetType() == typeof(ast.ExprNodeIdentifier))
{
dest.Append(dest.Members.GetObfuscatedSymbol(((ast.ExprNodeIdentifier)kp.Key).Name));
}
else if (kp.Key.GetType() == typeof(String) && Tokenizer.IsIdentifier((string)kp.Key) && !Tokenizer.IsKeyword((string)kp.Key))
{
dest.Append((string)kp.Key);
}
else
{
ExprNodeLiteral.RenderValue(dest, kp.Key);
}
// Value
dest.Append(':');
kp.Value.Render(dest);
}
dest.Unindent();
dest.StartLine();
dest.Append('}');
return(true);
}
public override bool Render(RenderContext dest)
{
// Statement
dest.Append("if(");
Condition.Render(dest);
dest.Append(")");
// True block
bool retv;
if (CheckForHangingElse())
{
dest.StartLine();
dest.Append("{");
TrueStatement.RenderIndented(dest);
dest.StartLine();
dest.Append("}");
retv = false;
}
else
{
retv = TrueStatement.RenderIndented(dest);
}
// False block
if (FalseStatement != null)
{
if (retv)
{
dest.Append(';');
}
dest.StartLine();
dest.Append("else");
retv = FalseStatement.RenderIndented(dest);
}
return(retv);
}
public override bool Render(RenderContext dest)
{
// Get obfuscated name before we enter our own scope
string strObfuscatedName = dest.Symbols.GetObfuscatedSymbol(Name);
// Enter a new symbol scope and tell symbol allocator
// about our local symbols
dest.EnterScope(Scope);
// `function`
dest.Append("function");
// Function name not present for anonymous functions
if (Name != null)
{
dest.Append(strObfuscatedName);
}
// Parameters
dest.Append('(');
for (int i = 0; i < Parameters.Count; i++)
{
if (i > 0)
dest.Append(',');
Parameters[i].Render(dest);
}
dest.Append(")");
// Body of the function
Code.Render(dest);
// Clean up scope and we're finished
dest.LeaveScope();
return false;
}
public override bool Render(RenderContext dest)
{
dest.Append(dest.Symbols.GetObfuscatedSymbol(Name));
return true;
}
public override bool Render(RenderContext dest)
{
switch (Op)
{
case Token.kw_typeof:
case Token.kw_void:
case Token.kw_delete:
dest.Append(Op.ToString().Substring(3));
break;
case Token.add:
break;
case Token.subtract:
dest.Append('-');
dest.NeedSpaceIf('-');
break;
case Token.bitwiseNot:
case Token.logicalNot:
case Token.increment:
case Token.decrement:
dest.Append(Tokenizer.FormatToken(Op));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
// RHS
WrapAndRender(dest, Rhs, false);
return true;
}
public override bool Render(RenderContext dest)
{
// some statement blocks require braces, even if they only
// contain a single statement
// Opening brace
if (WillRenderBraces)
{
dest.StartLine();
dest.Append('{');
dest.Indent();
dest.StartLine();
}
// Render each statement, optionally putting a brace between them
bool bNeedSemicolon = false;
bool bUnreachable = false;
for (var i=0; i<Content.Count; i++)
{
var s = Content[i];
// Unreachable code?
if (bUnreachable)
{
if (!s.IsDeclarationOnly())
{
dest.Compiler.RecordWarning(Content[i].Bookmark, "unreachable code");
bUnreachable = false;
}
}
// Pending semicolon?
if (bNeedSemicolon)
dest.Append(';');
if (i>0)
dest.StartLine();
// Get the next statement and render it
bNeedSemicolon=s.Render(dest);
bUnreachable |= s.BreaksExecutionFlow();
// In formatted mode, append the terminating semicolon immediately
if (bNeedSemicolon && dest.Compiler.Formatted)
{
dest.Append(';');
bNeedSemicolon = false;
}
}
// Closing brace
if (WillRenderBraces)
{
dest.Unindent();
dest.StartLine();
dest.Append('}');
return false;
}
return bNeedSemicolon;
}
public override bool Render(RenderContext dest)
{
if (Lhs != null)
{
WrapAndRender(dest, Lhs, false);
dest.Append(".");
dest.Append(dest.Members.GetObfuscatedSymbol(Name));
}
else
{
// Find the symbol and check if it's a constant
var s = dest.CurrentScope.FindSymbol(Name);
if (s != null && s.ConstValue != null)
{
ExprNodeLiteral.RenderValue(dest, s.ConstValue);
}
else
{
dest.Append(dest.Symbols.GetObfuscatedSymbol(Name));
}
}
return true;
}
public override bool Render(RenderContext dest)
{
// Statement
dest.Append("switch(");
TestExpression.Render(dest);
dest.Append(')');
dest.StartLine();
// Opening brace
dest.Append('{');
// Cases
dest.Indent();
bool bNeedSemicolon=false;
for (int i=0; i<Cases.Count; i++)
{
var c = Cases[i];
// Separator
if (bNeedSemicolon)
dest.Append(';');
// `case` or `default`
dest.StartLine();
if (c.Value != null)
{
dest.Append("case");
c.Value.Render(dest);
dest.Append(":");
}
else
{
dest.Append("default:");
}
// Is there any code associated with this case?
if (c.Code != null)
{
bNeedSemicolon = c.Code.RenderIndented(dest);
// Check for no break between case blocks
if (c.Code.Content.Count > 0 && i!=Cases.Count-1)
{
if (!c.Code.Content[c.Code.Content.Count - 1].BreaksExecutionFlow())
{
dest.Compiler.RecordWarning(Cases[i+1].Code.Bookmark, "execution falls through to next case. Insert a comment \"// fall through\" to disable this warning");
}
}
}
else
{
bNeedSemicolon = false;
}
}
// Close brace
dest.Unindent();
dest.StartLine();
dest.Append("}");
return false;
}
public override bool Render(RenderContext dest)
{
dest.Compiler.RecordWarning(Bookmark, "use of debugger statement");
dest.Append(Op.ToString().Substring(3));
return(true);
}
public override bool Render(RenderContext dest)
{
dest.Append("for(");
if (Initialize != null)
Initialize.Render(dest);
dest.Append(";");
if (Condition != null)
Condition.Render(dest);
dest.Append(";");
if (Increment != null)
Increment.Render(dest);
dest.Append(")");
return Code.RenderIndented(dest);
}
public override bool Render(RenderContext dest)
{
dest.Compiler.RecordWarning(Bookmark, "use of debugger statement");
dest.Append(Op.ToString().Substring(3));
return true;
}
public override bool Render(RenderContext dest)
{
dest.Append(RegEx);
return true;
}
public override bool Render(RenderContext dest)
{
// Statement
dest.Append("if(");
Condition.Render(dest);
dest.Append(")");
// True block
bool retv;
if (CheckForHangingElse())
{
dest.StartLine();
dest.Append("{");
TrueStatement.RenderIndented(dest);
dest.StartLine();
dest.Append("}");
retv = false;
}
else
{
retv = TrueStatement.RenderIndented(dest);
}
// False block
if (FalseStatement != null)
{
if (retv)
dest.Append(';');
dest.StartLine();
dest.Append("else");
retv = FalseStatement.RenderIndented(dest);
}
return retv;
}
public override bool Render(RenderContext dest)
{
// LHS
WrapAndRender(dest, Lhs, false);
// Operator
switch (Op)
{
case Token.assign:
case Token.addAssign:
case Token.subtractAssign:
case Token.multiplyAssign:
case Token.divideAssign:
case Token.modulusAssign:
case Token.shlAssign:
case Token.shrAssign:
case Token.shrzAssign:
case Token.bitwiseXorAssign:
case Token.bitwiseOrAssign:
case Token.bitwiseAndAssign:
dest.Append(Tokenizer.FormatToken(Op));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
// RHS
WrapAndRender(dest, Rhs, true);
return true;
}
// Render an child node, wrapping it in parentheses if necessary
public void WrapAndRender(RenderContext dest, ExprNode other, bool bWrapEqualPrecedence)
{
var precOther=other.GetPrecedence();
var precThis = this.GetPrecedence();
if (precOther < precThis || (precOther==precThis && bWrapEqualPrecedence))
{
dest.Append("(");
other.Render(dest);
dest.Append(")");
}
else
{
other.Render(dest);
}
}
public override bool Render(RenderContext dest)
{
// some statement blocks require braces, even if they only
// contain a single statement
// Opening brace
if (WillRenderBraces)
{
dest.StartLine();
dest.Append('{');
dest.Indent();
dest.StartLine();
}
// Render each statement, optionally putting a brace between them
bool bNeedSemicolon = false;
bool bUnreachable = false;
for (var i = 0; i < Content.Count; i++)
{
var s = Content[i];
// Unreachable code?
if (bUnreachable)
{
if (!s.IsDeclarationOnly())
{
dest.Compiler.RecordWarning(Content[i].Bookmark, "unreachable code");
bUnreachable = false;
}
}
// Pending semicolon?
if (bNeedSemicolon)
{
dest.Append(';');
}
if (i > 0)
{
dest.StartLine();
}
// Get the next statement and render it
bNeedSemicolon = s.Render(dest);
bUnreachable |= s.BreaksExecutionFlow();
// In formatted mode, append the terminating semicolon immediately
if (bNeedSemicolon && dest.Compiler.Formatted)
{
dest.Append(';');
bNeedSemicolon = false;
}
}
// Closing brace
if (WillRenderBraces)
{
dest.Unindent();
dest.StartLine();
dest.Append('}');
return(false);
}
return(bNeedSemicolon);
}