protected virtual LiteralNode ParseNegativeNumericLiteralNode(ILiteralNodeParent parent, NegativeSignToken negativeSign) { // PARSE: <number> ::= integer | float | scaledDecimal Token token = this.GetNextTokenxx(Preference.NegativeSign); if (token is SmallIntegerToken) { return(new SmallIntegerLiteralNode(parent, (SmallIntegerToken)token, negativeSign)); } if (token is LargeIntegerToken) { return(new LargeIntegerLiteralNode(parent, (LargeIntegerToken)token, negativeSign)); } if (token is FloatEToken) { return(new FloatELiteralNode(parent, (FloatEToken)token, negativeSign)); } if (token is FloatDToken) { return(new FloatDLiteralNode(parent, (FloatDToken)token, negativeSign)); } if (token is ScaledDecimalToken) { return(new ScaledDecimalLiteralNode(parent, (ScaledDecimalToken)token, negativeSign)); } // We don't know what that is.... the negative sign token thrown away and lost :-/ this.ReportParserError(parent, SemanticErrors.UnrecognizedLiteral, token); this.ResidueToken = token; return(null); }
protected override LiteralNode ParseLiteral(ILiteralNodeParent parent, Token token) { if ((parent is ArrayLiteralNode) && Parser.IsOpeningParenthesis(token)) { // Stupid VSE allows declarations of arrays like: #( 1 2 ( 3 4 ) 5 6), // which is identical to: #( 1 2 #( 3 4 ) 5 6). // Only the inner (child) arrays may omit the hash prefix. // Here we emulate this and create a 'fake' hash token. // The fake hash token gets the same source positions and the parenthesis token. SpecialCharacterToken hash = new SpecialCharacterToken(SemanticConstants.LiteralArrayPrefix); hash.SetTokenValues(token.StartPosition, token.StopPosition, null); this.ResidueToken = token; return(this.ParseArrayLiteral(parent, hash)); } if (!Parser.IsLiteralArrayPrefix(token)) { return(base.ParseLiteral(parent, token)); } Token token2 = this.GetNextTokenxx(Preference.Default); if (VseCompatibleParser.IsOpeningByteArrayBracket(token2)) { return(this.ParseByteArrayLiteral(parent, (SpecialCharacterToken)token, (SpecialCharacterToken)token2)); } this.ResidueToken = token2; return(base.ParseLiteral(parent, token)); }
/// <summary> /// Create and initialize a new literal node. /// </summary> /// <param name="parent">Parent node that defines the literal node.</param> protected LiteralNode(ILiteralNodeParent parent) { #if DEBUG if (parent == null) { throw new ArgumentNullException("parent"); } #endif this.Parent = parent; }
/// <summary> /// Create and initialize a new identifier literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> protected internal IdentifierLiteralNode(ILiteralNodeParent parent, ILiteralArrayIdentifierToken token) : base(parent) { #if DEBUG if (token == null) { throw new ArgumentNullException("token"); } #endif this.Token = token; }
/// <summary> /// Create and initialize a new single value literal node. /// </summary> /// <param name="parent">The parent node that defines the literal node.</param> /// <param name="token">Token defining the literal node.</param> protected SingleValueLiteralNode(ILiteralNodeParent parent, TToken token) : base(parent) { #if DEBUG if (token == null) { throw new ArgumentNullException("token"); } #endif this.Token = token; }
/// <summary> /// Create and initialize a new literal array node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="arrayToken">Hash token that defines the start of array literals.</param> /// <param name="leftParenthesis">Opening left parenthesis of the literal array.</param> protected internal ByteArrayLiteralNode(ILiteralNodeParent parent, SpecialCharacterToken arrayToken, SpecialCharacterToken leftBracket) : base(parent) { #if DEBUG if (!Parser.IsLiteralArrayPrefix(arrayToken)) throw new ArgumentException("arrayToken"); if (!VseCompatibleParser.IsOpeningByteArrayBracket(leftBracket)) throw new ArgumentException("leftBracket"); #endif this.ArrayToken = arrayToken; this.LeftBracket = leftBracket; this.Elements = new List<SmallIntegerLiteralNode>(); }
/// <summary> /// Create and initialize a new literal array node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="arrayToken">Hash token that defines the start of array literals.</param> /// <param name="leftParenthesis">Opening left parenthesis of the literal array.</param> protected internal ArrayLiteralNode(ILiteralNodeParent parent, SpecialCharacterToken arrayToken, SpecialCharacterToken leftParenthesis) : base(parent) { #if DEBUG if (!Parser.IsLiteralArrayPrefix(arrayToken)) throw new ArgumentException("arrayToken"); if (!Parser.IsOpeningParenthesis(leftParenthesis)) throw new ArgumentException("leftParenthesis"); #endif this.ArrayToken = arrayToken; this.LeftParenthesis = leftParenthesis; this.Elements = new List<LiteralNode>(); }
/// <summary> /// Create and initialize a new literal array node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="arrayToken">Hash token that defines the start of array literals.</param> /// <param name="leftParenthesis">Opening left parenthesis of the literal array.</param> protected internal ArrayLiteralNode(ILiteralNodeParent parent, SpecialCharacterToken arrayToken, SpecialCharacterToken leftParenthesis) : base(parent) { #if DEBUG if (!Parser.IsLiteralArrayPrefix(arrayToken)) { throw new ArgumentException("arrayToken"); } if (!Parser.IsOpeningParenthesis(leftParenthesis)) { throw new ArgumentException("leftParenthesis"); } #endif this.ArrayToken = arrayToken; this.LeftParenthesis = leftParenthesis; this.Elements = new List <LiteralNode>(); }
/// <summary> /// Create and initialize a new literal array node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="arrayToken">Hash token that defines the start of array literals.</param> /// <param name="leftParenthesis">Opening left parenthesis of the literal array.</param> protected internal ByteArrayLiteralNode(ILiteralNodeParent parent, SpecialCharacterToken arrayToken, SpecialCharacterToken leftBracket) : base(parent) { #if DEBUG if (!Parser.IsLiteralArrayPrefix(arrayToken)) { throw new ArgumentException("arrayToken"); } if (!VseCompatibleParser.IsOpeningByteArrayBracket(leftBracket)) { throw new ArgumentException("leftBracket"); } #endif this.ArrayToken = arrayToken; this.LeftBracket = leftBracket; this.Elements = new List <SmallIntegerLiteralNode>(); }
/// <summary> /// Create and initialize a new identifier literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> protected internal IdentifierLiteralNode(ILiteralNodeParent parent, ILiteralArrayIdentifierToken token) : base(parent) { #if DEBUG if (token == null) throw new ArgumentNullException("token"); #endif this.Token = token; }
protected virtual ArrayLiteralNode ParseArrayLiteral(ILiteralNodeParent parent, SpecialCharacterToken arrayToken) { // PARSE: <array literal> ::= '#(' <array element>* ')' // <array element> ::= <literal> | identifier Token token = this.GetNextTokenxx(Preference.Default); if (!Parser.IsOpeningParenthesis(token)) { this.ReportParserError(parent, SemanticErrors.MissingLiteralArrayOpeningParenthesis, token); // The hash token is thrown away and lost :-/ ... only the current token is passed on. this.ResidueToken = token; return(null); } List <LiteralNode> elements = new List <LiteralNode>(); ArrayLiteralNode result = new ArrayLiteralNode(parent, arrayToken, (SpecialCharacterToken)token); // Process tokens inside the array ... while (true) { // ... get next token in the array ... token = this.GetNextTokenxx(Preference.NegativeSign | Preference.UnquotedSelector); // Is this closing parenthesis? if (Parser.IsClosingParenthesis(token)) { // Closing parenthesis ... done with the array, return litral array node. result.SetContents(elements, (SpecialCharacterToken)token); this.ResidueToken = null; return(result); } if (token is EofToken) { // Unfinished source code ... return result.SetContents(elements, null); this.ReportParserError(parent, SemanticErrors.MissingLiteralArrayClosingParenthesis, token); this.ResidueToken = token; return(result); } // PARSE: <array element> ::= <literal> | identifier if (token is ILiteralArrayIdentifierToken) { // identifier ... special case only inside arrays. elements.Add(new IdentifierLiteralNode(result, (ILiteralArrayIdentifierToken)token)); } else { // ... it's not identifier, so it must be an literal LiteralNode element = this.ParseLiteral(result, token); if (element == null) { // Report error in source code ... here, it must be a literal this.ReportParserError(result, SemanticErrors.UnrecognizedLiteral, token); result.SetContents(elements, null); return(result); } else { // ... add the child element to the array elements. elements.Add(element); } } } }
/// <summary> /// Parse a literal node as described in X3J20 "3.4.6 Literals". /// </summary> /// <remarks> /// If the given token is not a legal token for a literal node, /// it is simply returned in the residueToken output parameter, /// and the function returns null. /// </remarks> /// <param name="parent">Parent node that defines the literal node.</param> /// <param name="token">First token of the literal node.</param> /// <returns>A literal node, or null in case of non-literal token.</returns> protected virtual LiteralNode ParseLiteral(ILiteralNodeParent parent, Token token) { // PARSE: <literal> ::= <number literal> | <string literal> | <character literal> | // <symbol literal> | <selector literal> | <array literal> // <string literal> ::= quotedString if (token is StringToken) // 'example' { return(new StringLiteralNode(parent, (StringToken)token)); } // <symbol literal> ::= hashedString if (token is HashedStringToken) // #'example' { return(new SymbolLiteralNode(parent, (HashedStringToken)token)); } // <character literal> ::= quotedCharacter if (token is CharacterToken) // $e { return(new CharacterLiteralNode(parent, (CharacterToken)token)); } // <selector literal> ::= quotedSelector if (token is QuotedSelectorToken) // #example ..or.. #example: ..or.. #example:example: ..or.. #+ { return(new SelectorLiteralNode(parent, (QuotedSelectorToken)token)); } // <number literal> ::= ['-'] <number> if (token is NegativeSignToken) { return(this.ParseNegativeNumericLiteralNode(parent, (NegativeSignToken)token)); } // <number> ::= integer | float | scaledDecimal if (token is SmallIntegerToken) { return(new SmallIntegerLiteralNode(parent, (SmallIntegerToken)token, null)); } if (token is LargeIntegerToken) { return(new LargeIntegerLiteralNode(parent, (LargeIntegerToken)token, null)); } if (token is FloatEToken) { return(new FloatELiteralNode(parent, (FloatEToken)token, null)); } if (token is FloatDToken) { return(new FloatDLiteralNode(parent, (FloatDToken)token, null)); } if (token is ScaledDecimalToken) { return(new ScaledDecimalLiteralNode(parent, (ScaledDecimalToken)token, null)); } // <array literal> ::= '#(' <array element>* ')' // <array element> ::= <literal> | identifier if (Parser.IsLiteralArrayPrefix(token)) { return(this.ParseArrayLiteral(parent, (SpecialCharacterToken)token)); } this.ResidueToken = token; return(null); }
protected ByteArrayLiteralNode ParseByteArrayLiteral(ILiteralNodeParent parent, SpecialCharacterToken arrayToken, SpecialCharacterToken leftBracket) { // PARSE: <array literal> ::= '#[' <number literal>* ']' List <SmallIntegerLiteralNode> elements = new List <SmallIntegerLiteralNode>(); ByteArrayLiteralNode result = new ByteArrayLiteralNode(parent, arrayToken, leftBracket); // Process tokens inside the array ... while (true) { // ... get next token in the array ... Token token = this.GetNextTokenxx(Preference.NegativeSign); // Is this closing parenthesis? if (VseCompatibleParser.IsClosingByteArrayBracket(token)) { // Closing parenthesis ... done with the array, return litral array node. result.SetContents(elements, (SpecialCharacterToken)token); this.ResidueToken = null; return(result); } if (token is EofToken) { // Unfinished source code ... return result.SetContents(elements, null); this.ReportParserError(parent, "Missing literal byte array closing bracket.", token); this.ResidueToken = token; return(result); } // PARSE: <numeric liteal> if (token is SmallIntegerToken) { elements.Add(new SmallIntegerLiteralNode(result, (SmallIntegerToken)token, null)); } else if (token is NegativeSignToken) { NegativeSignToken negativeSign = (NegativeSignToken)token; token = this.GetNextTokenxx(Preference.NegativeSign); if (token is SmallIntegerToken) { elements.Add(new SmallIntegerLiteralNode(result, (SmallIntegerToken)token, negativeSign)); } else { this.ReportParserError(parent, "Unrecognized literal.", token); this.ResidueToken = token; result.SetContents(elements, null); return(result); } } else { this.ReportParserError(parent, "Unrecognized literal.", token); this.ResidueToken = token; result.SetContents(elements, null); return(result); } } }
protected virtual LiteralNode ParseNegativeNumericLiteralNode(ILiteralNodeParent parent, NegativeSignToken negativeSign) { // PARSE: <number> ::= integer | float | scaledDecimal Token token = this.GetNextTokenxx(Preference.NegativeSign); if (token is SmallIntegerToken) return new SmallIntegerLiteralNode(parent, (SmallIntegerToken)token, negativeSign); if (token is LargeIntegerToken) return new LargeIntegerLiteralNode(parent, (LargeIntegerToken)token, negativeSign); if (token is FloatEToken) return new FloatELiteralNode(parent, (FloatEToken)token, negativeSign); if (token is FloatDToken) return new FloatDLiteralNode(parent, (FloatDToken)token, negativeSign); if (token is ScaledDecimalToken) return new ScaledDecimalLiteralNode(parent, (ScaledDecimalToken)token, negativeSign); // We don't know what that is.... the negative sign token thrown away and lost :-/ this.ReportParserError(parent, SemanticErrors.UnrecognizedLiteral, token); this.ResidueToken = token; return null; }
/// <summary> /// Create and initialize a new float literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> /// <param name="negativeSignToken">Optional negative sign token indicating a negative numeric value.</param> protected internal FloatDLiteralNode(ILiteralNodeParent parent, FloatDToken token, NegativeSignToken negativeSignToken) : base(parent, token, negativeSignToken) { }
/// <summary> /// Create and initialize a new large integer literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> /// <param name="negativeSignToken">Optional negative sign token indicating a negative numeric value.</param> protected internal LargeIntegerLiteralNode(ILiteralNodeParent parent, LargeIntegerToken token, NegativeSignToken negativeSignToken) : base(parent, token, negativeSignToken) { }
protected virtual ArrayLiteralNode ParseArrayLiteral(ILiteralNodeParent parent, SpecialCharacterToken arrayToken) { // PARSE: <array literal> ::= '#(' <array element>* ')' // <array element> ::= <literal> | identifier Token token = this.GetNextTokenxx(Preference.Default); if (!Parser.IsOpeningParenthesis(token)) { this.ReportParserError(parent, SemanticErrors.MissingLiteralArrayOpeningParenthesis, token); // The hash token is thrown away and lost :-/ ... only the current token is passed on. this.ResidueToken = token; return null; } List<LiteralNode> elements = new List<LiteralNode>(); ArrayLiteralNode result = new ArrayLiteralNode(parent, arrayToken, (SpecialCharacterToken)token); // Process tokens inside the array ... while (true) { // ... get next token in the array ... token = this.GetNextTokenxx(Preference.NegativeSign | Preference.UnquotedSelector); // Is this closing parenthesis? if (Parser.IsClosingParenthesis(token)) { // Closing parenthesis ... done with the array, return litral array node. result.SetContents(elements, (SpecialCharacterToken)token); this.ResidueToken = null; return result; } if (token is EofToken) { // Unfinished source code ... return result.SetContents(elements, null); this.ReportParserError(parent, SemanticErrors.MissingLiteralArrayClosingParenthesis, token); this.ResidueToken = token; return result; } // PARSE: <array element> ::= <literal> | identifier if (token is ILiteralArrayIdentifierToken) { // identifier ... special case only inside arrays. elements.Add(new IdentifierLiteralNode(result, (ILiteralArrayIdentifierToken)token)); } else { // ... it's not identifier, so it must be an literal LiteralNode element = this.ParseLiteral(result, token); if (element == null) { // Report error in souce code ... here, it must be a literal this.ReportParserError(result, SemanticErrors.UnrecognizedLiteral, token); result.SetContents(elements, null); return result; } else { // ... add the child element to the array elements. elements.Add(element); } } } }
/// <summary> /// Create and initialize a new string literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> protected internal StringLiteralNode(ILiteralNodeParent parent, StringToken token) : base(parent, token) { }
/// <summary> /// Create and initialize a new symbol literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> protected internal SymbolLiteralNode(ILiteralNodeParent parent, HashedStringToken token) : base(parent, token) { }
/// <summary> /// Create and initialize a new numeric literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> /// <param name="negativeSignToken">Optional negative sign token indicating a negative numeric value.</param> protected NumericLiteralNode(ILiteralNodeParent parent, TToken token, NegativeSignToken negativeSignToken) : base(parent, token) { this.NegativeSignToken = negativeSignToken; // OK with null. }
/// <summary> /// Create and initialize a new character literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> protected internal CharacterLiteralNode(ILiteralNodeParent parent, CharacterToken token) : base(parent, token) { }
/// <summary> /// Parse a literal node as described in X3J20 "3.4.6 Literals". /// </summary> /// <remarks> /// If the given token is not a legal token for a literal node, /// it is simply returned in the residueToken output parameter, /// and the function returns null. /// </remarks> /// <param name="parent">Parent node that defines the literal node.</param> /// <param name="token">First token of the literal node.</param> /// <returns>A literal node, or null in case of non-literal token.</returns> protected virtual LiteralNode ParseLiteral(ILiteralNodeParent parent, Token token) { // PARSE: <literal> ::= <number literal> | <string literal> | <character literal> | // <symbol literal> | <selector literal> | <array literal> // <string literal> ::= quotedString if (token is StringToken) // 'example' return new StringLiteralNode(parent, (StringToken)token); // <symbol literal> ::= hashedString if (token is HashedStringToken) // #'example' return new SymbolLiteralNode(parent, (HashedStringToken)token); // <character literal> ::= quotedCharacter if (token is CharacterToken) // $e return new CharacterLiteralNode(parent, (CharacterToken)token); // <selector literal> ::= quotedSelector if (token is QuotedSelectorToken) // #example ..or.. #example: ..or.. #example:example: ..or.. #+ return new SelectorLiteralNode(parent, (QuotedSelectorToken)token); // <number literal> ::= ['-'] <number> if (token is NegativeSignToken) return this.ParseNegativeNumericLiteralNode(parent, (NegativeSignToken)token); // <number> ::= integer | float | scaledDecimal if (token is SmallIntegerToken) return new SmallIntegerLiteralNode(parent, (SmallIntegerToken)token, null); if (token is LargeIntegerToken) return new LargeIntegerLiteralNode(parent, (LargeIntegerToken)token, null); if (token is FloatEToken) return new FloatELiteralNode(parent, (FloatEToken)token, null); if (token is FloatDToken) return new FloatDLiteralNode(parent, (FloatDToken)token, null); if (token is ScaledDecimalToken) return new ScaledDecimalLiteralNode(parent, (ScaledDecimalToken)token, null); // <array literal> ::= '#(' <array element>* ')' // <array element> ::= <literal> | identifier if (Parser.IsLiteralArrayPrefix(token)) return this.ParseArrayLiteral(parent, (SpecialCharacterToken)token); this.ResidueToken = token; return null; }
/// <summary> /// Create and initialize a new float literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> /// <param name="negativeSignToken">Optional negative sign token indicating a negative numeric value.</param> protected FloatLiteralNode(ILiteralNodeParent parent, TToken token, NegativeSignToken negativeSignToken) : base(parent, token, negativeSignToken) { }
protected override LiteralNode ParseLiteral(ILiteralNodeParent parent, Token token) { if ((parent is ArrayLiteralNode) && Parser.IsOpeningParenthesis(token)) { // Stupid VSE allows declarations of arrays like: #( 1 2 ( 3 4 ) 5 6), // which is identical to: #( 1 2 #( 3 4 ) 5 6). // Only the inner (child) arrays may omit the hash prefix. // Here we emulate this and create a 'fake' hash token. // The fake hash token gets the same source positions and the parenthesis token. SpecialCharacterToken hash = new SpecialCharacterToken(SemanticConstants.LiteralArrayPrefix); hash.SetTokenValues(token.StartPosition, token.StopPosition, null); this.ResidueToken = token; return this.ParseArrayLiteral(parent, hash); } if (!Parser.IsLiteralArrayPrefix(token)) return base.ParseLiteral(parent, token); Token token2 = this.GetNextTokenxx(Preference.Default); if (VseCompatibleParser.IsOpeningByteArrayBracket(token2)) return this.ParseByteArrayLiteral(parent, (SpecialCharacterToken) token, (SpecialCharacterToken)token2); this.ResidueToken = token2; return base.ParseLiteral(parent, token); }
/// <summary> /// Create and initialize a new scaled decimal literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> /// <param name="negativeSignToken">Optional negative sign token indicating a negative numeric value.</param> protected internal ScaledDecimalLiteralNode(ILiteralNodeParent parent, ScaledDecimalToken token, NegativeSignToken negativeSignToken) : base(parent, token, negativeSignToken) { }
protected ByteArrayLiteralNode ParseByteArrayLiteral(ILiteralNodeParent parent, SpecialCharacterToken arrayToken, SpecialCharacterToken leftBracket) { // PARSE: <array literal> ::= '#[' <number literal>* ']' List<SmallIntegerLiteralNode> elements = new List<SmallIntegerLiteralNode>(); ByteArrayLiteralNode result = new ByteArrayLiteralNode(parent, arrayToken, leftBracket); // Process tokens inside the array ... while (true) { // ... get next token in the array ... Token token = this.GetNextTokenxx(Preference.NegativeSign); // Is this closing parenthesis? if (VseCompatibleParser.IsClosingByteArrayBracket(token)) { // Closing parenthesis ... done with the array, return litral array node. result.SetContents(elements, (SpecialCharacterToken)token); this.ResidueToken = null; return result; } if (token is EofToken) { // Unfinished source code ... return result.SetContents(elements, null); this.ReportParserError(parent, "Missing literal byte array closing bracket.", token); this.ResidueToken = token; return result; } // PARSE: <numeric liteal> if (token is SmallIntegerToken) { elements.Add(new SmallIntegerLiteralNode(result, (SmallIntegerToken)token, null)); } else if (token is NegativeSignToken) { NegativeSignToken negativeSign = (NegativeSignToken)token; token = this.GetNextTokenxx(Preference.NegativeSign); if (token is SmallIntegerToken) { elements.Add(new SmallIntegerLiteralNode(result, (SmallIntegerToken)token, negativeSign)); } else { this.ReportParserError(parent, "Unrecognized literal.", token); this.ResidueToken = token; result.SetContents(elements, null); return result; } } else { this.ReportParserError(parent, "Unrecognized literal.", token); this.ResidueToken = token; result.SetContents(elements, null); return result; } } }
/// <summary> /// Create and initialize a new small integer literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> /// <param name="negativeSignToken">Optional negative sign token indicating a negative numeric value.</param> public SmallIntegerLiteralNode(ILiteralNodeParent parent, SmallIntegerToken token, NegativeSignToken negativeSignToken) : base(parent, token, negativeSignToken) { }
/// <summary> /// Create and initialize a new selector literal node. /// </summary> /// <param name="parent">Parent node that defines this literal node.</param> /// <param name="token">Token defining the value of the literal node.</param> protected internal SelectorLiteralNode(ILiteralNodeParent parent, QuotedSelectorToken token) : base(parent, token) { }