/// <summary>
/// Instantiates a new BinaryOperatorAttribute
/// </summary>
/// <param name="instanceName">Registry name of token</param>
/// <param name="nodeType">
/// Type of node to create when parsing. Must inherit from
/// NodeOperatorBinary.
/// </param>
/// <param name="precedence">Precedence level of operator.</param>
public BinaryOperatorAttribute(string instanceName, Type nodeType, Precedence precedence) : base()
{
TokenInstance = TokenTypeRegistry.Get(instanceName);
NodeType = nodeType;
PrecedenceLevel = precedence;
IsRightAssociative = false;
}
/// <summary>
/// Refines the available keywords
/// </summary>
/// <param name="expectedTokenTypes">Expected token types</param>
/// <param name="keywords">Keywords</param>
private void RefineAvailableKeywords(List <TokenType> expectedTokens,
Dictionary <string, Tuple <string> > keywords)
{
var tokens = expectedTokens.Select(val => TokenTypeRegistry.GetText(val));
foreach (var key in keywords.Keys.Where(val => !tokens.Contains(val)).ToList())
{
keywords.Remove(key);
}
}
/// <summary>
/// Refines the available keywords
/// </summary>
/// <param name="expectedTokenTypes">Expected token types</param>
/// <param name="keywords">Keywords</param>
internal static IEnumerable <KeyValuePair <string, string> > RefineAvailableKeywords(IEnumerable <TokenType> expectedTokenTypes, string word, bool usePrefix)
{
foreach (var tokenType in expectedTokenTypes.Where(tokType => !DoNotSuggest.Contains(tokType)))
{
var tokenString = TokenTypeRegistry.GetText(tokenType);
if (Keywords.DefinitionMap.TryGetValue(tokenString, out string initialDef) && IsMatch(word, tokenString, usePrefix))
{
// TODO: Consolidate the various lists and dictionaries.
var tokenDefinition = PSharpQuickInfoSource.TokenTypeTips.TryGetValue(tokenType, out string betterDef) ? betterDef : initialDef;
yield return(new KeyValuePair <string, string>(tokenString, tokenDefinition));
}
}
}
/// <summary>
/// Option for on-demand initialization to prevent sudden lag during evaluation.
/// The calling assembly is loaded via Extensibility unless specified otherwise.
/// </summary>
public static void Initialize(bool loadCallingAssembly = true, bool force = false)
{
if (loadCallingAssembly)
{
Assembly callingAssembly = Assembly.GetCallingAssembly();
Extensibility.LoadedExtensions.Add(callingAssembly);
}
FunctionRegistry.Init(force);
TokenTypeRegistry.RegisterTokens(force);
HelpLibrary.Init(force);
Parser.Init(force);
}
/// <summary>
/// Instantiates a new PostfixOperatorAttribute
/// </summary>
/// <param name="instanceName">Registry name of token</param>
/// <param name="nodeType">
/// Type of node to create. Must inherit from
/// NodeOperatorUnary.
/// </param>
public PostfixOperatorAttribute(string instanceName, Type nodeType) : base()
{
TokenInstance = TokenTypeRegistry.Get(instanceName);
NodeType = nodeType;
}
private EventDeclaration VisitEventDeclaration(NamespaceDeclaration namespaceNode, MachineDeclaration machineNode, ModifierSet modSet, bool isExtern)
{
// Lookup or Insert into (immediately) containing namespace or machine declaration.
var declarations = (machineNode != null) ? machineNode.EventDeclarations : namespaceNode.EventDeclarations;
var node = new EventDeclaration(base.TokenStream.Program, machineNode, modSet)
{
EventKeyword = base.TokenStream.Peek()
};
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Identifier &&
base.TokenStream.Peek().Type != TokenType.HaltEvent &&
base.TokenStream.Peek().Type != TokenType.DefaultEvent))
{
throw new ParsingException("Expected event identifier.",
new List <TokenType>
{
TokenType.Identifier,
TokenType.HaltEvent,
TokenType.DefaultEvent
});
}
node.Identifier = NameVisitor.VisitSimpleQualifiedName(base.TokenStream, TokenType.EventIdentifier);
if (declarations.Find(node.Identifier.Text, out var existingDecl))
{
var details = existingDecl.IsExtern ? "declared \"extern\"" : "defined";
throw new ParsingException($"Event {node.Identifier.Text} has already been {details} earlier in this file.",
new List <TokenType> {
});
}
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Assert &&
base.TokenStream.Peek().Type != TokenType.Assume &&
base.TokenStream.Peek().Type != TokenType.LeftAngleBracket &&
base.TokenStream.Peek().Type != TokenType.LeftParenthesis &&
base.TokenStream.Peek().Type != TokenType.Colon &&
base.TokenStream.Peek().Type != TokenType.Semicolon))
{
// TODO: Create an overload of ParsingException ctor that generates the message with a predefined format enum.
var expectedTokenTypes = new List <TokenType>
{
TokenType.Assert,
TokenType.Assume,
TokenType.LeftAngleBracket,
TokenType.LeftParenthesis,
TokenType.Semicolon,
TokenType.Colon
};
var itemsString = string.Join("\", \"", expectedTokenTypes.Select(l => TokenTypeRegistry.GetText(l)).ToArray());
throw new ParsingException($"Expected one of: \"{itemsString}\".", expectedTokenTypes);
}
VisitGenericType(node);
VisitBaseEventDeclaration(node, declarations);
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Assert &&
base.TokenStream.Peek().Type != TokenType.Assume &&
base.TokenStream.Peek().Type != TokenType.LeftParenthesis &&
base.TokenStream.Peek().Type != TokenType.Semicolon))
{
throw new ParsingException("Expected \"(\" or \";\".",
new List <TokenType>
{
TokenType.Assert,
TokenType.Assume,
TokenType.LeftParenthesis,
TokenType.Semicolon
});
}
if (base.TokenStream.Peek().Type == TokenType.Assert ||
base.TokenStream.Peek().Type == TokenType.Assume)
{
if (isExtern)
{
throw new ParsingException("\"extern\" cannot have an Assert or Assume specification.",
new List <TokenType> {
});
}
bool isAssert = true;
if (base.TokenStream.Peek().Type == TokenType.Assert)
{
node.AssertKeyword = base.TokenStream.Peek();
}
else
{
node.AssumeKeyword = base.TokenStream.Peek();
isAssert = false;
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier ||
!int.TryParse(base.TokenStream.Peek().TextUnit.Text, out int value))
{
throw new ParsingException("Expected integer.",
new List <TokenType>
{
TokenType.Identifier
});
}
if (isAssert)
{
node.AssertValue = value;
}
else
{
node.AssumeValue = value;
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.LeftParenthesis &&
base.TokenStream.Peek().Type != TokenType.Semicolon))
{
throw new ParsingException("Expected \"(\" or \";\".",
new List <TokenType>
{
TokenType.LeftParenthesis,
TokenType.Semicolon
});
}
}
if (base.TokenStream.Peek().Type == TokenType.LeftParenthesis)
{
node.LeftParenthesis = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
bool isType = false;
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.RightParenthesis)
{
if (isType &&
base.TokenStream.Peek().Type != TokenType.Colon &&
base.TokenStream.Peek().Type != TokenType.Comma)
{
TextUnit textUnit = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref textUnit);
var typeIdentifier = new Token(textUnit, TokenType.TypeIdentifier);
node.PayloadTypes.Add(typeIdentifier);
}
else if (base.TokenStream.Peek().Type != TokenType.Colon &&
base.TokenStream.Peek().Type != TokenType.Comma)
{
node.PayloadIdentifiers.Add(base.TokenStream.Peek());
isType = true;
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
if (!base.TokenStream.Done)
{
if (base.TokenStream.Peek().Type == TokenType.Comma)
{
isType = false;
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
else if (base.TokenStream.Peek().Type == TokenType.Colon)
{
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
}
}
if (node.PayloadIdentifiers.Count != node.PayloadTypes.Count)
{
throw new ParsingException("The payload type of event '" + node.Identifier.TextUnit.Text +
"' was not declared correctly.\n" +
" You must declare both a type and a name identifier, for example:\n\n" +
" event e (a:int, b:bool)\n",
new List <TokenType>
{
TokenType.RightParenthesis
});
}
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.RightParenthesis)
{
throw new ParsingException("Expected \")\".",
new List <TokenType>
{
TokenType.RightParenthesis
});
}
node.RightParenthesis = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Semicolon)
{
throw new ParsingException("Expected \";\".",
new List <TokenType>
{
TokenType.Semicolon
});
}
node.SemicolonToken = base.TokenStream.Peek();
declarations.Add(node, isExtern);
return(node);
}
