/// <summary>
/// Initializes a new instance of the VariableDeclarationStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="expression">The inner expression.</param>
internal VariableDeclarationStatement(CodeUnitProxy proxy, VariableDeclarationExpression expression)
: base(proxy, StatementType.VariableDeclaration)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
this.expression.Value = expression;
}
/// <summary>
/// Initializes a new instance of the FixedStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="fixedVariable">The fixed variable.</param>
internal FixedStatement(CodeUnitProxy proxy, VariableDeclarationExpression fixedVariable)
: base(proxy, StatementType.Fixed)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(fixedVariable, "fixedVariable");
this.fixedVariable.Value = fixedVariable;
}
/// <summary>
/// Initializes a new instance of the VariableDeclarationStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="expression">The inner expression.</param>
internal VariableDeclarationStatement(CodeUnitProxy proxy, VariableDeclarationExpression expression)
: base(proxy, StatementType.VariableDeclaration)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
this.expression.Value = expression;
}
/// <summary>
/// Initializes a new instance of the FixedStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="fixedVariable">The fixed variable.</param>
internal FixedStatement(CodeUnitProxy proxy, VariableDeclarationExpression fixedVariable)
: base(proxy, StatementType.Fixed)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(fixedVariable, "fixedVariable");
this.fixedVariable.Value = fixedVariable;
}
/// <summary>
/// Initializes a new instance of the ForeachStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="iterationVariable">The iteration variable declared in foreach statement declaration.</param>
/// <param name="collection">The enumerable expression being iterated over.</param>
internal ForeachStatement(CodeUnitProxy proxy, VariableDeclarationExpression iterationVariable, Expression collection)
: base(proxy, StatementType.Foreach)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(iterationVariable, "iterationVariable");
Param.AssertNotNull(collection, "collection");
this.iterationVariable.Value = iterationVariable;
this.collection.Value = collection;
}
/// <summary>
/// Initializes a new instance of the ForeachStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="iterationVariable">The iteration variable declared in foreach statement declaration.</param>
/// <param name="collection">The enumerable expression being iterated over.</param>
internal ForeachStatement(CodeUnitProxy proxy, VariableDeclarationExpression iterationVariable, Expression collection)
: base(proxy, StatementType.Foreach)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(iterationVariable, "iterationVariable");
Param.AssertNotNull(collection, "collection");
this.iterationVariable.Value = iterationVariable;
this.collection.Value = collection;
}
/// <summary>
/// Initializes a new instance of the VariableDeclarationStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="expression">The inner expression.</param>
/// <param name="constant">Indicates whether the item is constant.</param>
internal VariableDeclarationStatement(
CodeUnitProxy proxy, VariableDeclarationExpression expression, bool constant)
: base(proxy, StatementType.VariableDeclaration)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
Param.Ignore(constant);
this.expression.Value = expression;
this.constant.Value = constant;
}
/// <summary>
/// Initializes a new instance of the VariableDeclarationStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="expression">The inner expression.</param>
/// <param name="constant">Indicates whether the item is constant.</param>
internal VariableDeclarationStatement(
CodeUnitProxy proxy, VariableDeclarationExpression expression, bool constant)
: base(proxy, StatementType.VariableDeclaration)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
Param.Ignore(constant);
this.expression.Value = expression;
this.constant.Value = constant;
}
/// <summary>
/// Initializes the contents of the statement.
/// </summary>
private void Initialize()
{
CodeUnit start = this.FindFirstChild <OpenParenthesisToken>();
if (start == null)
{
throw new SyntaxException(this.Document, this.LineNumber);
}
Expression expression = start.FindNextSiblingExpression();
if (expression != null)
{
this.catchExpression.Value = expression;
if (expression.ExpressionType == ExpressionType.Literal)
{
this.exceptionType.Value = CodeParser.ExtractTypeTokenFromLiteralExpression((LiteralExpression)expression);
}
else if (expression.ExpressionType == ExpressionType.VariableDeclaration)
{
VariableDeclarationExpression variableDeclaration = (VariableDeclarationExpression)expression;
this.exceptionType.Value = variableDeclaration.Type;
foreach (VariableDeclaratorExpression declarator in variableDeclaration.Declarators)
{
this.identifier.Value = declarator.Identifier.Text;
break;
}
}
start = expression;
}
CloseParenthesisToken closeParen = start.FindNextSibling <CloseParenthesisToken>();
if (closeParen == null)
{
throw new SyntaxException(this.Document, this.LineNumber);
}
this.body.Value = closeParen.FindNextSibling <BlockStatement>();
if (this.body.Value == null)
{
throw new SyntaxException(this.Document, this.LineNumber);
}
// Look for the try-statement that this catch-statement is attached to.
this.tryStatement.Value = null;
for (CodeUnit c = this.FindPreviousSibling(); c != null; c = c.FindNext())
{
if (c.Is(StatementType.Try))
{
this.tryStatement.Value = (TryStatement)c;
}
else if (!c.Is(StatementType.Catch) && (!c.Is(CodeUnitType.LexicalElement) || c.Is(LexicalElementType.Token)))
{
break;
}
}
if (this.tryStatement.Value == null)
{
throw new SyntaxException(this.Document, this.LineNumber);
}
}
/// <summary>
/// Reads an expression beginning with two unknown words.
/// </summary>
/// <param name="expressionProxy">Proxy object for the expression being created.</param>
/// <param name="parentProxy">Represents the parent item.</param>
/// <param name="type">The type of the variable.</param>
/// <param name="previousPrecedence">The precedence of the previous expression.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the expression.</returns>
private VariableDeclarationExpression GetVariableDeclarationExpression(
CodeUnitProxy expressionProxy, CodeUnitProxy parentProxy, Expression type, ExpressionPrecedence previousPrecedence, bool unsafeCode)
{
Param.AssertNotNull(expressionProxy, "expressionProxy");
Param.AssertNotNull(parentProxy, "parentProxy");
Param.AssertNotNull(type, "type");
Param.Ignore(previousPrecedence);
Param.Ignore(unsafeCode);
CsLanguageService.Debug.Assert(
type.ExpressionType == ExpressionType.Literal ||
type.ExpressionType == ExpressionType.MemberAccess ||
type.ExpressionType == ExpressionType.QualifiedAlias,
"The left side of a variable declaration must either be a literal or a member access.");
VariableDeclarationExpression expression = null;
if (CheckPrecedence(previousPrecedence, ExpressionPrecedence.None))
{
// Move past whitespace, etc, and add it to the expression proxy if we've already started the expression,
// otherwise add it to the parent.
this.AdvanceToNextCodeSymbol(expressionProxy.Children.Count > 0 ? expressionProxy : parentProxy);
// Convert the type expression to a literal type token expression.
LiteralExpression literalType = null;
if (type.ExpressionType == ExpressionType.Literal)
{
literalType = (LiteralExpression)type;
if (!literalType.Token.Is(TokenType.Type))
{
literalType = null;
}
}
if (literalType == null)
{
literalType = this.ConvertTypeExpression(type);
}
// Get each declarator.
while (true)
{
var variableDeclaratorExpressionProxy = new CodeUnitProxy(this.document);
// Get the next word.
Symbol symbol = this.PeekNextSymbol();
if (symbol.SymbolType != SymbolType.Other)
{
throw this.CreateSyntaxException();
}
// Get the identifier.
LiteralExpression identifier = this.GetLiteralExpression(variableDeclaratorExpressionProxy, unsafeCode);
if (identifier == null || identifier.Children.Count == 0)
{
throw new SyntaxException(this.document, symbol.LineNumber);
}
// Get the initializer if it exists.
Expression initializer = null;
symbol = this.PeekNextSymbol();
if (symbol.SymbolType == SymbolType.Equals)
{
// Add the equals token.
this.GetOperatorSymbolToken(variableDeclaratorExpressionProxy, OperatorType.Equals);
// Check whether this is an array initializer.
symbol = this.PeekNextSymbol();
if (symbol.SymbolType == SymbolType.OpenCurlyBracket)
{
initializer = this.GetArrayInitializerExpression(variableDeclaratorExpressionProxy, unsafeCode);
}
else
{
initializer = this.GetNextExpression(variableDeclaratorExpressionProxy, ExpressionPrecedence.None, unsafeCode);
}
}
// Create and add the declarator.
var declarator = new VariableDeclaratorExpression(variableDeclaratorExpressionProxy, identifier, initializer);
expressionProxy.Children.Add(declarator);
// Now check if the next character is a comma. If so there is another declarator.
symbol = this.PeekNextSymbol();
if (symbol.SymbolType != SymbolType.Comma)
{
// There are no more declarators.
break;
}
// Add the comma.
this.GetToken(expressionProxy, TokenType.Comma, SymbolType.Comma);
}
// Create the expression.
expression = new VariableDeclarationExpression(expressionProxy, literalType);
parentProxy.Children.Add(expression);
}
return expression;
}
/// <summary>
/// Parses and returns a field.
/// </summary>
/// <param name="elementProxy">Proxy for the element being created.</param>
/// <param name="parent">The parent of the element.</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="attributes">The attributes on the element.</param>
/// <returns>Returns the element.</returns>
private Field GetField(CodeUnitProxy elementProxy, Element parent, bool unsafeCode, bool generated, ICollection<Attribute> attributes)
{
Param.AssertNotNull(elementProxy, "elementProxy");
Param.AssertNotNull(parent, "parent");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
Param.Ignore(attributes);
// Get the modifiers and access.
AccessModifierType accessModifier = AccessModifierType.Private;
Dictionary<TokenType, Token> modifiers = this.GetElementModifiers(elementProxy, ref accessModifier, FieldModifiers);
unsafeCode |= modifiers.ContainsKey(TokenType.Unsafe);
var declarationExpressionProxy = new CodeUnitProxy(this.document);
// Get the field type.
var fieldTypeExpressionProxy = new CodeUnitProxy(this.document);
TypeToken fieldType = this.GetTypeToken(fieldTypeExpressionProxy, unsafeCode, true);
var fieldTypeExpression = new LiteralExpression(fieldTypeExpressionProxy, fieldType);
declarationExpressionProxy.Children.Add(fieldTypeExpression);
// Get all of the variable declarators.
string firstFieldName = this.GetFieldDeclarators(declarationExpressionProxy, unsafeCode, fieldType);
if (string.IsNullOrWhiteSpace(firstFieldName))
{
throw this.CreateSyntaxException();
}
var variableDeclarationStatementProxy = new CodeUnitProxy(this.document);
var declarationExpression = new VariableDeclarationExpression(declarationExpressionProxy, fieldTypeExpression);
variableDeclarationStatementProxy.Children.Add(declarationExpression);
var variableDeclarationStatement = new VariableDeclarationStatement(variableDeclarationStatementProxy, declarationExpression);
elementProxy.Children.Add(variableDeclarationStatement);
var field = new Field(elementProxy, firstFieldName, attributes, fieldType, unsafeCode);
// Get the trailing semicolon.
this.GetToken(elementProxy, TokenType.Semicolon, SymbolType.Semicolon);
return field;
}
