/// <summary>
/// Parses an attribute.
/// </summary>
/// <param name="parentReference">The parent code unit.</param>
/// <param name="unsafeCode">Indicates whether the attribute lies within a block of unsafe code.</param>
/// <param name="masterDocument">The master document object.</param>
/// <returns>Returns the attribute.</returns>
internal Attribute ParseAttribute(Reference<ICodePart> parentReference, bool unsafeCode, CsDocument masterDocument)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
Param.AssertNotNull(masterDocument, "masterDocument");
Debug.Assert(this.document == null, "A CodeParser instance may only be used once.");
this.document = masterDocument;
var attributeReference = new Reference<ICodePart>();
// Get the first symbol and make sure it is the right type.
Symbol firstSymbol = this.symbols.Peek(1);
Debug.Assert(firstSymbol != null && firstSymbol.SymbolType == SymbolType.OpenSquareBracket, "Expected an opening square bracket");
// The list of attribute expressions in the attribute.
List<AttributeExpression> attributeExpressions = new List<AttributeExpression>();
// Move past the opening square bracket.
Bracket openingBracket = new Bracket(
firstSymbol.Text, CsTokenType.OpenAttributeBracket, firstSymbol.Location, attributeReference, this.symbols.Generated);
Node<CsToken> openingBracketNode = this.tokens.InsertLast(openingBracket);
this.symbols.Advance();
// Get each of the child attribute expressions within this attribute.
while (true)
{
// Move to the next symbol.
this.AdvanceToNextCodeSymbol(attributeReference);
Symbol symbol = this.symbols.Peek(1);
if (symbol == null)
{
throw new SyntaxException(this.document.SourceCode, firstSymbol.LineNumber);
}
// Check the type. If this is the closing bracket then we are done.
if (symbol.SymbolType == SymbolType.CloseSquareBracket)
{
Bracket closingBracket = new Bracket(
symbol.Text, CsTokenType.CloseAttributeBracket, symbol.Location, attributeReference, this.symbols.Generated);
Node<CsToken> closingBracketNode = this.tokens.InsertLast(closingBracket);
this.symbols.Advance();
openingBracket.MatchingBracketNode = closingBracketNode;
closingBracket.MatchingBracketNode = openingBracketNode;
break;
}
// Check to see if there is a target specified.
LiteralExpression target = null;
this.AdvanceToNextCodeSymbol(attributeReference);
symbol = this.symbols.Peek(1);
if (symbol == null)
{
throw new SyntaxException(this.document.SourceCode, firstSymbol.LineNumber);
}
Node<CsToken> previousTokenNode = this.tokens.Last;
var attributeExpressionReference = new Reference<ICodePart>();
if (symbol.SymbolType == SymbolType.Other || symbol.SymbolType == SymbolType.Return)
{
// Peek ahead to the next symbol and check if it's a colon.
int index = this.GetNextCodeSymbolIndex(2);
if (index != -1)
{
Symbol colon = this.symbols.Peek(index);
if (colon.SymbolType == SymbolType.Colon)
{
// This is a target. Get the literal target expression and move past the colon.
// Change the type of the target symbol to OTHER so that it will be parsed
// correctly by the literal expression parser.
symbol.SymbolType = SymbolType.Other;
// Get the literal expression.
var targetReference = new Reference<ICodePart>();
target = this.GetLiteralExpression(targetReference, unsafeCode);
Debug.Assert(target != null, "We should always succeed getting a Literal here since we have already seen a type of Other.");
targetReference.Target = target;
// Add the colon.
this.AdvanceToNextCodeSymbol(attributeExpressionReference);
this.tokens.Add(new CsToken(colon.Text, CsTokenType.AttributeColon, symbol.Location, attributeExpressionReference, this.symbols.Generated));
this.symbols.Advance();
this.AdvanceToNextCodeSymbol(attributeExpressionReference);
}
}
}
// Now get the attribute call expression.
Expression initialization = this.GetNextExpression(ExpressionPrecedence.None, attributeExpressionReference, unsafeCode);
if (initialization == null)
{
throw new SyntaxException(this.document.SourceCode, firstSymbol.LineNumber);
}
// Create and add the attribute expression.
Debug.Assert(previousTokenNode.Next != null, "Nothing was added to the token list!");
var attributeExpression = new AttributeExpression(
new CsTokenList(this.tokens, previousTokenNode.Next, this.tokens.Last),
target,
initialization);
attributeExpressions.Add(attributeExpression);
attributeExpressionReference.Target = attributeExpression;
// Get the next item, which must either be a comma or the closing attribute bracket.
this.AdvanceToNextCodeSymbol(attributeReference);
symbol = this.symbols.Peek(1);
if (symbol == null)
{
throw new SyntaxException(this.document.SourceCode, firstSymbol.LineNumber);
}
if (symbol.SymbolType == SymbolType.Comma)
{
// Add the comma and continue.
this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma, attributeReference));
}
else if (symbol.SymbolType != SymbolType.CloseSquareBracket)
{
// This type of symbol is unexpected.
throw new SyntaxException(this.document.SourceCode, firstSymbol.LineNumber);
}
}
// Get the location of the attribute.
CodeLocation location = CsToken.JoinLocations(this.tokens.First, this.tokens.Last);
// Create and return the attribute.
var attribute = new Attribute(
this.tokens,
location,
parentReference,
attributeExpressions.ToArray(),
this.tokens.First.Value.Generated || this.tokens.Last.Value.Generated);
attributeReference.Target = attribute;
return attribute;
}
/// <summary>
/// Parses the iterators from a for-statement.
/// </summary>
/// <param name="statementReference">A reference to the statement being created.</param>
/// <param name="unsafeCode">Indicates whether the code is located within an unsafe block.</param>
/// <param name="openParenthesis">The opening parentheis.</param>
/// <param name="openParenthesisNode">The opening parenthesis node.</param>
/// <returns>Returns the list of iterators.</returns>
private List<Expression> ParseForStatementIterators(
Reference<ICodePart> statementReference, bool unsafeCode, Bracket openParenthesis, Node<CsToken> openParenthesisNode)
{
Param.AssertNotNull(statementReference, "statementReference");
Param.Ignore(unsafeCode);
Param.AssertNotNull(openParenthesis, "openParenthesis");
Param.AssertNotNull(openParenthesisNode, "openParenthesisNode");
// Get the iterators.
List<Expression> iterators = new List<Expression>();
while (true)
{
// Check the type of the next symbol.
Symbol symbol = this.GetNextSymbol(statementReference);
if (symbol.SymbolType == SymbolType.CloseParenthesis)
{
// This is the end of the iterator list. Add the parenthesis and break.
Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis, statementReference);
Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis);
openParenthesis.MatchingBracketNode = closeParenthesisNode;
closeParenthesis.MatchingBracketNode = openParenthesisNode;
break;
}
// Get the next iterator expression.
Expression iterator = this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode);
if (iterator == null || iterator.Tokens.First == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
// Add the initializer to the list.
iterators.Add(iterator);
// If the next symbol is a comma, save it.
symbol = this.GetNextSymbol(statementReference);
if (symbol.SymbolType == SymbolType.Comma)
{
this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma, statementReference));
}
else if (symbol.SymbolType != SymbolType.CloseParenthesis)
{
// If it's not a comma it must be a closing parenthesis.
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
}
return iterators;
}
private MasterList<CsToken> GetGenericArgumentList(
Reference<ICodePart> genericTypeReference, bool unsafeCode, CsToken name, int startIndex, out int endIndex)
{
Param.AssertNotNull(genericTypeReference, "genericTypeReference");
Param.Ignore(unsafeCode);
Param.Ignore(name);
Param.AssertGreaterThanOrEqualToZero(startIndex, "startIndex");
endIndex = -1;
MasterList<CsToken> genericArgumentListTokens = null;
// Move past whitespace and comments.
int index = startIndex;
while (true)
{
Symbol next = this.symbols.Peek(index);
if (next == null ||
(next.SymbolType != SymbolType.WhiteSpace &&
next.SymbolType != SymbolType.EndOfLine &&
next.SymbolType != SymbolType.SingleLineComment &&
next.SymbolType != SymbolType.MultiLineComment &&
next.SymbolType != SymbolType.PreprocessorDirective))
{
break;
}
++index;
}
// The next symbol should be an opening bracket, if this is a generic.
Symbol symbol = this.symbols.Peek(index);
if (symbol != null && symbol.SymbolType == SymbolType.LessThan)
{
// This might be a generic. Assume that it is and start creating tokens.
genericArgumentListTokens = new MasterList<CsToken>();
// Add the name if one was provided.
if (name != null)
{
genericArgumentListTokens.Add(name);
}
Node<CsToken> openingGenericBracketNode = null;
// Add everything up to the opening bracket into the token list.
for (int i = startIndex; i <= index; ++i)
{
symbol = this.symbols.Peek(i);
Debug.Assert(symbol != null, "The next symbol should not be null");
if (symbol.SymbolType == SymbolType.LessThan)
{
if (openingGenericBracketNode != null)
{
// This is not a generic statement.
return null;
}
Bracket openingGenericBracket = new Bracket(
symbol.Text, CsTokenType.OpenGenericBracket, symbol.Location, genericTypeReference, this.symbols.Generated);
openingGenericBracketNode = genericArgumentListTokens.InsertLast(openingGenericBracket);
}
else
{
genericArgumentListTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType), genericTypeReference));
}
}
// Loop through the rest of the symbols.
while (true)
{
symbol = this.symbols.Peek(++index);
if (symbol == null)
{
// The code ran out before we found the end of the generic.
throw new SyntaxException(this.document.SourceCode, name.LineNumber);
}
else if (symbol.SymbolType == SymbolType.GreaterThan)
{
if (openingGenericBracketNode == null)
{
// This is not a generic statement.
return null;
}
// This is the end of the generic statement. Add the closing bracket to the token list.
Bracket closingGenericBracket = new Bracket(
symbol.Text, CsTokenType.CloseGenericBracket, symbol.Location, genericTypeReference, this.symbols.Generated);
Node<CsToken> closingGenericBracketNode = genericArgumentListTokens.InsertLast(closingGenericBracket);
((Bracket)openingGenericBracketNode.Value).MatchingBracketNode = closingGenericBracketNode;
closingGenericBracket.MatchingBracketNode = openingGenericBracketNode;
endIndex = index;
break;
}
else if (symbol.SymbolType == SymbolType.Out || symbol.SymbolType == SymbolType.In)
{
// Get the in or out keyword.
genericArgumentListTokens.Add(this.ConvertSymbol(
symbol, symbol.SymbolType == SymbolType.In ? CsTokenType.In : CsTokenType.Out, genericTypeReference));
}
else if (symbol.SymbolType == SymbolType.Other)
{
int lastIndex = 0;
var wordReference = new Reference<ICodePart>();
CsToken word = this.GetTypeTokenAux(wordReference, genericTypeReference, unsafeCode, true, false, index, out lastIndex);
if (word == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
// Advance the index to the end of the token.
index = lastIndex;
// Add the token.
genericArgumentListTokens.Add(word);
}
else if (symbol.SymbolType == SymbolType.WhiteSpace ||
symbol.SymbolType == SymbolType.EndOfLine ||
symbol.SymbolType == SymbolType.SingleLineComment ||
symbol.SymbolType == SymbolType.MultiLineComment ||
symbol.SymbolType == SymbolType.PreprocessorDirective)
{
// Add these to the token list.
genericArgumentListTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType), genericTypeReference));
}
else if (symbol.SymbolType == SymbolType.Comma)
{
genericArgumentListTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Comma, genericTypeReference));
}
else if (symbol.SymbolType == SymbolType.OpenSquareBracket)
{
// An attribute on the generic type.
genericArgumentListTokens.Add(this.GetAttribute(genericTypeReference, unsafeCode));
}
else
{
// Any other symbol signifies that this is not a generic statement.
genericArgumentListTokens = null;
break;
}
}
}
return genericArgumentListTokens;
}
/// <summary>
/// Gets array brackets symbol for a type token, if they exist.
/// </summary>
/// <param name="typeTokenReference">A reference to the type token.</param>
/// <param name="typeTokens">The tokens within the type token.</param>
/// <param name="startIndex">The start index within the symbols.</param>
private void GetTypeTokenArrayBrackets(Reference<ICodePart> typeTokenReference, MasterList<CsToken> typeTokens, ref int startIndex)
{
Param.AssertNotNull(typeTokenReference, "typeTokenReference");
Param.AssertNotNull(typeTokens, "typeTokens");
Param.AssertGreaterThanOrEqualToZero(startIndex, "startIndex");
int index = this.GetNextCodeSymbolIndex(startIndex);
if (index != -1)
{
Symbol symbol = this.symbols.Peek(index);
if (symbol.SymbolType == SymbolType.OpenSquareBracket)
{
// Add the tokens up to this point.
for (int i = startIndex; i <= index - 1; ++i)
{
Symbol symbolToConvert = this.symbols.Peek(startIndex);
typeTokens.Add(this.ConvertSymbol(symbolToConvert, TokenTypeFromSymbolType(symbolToConvert.SymbolType), typeTokenReference));
++startIndex;
}
// Now collect the brackets.
Node<CsToken> openingBracketNode = null;
while (true)
{
symbol = this.symbols.Peek(startIndex);
if (symbol.SymbolType == SymbolType.WhiteSpace ||
symbol.SymbolType == SymbolType.EndOfLine ||
symbol.SymbolType == SymbolType.SingleLineComment ||
symbol.SymbolType == SymbolType.MultiLineComment ||
symbol.SymbolType == SymbolType.PreprocessorDirective)
{
typeTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType), typeTokenReference));
++startIndex;
}
else if (symbol.SymbolType == SymbolType.Number)
{
typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Number, typeTokenReference));
++startIndex;
}
else if (symbol.SymbolType == SymbolType.Other)
{
// A const used in place of a number.
typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Other, typeTokenReference));
++startIndex;
}
else if (symbol.SymbolType == SymbolType.Comma)
{
typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Comma, typeTokenReference));
++startIndex;
}
else if (symbol.SymbolType == SymbolType.OpenSquareBracket)
{
if (openingBracketNode != null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
Bracket openingBracket = new Bracket(
symbol.Text, CsTokenType.OpenSquareBracket, symbol.Location, typeTokenReference, this.symbols.Generated);
openingBracketNode = typeTokens.InsertLast(openingBracket);
++startIndex;
}
else if (symbol.SymbolType == SymbolType.CloseSquareBracket)
{
if (openingBracketNode == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
Bracket closingBracket = new Bracket(
symbol.Text, CsTokenType.CloseSquareBracket, symbol.Location, typeTokenReference, this.symbols.Generated);
Node<CsToken> closingBracketNode = typeTokens.InsertLast(closingBracket);
++startIndex;
((Bracket)openingBracketNode.Value).MatchingBracketNode = closingBracketNode;
closingBracket.MatchingBracketNode = openingBracketNode;
openingBracketNode = null;
// Check whether the next character is another opening bracket.
int temp = this.GetNextCodeSymbolIndex(startIndex);
if (temp != -1 && this.symbols.Peek(temp).SymbolType != SymbolType.OpenSquareBracket)
{
break;
}
}
else
{
if (openingBracketNode != null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
break;
}
}
}
}
}
private static string GetOpeningOrClosingBracketText(Bracket bracket)
{
switch (bracket.CsTokenType)
{
case CsTokenType.OpenParenthesis:
case CsTokenType.OpenCurlyBracket:
case CsTokenType.OpenSquareBracket:
case CsTokenType.OpenGenericBracket:
case CsTokenType.OpenAttributeBracket:
return Microsoft.StyleCop.CSharp.Strings.Opening;
case CsTokenType.CloseParenthesis:
case CsTokenType.CloseCurlyBracket:
case CsTokenType.CloseSquareBracket:
case CsTokenType.CloseGenericBracket:
case CsTokenType.CloseAttributeBracket:
return Microsoft.StyleCop.CSharp.Strings.Closing;
}
return string.Empty;
}
private void GetTypeTokenArrayBrackets(MasterList<CsToken> typeTokens, ref int startIndex)
{
Symbol symbol;
int nextCodeSymbolIndex = this.GetNextCodeSymbolIndex(startIndex);
if ((nextCodeSymbolIndex == -1) || (this.symbols.Peek(nextCodeSymbolIndex).SymbolType != SymbolType.OpenSquareBracket))
{
return;
}
for (int i = startIndex; i <= (nextCodeSymbolIndex - 1); i++)
{
Symbol symbol2 = this.symbols.Peek(startIndex);
typeTokens.Add(this.ConvertSymbol(symbol2, TokenTypeFromSymbolType(symbol2.SymbolType)));
startIndex++;
}
Microsoft.StyleCop.Node<CsToken> node = null;
Label_0067:
symbol = this.symbols.Peek(startIndex);
if (((symbol.SymbolType == SymbolType.WhiteSpace) || (symbol.SymbolType == SymbolType.EndOfLine)) || (((symbol.SymbolType == SymbolType.SingleLineComment) || (symbol.SymbolType == SymbolType.MultiLineComment)) || (symbol.SymbolType == SymbolType.PreprocessorDirective)))
{
typeTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType)));
startIndex++;
goto Label_0067;
}
if (symbol.SymbolType == SymbolType.Number)
{
typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Number));
startIndex++;
goto Label_0067;
}
if (symbol.SymbolType == SymbolType.Other)
{
typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Other));
startIndex++;
goto Label_0067;
}
if (symbol.SymbolType == SymbolType.Comma)
{
typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Comma));
startIndex++;
goto Label_0067;
}
if (symbol.SymbolType == SymbolType.OpenSquareBracket)
{
if (node != null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
Bracket item = new Bracket(symbol.Text, CsTokenType.OpenSquareBracket, symbol.Location, this.symbols.Generated);
node = typeTokens.InsertLast(item);
startIndex++;
goto Label_0067;
}
if (symbol.SymbolType == SymbolType.CloseSquareBracket)
{
if (node == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
Bracket bracket2 = new Bracket(symbol.Text, CsTokenType.CloseSquareBracket, symbol.Location, this.symbols.Generated);
Microsoft.StyleCop.Node<CsToken> node2 = typeTokens.InsertLast(bracket2);
startIndex++;
((Bracket) node.Value).MatchingBracketNode = node2;
bracket2.MatchingBracketNode = node;
node = null;
int count = this.GetNextCodeSymbolIndex(startIndex);
if ((count != -1) && (this.symbols.Peek(count).SymbolType != SymbolType.OpenSquareBracket))
{
return;
}
goto Label_0067;
}
if (node != null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
}
private List<Expression> ParseForStatementIterators(bool unsafeCode, Bracket openParenthesis, Microsoft.StyleCop.Node<CsToken> openParenthesisNode)
{
List<Expression> list = new List<Expression>();
while (true)
{
Symbol nextSymbol = this.GetNextSymbol();
if (nextSymbol.SymbolType == SymbolType.CloseParenthesis)
{
Bracket bracketToken = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis);
Microsoft.StyleCop.Node<CsToken> node = this.tokens.InsertLast(bracketToken);
openParenthesis.MatchingBracketNode = node;
bracketToken.MatchingBracketNode = openParenthesisNode;
return list;
}
Expression nextExpression = this.GetNextExpression(ExpressionPrecedence.None, unsafeCode);
if ((nextExpression == null) || (nextExpression.Tokens.First == null))
{
throw new SyntaxException(this.document.SourceCode, nextSymbol.LineNumber);
}
list.Add(nextExpression);
nextSymbol = this.GetNextSymbol();
if (nextSymbol.SymbolType != SymbolType.Comma)
{
if (nextSymbol.SymbolType != SymbolType.CloseParenthesis)
{
throw new SyntaxException(this.document.SourceCode, nextSymbol.LineNumber);
}
}
else
{
this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma));
}
}
}
internal Microsoft.StyleCop.CSharp.Attribute ParseAttribute(bool unsafeCode)
{
Symbol symbol = this.symbols.Peek(1);
List<AttributeExpression> list = new List<AttributeExpression>();
Bracket item = new Bracket(symbol.Text, CsTokenType.OpenAttributeBracket, symbol.Location, this.symbols.Generated);
Microsoft.StyleCop.Node<CsToken> node = this.tokens.InsertLast(item);
this.symbols.Advance();
Label_004A:
this.AdvanceToNextCodeSymbol();
Symbol symbol2 = this.symbols.Peek(1);
if (symbol2 == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
if (symbol2.SymbolType == SymbolType.CloseSquareBracket)
{
Bracket bracket2 = new Bracket(symbol2.Text, CsTokenType.CloseAttributeBracket, symbol2.Location, this.symbols.Generated);
Microsoft.StyleCop.Node<CsToken> node2 = this.tokens.InsertLast(bracket2);
this.symbols.Advance();
item.MatchingBracketNode = node2;
bracket2.MatchingBracketNode = node;
}
else
{
LiteralExpression target = null;
this.AdvanceToNextCodeSymbol();
symbol2 = this.symbols.Peek(1);
if (symbol2 == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
Microsoft.StyleCop.Node<CsToken> last = this.tokens.Last;
if ((symbol2.SymbolType == SymbolType.Other) || (symbol2.SymbolType == SymbolType.Return))
{
int nextCodeSymbolIndex = this.GetNextCodeSymbolIndex(2);
if (nextCodeSymbolIndex != -1)
{
Symbol symbol3 = this.symbols.Peek(nextCodeSymbolIndex);
if (symbol3.SymbolType == SymbolType.Colon)
{
symbol2.SymbolType = SymbolType.Other;
target = this.GetLiteralExpression(unsafeCode);
this.AdvanceToNextCodeSymbol();
this.tokens.Add(new CsToken(symbol3.Text, CsTokenType.AttributeColon, symbol2.Location, this.symbols.Generated));
this.symbols.Advance();
this.AdvanceToNextCodeSymbol();
}
}
}
Expression nextExpression = this.GetNextExpression(ExpressionPrecedence.None, unsafeCode);
if (nextExpression == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
list.Add(new AttributeExpression(new CsTokenList(this.tokens, last.Next, this.tokens.Last), target, nextExpression));
this.AdvanceToNextCodeSymbol();
symbol2 = this.symbols.Peek(1);
if (symbol2 == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
if (symbol2.SymbolType != SymbolType.Comma)
{
if (symbol2.SymbolType != SymbolType.CloseSquareBracket)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
}
else
{
this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma));
}
goto Label_004A;
}
return new Microsoft.StyleCop.CSharp.Attribute(this.tokens, CodeLocation.Join<CsToken>(this.tokens.First, this.tokens.Last), list.ToArray(), this.tokens.First.Value.Generated || this.tokens.Last.Value.Generated);
}
private MasterList<CsToken> GetGenericArgumentList(bool unsafeCode, CsToken name, int startIndex, out int endIndex)
{
endIndex = -1;
MasterList<CsToken> list = null;
int count = startIndex;
while (true)
{
Symbol symbol = this.symbols.Peek(count);
if ((symbol == null) || (((symbol.SymbolType != SymbolType.WhiteSpace) && (symbol.SymbolType != SymbolType.EndOfLine)) && (((symbol.SymbolType != SymbolType.SingleLineComment) && (symbol.SymbolType != SymbolType.MultiLineComment)) && (symbol.SymbolType != SymbolType.PreprocessorDirective))))
{
break;
}
count++;
}
Symbol symbol2 = this.symbols.Peek(count);
if ((symbol2 == null) || (symbol2.SymbolType != SymbolType.LessThan))
{
return list;
}
list = new MasterList<CsToken>();
if (name != null)
{
list.Add(name);
}
Microsoft.StyleCop.Node<CsToken> node = null;
for (int i = startIndex; i <= count; i++)
{
symbol2 = this.symbols.Peek(i);
if (symbol2.SymbolType == SymbolType.LessThan)
{
if (node != null)
{
return null;
}
Bracket item = new Bracket(symbol2.Text, CsTokenType.OpenGenericBracket, symbol2.Location, this.symbols.Generated);
node = list.InsertLast(item);
}
else
{
list.Add(this.ConvertSymbol(symbol2, TokenTypeFromSymbolType(symbol2.SymbolType)));
}
}
Label_00F4:
symbol2 = this.symbols.Peek(++count);
if (symbol2 == null)
{
throw new SyntaxException(this.document.SourceCode, name.LineNumber);
}
if (symbol2.SymbolType == SymbolType.GreaterThan)
{
if (node == null)
{
return null;
}
Bracket bracket2 = new Bracket(symbol2.Text, CsTokenType.CloseGenericBracket, symbol2.Location, this.symbols.Generated);
Microsoft.StyleCop.Node<CsToken> node2 = list.InsertLast(bracket2);
((Bracket) node.Value).MatchingBracketNode = node2;
bracket2.MatchingBracketNode = node;
endIndex = count;
return list;
}
if (symbol2.SymbolType == SymbolType.Other)
{
int num3 = 0;
CsToken token = this.GetTypeTokenAux(unsafeCode, true, false, count, out num3);
if (token == null)
{
throw new SyntaxException(this.document.SourceCode, symbol2.LineNumber);
}
count = num3;
list.Add(token);
goto Label_00F4;
}
if (((symbol2.SymbolType == SymbolType.WhiteSpace) || (symbol2.SymbolType == SymbolType.EndOfLine)) || (((symbol2.SymbolType == SymbolType.SingleLineComment) || (symbol2.SymbolType == SymbolType.MultiLineComment)) || (symbol2.SymbolType == SymbolType.PreprocessorDirective)))
{
list.Add(this.ConvertSymbol(symbol2, TokenTypeFromSymbolType(symbol2.SymbolType)));
goto Label_00F4;
}
if (symbol2.SymbolType == SymbolType.Comma)
{
list.Add(this.ConvertSymbol(symbol2, CsTokenType.Comma));
goto Label_00F4;
}
return null;
}
private ParenthesizedExpression GetConditionalPreprocessorParenthesizedExpression(SourceCode sourceCode)
{
this.AdvanceToNextConditionalDirectiveCodeSymbol();
Symbol symbol = this.symbols.Peek(1);
if ((symbol == null) || (symbol.SymbolType != SymbolType.OpenParenthesis))
{
throw new SyntaxException(sourceCode, symbol.LineNumber);
}
this.symbols.Advance();
Bracket item = new Bracket(symbol.Text, CsTokenType.OpenParenthesis, symbol.Location, this.symbols.Generated);
Microsoft.StyleCop.Node<CsToken> firstItemNode = this.tokens.InsertLast(item);
Expression nextConditionalPreprocessorExpression = this.GetNextConditionalPreprocessorExpression(sourceCode, ExpressionPrecedence.None);
if (nextConditionalPreprocessorExpression == null)
{
throw new SyntaxException(sourceCode, symbol.LineNumber);
}
this.AdvanceToNextConditionalDirectiveCodeSymbol();
Symbol symbol2 = this.symbols.Peek(1);
if ((symbol2 == null) || (symbol2.SymbolType != SymbolType.CloseParenthesis))
{
throw new SyntaxException(sourceCode, symbol.LineNumber);
}
this.symbols.Advance();
Bracket bracket2 = new Bracket(symbol2.Text, CsTokenType.CloseParenthesis, symbol2.Location, this.symbols.Generated);
Microsoft.StyleCop.Node<CsToken> node2 = this.tokens.InsertLast(bracket2);
item.MatchingBracketNode = node2;
bracket2.MatchingBracketNode = firstItemNode;
return new ParenthesizedExpression(new CsTokenList(this.tokens, firstItemNode, this.tokens.Last), nextConditionalPreprocessorExpression);
}
/// <summary>
/// Gets friendly output text for "opening" or "closing", depending on the type of the bracket.
/// </summary>
/// <param name="bracket">The bracket.</param>
/// <returns>Returns the opening or closing text.</returns>
private static string GetOpeningOrClosingBracketText(Bracket bracket)
{
Param.AssertNotNull(bracket, "bracket");
switch (bracket.CsTokenType)
{
case CsTokenType.OpenAttributeBracket:
case CsTokenType.OpenCurlyBracket:
case CsTokenType.OpenGenericBracket:
case CsTokenType.OpenParenthesis:
case CsTokenType.OpenSquareBracket:
return Strings.Opening;
case CsTokenType.CloseAttributeBracket:
case CsTokenType.CloseCurlyBracket:
case CsTokenType.CloseGenericBracket:
case CsTokenType.CloseParenthesis:
case CsTokenType.CloseSquareBracket:
return Strings.Closing;
default:
Debug.Fail("Invalid bracket type.");
return string.Empty;
}
}
/// <summary>
/// Reads an expression wrapped in parenthesis.
/// </summary>
/// <param name="sourceCode">The source code containing the expression.</param>
/// <param name="parentReference">The parent code part.</param>
/// <returns>Returns the expression.</returns>
private ParenthesizedExpression GetConditionalPreprocessorParenthesizedExpression(
SourceCode sourceCode, Reference<ICodePart> parentReference)
{
Param.AssertNotNull(sourceCode, "sourceCode");
Param.AssertNotNull(parentReference, "parentReference");
// Get the opening parenthesis.
this.AdvanceToNextConditionalDirectiveCodeSymbol(parentReference);
Symbol firstSymbol = this.symbols.Peek(1);
if (firstSymbol == null || firstSymbol.SymbolType != SymbolType.OpenParenthesis)
{
throw new SyntaxException(sourceCode, firstSymbol.LineNumber);
}
var expressionReference = new Reference<ICodePart>();
this.symbols.Advance();
Bracket openParenthesis = new Bracket(
firstSymbol.Text, CsTokenType.OpenParenthesis, firstSymbol.Location, expressionReference, this.symbols.Generated);
Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis);
// Get the inner expression.
Expression innerExpression = this.GetNextConditionalPreprocessorExpression(sourceCode, ExpressionPrecedence.None);
if (innerExpression == null)
{
throw new SyntaxException(sourceCode, firstSymbol.LineNumber);
}
// Get the closing parenthesis.
this.AdvanceToNextConditionalDirectiveCodeSymbol(expressionReference);
Symbol symbol = this.symbols.Peek(1);
if (symbol == null || symbol.SymbolType != SymbolType.CloseParenthesis)
{
throw new SyntaxException(sourceCode, firstSymbol.LineNumber);
}
this.symbols.Advance();
Bracket closeParenthesis = new Bracket(
symbol.Text, CsTokenType.CloseParenthesis, symbol.Location, expressionReference, this.symbols.Generated);
Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis);
openParenthesis.MatchingBracketNode = closeParenthesisNode;
closeParenthesis.MatchingBracketNode = openParenthesisNode;
// Create the token list for the expression.
CsTokenList partialTokens = new CsTokenList(this.tokens, openParenthesisNode, this.tokens.Last);
// Create and return the expression.
var expression = new ParenthesizedExpression(partialTokens, innerExpression);
expressionReference.Target = expression;
return expression;
}
