internal IsExpression(CsTokenList tokens, Expression value, LiteralExpression type)
: base(ExpressionType.Is, tokens)
{
this.value = value;
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
base.AddExpression(value);
base.AddExpression(type);
}
internal MemberAccessExpression(CsTokenList tokens, Operator operatorType, Expression leftHandSide, LiteralExpression rightHandSide)
: base(ExpressionType.MemberAccess, tokens)
{
this.operatorType = operatorType;
this.leftHandSide = leftHandSide;
this.rightHandSide = rightHandSide;
base.AddExpression(leftHandSide);
base.AddExpression(rightHandSide);
}
/// <summary>
/// Initializes a new instance of the LabelStatement class.
/// </summary>
/// <param name="tokens">The list of tokens that form the statement.</param>
/// <param name="identifier">The label identifier.</param>
internal LabelStatement(CsTokenList tokens, LiteralExpression identifier)
: base(StatementType.Label, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(identifier, "identifier");
this.identifier = identifier;
this.AddExpression(identifier);
}
/// <summary>
/// Initializes a new instance of the DefaultValueExpression class.
/// </summary>
/// <param name="tokens">The list of tokens that form the expression.</param>
/// <param name="type">The type to obtain the default value of.</param>
internal DefaultValueExpression(CsTokenList tokens, LiteralExpression type)
: base(ExpressionType.DefaultValue, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(type, "type");
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
this.AddExpression(type);
}
internal AttributeExpression(CsTokenList tokens, LiteralExpression target, Expression initialization)
: base(ExpressionType.Attribute, tokens)
{
this.target = target;
if (target != null)
{
base.AddExpression(target);
}
this.initialization = initialization;
base.AddExpression(initialization);
}
internal VariableDeclarationExpression(CsTokenList tokens, LiteralExpression type, ICollection<VariableDeclaratorExpression> declarators)
: base(ExpressionType.VariableDeclaration, tokens)
{
this.declarators = declarators;
base.AddExpression(type);
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
foreach (VariableDeclaratorExpression expression in declarators)
{
base.AddExpression(expression);
expression.ParentVariable = this;
}
}
/// <summary>
/// Initializes a new instance of the AsExpression class.
/// </summary>
/// <param name="tokens">The list of tokens that form the expression.</param>
/// <param name="value">The value to convert.</param>
/// <param name="type">The type of the conversion.</param>
internal AsExpression(CsTokenList tokens, Expression value, LiteralExpression type)
: base(ExpressionType.As, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(value, "value");
Param.AssertNotNull(type, "type");
this.value = value;
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
this.AddExpression(value);
this.AddExpression(type);
}
/// <summary>
/// Initializes a new instance of the CastExpression class.
/// </summary>
/// <param name="tokens">The list of tokens that form the expression.</param>
/// <param name="type">The cast type.</param>
/// <param name="castedExpression">The expression being casted.</param>
internal CastExpression(CsTokenList tokens, LiteralExpression type, Expression castedExpression)
: base(ExpressionType.Cast, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(type, "type");
Param.AssertNotNull(castedExpression, "castedExpression");
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
this.castedExpression = castedExpression;
this.AddExpression(type);
this.AddExpression(castedExpression);
}
/// <summary>
/// Initializes a new instance of the AttributeExpression class.
/// </summary>
/// <param name="tokens">The list of tokens that form the expression.</param>
/// <param name="target">The attribute target, if any.</param>
/// <param name="initialization">The attribute initialization call.</param>
internal AttributeExpression(CsTokenList tokens, LiteralExpression target, Expression initialization)
: base(ExpressionType.Attribute, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.Ignore(target);
Param.AssertNotNull(initialization, "initialization");
// Add the target expression.
this.target = target;
if (target != null)
{
this.AddExpression(target);
}
// Add the initialization expression.
this.initialization = initialization;
this.AddExpression(initialization);
}
/// <summary>
/// Initializes a new instance of the MemberAccessExpression class.
/// </summary>
/// <param name="tokens">The list of tokens that form the expression.</param>
/// <param name="operatorType">The type of opertion being performed.</param>
/// <param name="leftHandSide">The left side of the operation.</param>
/// <param name="rightHandSide">The member being accessed.</param>
internal MemberAccessExpression(
CsTokenList tokens,
Operator operatorType,
Expression leftHandSide,
LiteralExpression rightHandSide)
: base(ExpressionType.MemberAccess, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.Ignore(operatorType);
Param.AssertNotNull(leftHandSide, "leftHandSide");
Param.AssertNotNull(rightHandSide, "rightHandSide");
this.operatorType = operatorType;
this.leftHandSide = leftHandSide;
this.rightHandSide = rightHandSide;
this.AddExpression(leftHandSide);
this.AddExpression(rightHandSide);
}
/// <summary>
/// Initializes a new instance of the EventDeclaratorExpression class.
/// </summary>
/// <param name="tokens">The list of tokens that form the statement.</param>
/// <param name="identifier">The identifier name of the event.</param>
/// <param name="initializer">The initialization expression for the event.</param>
internal EventDeclaratorExpression(
CsTokenList tokens,
LiteralExpression identifier,
Expression initializer)
: base(ExpressionType.EventDeclarator, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(identifier, "identifier");
Param.Ignore(initializer);
this.identifier = identifier;
this.initializer = initializer;
this.AddExpression(identifier);
if (initializer != null)
{
this.AddExpression(initializer);
}
}
/// <summary>
/// Initializes a new instance of the VariableDeclarationExpression class.
/// </summary>
/// <param name="tokens">The list of tokens that form the statement.</param>
/// <param name="type">The type of the variable or variables being declared.</param>
/// <param name="declarators">The list of declarators in the expression.</param>
internal VariableDeclarationExpression(
CsTokenList tokens,
LiteralExpression type,
ICollection<VariableDeclaratorExpression> declarators)
: base(ExpressionType.VariableDeclaration, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(type, "type");
Param.AssertNotNull(declarators, "declarators");
this.declarators = declarators;
Debug.Assert(declarators.IsReadOnly, "The declarators collection should be read-only.");
this.AddExpression(type);
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
foreach (VariableDeclaratorExpression expression in declarators)
{
this.AddExpression(expression);
expression.ParentVariable = this;
}
}
/// <summary>
/// Reads an expression starting with an unknown word.
/// </summary>
/// <returns>Returns the expression.</returns>
private LiteralExpression GetConditionalPreprocessorConstantExpression()
{
// Get the first symbol.
Symbol symbol = this.symbols.Peek(1);
Debug.Assert(symbol != null && symbol.SymbolType == SymbolType.Other, "Expected a text symbol");
var expressionReference = new Reference<ICodePart>();
// Convert the symbol to a token.
this.symbols.Advance();
CsToken literalToken = new CsToken(symbol.Text, CsTokenType.Other, symbol.Location, expressionReference, this.symbols.Generated);
Node<CsToken> literalTokenNode = this.tokens.InsertLast(literalToken);
// Create a literal expression from this token.
var expression = new LiteralExpression(this.tokens, literalTokenNode);
expressionReference.Target = expression;
return expression;
}
/// <summary>
/// Converts the given expression into a literal expression containing a type token.
/// </summary>
/// <param name="expression">The expression to convert.</param>
/// <returns>Returns the converted expression.</returns>
private LiteralExpression ConvertTypeExpression(Expression expression)
{
Param.AssertNotNull(expression, "expression");
// Get the first and last token in the expression.
Node<CsToken> firstTokenNode = expression.Tokens.First;
Node<CsToken> lastTokenNode = expression.Tokens.Last;
var typeTokenReference = new Reference<ICodePart>();
var expressionReference = new Reference<ICodePart>();
// Create a new token list containing these tokens.
List<CsToken> tokenList = new List<CsToken>();
foreach (CsToken token in expression.Tokens)
{
tokenList.Add(token);
token.ParentRef = typeTokenReference;
}
// Remove the extra tokens from the master list.
if (firstTokenNode != null && expression.Tokens.First != null)
{
Node<CsToken> temp = firstTokenNode.Next;
if (!expression.Tokens.OutOfBounds(temp))
{
this.tokens.RemoveRange(temp, expression.Tokens.Last);
}
}
// Add the child tokens to a token list.
MasterList<CsToken> childTokens = new MasterList<CsToken>(tokenList);
// Create the new type token.
TypeToken typeToken = new TypeToken(
childTokens, CsToken.JoinLocations(firstTokenNode, lastTokenNode), expressionReference, firstTokenNode.Value.Generated);
typeTokenReference.Target = typeToken;
// Insert the new token.
Node<CsToken> typeTokenNode = this.tokens.Replace(firstTokenNode, typeToken);
// Create the literal expression.
var literalExpression = new LiteralExpression(
new CsTokenList(this.tokens, firstTokenNode, firstTokenNode),
typeTokenNode);
expressionReference.Target = literalExpression;
return literalExpression;
}
private Expression GetNextExpression(
ExpressionPrecedence previousPrecedence,
Reference<ICodePart> parentReference,
bool unsafeCode,
bool allowVariableDeclaration,
bool typeExpression)
{
Param.Ignore(previousPrecedence);
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
Param.Ignore(allowVariableDeclaration);
Param.Ignore(typeExpression);
// Saves the next expression.
Expression expression = null;
// Get the next symbol.
Symbol symbol = this.GetNextSymbol(parentReference);
if (symbol != null)
{
switch (symbol.SymbolType)
{
case SymbolType.Other:
if (this.IsLambdaExpression())
{
expression = this.GetLambdaExpression(parentReference, unsafeCode);
}
else if (this.IsQueryExpression(unsafeCode))
{
expression = this.GetQueryExpression(parentReference, unsafeCode);
}
// If the expression is still null now, this is just a regular 'other' expression.
if (expression == null)
{
expression = this.GetOtherExpression(parentReference, allowVariableDeclaration, unsafeCode);
}
break;
case SymbolType.Checked:
expression = this.GetCheckedExpression(parentReference, unsafeCode);
break;
case SymbolType.Unchecked:
expression = this.GetUncheckedExpression(parentReference, unsafeCode);
break;
case SymbolType.New:
expression = this.GetNewAllocationExpression(parentReference, unsafeCode);
break;
case SymbolType.Stackalloc:
expression = this.GetStackallocExpression(parentReference, unsafeCode);
break;
case SymbolType.Sizeof:
expression = this.GetSizeofExpression(parentReference, unsafeCode);
break;
case SymbolType.Typeof:
expression = this.GetTypeofExpression(parentReference, unsafeCode);
break;
case SymbolType.Default:
expression = this.GetDefaultValueExpression(parentReference, unsafeCode);
break;
case SymbolType.Delegate:
expression = this.GetAnonymousMethodExpression(parentReference, unsafeCode);
break;
case SymbolType.Increment:
if (this.IsUnaryExpression())
{
expression = this.GetUnaryIncrementExpression(unsafeCode);
}
break;
case SymbolType.Decrement:
if (this.IsUnaryExpression())
{
expression = this.GetUnaryDecrementExpression(unsafeCode);
}
break;
case SymbolType.Plus:
case SymbolType.Minus:
if (this.IsUnaryExpression())
{
expression = this.GetUnaryExpression(parentReference, unsafeCode);
}
break;
case SymbolType.Not:
case SymbolType.Tilde:
expression = this.GetUnaryExpression(parentReference, unsafeCode);
break;
case SymbolType.OpenParenthesis:
if (this.IsLambdaExpression())
{
expression = this.GetLambdaExpression(parentReference, unsafeCode);
}
else
{
expression = this.GetOpenParenthesisExpression(previousPrecedence, unsafeCode);
}
break;
case SymbolType.Number:
var numberExpressionReference = new Reference<ICodePart>();
Node<CsToken> tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Number, SymbolType.Number, numberExpressionReference));
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
numberExpressionReference.Target = expression;
break;
case SymbolType.String:
var stringExpressionReference = new Reference<ICodePart>();
tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.String, SymbolType.String, stringExpressionReference));
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
stringExpressionReference.Target = expression;
break;
case SymbolType.True:
var trueExpressionReference = new Reference<ICodePart>();
tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.True, SymbolType.True, trueExpressionReference));
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
trueExpressionReference.Target = expression;
break;
case SymbolType.False:
var falseExpressionReference = new Reference<ICodePart>();
tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.False, SymbolType.False, falseExpressionReference));
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
falseExpressionReference.Target = expression;
break;
case SymbolType.Null:
var nullExpressionReference = new Reference<ICodePart>();
tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Null, SymbolType.Null, nullExpressionReference));
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
nullExpressionReference.Target = expression;
break;
case SymbolType.This:
var thisExpressionReference = new Reference<ICodePart>();
tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.This, SymbolType.This, thisExpressionReference));
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
thisExpressionReference.Target = expression;
break;
case SymbolType.Base:
var baseExpressionReference = new Reference<ICodePart>();
tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Base, SymbolType.Base, baseExpressionReference));
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
baseExpressionReference.Target = expression;
break;
case SymbolType.Multiplication:
if (!unsafeCode)
{
goto default;
}
expression = this.GetUnsafeAccessExpression(parentReference, unsafeCode);
break;
case SymbolType.LogicalAnd:
if (!unsafeCode)
{
goto default;
}
expression = this.GetUnsafeAccessExpression(parentReference, unsafeCode);
break;
default:
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
}
// Gather up all extensions to this expression.
while (expression != null)
{
var expressionReference = new Reference<ICodePart>(expression);
// Check if there is an extension to this expression.
Expression extension = this.GetExpressionExtension(expression, previousPrecedence, expressionReference, unsafeCode, typeExpression, allowVariableDeclaration);
if (extension != null)
{
// The larger expression is what we want to return here.
expression = extension;
}
else
{
// There are no more extensions.
break;
}
}
// Return the expression.
return expression;
}
/// <summary>
/// Reads an expression starting with an unknown word.
/// </summary>
/// <param name="parentReference">The parent code part.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <returns>Returns the expression.</returns>
private LiteralExpression GetLiteralExpression(Reference<ICodePart> parentReference, bool unsafeCode)
{
Param.Ignore(unsafeCode);
Param.AssertNotNull(parentReference, "parentReference");
// Get the first symbol.
Symbol symbol = this.GetNextSymbol(parentReference);
// Create a reference to the literal expression we're creating.
var expressionReference = new Reference<ICodePart>();
// First, check if this is a generic.
CsToken literalToken = null;
int temp;
bool generic = false;
if (symbol.SymbolType == SymbolType.Other && this.HasTypeSignature(1, false, out temp, out generic) && generic)
{
literalToken = this.GetGenericToken(expressionReference, unsafeCode);
}
if (literalToken == null)
{
// This is not a generic. Just convert the symbol to a token.
literalToken = this.GetToken(CsTokenType.Other, SymbolType.Other, expressionReference);
}
// Add the token to the document.
Node<CsToken> literalTokenNode = this.tokens.InsertLast(literalToken);
// Create a literal expression from this token.
var expression = new LiteralExpression(this.tokens, literalTokenNode);
expressionReference.Target = expression;
return expression;
}
private GotoStatement ParseGotoStatement(bool unsafeCode)
{
CsToken item = this.GetToken(CsTokenType.Goto, SymbolType.Goto);
Microsoft.StyleCop.Node<CsToken> firstItemNode = this.tokens.InsertLast(item);
Symbol nextSymbol = this.GetNextSymbol();
Expression identifier = null;
if (nextSymbol.SymbolType == SymbolType.Default)
{
Microsoft.StyleCop.Node<CsToken> tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Other, SymbolType.Default));
identifier = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
}
else if (nextSymbol.SymbolType == SymbolType.Case)
{
this.tokens.Add(this.GetToken(CsTokenType.Other, SymbolType.Case));
identifier = this.GetNextExpression(ExpressionPrecedence.None, unsafeCode);
}
else
{
identifier = this.GetNextExpression(ExpressionPrecedence.None, unsafeCode);
}
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon));
return new GotoStatement(new CsTokenList(this.tokens, firstItemNode, firstItemNode), identifier);
}
private Constructor ParseConstructor(CsElement parent, bool unsafeCode, bool generated, XmlHeader xmlHeader, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes)
{
Microsoft.StyleCop.Node<CsToken> last = this.tokens.Last;
AccessModifierType @private = AccessModifierType.Private;
Dictionary<CsTokenType, CsToken> elementModifiers = this.GetElementModifiers(ref @private, ConstructorModifiers);
unsafeCode |= elementModifiers.ContainsKey(CsTokenType.Unsafe);
CsToken elementNameToken = this.GetElementNameToken(unsafeCode);
this.tokens.Add(elementNameToken);
IList<Parameter> parameters = this.ParseParameterList(unsafeCode, SymbolType.OpenParenthesis);
MethodInvocationExpression initializerExpression = null;
if (this.GetNextSymbol().SymbolType == SymbolType.Colon)
{
this.tokens.Add(this.GetToken(CsTokenType.BaseColon, SymbolType.Colon));
Symbol nextSymbol = this.GetNextSymbol();
if ((nextSymbol.SymbolType != SymbolType.This) && (nextSymbol.SymbolType != SymbolType.Base))
{
throw this.CreateSyntaxException();
}
Microsoft.StyleCop.Node<CsToken> tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Other, nextSymbol.SymbolType));
LiteralExpression methodName = new LiteralExpression(this.tokens, tokenNode);
initializerExpression = this.GetMethodInvocationExpression(methodName, ExpressionPrecedence.None, unsafeCode);
}
Microsoft.StyleCop.Node<CsToken> firstItemNode = (last == null) ? this.tokens.First : last.Next;
CsTokenList tokens = new CsTokenList(this.tokens, firstItemNode, this.tokens.Last);
Declaration declaration = new Declaration(tokens, elementNameToken.Text, ElementType.Constructor, @private, elementModifiers);
Constructor element = new Constructor(this.document, parent, xmlHeader, attributes, declaration, parameters, initializerExpression, unsafeCode, generated);
if (elementModifiers.ContainsKey(CsTokenType.Extern))
{
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon));
return element;
}
this.ParseStatementContainer(element, true, unsafeCode);
return element;
}
private Expression GetNextExpression(ExpressionPrecedence previousPrecedence, bool unsafeCode, bool allowVariableDeclaration, bool typeExpression)
{
Expression leftSide = null;
Symbol nextSymbol = this.GetNextSymbol();
if (nextSymbol != null)
{
Microsoft.StyleCop.Node<CsToken> node;
switch (nextSymbol.SymbolType)
{
case SymbolType.Not:
case SymbolType.Tilde:
leftSide = this.GetUnaryExpression(unsafeCode);
goto Label_03B9;
case SymbolType.Base:
node = this.tokens.InsertLast(this.GetToken(CsTokenType.Base, SymbolType.Base));
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_03B9;
case SymbolType.Plus:
case SymbolType.Minus:
if (this.IsUnaryExpression())
{
leftSide = this.GetUnaryExpression(unsafeCode);
}
goto Label_03B9;
case SymbolType.PlusEquals:
case SymbolType.MinusEquals:
case SymbolType.Static:
case SymbolType.Struct:
case SymbolType.Switch:
case SymbolType.Throw:
case SymbolType.Try:
case SymbolType.WhiteSpace:
case SymbolType.EndOfLine:
goto Label_0390;
case SymbolType.Multiplication:
if (!unsafeCode)
{
goto Label_0390;
}
leftSide = this.GetUnsafeAccessExpression(unsafeCode);
goto Label_03B9;
case SymbolType.OpenParenthesis:
if (this.IsLambdaExpression())
{
leftSide = this.GetLambdaExpression(unsafeCode);
}
else
{
leftSide = this.GetOpenParenthesisExpression(unsafeCode);
}
goto Label_03B9;
case SymbolType.Increment:
if (this.IsUnaryExpression())
{
leftSide = this.GetUnaryIncrementExpression(unsafeCode);
}
goto Label_03B9;
case SymbolType.Decrement:
if (this.IsUnaryExpression())
{
leftSide = this.GetUnaryDecrementExpression(unsafeCode);
}
goto Label_03B9;
case SymbolType.LogicalAnd:
if (!unsafeCode)
{
goto Label_0390;
}
leftSide = this.GetUnsafeAccessExpression(unsafeCode);
goto Label_03B9;
case SymbolType.Default:
leftSide = this.GetDefaultValueExpression(unsafeCode);
goto Label_03B9;
case SymbolType.Delegate:
leftSide = this.GetAnonymousMethodExpression(unsafeCode);
goto Label_03B9;
case SymbolType.False:
node = this.tokens.InsertLast(this.GetToken(CsTokenType.False, SymbolType.False));
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_03B9;
case SymbolType.Checked:
leftSide = this.GetCheckedExpression(unsafeCode);
goto Label_03B9;
case SymbolType.New:
leftSide = this.GetNewAllocationExpression(unsafeCode);
goto Label_03B9;
case SymbolType.Null:
node = this.tokens.InsertLast(this.GetToken(CsTokenType.Null, SymbolType.Null));
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_03B9;
case SymbolType.Sizeof:
leftSide = this.GetSizeofExpression(unsafeCode);
goto Label_03B9;
case SymbolType.Stackalloc:
leftSide = this.GetStackallocExpression(unsafeCode);
goto Label_03B9;
case SymbolType.This:
node = this.tokens.InsertLast(this.GetToken(CsTokenType.This, SymbolType.This));
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_03B9;
case SymbolType.True:
node = this.tokens.InsertLast(this.GetToken(CsTokenType.True, SymbolType.True));
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_03B9;
case SymbolType.Typeof:
leftSide = this.GetTypeofExpression(unsafeCode);
goto Label_03B9;
case SymbolType.Unchecked:
leftSide = this.GetUncheckedExpression(unsafeCode);
goto Label_03B9;
case SymbolType.Other:
if (!this.IsLambdaExpression())
{
if (this.IsQueryExpression(unsafeCode))
{
leftSide = this.GetQueryExpression(unsafeCode);
}
break;
}
leftSide = this.GetLambdaExpression(unsafeCode);
break;
case SymbolType.String:
node = this.tokens.InsertLast(this.GetToken(CsTokenType.String, SymbolType.String));
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_03B9;
case SymbolType.Number:
node = this.tokens.InsertLast(this.GetToken(CsTokenType.Number, SymbolType.Number));
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_03B9;
default:
goto Label_0390;
}
if (leftSide == null)
{
leftSide = this.GetOtherExpression(allowVariableDeclaration, unsafeCode);
}
}
goto Label_03B9;
Label_0390:
throw new SyntaxException(this.document.SourceCode, nextSymbol.LineNumber);
Label_03B9:
while (leftSide != null)
{
Expression expression2 = this.GetExpressionExtension(leftSide, previousPrecedence, unsafeCode, typeExpression, allowVariableDeclaration);
if (expression2 == null)
{
return leftSide;
}
leftSide = expression2;
}
return leftSide;
}
private Expression GetNextConditionalPreprocessorExpression(SourceCode sourceCode, ExpressionPrecedence previousPrecedence)
{
this.AdvanceToNextConditionalDirectiveCodeSymbol();
Expression leftSide = null;
Symbol symbol = this.symbols.Peek(1);
if (symbol != null)
{
CsToken token;
Microsoft.StyleCop.Node<CsToken> node;
SymbolType symbolType = symbol.SymbolType;
if (symbolType <= SymbolType.Not)
{
switch (symbolType)
{
case SymbolType.OpenParenthesis:
leftSide = this.GetConditionalPreprocessorParenthesizedExpression(sourceCode);
goto Label_012D;
case SymbolType.Not:
leftSide = this.GetConditionalPreprocessorNotExpression(sourceCode);
goto Label_012D;
}
goto Label_010E;
}
switch (symbolType)
{
case SymbolType.False:
this.symbols.Advance();
token = new CsToken(symbol.Text, CsTokenType.False, symbol.Location, this.symbols.Generated);
node = this.tokens.InsertLast(token);
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_012D;
case SymbolType.True:
this.symbols.Advance();
token = new CsToken(symbol.Text, CsTokenType.True, symbol.Location, this.symbols.Generated);
node = this.tokens.InsertLast(token);
leftSide = new LiteralExpression(new CsTokenList(this.tokens, node, node), node);
goto Label_012D;
}
if (symbolType != SymbolType.Other)
{
goto Label_010E;
}
leftSide = this.GetConditionalPreprocessorConstantExpression();
}
goto Label_012D;
Label_010E:
throw new SyntaxException(sourceCode, symbol.LineNumber);
Label_012D:
while (leftSide != null)
{
Expression expression2 = this.GetConditionalPreprocessorExpressionExtension(sourceCode, leftSide, previousPrecedence);
if (expression2 == null)
{
return leftSide;
}
leftSide = expression2;
}
return leftSide;
}
internal LabelStatement(CsTokenList tokens, LiteralExpression identifier)
: base(StatementType.Label, tokens)
{
this.identifier = identifier;
base.AddExpression(identifier);
}
/// <summary>
/// Reads the next goto-statement from the file and returns it.
/// </summary>
/// <param name="parentReference">The parent code unit.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the statement.</returns>
private GotoStatement ParseGotoStatement(Reference<ICodePart> parentReference, bool unsafeCode)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
var statementReference = new Reference<ICodePart>();
// Move past the goto keyword.
CsToken firstToken = this.GetToken(CsTokenType.Goto, SymbolType.Goto, parentReference, statementReference);
Node<CsToken> firstTokenNode = this.tokens.InsertLast(firstToken);
// Get the next symbol.
Symbol symbol = this.GetNextSymbol(statementReference);
Expression identifier = null;
if (symbol.SymbolType == SymbolType.Default)
{
Node<CsToken> tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Other, SymbolType.Default, statementReference));
identifier = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
}
else if (symbol.SymbolType == SymbolType.Case)
{
this.tokens.Add(this.GetToken(CsTokenType.Other, SymbolType.Case, statementReference));
identifier = this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode);
}
else
{
identifier = this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode);
}
// Get the closing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, statementReference));
// Create the token list for the statement.
CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, firstTokenNode);
// Create and return the goto-statement.
var statement = new GotoStatement(partialTokens, identifier);
statementReference.Target = statement;
return statement;
}
internal TypeofExpression(CsTokenList tokens, LiteralExpression type)
: base(ExpressionType.Typeof, tokens)
{
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
base.AddExpression(type);
}
internal DefaultValueExpression(CsTokenList tokens, LiteralExpression type)
: base(ExpressionType.DefaultValue, tokens)
{
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
base.AddExpression(type);
}
/// <summary>
/// Parses and returns a constructor.
/// </summary>
/// <param name="parent">The parent of the element.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <param name="xmlHeader">The element's documentation header.</param>
/// <param name="attributes">The attributes on the element.</param>
/// <returns>Returns the element.</returns>
private Constructor ParseConstructor(
CsElement parent,
Reference<ICodePart> elementReference,
bool unsafeCode,
bool generated,
XmlHeader xmlHeader,
ICollection<Attribute> attributes)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
Param.Ignore(xmlHeader);
Param.Ignore(attributes);
Node<CsToken> previousTokenNode = this.tokens.Last;
// Get the modifiers and access.
AccessModifierType accessModifier = AccessModifierType.Private;
Dictionary<CsTokenType, CsToken> modifiers = this.GetElementModifiers(elementReference, ref accessModifier, ConstructorModifiers);
unsafeCode |= modifiers.ContainsKey(CsTokenType.Unsafe);
// Get the name of the constructor.
CsToken name = this.GetElementNameToken(elementReference, unsafeCode);
this.tokens.Add(name);
// Get the parameter list.
IList<Parameter> parameters = this.ParseParameterList(elementReference, unsafeCode, SymbolType.OpenParenthesis);
// Get the constructor initializer if there is one.
MethodInvocationExpression constructorInitializer = null;
Symbol symbol = this.GetNextSymbol(elementReference);
if (symbol.SymbolType == SymbolType.Colon)
{
this.tokens.Add(this.GetToken(CsTokenType.BaseColon, SymbolType.Colon, elementReference));
// The next symbol must be the keyword base or this.
symbol = this.GetNextSymbol(elementReference);
if (symbol.SymbolType != SymbolType.This && symbol.SymbolType != SymbolType.Base)
{
throw this.CreateSyntaxException();
}
var initializerNameExpressionReference = new Reference<ICodePart>();
Node<CsToken> initializerNameTokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Other, symbol.SymbolType, initializerNameExpressionReference));
// Get the name expression.
LiteralExpression initializerNameExpression = new LiteralExpression(this.tokens, initializerNameTokenNode);
initializerNameExpressionReference.Target = initializerNameExpression;
// Get the initializer expression.
constructorInitializer = this.GetMethodInvocationExpression(
initializerNameExpression, ExpressionPrecedence.None, unsafeCode);
}
// Create the declaration.
Node<CsToken> firstTokenNode = previousTokenNode == null ? this.tokens.First : previousTokenNode.Next;
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
Declaration declaration = new Declaration(
declarationTokens, name.Text, ElementType.Constructor, accessModifier, modifiers);
Constructor constructor = new Constructor(
this.document,
parent,
xmlHeader,
attributes,
declaration,
parameters,
constructorInitializer,
unsafeCode,
generated);
elementReference.Target = constructor;
// If the constructor is extern, it will not have a body.
if (modifiers.ContainsKey(CsTokenType.Extern))
{
// Get the closing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference));
}
else
{
// Get the body.
this.ParseStatementContainer(constructor, true, unsafeCode);
}
return constructor;
}
/// <summary>
/// Reads the next expression from a conditional preprocessor directive.
/// </summary>
/// <param name="sourceCode">The source code.</param>
/// <param name="previousPrecedence">The precedence of the expression just before this one.</param>
/// <returns>Returns the expression.</returns>
private Expression GetNextConditionalPreprocessorExpression(SourceCode sourceCode, ExpressionPrecedence previousPrecedence)
{
Param.AssertNotNull(sourceCode, "sourceCode");
Param.Ignore(previousPrecedence);
var parentReference = new Reference<ICodePart>();
// Move past comments and whitepace.
this.AdvanceToNextConditionalDirectiveCodeSymbol(parentReference);
// Saves the next expression.
Expression expression = null;
// Get the next symbol.
Symbol symbol = this.symbols.Peek(1);
if (symbol != null)
{
switch (symbol.SymbolType)
{
case SymbolType.Other:
expression = this.GetConditionalPreprocessorConstantExpression();
break;
case SymbolType.Not:
expression = this.GetConditionalPreprocessorNotExpression(sourceCode, parentReference);
break;
case SymbolType.OpenParenthesis:
expression = this.GetConditionalPreprocessorParenthesizedExpression(sourceCode, parentReference);
break;
case SymbolType.False:
this.symbols.Advance();
var falseExpressionReference = new Reference<ICodePart>();
CsToken token = new CsToken(symbol.Text, CsTokenType.False, symbol.Location, falseExpressionReference, this.symbols.Generated);
Node<CsToken> tokenNode = this.tokens.InsertLast(token);
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
falseExpressionReference.Target = expression;
break;
case SymbolType.True:
this.symbols.Advance();
var trueExpressionReference = new Reference<ICodePart>();
token = new CsToken(symbol.Text, CsTokenType.True, symbol.Location, trueExpressionReference, this.symbols.Generated);
tokenNode = this.tokens.InsertLast(token);
expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode);
trueExpressionReference.Target = expression;
break;
default:
throw new SyntaxException(sourceCode, symbol.LineNumber);
}
}
// Gather up all extensions to this expression.
while (expression != null)
{
var expressionReference = new Reference<ICodePart>(expression);
// Check if there is an extension to this expression.
Expression extension = this.GetConditionalPreprocessorExpressionExtension(
sourceCode, expressionReference, expression, previousPrecedence);
if (extension != null)
{
// The larger expression is what we want to return here.
expression = extension;
}
else
{
// There are no more extensions.
break;
}
}
// Return the expression.
return expression;
}
/// <summary>
/// Extracts a TypeToken from the literal expression, assuming that one exists.
/// </summary>
/// <param name="literal">The literal expression.</param>
/// <returns>Returns the type token.</returns>
internal static TypeToken ExtractTypeTokenFromLiteralExpression(LiteralExpression literal)
{
Param.AssertNotNull(literal, "literal");
Debug.Assert(
literal.TokenNode != null &&
literal.TokenNode.Value != null &&
(literal.TokenNode.Value.CsTokenClass == CsTokenClass.Type ||
literal.TokenNode.Value.CsTokenClass == CsTokenClass.GenericType),
"The literal expression does not contain a TypeToken");
return (TypeToken)literal.TokenNode.Value;
}
internal static TypeToken ExtractTypeTokenFromLiteralExpression(LiteralExpression literal)
{
return (TypeToken) literal.TokenNode.Value;
}