public void Visit(JsConstantWrapperPP node)
{
// it's a constant, so we don't care
}
public void Visit(JsConstantWrapperPP node)
{
// it's a constant, so we don't care
}
public void Visit(JsConstantWrapperPP node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(JsConstantWrapperPP node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(JsConstantWrapperPP node)
{
// not applicable; terminate
}
public void Visit(JsConstantWrapperPP node)
{
// not applicable; terminate
}
//---------------------------------------------------------------------------------------
// ParseUnaryExpression
//
// UnaryExpression :
// PostfixExpression |
// 'delete' UnaryExpression |
// 'void' UnaryExpression |
// 'typeof' UnaryExpression |
// '++' UnaryExpression |
// '--' UnaryExpression |
// '+' UnaryExpression |
// '-' UnaryExpression |
// '~' UnaryExpression |
// '!' UnaryExpression
//
//---------------------------------------------------------------------------------------
private JsAstNode ParseUnaryExpression(out bool isLeftHandSideExpr, bool isMinus)
{
isLeftHandSideExpr = false;
bool dummy = false;
JsContext exprCtx = null;
JsAstNode expr = null;
TryItAgain:
JsAstNode ast = null;
switch (m_currentToken.Token)
{
case JsToken.Void:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.Void
};
break;
case JsToken.TypeOf:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.TypeOf
};
break;
case JsToken.Plus:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.Plus
};
break;
case JsToken.Minus:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, true);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.Minus
};
break;
case JsToken.BitwiseNot:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.BitwiseNot
};
break;
case JsToken.LogicalNot:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.LogicalNot
};
break;
case JsToken.Delete:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.Delete
};
break;
case JsToken.Increment:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.Increment
};
break;
case JsToken.Decrement:
exprCtx = m_currentToken.Clone();
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this)
{
Operand = expr,
OperatorContext = exprCtx,
OperatorToken = JsToken.Decrement
};
break;
case JsToken.ConditionalCommentStart:
// skip past the start to the next token
exprCtx = m_currentToken.Clone();
GetNextToken();
if (m_currentToken.Token == JsToken.ConditionalCommentEnd)
{
// empty conditional-compilation comment -- ignore
GetNextToken();
goto TryItAgain;
}
else if (m_currentToken.Token == JsToken.ConditionalCompilationOn)
{
// /*@cc_on -- check for @IDENT@*/ or !@*/
GetNextToken();
if (m_currentToken.Token == JsToken.ConditionalCompilationVariable)
{
// /*@cc_on@IDENT -- check for @*/
ast = new JsConstantWrapperPP(m_currentToken.Clone(), this)
{
VarName = m_currentToken.Code,
ForceComments = true
};
GetNextToken();
if (m_currentToken.Token == JsToken.ConditionalCommentEnd)
{
// skip the close and keep going
GetNextToken();
}
else
{
// too complicated
CCTooComplicated(null);
goto TryItAgain;
}
}
else if (m_currentToken.Token == JsToken.LogicalNot)
{
// /*@cc_on! -- check for @*/
var operatorContext = m_currentToken.Clone();
GetNextToken();
if (m_currentToken.Token == JsToken.ConditionalCommentEnd)
{
// we have /*@cc_on!@*/
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
exprCtx.UpdateWith(expr.Context);
var unary = new JsUnaryOperator(exprCtx, this)
{
Operand = expr,
OperatorContext = operatorContext,
OperatorToken = JsToken.LogicalNot
};
unary.OperatorInConditionalCompilationComment = true;
unary.ConditionalCommentContainsOn = true;
ast = unary;
}
else
{
// too complicated
CCTooComplicated(null);
goto TryItAgain;
}
}
else
{
// too complicated
CCTooComplicated(null);
goto TryItAgain;
}
}
else if (m_currentToken.Token == JsToken.LogicalNot)
{
// /*@! -- check for @*/
var operatorContext = m_currentToken.Clone();
GetNextToken();
if (m_currentToken.Token == JsToken.ConditionalCommentEnd)
{
// we have /*@!@*/
GetNextToken();
expr = ParseUnaryExpression(out dummy, false);
exprCtx.UpdateWith(expr.Context);
var unary = new JsUnaryOperator(exprCtx, this)
{
Operand = expr,
OperatorContext = operatorContext,
OperatorToken = JsToken.LogicalNot
};
unary.OperatorInConditionalCompilationComment = true;
ast = unary;
}
else
{
// too complicated
CCTooComplicated(null);
goto TryItAgain;
}
}
else if (m_currentToken.Token == JsToken.ConditionalCompilationVariable)
{
// @IDENT -- check for @*/
ast = new JsConstantWrapperPP(m_currentToken.Clone(), this)
{
VarName = m_currentToken.Code,
ForceComments = true
};
GetNextToken();
if (m_currentToken.Token == JsToken.ConditionalCommentEnd)
{
// skip the close and keep going
GetNextToken();
}
else
{
// too complicated
CCTooComplicated(null);
goto TryItAgain;
}
}
else
{
// we ONLY support /*@id@*/ or /*@cc_on@id@*/ or /*@!@*/ or /*@cc_on!@*/ in expressions right now.
// throw an error, skip to the end of the comment, then ignore it and start
// looking for the next token.
CCTooComplicated(null);
goto TryItAgain;
}
break;
default:
m_noSkipTokenSet.Add(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet);
try
{
ast = ParseLeftHandSideExpression(isMinus);
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet, exc) == -1)
{
throw;
}
else
{
if (exc._partiallyComputedNode == null)
SkipTokensAndThrow();
else
ast = exc._partiallyComputedNode;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet);
}
ast = ParsePostfixExpression(ast, out isLeftHandSideExpr);
break;
}
return ast;
}
public void Visit(JsConstantWrapperPP node)
{
// we're good
}
private JsAstNode ParseLeftHandSideExpression(bool isMinus)
{
JsAstNode ast = null;
bool skipToken = true;
List<JsContext> newContexts = null;
TryItAgain:
// new expression
while (JsToken.New == m_currentToken.Token)
{
if (null == newContexts)
newContexts = new List<JsContext>(4);
newContexts.Add(m_currentToken.Clone());
GetNextToken();
}
JsToken token = m_currentToken.Token;
switch (token)
{
// primary expression
case JsToken.Identifier:
ast = new JsLookup(m_currentToken.Clone(), this)
{
Name = m_scanner.Identifier
};
break;
case JsToken.ConditionalCommentStart:
// skip past the start to the next token
GetNextToken();
if (m_currentToken.Token == JsToken.ConditionalCompilationVariable)
{
// we have /*@id
ast = new JsConstantWrapperPP(m_currentToken.Clone(), this)
{
VarName = m_currentToken.Code,
ForceComments = true
};
GetNextToken();
if (m_currentToken.Token == JsToken.ConditionalCommentEnd)
{
// skip past the closing comment
GetNextToken();
}
else
{
// we ONLY support /*@id@*/ in expressions right now. If there's not
// a closing comment after the ID, then we don't support it.
// throw an error, skip to the end of the comment, then ignore it and start
// looking for the next token.
CCTooComplicated(null);
goto TryItAgain;
}
}
else if (m_currentToken.Token == JsToken.ConditionalCommentEnd)
{
// empty conditional comment! Ignore.
GetNextToken();
goto TryItAgain;
}
else
{
// we DON'T have "/*@IDENT". We only support "/*@IDENT @*/", so since this isn't
// and id, throw the error, skip to the end of the comment, and ignore it
// by looping back and looking for the NEXT token.
m_currentToken.HandleError(JsError.ConditionalCompilationTooComplex);
// skip to end of conditional comment
while (m_currentToken.Token != JsToken.EndOfFile && m_currentToken.Token != JsToken.ConditionalCommentEnd)
{
GetNextToken();
}
GetNextToken();
goto TryItAgain;
}
break;
case JsToken.This:
ast = new JsThisLiteral(m_currentToken.Clone(), this);
break;
case JsToken.StringLiteral:
ast = new JsConstantWrapper(m_scanner.StringLiteralValue, JsPrimitiveType.String, m_currentToken.Clone(), this)
{
MayHaveIssues = m_scanner.LiteralHasIssues
};
break;
case JsToken.IntegerLiteral:
case JsToken.NumericLiteral:
{
JsContext numericContext = m_currentToken.Clone();
double doubleValue;
if (ConvertNumericLiteralToDouble(m_currentToken.Code, (token == JsToken.IntegerLiteral), out doubleValue))
{
// conversion worked fine
// check for some boundary conditions
var mayHaveIssues = m_scanner.LiteralHasIssues;
if (doubleValue == double.MaxValue)
{
ReportError(JsError.NumericMaximum, numericContext, true);
}
else if (isMinus && -doubleValue == double.MinValue)
{
ReportError(JsError.NumericMinimum, numericContext, true);
}
// create the constant wrapper from the value
ast = new JsConstantWrapper(doubleValue, JsPrimitiveType.Number, numericContext, this)
{
MayHaveIssues = mayHaveIssues
};
}
else
{
// if we went overflow or are not a number, then we will use the "Other"
// primitive type so we don't try doing any numeric calcs with it.
if (double.IsInfinity(doubleValue))
{
// overflow
// and if we ARE an overflow, report it
ReportError(JsError.NumericOverflow, numericContext, true);
}
// regardless, we're going to create a special constant wrapper
// that simply echos the input as-is
ast = new JsConstantWrapper(m_currentToken.Code, JsPrimitiveType.Other, numericContext, this)
{
MayHaveIssues = true
};
}
break;
}
case JsToken.True:
ast = new JsConstantWrapper(true, JsPrimitiveType.Boolean, m_currentToken.Clone(), this);
break;
case JsToken.False:
ast = new JsConstantWrapper(false, JsPrimitiveType.Boolean, m_currentToken.Clone(), this);
break;
case JsToken.Null:
ast = new JsConstantWrapper(null, JsPrimitiveType.Null, m_currentToken.Clone(), this);
break;
case JsToken.ConditionalCompilationVariable:
ast = new JsConstantWrapperPP(m_currentToken.Clone(), this)
{
VarName = m_currentToken.Code,
ForceComments = false
};
break;
case JsToken.DivideAssign:
// normally this token is not allowed on the left-hand side of an expression.
// BUT, this might be the start of a regular expression that begins with an equals sign!
// we need to test to see if we can parse a regular expression, and if not, THEN
// we can fail the parse.
case JsToken.Divide:
// could it be a regexp?
ast = ScanRegularExpression();
if (ast != null)
{
// yup -- we're done here
break;
}
// nope -- go to the default branch
goto default;
// expression
case JsToken.LeftParenthesis:
{
var groupingOp = new JsGroupingOperator(m_currentToken.Clone(), this);
ast = groupingOp;
GetNextToken();
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ParenExpressionNoSkipToken);
try
{
// parse an expression
groupingOp.Operand = ParseExpression();
if (JsToken.RightParenthesis != m_currentToken.Token)
{
ReportError(JsError.NoRightParenthesis);
}
else
{
// add the closing paren to the expression context
ast.Context.UpdateWith(m_currentToken);
}
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_ParenExpressionNoSkipToken, exc) == -1)
throw;
else
groupingOp.Operand = exc._partiallyComputedNode;
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ParenExpressionNoSkipToken);
}
}
break;
// array initializer
case JsToken.LeftBracket:
JsContext listCtx = m_currentToken.Clone();
GetNextToken();
JsAstNodeList list = new JsAstNodeList(CurrentPositionContext(), this);
var hasTrailingCommas = false;
while (JsToken.RightBracket != m_currentToken.Token)
{
if (JsToken.Comma != m_currentToken.Token)
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet);
try
{
var expression = ParseExpression(true);
list.Append(expression);
if (JsToken.Comma != m_currentToken.Token)
{
if (JsToken.RightBracket != m_currentToken.Token)
{
ReportError(JsError.NoRightBracket);
}
break;
}
else
{
// we have a comma -- skip it after adding it as a terminator
// on the previous expression
var commaContext = m_currentToken.Clone();
expression.IfNotNull(e => e.TerminatingContext = commaContext);
GetNextToken();
// if the next token is the closing brackets, then we need to
// add a missing value to the array because we end in a comma and
// we need to keep it for cross-platform compat.
// TECHNICALLY, that puts an extra item into the array for most modern browsers, but not ALL.
if (m_currentToken.Token == JsToken.RightBracket)
{
hasTrailingCommas = true;
list.Append(new JsConstantWrapper(JsMissing.Value, JsPrimitiveType.Other, m_currentToken.Clone(), this));
// throw a cross-browser warning about trailing commas
commaContext.HandleError(JsError.ArrayLiteralTrailingComma);
break;
}
}
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
list.Append(exc._partiallyComputedNode);
if (IndexOfToken(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet, exc) == -1)
{
listCtx.UpdateWith(CurrentPositionContext());
exc._partiallyComputedNode = new JsArrayLiteral(listCtx, this)
{
Elements = list,
MayHaveIssues = true
};
throw;
}
else
{
if (JsToken.RightBracket == m_currentToken.Token)
break;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet);
}
}
else
{
// comma -- missing array item in the list
var commaContext = m_currentToken.Clone();
list.Append(new JsConstantWrapper(JsMissing.Value, JsPrimitiveType.Other, m_currentToken.Clone(), this)
{
TerminatingContext = commaContext
});
// skip over the comma
GetNextToken();
// if the next token is the closing brace, then we end with a comma -- and we need to
// add ANOTHER missing value to make sure this last comma doesn't get left off.
// TECHNICALLY, that puts an extra item into the array for most modern browsers, but not ALL.
if (m_currentToken.Token == JsToken.RightBracket)
{
hasTrailingCommas = true;
list.Append(new JsConstantWrapper(JsMissing.Value, JsPrimitiveType.Other, m_currentToken.Clone(), this));
// throw a cross-browser warning about trailing commas
commaContext.HandleError(JsError.ArrayLiteralTrailingComma);
break;
}
}
}
listCtx.UpdateWith(m_currentToken);
ast = new JsArrayLiteral(listCtx, this)
{
Elements = list,
MayHaveIssues = hasTrailingCommas
};
break;
// object initializer
case JsToken.LeftCurly:
JsContext objCtx = m_currentToken.Clone();
GetNextToken();
var propertyList = new JsAstNodeList(CurrentPositionContext(), this);
if (JsToken.RightCurly != m_currentToken.Token)
{
for (; ; )
{
JsObjectLiteralField field = null;
JsAstNode value = null;
bool getterSetter = false;
string ident;
switch (m_currentToken.Token)
{
case JsToken.Identifier:
field = new JsObjectLiteralField(m_scanner.Identifier, JsPrimitiveType.String, m_currentToken.Clone(), this);
break;
case JsToken.StringLiteral:
field = new JsObjectLiteralField(m_scanner.StringLiteralValue, JsPrimitiveType.String, m_currentToken.Clone(), this)
{
MayHaveIssues = m_scanner.LiteralHasIssues
};
break;
case JsToken.IntegerLiteral:
case JsToken.NumericLiteral:
{
double doubleValue;
if (ConvertNumericLiteralToDouble(m_currentToken.Code, (m_currentToken.Token == JsToken.IntegerLiteral), out doubleValue))
{
// conversion worked fine
field = new JsObjectLiteralField(
doubleValue,
JsPrimitiveType.Number,
m_currentToken.Clone(),
this
);
}
else
{
// something went wrong and we're not sure the string representation in the source is
// going to convert to a numeric value well
if (double.IsInfinity(doubleValue))
{
ReportError(JsError.NumericOverflow, m_currentToken.Clone(), true);
}
// use the source as the field name, not the numeric value
field = new JsObjectLiteralField(
m_currentToken.Code,
JsPrimitiveType.Other,
m_currentToken.Clone(),
this);
}
break;
}
case JsToken.Get:
case JsToken.Set:
if (PeekToken() == JsToken.Colon)
{
// the field is either "get" or "set" and isn't the special Mozilla getter/setter
field = new JsObjectLiteralField(m_currentToken.Code, JsPrimitiveType.String, m_currentToken.Clone(), this);
}
else
{
// ecma-script get/set property construct
getterSetter = true;
bool isGet = (m_currentToken.Token == JsToken.Get);
value = ParseFunction(
(JsToken.Get == m_currentToken.Token ? JsFunctionType.Getter : JsFunctionType.Setter),
m_currentToken.Clone()
);
JsFunctionObject funcExpr = value as JsFunctionObject;
if (funcExpr != null)
{
// getter/setter is just the literal name with a get/set flag
field = new JsGetterSetter(
funcExpr.Name,
isGet,
funcExpr.IdContext.Clone(),
this
);
}
else
{
ReportError(JsError.FunctionExpressionExpected);
}
}
break;
default:
// NOT: identifier token, string, number, or getter/setter.
// see if it's a token that COULD be an identifierName.
ident = m_scanner.Identifier;
if (JsScanner.IsValidIdentifier(ident))
{
// BY THE SPEC, if it's a valid identifierName -- which includes reserved words -- then it's
// okay for object literal syntax. However, reserved words here won't work in all browsers,
// so if it is a reserved word, let's throw a low-sev cross-browser warning on the code.
if (JsKeyword.CanBeIdentifier(m_currentToken.Token) == null)
{
ReportError(JsError.ObjectLiteralKeyword, m_currentToken.Clone(), true);
}
field = new JsObjectLiteralField(ident, JsPrimitiveType.String, m_currentToken.Clone(), this);
}
else
{
// throw an error but use it anyway, since that's what the developer has going on
ReportError(JsError.NoMemberIdentifier, m_currentToken.Clone(), true);
field = new JsObjectLiteralField(m_currentToken.Code, JsPrimitiveType.String, m_currentToken.Clone(), this);
}
break;
}
if (field != null)
{
if (!getterSetter)
{
GetNextToken();
}
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet);
try
{
if (!getterSetter)
{
// get the value
if (JsToken.Colon != m_currentToken.Token)
{
ReportError(JsError.NoColon, true);
value = ParseExpression(true);
}
else
{
field.ColonContext = m_currentToken.Clone();
GetNextToken();
value = ParseExpression(true);
}
}
// put the pair into the list of fields
var propCtx = field.Context.Clone().CombineWith(value.IfNotNull(v => v.Context));
var property = new JsObjectLiteralProperty(propCtx, this)
{
Name = field,
Value = value
};
propertyList.Append(property);
if (JsToken.RightCurly == m_currentToken.Token)
{
break;
}
else
{
if (JsToken.Comma == m_currentToken.Token)
{
// skip the comma after adding it to the property as a terminating context
property.IfNotNull(p => p.TerminatingContext = m_currentToken.Clone());
GetNextToken();
// if the next token is the right-curly brace, then we ended
// the list with a comma, which is perfectly fine
if (m_currentToken.Token == JsToken.RightCurly)
{
break;
}
}
else
{
if (m_foundEndOfLine)
{
ReportError(JsError.NoRightCurly);
}
else
ReportError(JsError.NoComma, true);
SkipTokensAndThrow();
}
}
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
{
// the problem was in ParseExpression trying to determine value
value = exc._partiallyComputedNode;
var propCtx = field.Context.Clone().CombineWith(value.IfNotNull(v => v.Context));
var property = new JsObjectLiteralProperty(propCtx, this)
{
Name = field,
Value = value
};
propertyList.Append(property);
}
if (IndexOfToken(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = new JsObjectLiteral(objCtx, this)
{
Properties = propertyList
};
throw;
}
else
{
if (JsToken.Comma == m_currentToken.Token)
GetNextToken();
if (JsToken.RightCurly == m_currentToken.Token)
break;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet);
}
}
}
}
objCtx.UpdateWith(m_currentToken);
ast = new JsObjectLiteral(objCtx, this)
{
Properties = propertyList
};
break;
// function expression
case JsToken.Function:
ast = ParseFunction(JsFunctionType.Expression, m_currentToken.Clone());
skipToken = false;
break;
case JsToken.AspNetBlock:
ast = new JsAspNetBlockNode(m_currentToken.Clone(), this)
{
AspNetBlockText = m_currentToken.Code
};
break;
default:
string identifier = JsKeyword.CanBeIdentifier(m_currentToken.Token);
if (null != identifier)
{
ast = new JsLookup(m_currentToken.Clone(), this)
{
Name = identifier
};
}
else
{
ReportError(JsError.ExpressionExpected);
SkipTokensAndThrow();
}
break;
}
// can be a CallExpression, that is, followed by '.' or '(' or '['
if (skipToken)
GetNextToken();
return MemberExpression(ast, newContexts);
}
public void Visit(JsConstantWrapperPP node)
{
// nothing to do
}
public void Visit(JsConstantWrapperPP node)
{
// nothing to do
}
public void Visit(JsConstantWrapperPP node)
{
// we're good
}
public void Visit(JsConstantWrapperPP node)
{
if (node != null)
{
var symbol = StartSymbol(node);
if (node.ForceComments)
{
Output("/*");
}
// varname must include the @ sign
Output(node.VarName);
m_startOfStatement = false;
SetContextOutputPosition(node.Context);
if (node.ForceComments)
{
Output("@*/");
}
EndSymbol(symbol);
}
}