/// <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); }