/// <summary>
/// Initializes a new instance of the QueryContinuationClause class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the clause.
/// </param>
/// <param name="variable">
/// The continuation clause variable.
/// </param>
/// <param name="clauses">
/// The collection of clauses in the expression.
/// </param>
internal QueryContinuationClause(CsTokenList tokens, Variable variable, ICollection<QueryClause> clauses)
: base(QueryClauseType.Continuation, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(clauses, "clauses");
Param.AssertNotNull(variable, "variable");
this.variable = variable;
this.clauses = new CodeUnitCollection<QueryClause>(this);
this.clauses.AddRange(clauses);
Debug.Assert(clauses.IsReadOnly, "The collection of query clauses should be read-only.");
}
/// <summary>
/// Gets the next variable.
/// </summary>
/// <param name="parentReference">
/// The parent code unit.
/// </param>
/// <param name="unsafeCode">
/// Indicates whether the code is within an unsafe block.
/// </param>
/// <param name="allowTypelessVariable">
/// Indicates whether to allow a variable with no type defined.
/// </param>
/// <param name="onlyTypelessVariable">
/// Indicates whether to only get a typeless variable.
/// </param>
/// <returns>
/// Returns the variable.
/// </returns>
private Variable GetVariable(Reference<ICodePart> parentReference, bool unsafeCode, bool allowTypelessVariable, bool onlyTypelessVariable)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
Param.Ignore(allowTypelessVariable);
Param.Ignore(onlyTypelessVariable);
this.AdvanceToNextCodeSymbol(parentReference);
Reference<ICodePart> variableReference = new Reference<ICodePart>();
// Get the type token representing either the type or the identifier.
TypeToken type = this.GetTypeToken(variableReference, unsafeCode, true, false);
if (type == null)
{
throw this.CreateSyntaxException();
}
Variable variable = null;
if (onlyTypelessVariable)
{
// The token is not a type, just an identifier.
Debug.Assert(type.ChildTokens.Count == 1, "The count is invalid");
CsToken identifierToken = type.ChildTokens.First.Value;
this.tokens.Add(identifierToken);
variable = new Variable(null, type.Text, VariableModifiers.None, type.Location, parentReference, type.Generated);
identifierToken.ParentRef = new Reference<ICodePart>(variable);
}
else
{
int index = this.GetNextCodeSymbolIndex(1);
if (index != -1)
{
// Look ahead to the next symbol to see what it is.
Symbol symbol = this.symbols.Peek(index);
if (symbol == null || symbol.SymbolType != SymbolType.Other)
{
// This variable has no type, only an identifier.
if (!allowTypelessVariable)
{
throw this.CreateSyntaxException();
}
// The token is not a type, just an identifier.
Debug.Assert(type.ChildTokens.Count == 1, "The count is invalid");
this.tokens.Add(type.ChildTokens.First.Value);
variable = new Variable(null, type.Text, VariableModifiers.None, type.Location, parentReference, type.Generated);
}
else
{
// There is a type so add the type token.
this.tokens.Add(type);
this.AdvanceToNextCodeSymbol(variableReference);
// Create and add the identifier token.
CsToken identifier = new CsToken(symbol.Text, CsTokenType.Other, CsTokenClass.Token, symbol.Location, variableReference, this.symbols.Generated);
this.tokens.Add(identifier);
this.symbols.Advance();
// The variable has both a type and an identifier.
variable = new Variable(
type,
identifier.Text,
VariableModifiers.None,
CodeLocation.Join(type.Location, identifier.Location),
parentReference,
type.Generated || identifier.Generated);
}
}
}
variableReference.Target = variable;
return variable;
}
/// <summary>
/// Checks the prefix for a variable defined within a method or property.
/// </summary>
/// <param name="variable">
/// The variable to check.
/// </param>
/// <param name="element">
/// The element that contains the variable.
/// </param>
/// <param name="validPrefixes">
/// A list of valid prefixes that should not be considered hungarian.
/// </param>
private void CheckMethodVariablePrefix(Variable variable, CsElement element, Dictionary<string, string> validPrefixes)
{
Param.AssertNotNull(variable, "variable");
Param.AssertNotNull(element, "element");
Param.Ignore(validPrefixes);
// Skip past any prefixes in the name.
int index = NamingRules.MovePastPrefix(variable.Name);
// Check whether the name starts with a lower-case letter.
if (variable.Name.Length > index && char.IsLower(variable.Name, index))
{
// Check for hungarian notation.
this.CheckHungarian(variable.Name, index, variable.Location.LineNumber, element, validPrefixes);
// Check casing on the variable.
if ((variable.Modifiers & VariableModifiers.Const) == VariableModifiers.Const)
{
// Constants must start with an upper-case letter.
this.AddViolation(element, variable.Location.LineNumber, Rules.ConstFieldNamesMustBeginWithUpperCaseLetter, variable.Name);
}
}
else if ((variable.Modifiers & VariableModifiers.Const) == 0 && char.IsUpper(variable.Name, index))
{
// We check for IsUpper again to support languages that dont have upper or lower case like Chinese.
// Method variables must start with a lower-case letter.
this.AddViolation(element, variable.Location.LineNumber, Rules.FieldNamesMustBeginWithLowerCaseLetter, variable.Name);
}
}
/// <summary>
/// Reads the next for-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 ForStatement ParseForStatement(Reference<ICodePart> parentReference, bool unsafeCode)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
Reference<ICodePart> statementReference = new Reference<ICodePart>();
// Add the for keyword.
CsToken firstToken = this.GetToken(CsTokenType.For, SymbolType.For, parentReference, statementReference);
Node<CsToken> firstTokenNode = this.tokens.InsertLast(firstToken);
// Get the opening parenthesis.
Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis, statementReference);
Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis);
// Get each of the initializers.
List<Expression> initializers = this.ParseForStatementInitializers(statementReference, unsafeCode);
// Get the condition expression.
Expression condition = this.ParseForStatementCondition(statementReference, unsafeCode);
// Get the iterators.
List<Expression> iterators = this.ParseForStatementIterators(statementReference, unsafeCode, openParenthesis, openParenthesisNode);
// Get the embedded statement.
Statement childStatement = this.GetNextStatement(statementReference, unsafeCode);
if (childStatement == null || childStatement.Tokens.First == null)
{
throw new SyntaxException(this.document.SourceCode, firstToken.LineNumber);
}
// Create the token list for the statement.
CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
// Create and return the for-statement.
ForStatement statement = new ForStatement(partialTokens, initializers.ToArray(), condition, iterators.ToArray());
statement.EmbeddedStatement = childStatement;
statementReference.Target = statement;
// Add the variables declared in the statement.
foreach (Expression initializer in initializers)
{
VariableDeclarationExpression variableDeclaration = initializer as VariableDeclarationExpression;
if (variableDeclaration != null)
{
Reference<ICodePart> initializerReference = new Reference<ICodePart>(initializer);
foreach (VariableDeclaratorExpression declarator in variableDeclaration.Declarators)
{
Variable variable = new Variable(
variableDeclaration.Type,
declarator.Identifier.Token.Text,
VariableModifiers.None,
CodeLocation.Join(variableDeclaration.Type.Location, declarator.Identifier.Token.Location),
initializerReference,
variableDeclaration.Type.Generated || declarator.Identifier.Token.Generated);
// If there is already a variable in this scope with the same name, ignore this one.
if (!statement.Variables.Contains(declarator.Identifier.Token.Text))
{
statement.Variables.Add(variable);
}
}
}
}
return statement;
}
/// <summary>
/// Reads the next fixed-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 FixedStatement ParseFixedStatement(Reference<ICodePart> parentReference, bool unsafeCode)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
Reference<ICodePart> statementReference = new Reference<ICodePart>();
// Move past the fixed keyword.
CsToken firstToken = this.GetToken(CsTokenType.Fixed, SymbolType.Fixed, parentReference, statementReference);
Node<CsToken> firstTokenNode = this.tokens.InsertLast(firstToken);
// Make sure we're sitting on the opening parenthesis now.
Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis, statementReference);
Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis);
// Get the expression within the parenthesis. It must be a variable declaration.
VariableDeclarationExpression expression =
this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode, true, false) as VariableDeclarationExpression;
if (expression == null)
{
throw this.CreateSyntaxException();
}
// Get the closing parenthesis.
Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis, statementReference);
Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis);
openParenthesis.MatchingBracketNode = closeParenthesisNode;
closeParenthesis.MatchingBracketNode = openParenthesisNode;
// Get the embedded statement.
Statement childStatement = this.GetNextStatement(statementReference, unsafeCode);
if (childStatement == null)
{
throw this.CreateSyntaxException();
}
// Create the token list for the statement.
CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
// Create the fixed-statement.
FixedStatement statement = new FixedStatement(partialTokens, expression);
statement.EmbeddedStatement = childStatement;
statementReference.Target = statement;
// Add the variable if there is one.
foreach (VariableDeclaratorExpression declarator in expression.Declarators)
{
Variable variable = new Variable(
expression.Type,
declarator.Identifier.Token.Text,
VariableModifiers.None,
CodeLocation.Join(expression.Type.Location, declarator.Identifier.Token.Location),
statementReference,
expression.Type.Generated || declarator.Identifier.Token.Generated);
// If there is already a variable in this scope with the same name, ignore this one.
if (!statement.Variables.Contains(declarator.Identifier.Token.Text))
{
statement.Variables.Add(variable);
}
}
return statement;
}
/// <summary>
/// Looks for a catch-statement, and if it is found, parses and returns it.
/// </summary>
/// <param name="tryStatement">
/// The parent try statement.
/// </param>
/// <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 CatchStatement GetAttachedCatchStatement(TryStatement tryStatement, Reference<ICodePart> parentReference, bool unsafeCode)
{
Param.AssertNotNull(tryStatement, "tryStatement");
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
CatchStatement catchStatement = null;
// Look for a catch keyword.
Symbol symbol = this.GetNextSymbol(parentReference);
if (symbol.SymbolType == SymbolType.Catch)
{
Reference<ICodePart> statementReference = new Reference<ICodePart>();
// Move up to the catch keyword and add it.
CsToken firstToken = this.GetToken(CsTokenType.Catch, SymbolType.Catch, statementReference);
Node<CsToken> firstTokenNode = this.tokens.InsertLast(firstToken);
Expression catchExpression = null;
// Get the opening parenthesis, if there is one.
symbol = this.GetNextSymbol(statementReference);
if (symbol.SymbolType == SymbolType.OpenParenthesis)
{
Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis, statementReference);
Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis);
// Get the type, if there is one.
symbol = this.GetNextSymbol(statementReference);
if (symbol.SymbolType == SymbolType.Other)
{
catchExpression = this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode, true, true);
}
// Get the closing parenthesis.
Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis, statementReference);
Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis);
openParenthesis.MatchingBracketNode = closeParenthesisNode;
closeParenthesis.MatchingBracketNode = openParenthesisNode;
}
// Get the embedded statement. This must be a block statement.
BlockStatement childStatement = this.GetNextStatement(statementReference, unsafeCode) as BlockStatement;
if (childStatement == null)
{
throw new SyntaxException(this.document.SourceCode, firstToken.LineNumber);
}
// Create the token list for the statement.
CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
// Create the catch statement.
catchStatement = new CatchStatement(partialTokens, tryStatement, catchExpression, childStatement);
((IWriteableCodeUnit)catchStatement).SetParent(tryStatement);
statementReference.Target = catchStatement;
if (catchStatement.ClassType != null && catchStatement.Identifier != null)
{
// Add the variable.
Variable variable = new Variable(
catchStatement.ClassType,
catchStatement.Identifier.Text,
VariableModifiers.None,
CodeLocation.Join(catchStatement.ClassType.Location, catchStatement.Identifier.Location),
statementReference,
catchStatement.ClassType.Generated);
// If there is already a variable in this scope with the same name, ignore this one.
if (!catchStatement.Variables.Contains(catchStatement.Identifier.Text))
{
catchStatement.Variables.Add(variable);
}
}
}
return catchStatement;
}
/// <summary>
/// Reads the next variable declaration 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>
/// <param name="variables">
/// Returns the list of variables defined in the statement.
/// </param>
/// <returns>
/// Returns the statement.
/// </returns>
private VariableDeclarationStatement ParseVariableDeclarationStatement(Reference<ICodePart> parentReference, bool unsafeCode, VariableCollection variables)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
Param.Ignore(variables);
bool constant = false;
// Get the first symbol and make sure it is an unknown word or a const.
Symbol symbol = this.GetNextSymbol(parentReference);
CsToken firstToken = null;
Node<CsToken> firstTokenNode = null;
Reference<ICodePart> statementReference = new Reference<ICodePart>();
if (symbol.SymbolType == SymbolType.Const)
{
constant = true;
firstToken = new CsToken(symbol.Text, CsTokenType.Const, symbol.Location, statementReference, this.symbols.Generated);
firstTokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Const, SymbolType.Const, statementReference));
symbol = this.GetNextSymbol(statementReference);
}
if (symbol.SymbolType != SymbolType.Other)
{
throw this.CreateSyntaxException();
}
// Get the expression representing the type.
LiteralExpression type = this.GetTypeTokenExpression(statementReference, unsafeCode, true);
if (type == null || type.Tokens.First == null)
{
throw new SyntaxException(this.document.SourceCode, firstToken.LineNumber);
}
if (firstTokenNode == null)
{
firstTokenNode = type.Tokens.First;
}
// Get the rest of the declaration.
VariableDeclarationExpression expression = this.GetVariableDeclarationExpression(type, ExpressionPrecedence.None, unsafeCode);
// Get the closing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, statementReference));
// Add each of the variables defined in this statement to the variable list being returned.
if (variables != null)
{
VariableModifiers modifiers = constant ? VariableModifiers.Const : VariableModifiers.None;
foreach (VariableDeclaratorExpression declarator in expression.Declarators)
{
Variable variable = new Variable(
expression.Type,
declarator.Identifier.Token.Text,
modifiers,
CodeLocation.Join(expression.Type.Location, declarator.Identifier.Token.Location),
statementReference,
expression.Tokens.First.Value.Generated || declarator.Identifier.Token.Generated);
// There might already be a variable in this scope with the same name. This can happen
// in valid situation when there are ifdef's surrounding portions of the code.
// Just accept the first variable and ignore others.
if (!variables.Contains(declarator.Identifier.Token.Text))
{
variables.Add(variable);
}
}
}
// Create the token list for the statement.
CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
VariableDeclarationStatement statement = new VariableDeclarationStatement(partialTokens, constant, expression);
statementReference.Target = statement;
return statement;
}
/// <summary>
/// Reads the next foreach 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 ForeachStatement ParseForeachStatement(Reference<ICodePart> parentReference, bool unsafeCode)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
Reference<ICodePart> statementReference = new Reference<ICodePart>();
// Get the foreach keyword.
CsToken firstToken = this.GetToken(CsTokenType.Foreach, SymbolType.Foreach, parentReference, statementReference);
Node<CsToken> firstTokenNode = this.tokens.InsertLast(firstToken);
// Get the opening parenthesis.
Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis, statementReference);
Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis);
// Get the variable.
VariableDeclarationExpression variable =
this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode, true, false) as VariableDeclarationExpression;
if (variable == null)
{
throw this.CreateSyntaxException();
}
// Get the 'in' keyword and add it.
this.tokens.Add(this.GetToken(CsTokenType.In, SymbolType.In, statementReference));
// Get the item being iterated over.
Expression item = this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode);
if (item == null)
{
throw this.CreateSyntaxException();
}
// Get the closing parenthesis.
Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis, statementReference);
Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis);
openParenthesis.MatchingBracketNode = closeParenthesisNode;
closeParenthesis.MatchingBracketNode = openParenthesisNode;
// Get the embedded statement.
Statement childStatement = this.GetNextStatement(statementReference, unsafeCode);
if (childStatement == null)
{
throw this.CreateSyntaxException();
}
// Create the token list for the statement.
CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
// Create the foreach-statement.
ForeachStatement statement = new ForeachStatement(partialTokens, variable, item);
statement.EmbeddedStatement = childStatement;
statementReference.Target = statement;
// Add the variable.
foreach (VariableDeclaratorExpression declarator in variable.Declarators)
{
Variable localVariable = new Variable(
variable.Type,
declarator.Identifier.Token.Text,
VariableModifiers.None,
CodeLocation.Join(variable.Type.Location, declarator.Identifier.Token.Location),
statementReference,
variable.Type.Generated);
// If there is already a variable in this scope with the same name, ignore this one.
if (!statement.Variables.Contains(declarator.Identifier.Token.Text))
{
statement.Variables.Add(localVariable);
}
}
return statement;
}
/// <summary>
/// Initializes the method.
/// </summary>
internal override void Initialize()
{
base.Initialize();
if (this.parameters != null)
{
Reference<ICodePart> methodReference = new Reference<ICodePart>(this);
// Create a variable for each of the parameters.
foreach (Parameter parameter in this.parameters)
{
Variable variable = new Variable(parameter.Type, parameter.Name, VariableModifiers.None, parameter.Location, methodReference, parameter.Generated);
this.Variables.Add(variable);
}
}
}