private ITerm GetProduction(IParseNode node)
{
if (node is ParseProductionNode)
return GetProduction((CodePoint)node.Token);
else
return GetProduction((LabelRef)node.Label);
}
// Expression := [ "-" ] Term { ("+" | "-") Term }
public IParseNode Parse()
{
var tokens = new Tokenizer().Scan(_expression);
_walker = new TokenWalker(tokens);
_parseTree = ParseExpression();
return _parseTree;
}
private static void PopulateNode(TreeNode node, IParseNode start)
{
foreach (IParseNode ipn in start.INodes)
{
TreeNode tn = new TreeNode(ipn.Text);
tn.Tag = ipn;
node.Nodes.Add(tn);
PopulateNode(tn, ipn);
}
}
private IParseNode ApplyTopSortFilter(string sort, IParseNode node)
{
if (sort != null && filterTopSort)
{
node = SelectOnTopSort(node, sort);
if (node == null)
throw new InvalidOperationException("Desired start symbol not found.");
}
return node;
}
/// <summary>
/// Initializes a new instance of the <see cref="Link"/> class.
/// </summary>
/// <param name="parent">The parent/destination frame.</param>
/// <param name="label">The label of this link.</param>
/// <param name="length"></param>
public Link(Frame parent, IParseNode label, int length)
{
#region Contract
Contract.Requires<ArgumentNullException>(parent != null);
Contract.Requires<ArgumentNullException>(label != null);
Contract.Requires<ArgumentOutOfRangeException>(length >= 0);
#endregion
this.Parent = parent;
this.Label = label;
this.IsRejected = false;
this.Length = length;
}
private IParseNode SelectOnTopSort(IParseNode node, string sort)
{
if (node is AmbiguityNode)
{
throw new NotImplementedException();
}
else
{
ITerm prod = GetProduction(node);
return MatchProdOnTopSort(prod, sort) ? node : null;
}
}
// creates an appropriate Expression object from an abstract syntax tree node
public static Expression FromTreeNode(IParseNode ASTNode,
Dictionary<String, Terminal> terms,
Dictionary<String, Nonterminal> vars)
{
if (ASTNode is ParseTree)
{
ParseTree subtree = ASTNode as ParseTree;
if (subtree.Nonterminal != vars["expression"]) throw new Exception("EXPECTED EXPRESSION NODE");
switch (subtree.Children.Count)
{
case 1:
IParseNode child = subtree.Children[0];
if (child is ParseLeaf) // identifier or literal
return ExprFromLeaf(child as ParseLeaf);
else // another expr
return FromTreeNode(child, terms, vars);
case 2: // unary operation
{
IParseNode op = subtree.Children[0];
ParseLeaf opLeaf = op as ParseLeaf;
if (opLeaf == null) throw new Exception("MALFORMED AST");
IParseNode opnd = subtree.Children[1];
Expression baseExpr;
if (opnd is ParseLeaf)
baseExpr = ExprFromLeaf(opnd as ParseLeaf);
else
baseExpr = FromTreeNode(opnd as ParseTree, terms, vars);
return new UnaryOp(opLeaf.Token.Lexeme[0], baseExpr, opLeaf.Token);
}
case 3: // binary operation
{
IParseNode op = subtree.Children[1];
ParseLeaf opLeaf = op as ParseLeaf;
if (opLeaf == null) throw new Exception("MALFORMED AST");
IParseNode lhs = subtree.Children[0];
IParseNode rhs = subtree.Children[2];
Expression lhsExpr, rhsExpr;
if (lhs is ParseLeaf) lhsExpr = ExprFromLeaf(lhs as ParseLeaf);
else lhsExpr = FromTreeNode(lhs as ParseTree, terms, vars);
if (rhs is ParseLeaf) rhsExpr = ExprFromLeaf(rhs as ParseLeaf);
else rhsExpr = FromTreeNode(rhs as ParseTree, terms, vars);
return new BinaryOp(lhsExpr, opLeaf.Token.Lexeme[0], rhsExpr, opLeaf.Token);
}
default:
throw new Exception("MALFORMED AST");
}
}
else throw new Exception("EXPECTED LEAF NODE");
}
/// <summary>
/// Initializes a new instance of the <see cref="Path"/> class.
/// </summary>
/// <param name="next">The next node in the path; or <see langword="null"/>.</param>
/// <param name="link">The associated link; or <see langword="null"/>.</param>
/// <param name="frame">The associated stack frame.</param>
/// <param name="length"></param>
public Path(Path next, Link link, Frame frame, int length)
{
#region Contract
Contract.Requires<ArgumentNullException>(frame != null);
Contract.Requires<ArgumentOutOfRangeException>(length >= 0);
#endregion
this.Next = next;
this.Link = link;
this.Frame = frame;
this.Length = length;
this.AncestorCount = next != null ? next.AncestorCount + 1 : 0;
this.label = this.Link?.Label;
}
public object ApplyFilters(SglrEngine engine, IParseNode root, string sort, int startOffset, int inputLength)
{
IParseNode node = root;
InitializeFromParser(engine);
node = ApplyTopSortFilter(sort, node);
if (filterAny)
{
node = ApplyCycleDetectFilter(node);
node = FilterTree(node);
}
if (node == null)
return null;
return YieldTreeTop(node, startOffset);
}
/// <summary>
/// Gets the parse node for each ancestor, starting from this path.
/// </summary>
/// <returns>A list of parse nodes, one for each ancestor.</returns>
public IReadOnlyList<IParseNode> GetAncestorParseNodes()
{
// FIXME: ParentCount and the actual number of parents must match.
// And we should assert this.
IParseNode[] result = new IParseNode[this.AncestorCount];
Path n = this.Next;
int pos = 0;
while (n != null)
{
result[pos++] = n.label;
n = n.Next;
}
Contract.Assert(pos == this.AncestorCount);
return result;
}
public IParseNode Filter(IParseNode root)
{
if (root is IAmbiguityParseNode)
{
throw new NotSupportedException();
}
else
{
throw new NotSupportedException();
//var production = ((IApplicationParseNode)root).Production;
/*
IListTerm lhs = (IListTerm)production[0];
IConsTerm rhs = (IConsTerm)production[1];
String foundSort = prodReader.tryGetFirstSort(lhs);
assert foundSort != null;
assert "<START>".equals(prodReader.tryGetSort(rhs));
return sort.equals(foundSort);
*/
//final IStrategoTerm prod = getProduction(t);
//return matchProdOnTopSort(prod, sort) ? t : null;
}
}
private void VisitNode(IParseNode node, IParseNode parentNode, TreeNode parentTreeItem)
{
if (node == null)
throw new ArgumentNullException();
TreeNode treeNode = new TreeNode(node.ToString());
treeNode.Tag = node;
treeNode.ToolTipText = treeNode.Text;
if (parentTreeItem == null)
this.treeParseNodes.Nodes.Add(treeNode);
else
parentTreeItem.Nodes.Add(treeNode);
if (this.Errors.ContainsKey(node))
{
treeNode.ForeColor = Color.Red;
TreeNode n = treeNode;
while (n != null)
{
n.Expand();
n = n.Parent;
}
}
foreach (IParseNode child in node.GetChildNodes())
this.VisitNode(child, node, treeNode);
}
public void AddParserError(IParseNode node, SourceLocation startPosition, SourceLocation stopPosition, string parseErrorMessage, IToken offendingToken)
{
this.ErrorSink.Add(this.SourceUnit,
parseErrorMessage,
this.GetSpan(startPosition, stopPosition),
ErrorSinkWrapper.ParseErrorCode,
Microsoft.Scripting.Severity.Error);
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static SectionGroupCollectionResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new SectionGroupCollectionResponse());
}
private void FindSourcePoints(IParseNode node, ref int start, ref int end)
{
foreach (IToken token in node.GetTokens())
{
if (start == -1)
start = token.StartPosition.Position;
else
start = Math.Min(start, token.StartPosition.Position);
if (end == -1)
end = token.StopPosition.Position;
else
end = Math.Max(end, token.StopPosition.Position);
}
foreach (IParseNode child in node.GetChildNodes())
{
this.FindSourcePoints(child, ref start, ref end);
}
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static ConvertIdResult CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new ConvertIdResult());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static new ProvisioningObjectSummary CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new ProvisioningObjectSummary());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static OrganizationalBrandingLocalizationCollectionResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new OrganizationalBrandingLocalizationCollectionResponse());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static new OfficeGraphInsights CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new OfficeGraphInsights());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static Bundle CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new Bundle());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static ActivityBasedTimeoutPolicyCollectionResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new ActivityBasedTimeoutPolicyCollectionResponse());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static CertificateBasedAuthConfigurationCollectionResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new CertificateBasedAuthConfigurationCollectionResponse());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static new CloudAppSecuritySessionControl CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new CloudAppSecuritySessionControl());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static TranslateExchangeIdsRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new TranslateExchangeIdsRequestBody());
}
public bool HasValidLayout(IParseNode node)
{
return HasValidLayout(node.Label, node.Children);
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static CheckMemberObjectsRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new CheckMemberObjectsRequestBody());
}
internal DivisionOperator(IParseNode leftOperand, IParseNode rightOperand)
: base(leftOperand, rightOperand)
{
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static WindowsInformationProtectionIPRangeCollection CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new WindowsInformationProtectionIPRangeCollection());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static GetEmailActivityUserCountsWithPeriodResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new GetEmailActivityUserCountsWithPeriodResponse());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static new PlannerProgressTaskBoardTaskFormat CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new PlannerProgressTaskBoardTaskFormat());
}
/// <summary>
/// Report a semantical error encountered during parsing of the source code.
/// </summary>
/// <param name="node">Parse node responsible / signaling the error.</param>
/// <param name="parseErrorMessage">Parse error message because of source code semantical error.</param>
/// <param name="offendingToken">Token responsible for the problem.</param>
protected virtual void ReportParserError(IParseNode node, string parseErrorMessage, IToken offendingToken)
{
if (offendingToken == null)
throw new ArgumentNullException("token");
else
this.ReportParserError(node, offendingToken.StartPosition, offendingToken.StopPosition, parseErrorMessage, offendingToken);
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static new WorkbookChartGridlines CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new WorkbookChartGridlines());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static FilterByCurrentUserWithOnResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new FilterByCurrentUserWithOnResponse());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static BookingStaffMemberBaseCollectionResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new BookingStaffMemberBaseCollectionResponse());
}
public void VisitParseNode(IParseNode node)
{
Contract.Requires<ArgumentNullException>(node != null);
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static new OnenoteSection CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new OnenoteSection());
}
private void SelectNodeSource(IParseNode node)
{
if (node == null)
this.txtSource.SelectionLength = 0;
int start = -1;
int end = -1;
this.FindSourcePoints(node, ref start, ref end);
if ((start == -1) || (end == -1) || (start > end))
{
this.txtSource.SelectionLength = 0;
}
else
{
this.txtSource.SelectionStart = start;
this.txtSource.SelectionLength = end - start + 1;
}
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static TeamFunSettings CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new TeamFunSettings());
}
void IParseErrorSink.AddParserError(IParseNode node, SourceLocation startPosition, SourceLocation stopPosition, string parseErrorMessage, IronSmalltalk.Compiler.LexicalTokens.IToken offendingToken)
{
if (!this.Errors.ContainsKey(node))
this.Errors.Add(node, new List<string>());
this.Errors[node].Add(parseErrorMessage);
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static ServiceAnnouncementAttachmentCollectionResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new ServiceAnnouncementAttachmentCollectionResponse());
}
internal MultiplicationOperator(IParseNode leftOperand, IParseNode rightOperand)
: base(leftOperand, rightOperand)
{
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static GetActivitiesByIntervalResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new GetActivitiesByIntervalResponse());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static PlannerOrderHintsByAssignee CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new PlannerOrderHintsByAssignee());
}
internal BinaryOperator(IParseNode leftOperand, IParseNode rightOperand)
{
LeftOperand = leftOperand;
RightOperand = rightOperand;
}
// Create appropriate statement object from abstract syntax tree node
public static Statement FromTreeNode(IParseNode ASTNode,
Dictionary<String, Terminal> terms,
Dictionary<String, Nonterminal> vars)
{
ParseTree subtree = ASTNode as ParseTree;
if (subtree == null)
throw new Exception("EXPECTED TREE NODE");
if (subtree.Nonterminal != vars["statement"])
throw new Exception("EXPECTED STATEMENT NODE");
if (subtree.Children[0] is ParseTree) // -------------------------------------------------- Declaration
{
ParseTree declTree = subtree.Children[0] as ParseTree;
ParseLeaf idLeaf = declTree.Children[0] as ParseLeaf;
ParseLeaf typeLeaf = declTree.Children[1] as ParseLeaf;
if (idLeaf == null || typeLeaf == null)
throw new Exception("BAD AST STRUCTURE");
Token idToken = idLeaf.Token;
Token typeToken = typeLeaf.Token;
string identifier = idToken.Lexeme;
ValueType type = Value.TypeFromString(typeToken.Lexeme);
switch (declTree.Children.Count)
{
case 2: // ------------------------------------------------------------------------ simple declaration
return new Statement.DeclarationStmt(identifier, type, idToken);
case 3: // ------------------------------------------------------------------------ declaration with assignment
ParseLeaf valueLeaf = declTree.Children[2] as ParseLeaf;
Expression expr = Expression.FromTreeNode(declTree.Children[2], terms, vars);
return new Statement.DeclarationStmt(identifier, type, idToken, expr);
default:
throw new Exception("BAD AST STRUCTURE");
}
}
else // Assignment / read / print / assert / for statement
{
ParseLeaf firstChild = subtree.Children[0] as ParseLeaf;
if (firstChild.Terminal.MatchedTokenType != null &&
firstChild.Terminal.MatchedTokenType.Name == "identifier") // --------------------- assignment or for
{
if (subtree.Children.Count == 2) // ----------------------------------------------- assignment
{
return new AssignStmt(firstChild.Token.Lexeme,
Expression.FromTreeNode(subtree.Children[1], terms, vars),
firstChild.Token);
}
else if (subtree.Children.Count == 4) // ------------------------------------------ for
{
List<Statement> block = new List<Statement>();
ParseTree blockChild = subtree.Children[3] as ParseTree;
foreach (IParseNode blockSubtree in blockChild.Children)
block.Add(Statement.FromTreeNode(blockSubtree, terms, vars));
if (blockChild == null)
throw new Exception("MALFORMED AST");
return new ForStmt(firstChild.Token.Lexeme,
Expression.FromTreeNode(subtree.Children[1], terms, vars),
Expression.FromTreeNode(subtree.Children[2], terms, vars),
block, firstChild.Token);
}
else throw new Exception("MALFORMED AST");
}
else
{
if (subtree.Children.Count != 2)
throw new Exception("MALFORMED AST");
switch (firstChild.Token.Lexeme)
{
case "assert": // ------------------------------------------------------------- assert
return new AssertStmt(Expression.FromTreeNode(
subtree.Children[1],
terms, vars),
firstChild.Token);
case "print": // -------------------------------------------------------------- print
return new PrintStmt(Expression.FromTreeNode(
subtree.Children[1],
terms, vars),
firstChild.Token);
case "read": // --------------------------------------------------------------- read
ParseLeaf secondChild =
subtree.Children[1] as ParseLeaf;
if (secondChild == null)
throw new Exception("MALFORMED AST");
return new ReadStmt(secondChild.Token.Lexeme, firstChild.Token);
default:
throw new Exception("UNEXPECTED STATEMENT TYPE");
}
}
}
}
/// <summary>
/// Report a semantical error encountered during parsing of the source code.
/// </summary>
/// <param name="node">Parse node responsible / signaling the error.</param>
/// <param name="parseErrorMessage">Parse error message because of source code semantical error.</param>
/// <param name="offendingToken">Token responsible for the problem.</param>
protected override void ReportParserError(IParseNode node, string parseErrorMessage, IToken offendingToken)
{
if (offendingToken == null)
return; // Error must be encountered while scanning and reported by the Scanner.
base.ReportParserError(node, parseErrorMessage, offendingToken);
}
void IParseErrorSink.AddParserError(IParseNode node, SourceLocation startPosition, SourceLocation stopPosition, string parseErrorMessage, IronSmalltalk.Compiler.LexicalTokens.IToken offendingToken)
{
this.ReportError(parseErrorMessage, startPosition, stopPosition);
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static AgreementFileData CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new AgreementFileData());
}
internal MinusOperator(IParseNode leftOperand, IParseNode rightOperand)
: base(leftOperand, rightOperand)
{
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static new ScheduleChangeRequest CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new ScheduleChangeRequest());
}
internal UnaryMinus(IParseNode operand)
: base(operand)
{
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static TextColumn CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new TextColumn());
}
/// <summary>
/// Report a semantical error encountered during parsing of the source code.
/// </summary>
/// <param name="node">Parse node responsible / signaling the error.</param>
/// <param name="startPosition">Source code start position.</param>
/// <param name="stopPosition">source code end position.</param>
/// <param name="parseErrorMessage">Parse error message because of source code semantical error.</param>
/// <param name="offendingToken">Token responsible for the problem.</param>
protected virtual void ReportParserError(IParseNode node, SourceLocation startPosition, SourceLocation stopPosition, string parseErrorMessage, IToken offendingToken)
{
if (this.ErrorSink != null)
this.ErrorSink.AddParserError(node, startPosition, stopPosition, parseErrorMessage, offendingToken);
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static ForwardRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new ForwardRequestBody());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static GetAvailableExtensionPropertiesRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new GetAvailableExtensionPropertiesRequestBody());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static ConfigurationManagerClientEnabledFeatures CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new ConfigurationManagerClientEnabledFeatures());
}
internal UnaryOperator(IParseNode operand)
{
Operand = operand;
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static GetManagedAppPoliciesResponse CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new GetManagedAppPoliciesResponse());
}
/// <summary>
/// Creates a new instance of the appropriate class based on discriminator value
/// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
/// </summary>
public static new PlannerGroup CreateFromDiscriminatorValue(IParseNode parseNode)
{
_ = parseNode ?? throw new ArgumentNullException(nameof(parseNode));
return(new PlannerGroup());
}
public object ApplyFilters(SglrEngine engine, IParseNode root, string sort, int inputLength)
{
return ApplyFilters(engine, root, sort, 0, inputLength);
}
