public void Visit(JsConditionalCompilationComment node)
{
if (node != null)
{
if (node.Statements != null)
{
node.Statements.Accept(this);
}
}
}
public override void Visit(JsConditionalCompilationComment node)
{
if (node != null && node.Statements != null && node.Statements.Count > 0)
{
// increment the conditional comment level, recurse (process all the
// statements), then decrement the level when we are through.
++m_conditionalCommentLevel;
base.Visit(node);
--m_conditionalCommentLevel;
}
}
// unnest any child blocks
private static void UnnestBlocks(JsBlock node)
{
// walk the list of items backwards -- if we come
// to any blocks, unnest the block recursively.
// Remove any empty statements as well.
// We walk backwards because we could be adding any number of statements
// and we don't want to have to modify the counter.
for (int ndx = node.Count - 1; ndx >= 0; --ndx)
{
var nestedBlock = node[ndx] as JsBlock;
if (nestedBlock != null)
{
// unnest recursively
UnnestBlocks(nestedBlock);
// if the block has a block scope, then we can't really unnest it
// without merging lexical scopes
if (nestedBlock.BlockScope == null)
{
// remove the nested block
node.RemoveAt(ndx);
// then start adding the statements in the nested block to our own.
// go backwards so we can just keep using the same index
node.InsertRange(ndx, nestedBlock.Children);
}
}
else if (node[ndx] is JsEmptyStatement)
{
// remove empty statements (lone semicolons)
node.RemoveAt(ndx);
}
else if (ndx > 0)
{
// see if the previous node is a conditional-compilation comment, because
// we will also combine adjacent those
var previousComment = node[ndx - 1] as JsConditionalCompilationComment;
if (previousComment != null)
{
JsConditionalCompilationComment thisComment = node[ndx] as JsConditionalCompilationComment;
if (thisComment != null)
{
// two adjacent conditional comments -- combine them into the first.
previousComment.Statements.Append(thisComment.Statements);
// and remove the second one (which is now a duplicate)
node.RemoveAt(ndx);
}
}
}
}
}
public void Visit(JsConditionalCompilationComment node)
{
if (node != null)
{
// recurse the children, but as soon as we get the flag set to true, bail
foreach (var child in node.Children)
{
child.Accept(this);
if (m_needsParens)
{
break;
}
}
}
}
public void Visit(JsConditionalCompilationComment node)
{
// starts with a '/*@' or '//@', so we don't care
}
public void Visit(JsConditionalCompilationComment node)
{
// starts with a '/*@' or '//@', so we don't care
}
public void Visit(JsConditionalCompilationComment node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(JsConditionalCompilationComment node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(JsConditionalCompilationComment node)
{
// not applicable; terminate
}
public void Visit(JsConditionalCompilationComment node)
{
// not applicable; terminate
}
public void Visit(JsConditionalCompilationComment node)
{
if (node != null)
{
// recurse the children, but as soon as we get the flag set to true, bail
foreach (var child in node.Children)
{
child.Accept(this);
if (m_needsParens)
{
break;
}
}
}
}
JsAstNode ParseStatementLevelConditionalComment(bool fSourceElement)
{
JsContext context = m_currentToken.Clone();
JsConditionalCompilationComment conditionalComment = new JsConditionalCompilationComment(context, this);
GetNextToken();
while(m_currentToken.Token != JsToken.ConditionalCommentEnd && m_currentToken.Token != JsToken.EndOfFile)
{
// if we get ANOTHER start token, it's superfluous and we should ignore it.
// otherwise parse another statement and keep going
if (m_currentToken.Token == JsToken.ConditionalCommentStart)
{
GetNextToken();
}
else
{
conditionalComment.Append(ParseStatement(fSourceElement));
}
}
GetNextToken();
// if the conditional comment is empty (for whatever reason), then
// we don't want to return anything -- we found nothing.
return conditionalComment.Statements.Count > 0 ? conditionalComment : null;
}
public void Visit(JsConditionalCompilationComment node)
{
if (node != null)
{
if (node.Statements != null)
{
node.Statements.Accept(this);
}
}
}
public void Visit(JsConditionalCompilationComment node)
{
if (node != null)
{
var symbol = StartSymbol(node);
// if we have already output a cc_on and we don't want to keep any dupes, let's
// skip over any @cc_on statements at the beginning now
var ndx = 0;
if (m_outputCCOn && m_settings.IsModificationAllowed(JsTreeModifications.RemoveUnnecessaryCCOnStatements))
{
while (ndx < node.Statements.Count
&& (node.Statements[ndx].HideFromOutput || node.Statements[ndx] is JsConditionalCompilationOn))
{
++ndx;
}
}
// if there's anything left....
if (ndx < node.Statements.Count)
{
// start of comment
Output("/*");
MarkSegment(node, null, node.Context);
SetContextOutputPosition(node.Context);
// get the next statement, which will be the first one we output
var statement = node.Statements[ndx];
if (statement is JsConditionalCompilationStatement
|| statement is JsConstantWrapperPP)
{
// the next statement STARTS with an @-sign, so just output it. It will add the @ sign to begin
// the conditional-compilation comment
statement.Accept(this);
}
else
{
// next statement does NOT start with an @-sign, so add one now.
// outputting an @-sign as the last character will ensure that a
// space is inserted before any identifier character coming after.
OutputPossibleLineBreak('@');
// and then output the first statement
statement.Accept(this);
}
// go through the rest of the statements (if any)
JsAstNode prevStatement = statement;
while (++ndx < node.Statements.Count)
{
statement = node.Statements[ndx];
if (statement != null && !statement.HideFromOutput)
{
if (prevStatement != null && prevStatement.RequiresSeparator)
{
OutputPossibleLineBreak(';');
MarkSegment(prevStatement, null, prevStatement.TerminatingContext);
}
NewLine();
m_startOfStatement = true;
statement.Accept(this);
prevStatement = statement;
}
}
// output the closing comment
Output("@*/");
MarkSegment(node, null, node.Context);
}
EndSymbol(symbol);
}
}
public override void Visit(JsConditionalCompilationComment node)
{
if (node != null && node.Statements != null && node.Statements.Count > 0)
{
// increment the conditional comment level, recurse (process all the
// statements), then decrement the level when we are through.
++m_conditionalCommentLevel;
base.Visit(node);
--m_conditionalCommentLevel;
}
}