/// <summary>
/// Gets the name of the element.
/// </summary>
/// <returns>The name of the element.</returns>
protected override string GetElementName()
{
CodeUnit start = this.Children.First;
if (!this.ContainsModifier(TokenType.Implicit, TokenType.Explicit))
{
// Get the return type.
start = this.FindFirstChild <TypeToken>();
}
if (start != null)
{
Token next = start.FindNextSiblingToken();
if (next != null)
{
if (next.Is(TokenType.Operator))
{
// The next token is the operator name.
Token operatorName = next.FindNextSiblingToken();
if (operatorName != null)
{
return("operator " + operatorName.Text);
}
}
else
{
// This is a regular method.
return(next.Text);
}
}
}
throw new SyntaxException(this.Document, this.LineNumber);
}
/// <summary>
/// Extracts a variable from the clause.
/// </summary>
/// <param name="firstToken">The first token of the variable.</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>
protected static QueryClauseVariable ExtractQueryVariable(Token firstToken, bool allowTypelessVariable, bool onlyTypelessVariable)
{
Param.RequireNotNull(firstToken, "firstToken");
Param.Ignore(allowTypelessVariable);
Param.Ignore(onlyTypelessVariable);
if (onlyTypelessVariable || !firstToken.Is(TokenType.Type))
{
// In this case there is no type, only an identifier.
return(new QueryClauseVariable(null, firstToken.Text, firstToken.Location, firstToken.Generated));
}
else
{
TypeToken type = (TypeToken)firstToken;
// Attempt to get the identifier token coming after the type token.
Token identifier = firstToken.FindNextSiblingToken();
if (identifier == null || identifier.TokenType != TokenType.Literal)
{
CsLanguageService.Debug.Assert(allowTypelessVariable, "The clause does not allow typeless variables. The parser should have thrown syntax exception already.");
return(new QueryClauseVariable(null, type.Text, type.Location, type.Generated));
}
else
{
// There is a type and an identifier.
return(new QueryClauseVariable(type, identifier.Text, CodeUnit.JoinLocations(type, identifier), type.Generated || identifier.Generated));
}
}
}
/// <summary>
/// Sets the inherited items of the class.
/// </summary>
private void SetInheritedItems()
{
// Pull out the name of the base class and any implemented interfaces
// from the declaration of this class.
bool colon = false;
bool comma = false;
var interfaces = new List <string>();
this.baseClass.Value = string.Empty;
for (Token token = this.FindFirstChildToken(); token != null; token = token.FindNextSiblingToken())
{
if (colon)
{
if (token.Text.Length >= 2 &&
token.Text[0] == 'I' &&
char.IsUpper(token.Text[1]))
{
interfaces.Add(CodeParser.TrimType(token.Text));
}
else
{
this.baseClass.Value = CodeParser.TrimType(token.Text);
}
colon = false;
}
else if (comma)
{
interfaces.Add(CodeParser.TrimType(token.Text));
comma = false;
}
else
{
if (token.TokenType == TokenType.Where)
{
break;
}
else if (token.Text == ":")
{
if (this.baseClass.Value.Length > 0)
{
break;
}
else
{
colon = true;
}
}
else if (token.TokenType == TokenType.Comma)
{
comma = true;
}
}
}
this.implementedInterfaces.Value = interfaces.AsReadOnly();
}
/// <summary>
/// Gets the name of the element.
/// </summary>
/// <returns>The name of the element.</returns>
protected override string GetElementName()
{
for (Token token = this.FindFirstChildToken(); token != null; token = token.FindNextSiblingToken())
{
if (token.Is(TokenType.Literal) || token.Is(TokenType.Type))
{
return(token.Text);
}
}
throw new SyntaxException(this.Document, this.LineNumber);
}
/// <summary>
/// Initializes the element.
/// </summary>
private void Init()
{
this.namespaceType.Value = this.alias.Value = string.Empty;
// Find the 'using' keyword.
Token usingKeyword = this.FindFirstChild <UsingDirectiveToken>();
if (usingKeyword != null)
{
// Move past it.
Token index = usingKeyword.FindNextSiblingToken();
if (index != null)
{
// This word is usually the namespace type, unless an alias is defined.
this.namespaceType.Value = CodeParser.TrimType(CodeParser.GetFullName(this.Document, this, index, out index));
// Now see if the next word is an equals sign.
index = index.FindNextSiblingToken();
if (index != null)
{
if (index.Text == "=")
{
// Get the word after the equals sign, which will be the namespace.
index = index.FindNextSiblingToken();
if (index != null)
{
// Set the alias and the namespace.
this.alias.Value = this.namespaceType.Value;
this.namespaceType.Value = CodeParser.TrimType(index.Text);
}
}
}
}
}
}
/// <summary>
/// Gets the name of the element.
/// </summary>
/// <returns>The name of the element.</returns>
protected override string GetElementName()
{
// Get the enum keyword.
Token enumToken = this.FindFirstChild <EnumToken>();
if (enumToken != null)
{
// The next Token is the name.
Token nameToken = enumToken.FindNextSiblingToken();
if (nameToken != null)
{
return(nameToken.Text);
}
}
throw new SyntaxException(this.Document, this.LineNumber);
}
/// <summary>
/// Gets the base type of the item.
/// </summary>
/// <returns>Returns the name of the base type or null if none.</returns>
private string GetBaseType()
{
// Pull out the base type.
bool foundColon = false;
for (Token token = this.FindFirstChildToken(); token != null; token = token.FindNextSiblingToken())
{
if (foundColon)
{
return(token.Text);
}
else if (token.Text == ":")
{
foundColon = true;
}
}
return(null);
}
/// <summary>
/// Walks the element declaration and gathers the element modifiers.
/// </summary>
/// <param name="allowedModifiers">The modifiers which are allowed for the current element type.</param>
private void GatherDeclarationModifiers(IEnumerable <string> allowedModifiers)
{
Param.Ignore(allowedModifiers);
this.modifiers.Value = new Dictionary <TokenType, Token>();
Token accessModifierSeen = null;
this.accessModifier.Value = this.DefaultAccessModifierType;
for (Token token = this.FirstDeclarationToken; token != null; token = token.FindNextSiblingToken())
{
if (token.TokenType == TokenType.Public)
{
// A public access modifier can only be specified if there have been no other access modifiers.
if (accessModifierSeen != null)
{
throw new SyntaxException(this.Document, token.LineNumber);
}
this.accessModifier.Value = AccessModifierType.Public;
accessModifierSeen = token;
this.modifiers.Value.Add(TokenType.Public, token);
}
else if (token.TokenType == TokenType.Private)
{
// A private access modifier can only be specified if there have been no other access modifiers.
if (accessModifierSeen != null)
{
throw new SyntaxException(this.Document, token.LineNumber);
}
this.accessModifier.Value = AccessModifierType.Private;
accessModifierSeen = token;
this.modifiers.Value.Add(TokenType.Private, token);
}
else if (token.TokenType == TokenType.Internal)
{
// The access is internal unless we have already seen a protected access
// modifier, in which case it is protected internal.
if (accessModifierSeen == null)
{
this.accessModifier.Value = AccessModifierType.Internal;
}
else if (accessModifierSeen.TokenType == TokenType.Protected)
{
this.accessModifier.Value = AccessModifierType.ProtectedInternal;
}
else
{
throw new SyntaxException(this.Document, token.LineNumber);
}
accessModifierSeen = token;
this.modifiers.Value.Add(TokenType.Internal, token);
}
else if (token.TokenType == TokenType.Protected)
{
// The access is protected unless we have already seen an internal access
// modifier, in which case it is protected internal.
if (accessModifierSeen == null)
{
this.accessModifier.Value = AccessModifierType.Protected;
}
else if (accessModifierSeen.TokenType == TokenType.Internal)
{
this.accessModifier.Value = AccessModifierType.ProtectedInternal;
}
else
{
throw new SyntaxException(this.Document, token.LineNumber);
}
accessModifierSeen = token;
this.modifiers.Value.Add(TokenType.Protected, token);
}
else
{
if (!GetOtherElementModifier(allowedModifiers, this.modifiers.Value, token))
{
break;
}
}
}
}
/// <summary>
/// Extracts a variable from the clause.
/// </summary>
/// <param name="firstToken">The first token of the variable.</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>
protected static QueryClauseVariable ExtractQueryVariable(Token firstToken, bool allowTypelessVariable, bool onlyTypelessVariable)
{
Param.RequireNotNull(firstToken, "firstToken");
Param.Ignore(allowTypelessVariable);
Param.Ignore(onlyTypelessVariable);
if (onlyTypelessVariable || !firstToken.Is(TokenType.Type))
{
// In this case there is no type, only an identifier.
return new QueryClauseVariable(null, firstToken.Text, firstToken.Location, firstToken.Generated);
}
else
{
TypeToken type = (TypeToken)firstToken;
// Attempt to get the identifier token coming after the type token.
Token identifier = firstToken.FindNextSiblingToken();
if (identifier == null || identifier.TokenType != TokenType.Literal)
{
CsLanguageService.Debug.Assert(allowTypelessVariable, "The clause does not allow typeless variables. The parser should have thrown syntax exception already.");
return new QueryClauseVariable(null, type.Text, type.Location, type.Generated);
}
else
{
// There is a type and an identifier.
return new QueryClauseVariable(type, identifier.Text, CodeUnit.JoinLocations(type, identifier), type.Generated || identifier.Generated);
}
}
}
