public static SqlTextLength Create(SyntaxParseResult syntaxParseResult) { var textType = DetermineTextType(syntaxParseResult); var textLength = CalculateTextLength(syntaxParseResult, textType); return(new SqlTextLength(textLength)); }
private static SyntaxParseResult <IN> NoMatchingRuleError(IList <Token <IN> > tokens, int currentPosition, List <IN> allAcceptableTokens) { var noRuleErrors = new List <UnexpectedTokenSyntaxError <IN> >(); if (currentPosition < tokens.Count) { noRuleErrors.Add(new UnexpectedTokenSyntaxError <IN>(tokens[currentPosition], allAcceptableTokens.ToArray <IN>())); } else { noRuleErrors.Add(new UnexpectedTokenSyntaxError <IN>(new Token <IN>() { IsEOS = true }, allAcceptableTokens.ToArray <IN>())); } var error = new SyntaxParseResult <IN>(); error.IsError = true; error.Root = null; error.IsEnded = false; error.Errors = noRuleErrors; error.EndingPosition = currentPosition; return(error); }
public SyntaxParseResult <IN> Parse(IList <Token <IN> > tokens, string startingNonTerminal = null) { string start = startingNonTerminal ?? StartingNonTerminal; Dictionary <string, NonTerminal <IN> > NonTerminals = Configuration.NonTerminals; List <UnexpectedTokenSyntaxError <IN> > errors = new List <UnexpectedTokenSyntaxError <IN> >(); NonTerminal <IN> nt = NonTerminals[start]; List <Rule <IN> > rules = nt.Rules.Where <Rule <IN> >(r => r.PossibleLeadingTokens.Contains(tokens[0].TokenID)).ToList <Rule <IN> >(); List <SyntaxParseResult <IN> > rs = new List <SyntaxParseResult <IN> >(); foreach (Rule <IN> rule in rules) { SyntaxParseResult <IN> r = Parse(tokens, rule, 0, start); rs.Add(r); } SyntaxParseResult <IN> result = null; if (rs.Count > 0) { result = rs.Find(r => r.IsEnded && !r.IsError); if (result == null) { List <int> endingPositions = rs.Select(r => r.EndingPosition).ToList <int>(); int lastposition = endingPositions.Max(); List <SyntaxParseResult <IN> > furtherResults = rs.Where <SyntaxParseResult <IN> >(r => r.EndingPosition == lastposition).ToList <SyntaxParseResult <IN> >(); errors.Add(new UnexpectedTokenSyntaxError <IN>(tokens[lastposition], null)); furtherResults.ForEach(r => { if (r.Errors != null) { errors.AddRange(r.Errors); } }); } } if (result == null) { result = new SyntaxParseResult <IN>(); errors.Sort(); if (errors.Count > 0) { int lastErrorPosition = errors.Select(e => e.UnexpectedToken.PositionInTokenFlow).ToList().Max(); var lastErrors = errors.Where(e => e.UnexpectedToken.PositionInTokenFlow == lastErrorPosition).ToList(); result.Errors = lastErrors; } else { result.Errors = errors; } result.IsError = true; } return(result); }
public SyntaxParseResult <IN> ParseOneOrMore(IList <Token <IN> > tokens, OneOrMoreClause <IN> clause, int position) { var result = new SyntaxParseResult <IN>(); var manyNode = new ManySyntaxNode <IN>(""); var currentPosition = position; var innerClause = clause.Clause; bool isError; SyntaxParseResult <IN> lastInnerResult = null; SyntaxParseResult <IN> firstInnerResult = null; if (innerClause is TerminalClause <IN> ) { manyNode.IsManyTokens = true; firstInnerResult = ParseTerminal(tokens, innerClause as TerminalClause <IN>, currentPosition); } else if (innerClause is NonTerminalClause <IN> ) { manyNode.IsManyValues = true; firstInnerResult = ParseNonTerminal(tokens, innerClause as NonTerminalClause <IN>, currentPosition); } else { throw new InvalidOperationException("unable to apply repeater to " + innerClause.GetType().Name); } if (firstInnerResult != null && !firstInnerResult.IsError) { manyNode.Add(firstInnerResult.Root); lastInnerResult = firstInnerResult; currentPosition = firstInnerResult.EndingPosition; var more = new ZeroOrMoreClause <IN>(innerClause); var nextResult = ParseZeroOrMore(tokens, more, currentPosition); if (nextResult != null && !nextResult.IsError) { currentPosition = nextResult.EndingPosition; var moreChildren = (ManySyntaxNode <IN>)nextResult.Root; manyNode.Children.AddRange(moreChildren.Children); } isError = false; } else { isError = true; } result.EndingPosition = currentPosition; result.IsError = isError; result.Root = manyNode; result.IsEnded = lastInnerResult != null && lastInnerResult.IsEnded; return(result); }
public SyntaxParseResult <IN> ParseTerminal(IList <Token <IN> > tokens, TerminalClause <IN> term, int position) { SyntaxParseResult <IN> result = new SyntaxParseResult <IN>(); result.IsError = !term.Check(tokens[position].TokenID); result.EndingPosition = !result.IsError ? position + 1 : position; Token <IN> token = tokens[position]; token.Discarded = term.Discarded; result.Root = new SyntaxLeaf <IN>(token); return(result); }
private static SqlTextLengthSpecification DetermineTextLengthSpecification(SyntaxParseResult syntaxParseResult) { if (syntaxParseResult.Precision1.HasValue) { return(SqlTextLengthSpecification.Numeric); } if ("max".InsensitiveEquals(syntaxParseResult.Text)) { return(SqlTextLengthSpecification.Max); } return(SqlTextLengthSpecification.NotSpecified); }
public SyntaxParseResult <IN> CleanSyntaxTree(SyntaxParseResult <IN> result) { ISyntaxNode <IN> tree = result.Root; if (tree != null) { tree = RemoveByPassNodes(tree); if (NeedAssociativityProcessing(tree)) { tree = SetAssociativity(tree); } result.Root = tree; } return(result); }
private static TextType DetermineTextType(SyntaxParseResult syntaxParseResult) { if (syntaxParseResult.SqlTypeName.Equals("char") || syntaxParseResult.SqlTypeName.Equals("varchar")) { return(TextType.NonUnicode); } if (syntaxParseResult.SqlTypeName.Equals("nchar") || syntaxParseResult.SqlTypeName.Equals("nvarchar")) { return(TextType.Unicode); } throw new ArgumentException($"Type, {syntaxParseResult.SqlTypeName}, was non of the expected values " + $"of char, varchar, nchar, or nvarchar"); }
public SyntaxParseResult <IN> ParseChoice(IList <Token <IN> > tokens, ChoiceClause <IN> choice, int position) { var currentPosition = position; SyntaxParseResult <IN> result = new SyntaxParseResult <IN>() { IsError = true, IsEnded = false, EndingPosition = currentPosition }; foreach (var alternate in choice.Choices) { if (alternate is TerminalClause <IN> terminalAlternate) { result = ParseTerminal(tokens, terminalAlternate, currentPosition); } else if (alternate is NonTerminalClause <IN> nonTerminalAlternate) { result = ParseNonTerminal(tokens, nonTerminalAlternate, currentPosition); } else { throw new InvalidOperationException("unable to apply repeater inside " + choice.GetType().Name); } if (result.IsOk) { if (choice.IsTerminalChoice && choice.IsDiscarded && result.Root is SyntaxLeaf <IN> leaf) { var discardedToken = new SyntaxLeaf <IN>(leaf.Token, true); result.Root = discardedToken; } return(result); } } if (result.IsError && choice.IsTerminalChoice) { var terminalAlternates = choice.Choices.Cast <TerminalClause <IN> >(); var expected = terminalAlternates.Select(x => x.ExpectedToken).ToList(); result.Errors.Add(new UnexpectedTokenSyntaxError <IN>(tokens[currentPosition], expected.ToArray())); } return(result); }
private static int CalculateTextLength(SyntaxParseResult syntaxParseResult, TextType nonUnicode) { var textLengthSpecification = DetermineTextLengthSpecification(syntaxParseResult); switch (textLengthSpecification) { case SqlTextLengthSpecification.NotSpecified: return(1); case SqlTextLengthSpecification.Numeric: ValidateTextLength(nonUnicode, syntaxParseResult.Precision1.Value); return(syntaxParseResult.Precision1.Value); case SqlTextLengthSpecification.Max: ValidateSqlTypeIsVarcharOrNvarchar(syntaxParseResult); return(Int32.MaxValue); default: throw new ArgumentOutOfRangeException(); } }
public static void Main() { while (true) { Console.Write("> "); string input = Console.ReadLine(); if (input == "") { continue; } if (input == "exit") { return; } SyntaxLexer lexer = new SyntaxLexer(); SyntaxParser parser = new SyntaxParser(); Interpreter interpreter = new Interpreter(); List <SyntaxToken> tokens = lexer.Lex(input); SyntaxParseResult result = parser.Parse(tokens); foreach (Diagnostic diagnostic in result.Diagnostics) { Console.WriteLine($"{diagnostic.Severity}: {diagnostic.Message} at {diagnostic.Range.Start}"); } DustObject value = interpreter.Interpret(result.Node); Console.WriteLine($"{value.ToString().Value} ({value.TypeName})"); } }
public ExceptToFunctions(SyntaxParseResult result) { this.result = result; }
public SyntaxParseResult <IN> ParseNonTerminal(IList <Token <IN> > tokens, NonTerminalClause <IN> nonTermClause, int currentPosition) { var startPosition = currentPosition; var endingPosition = 0; var nt = Configuration.NonTerminals[nonTermClause.NonTerminalName]; var errors = new List <UnexpectedTokenSyntaxError <IN> >(); var i = 0; var allAcceptableTokens = new List <IN>(); nt.Rules.ForEach(r => { if (r != null && r.PossibleLeadingTokens != null) { allAcceptableTokens.AddRange(r.PossibleLeadingTokens); } }); allAcceptableTokens = allAcceptableTokens.Distinct().ToList(); var rules = nt.Rules .Where(r => startPosition < tokens.Count && r.PossibleLeadingTokens.Contains(tokens[startPosition].TokenID) || r.MayBeEmpty) .ToList(); if (rules.Count == 0) { return(NoMatchingRuleError(tokens, currentPosition, allAcceptableTokens)); } var innerRuleErrors = new List <UnexpectedTokenSyntaxError <IN> >(); var greaterIndex = 0; var rulesResults = new List <SyntaxParseResult <IN> >(); while (i < rules.Count) { var innerrule = rules[i]; var innerRuleRes = Parse(tokens, innerrule, startPosition, nonTermClause.NonTerminalName); rulesResults.Add(innerRuleRes); var other = greaterIndex == 0 && innerRuleRes.EndingPosition == 0; if (innerRuleRes.EndingPosition > greaterIndex && innerRuleRes.Errors != null && !innerRuleRes.Errors.Any() || other) { greaterIndex = innerRuleRes.EndingPosition; //innerRuleErrors.Clear(); innerRuleErrors.AddRange(innerRuleRes.Errors); } innerRuleErrors.AddRange(innerRuleRes.Errors); i++; } errors.AddRange(innerRuleErrors); SyntaxParseResult <IN> max = null; if (rulesResults.Any()) { if (rulesResults.Any(x => x.IsOk)) { max = rulesResults.Where(x => x.IsOk).OrderBy(x => x.EndingPosition).Last(); } else { max = rulesResults.Where(x => !x.IsOk).OrderBy(x => x.EndingPosition).Last(); } } else { max = new SyntaxParseResult <IN>(); max.IsError = true; max.Root = null; max.IsEnded = false; max.EndingPosition = currentPosition; } var result = new SyntaxParseResult <IN>(); result.Errors = errors; result.Root = max.Root; result.EndingPosition = max.EndingPosition; result.IsError = max.IsError; result.IsEnded = max.IsEnded; if (rulesResults.Any()) { var terr = rulesResults.SelectMany(x => x.Errors).ToList(); var unexpected = terr.Cast <UnexpectedTokenSyntaxError <IN> >().ToList(); var expecting = unexpected.SelectMany(x => x.ExpectedTokens).ToList(); result.AddExpectings(expecting); } return(result); }
public SyntaxParseResult <IN> ParseOption(IList <Token <IN> > tokens, OptionClause <IN> clause, Rule <IN> rule, int position) { var result = new SyntaxParseResult <IN>(); var currentPosition = position; var innerClause = clause.Clause; SyntaxParseResult <IN> innerResult = null; if (innerClause is TerminalClause <IN> ) { innerResult = ParseTerminal(tokens, innerClause as TerminalClause <IN>, currentPosition); } else if (innerClause is NonTerminalClause <IN> ) { innerResult = ParseNonTerminal(tokens, innerClause as NonTerminalClause <IN>, currentPosition); } else { throw new InvalidOperationException("unable to apply repeater to " + innerClause.GetType().Name); } if (innerResult.IsError) { if (innerClause is TerminalClause <IN> ) { result = new SyntaxParseResult <IN>(); result.IsError = true; result.Root = new SyntaxLeaf <IN>(Token <IN> .Empty()); result.EndingPosition = position; } else { result = new SyntaxParseResult <IN>(); result.IsError = true; var children = new List <ISyntaxNode <IN> > { innerResult.Root }; if (innerResult.IsError) { children.Clear(); } result.Root = new OptionSyntaxNode <IN>(rule.NonTerminalName + "__" + rule.Key, children, rule.GetVisitor()); result.EndingPosition = position; } } else { var node = innerResult.Root; var children = new List <ISyntaxNode <IN> > { innerResult.Root }; result.Root = new OptionSyntaxNode <IN>(rule.NonTerminalName + "__" + rule.Key, children, rule.GetVisitor()); result.EndingPosition = innerResult.EndingPosition; } return(result); }
public SyntaxParseResult <IN> ParseNonTerminal(IList <Token <IN> > tokens, NonTerminalClause <IN> nonTermClause, int currentPosition) { var startPosition = currentPosition; var endingPosition = 0; var nt = Configuration.NonTerminals[nonTermClause.NonTerminalName]; var errors = new List <UnexpectedTokenSyntaxError <IN> >(); var i = 0; var allAcceptableTokens = new List <IN>(); nt.Rules.ForEach(r => { if (r != null && r.PossibleLeadingTokens != null) { allAcceptableTokens.AddRange(r.PossibleLeadingTokens); } }); allAcceptableTokens = allAcceptableTokens.Distinct().ToList(); var rules = nt.Rules .Where(r => r.PossibleLeadingTokens.Contains(tokens[startPosition].TokenID) || r.MayBeEmpty) .ToList(); if (rules.Count == 0) { errors.Add(new UnexpectedTokenSyntaxError <IN>(tokens[startPosition], allAcceptableTokens.ToArray <IN>())); } var innerRuleErrors = new List <UnexpectedTokenSyntaxError <IN> >(); SyntaxParseResult <IN> okResult = null; var greaterIndex = 0; var allRulesInError = true; var test = new List <SyntaxParseResult <IN> >(); while (i < rules.Count) { var innerrule = rules[i]; var innerRuleRes = Parse(tokens, innerrule, startPosition, nonTermClause.NonTerminalName); if (!innerRuleRes.IsError && okResult == null || okResult != null && innerRuleRes.EndingPosition > okResult.EndingPosition) { okResult = innerRuleRes; okResult.Errors = innerRuleRes.Errors; endingPosition = innerRuleRes.EndingPosition; } else { test.Add(innerRuleRes); } var other = greaterIndex == 0 && innerRuleRes.EndingPosition == 0; if (innerRuleRes.EndingPosition > greaterIndex && innerRuleRes.Errors != null && !innerRuleRes.Errors.Any() || other) { greaterIndex = innerRuleRes.EndingPosition; innerRuleErrors.Clear(); innerRuleErrors.AddRange(innerRuleRes.Errors); } innerRuleErrors.AddRange(innerRuleRes.Errors); allRulesInError = allRulesInError && innerRuleRes.IsError; i++; } errors.AddRange(innerRuleErrors); var result = new SyntaxParseResult <IN>(); result.Errors = errors; if (okResult != null) { result.Root = okResult.Root; result.IsError = false; result.EndingPosition = okResult.EndingPosition; result.IsEnded = okResult.IsEnded; result.Errors = errors; } else { result.IsError = true; result.Errors = errors; greaterIndex = errors.Count > 0 ? errors.Select(e => e.UnexpectedToken.PositionInTokenFlow).Max() : 0; result.EndingPosition = greaterIndex; result.AddExpectings(errors.SelectMany(e => e.ExpectedTokens)); } if (test.Any()) { var terr = test.SelectMany(x => x.Errors).ToList(); var unexpected = terr.OfType <UnexpectedTokenSyntaxError <IN> >().ToList(); var expecting = unexpected.SelectMany(x => x.ExpectedTokens).ToList(); result.AddExpectings(expecting); ; } return(result); }
private static void ValidateSqlTypeIsVarcharOrNvarchar(SyntaxParseResult syntaxParseResult) { syntaxParseResult.SqlTypeName.Should().BeOneOf("varchar", "nvarchar"); }
public virtual SyntaxParseResult <IN> Parse(IList <Token <IN> > tokens, Rule <IN> rule, int position, string nonTerminalName) { int currentPosition = position; List <UnexpectedTokenSyntaxError <IN> > errors = new List <UnexpectedTokenSyntaxError <IN> >(); bool isError = false; List <ISyntaxNode <IN> > children = new List <ISyntaxNode <IN> >(); if (rule.PossibleLeadingTokens.Contains(tokens[position].TokenID)) { if (rule.Clauses != null && rule.Clauses.Count > 0) { children = new List <ISyntaxNode <IN> >(); foreach (IClause <IN> clause in rule.Clauses) { if (clause is TerminalClause <IN> ) { SyntaxParseResult <IN> termRes = ParseTerminal(tokens, clause as TerminalClause <IN>, currentPosition); if (!termRes.IsError) { children.Add(termRes.Root); currentPosition = termRes.EndingPosition; } else { Token <IN> tok = tokens[currentPosition]; errors.Add(new UnexpectedTokenSyntaxError <IN>(tok, ((TerminalClause <IN>)clause).ExpectedToken)); } isError = isError || termRes.IsError; } else if (clause is NonTerminalClause <IN> ) { SyntaxParseResult <IN> nonTerminalResult = ParseNonTerminal(tokens, clause as NonTerminalClause <IN>, currentPosition); if (!nonTerminalResult.IsError) { children.Add(nonTerminalResult.Root); currentPosition = nonTerminalResult.EndingPosition; if (nonTerminalResult.Errors != null && nonTerminalResult.Errors.Any()) { errors.AddRange(nonTerminalResult.Errors); } } else { errors.AddRange(nonTerminalResult.Errors); } isError = isError || nonTerminalResult.IsError; } if (isError) { break; } } } } if (nonTerminalName == "rootGroup") { ; } SyntaxParseResult <IN> result = new SyntaxParseResult <IN>(); result.IsError = isError; result.Errors = errors; result.EndingPosition = currentPosition; if (!isError) { SyntaxNode <IN> node = null; if (rule.IsSubRule) { node = new GroupSyntaxNode <IN>($"{nonTerminalName}__{rule.Key}", children); } else { node = new SyntaxNode <IN>($"{nonTerminalName}__{rule.Key}", children); } node = ManageExpressionRules(rule, node); if (node.IsByPassNode) // inutile de créer un niveau supplémentaire { result.Root = children[0]; } result.Root = node; result.IsEnded = result.EndingPosition >= tokens.Count - 1 || result.EndingPosition == tokens.Count - 2 && tokens[tokens.Count - 1].TokenID.Equals(default(IN)); if (result.IsEnded) { ; } if (rule.IsExpressionRule) { } } return(result); }
public override SyntaxParseResult <IN> Parse(IList <Token <IN> > tokens, Rule <IN> rule, int position, string nonTerminalName) { var currentPosition = position; var errors = new List <UnexpectedTokenSyntaxError <IN> >(); var isError = false; var children = new List <ISyntaxNode <IN> >(); if (rule.PossibleLeadingTokens.Contains(tokens[position].TokenID) || rule.MayBeEmpty) { if (rule.Clauses != null && rule.Clauses.Count > 0) { children = new List <ISyntaxNode <IN> >(); foreach (var clause in rule.Clauses) { if (clause is TerminalClause <IN> termClause) { var termRes = ParseTerminal(tokens, termClause, currentPosition); if (!termRes.IsError) { children.Add(termRes.Root); currentPosition = termRes.EndingPosition; } else { var tok = tokens[currentPosition]; errors.Add(new UnexpectedTokenSyntaxError <IN>(tok, ((TerminalClause <IN>)clause).ExpectedToken)); } isError = isError || termRes.IsError; } else if (clause is NonTerminalClause <IN> ) { var nonTerminalResult = ParseNonTerminal(tokens, clause as NonTerminalClause <IN>, currentPosition); if (!nonTerminalResult.IsError) { errors.AddRange(nonTerminalResult.Errors); children.Add(nonTerminalResult.Root); currentPosition = nonTerminalResult.EndingPosition; } else { errors.AddRange(nonTerminalResult.Errors); } isError = isError || nonTerminalResult.IsError; } else if (clause is OneOrMoreClause <IN> || clause is ZeroOrMoreClause <IN> ) { SyntaxParseResult <IN> manyResult = null; if (clause is OneOrMoreClause <IN> oneOrMore) { manyResult = ParseOneOrMore(tokens, oneOrMore, currentPosition); } else if (clause is ZeroOrMoreClause <IN> zeroOrMore) { manyResult = ParseZeroOrMore(tokens, zeroOrMore, currentPosition); } if (!manyResult.IsError) { errors.AddRange(manyResult.Errors); children.Add(manyResult.Root); currentPosition = manyResult.EndingPosition; } else { if (manyResult.Errors != null && manyResult.Errors.Count > 0) { errors.AddRange(manyResult.Errors); } } isError = isError || manyResult.IsError; } else if (clause is OptionClause <IN> option) { var optionResult = ParseOption(tokens, option, rule, currentPosition); currentPosition = optionResult.EndingPosition; children.Add(optionResult.Root); } if (isError) { break; } } } } var result = new SyntaxParseResult <IN>(); result.IsError = isError; result.Errors = errors; result.EndingPosition = currentPosition; if (!isError) { SyntaxNode <IN> node = null; if (rule.IsSubRule) { node = new GroupSyntaxNode <IN>(nonTerminalName + "__" + rule.Key, children); node = ManageExpressionRules(rule, node); result.Root = node; result.IsEnded = currentPosition >= tokens.Count - 1 || currentPosition == tokens.Count - 2 && tokens[tokens.Count - 1].TokenID.Equals(default(IN)); } else { node = new SyntaxNode <IN>(nonTerminalName + "__" + rule.Key, children); node.ExpressionAffix = rule.ExpressionAffix; node = ManageExpressionRules(rule, node); result.Root = node; result.IsEnded = currentPosition >= tokens.Count - 1 || currentPosition == tokens.Count - 2 && tokens[tokens.Count - 1].TokenID.Equals(default(IN)); } } return(result); }
public SyntaxParseResult <IN> ParseNonTerminal(IList <Token <IN> > tokens, NonTerminalClause <IN> nonTermClause, int currentPosition) { int startPosition = currentPosition; int endingPosition = 0; NonTerminal <IN> nt = Configuration.NonTerminals[nonTermClause.NonTerminalName]; List <UnexpectedTokenSyntaxError <IN> > errors = new List <UnexpectedTokenSyntaxError <IN> >(); int i = 0; List <IN> allAcceptableTokens = new List <IN>(); nt.Rules.ForEach(r => { if (r != null && r.PossibleLeadingTokens != null) { allAcceptableTokens.AddRange(r.PossibleLeadingTokens); } }); allAcceptableTokens = allAcceptableTokens.Distinct <IN>().ToList <IN>(); List <Rule <IN> > rules = nt.Rules .Where <Rule <IN> >(r => r.PossibleLeadingTokens.Contains(tokens[startPosition].TokenID) || r.MayBeEmpty) .ToList <Rule <IN> >(); if (rules.Count == 0) { errors.Add(new UnexpectedTokenSyntaxError <IN>(tokens[startPosition], allAcceptableTokens.ToArray <IN>())); } List <UnexpectedTokenSyntaxError <IN> > innerRuleErrors = new List <UnexpectedTokenSyntaxError <IN> >(); SyntaxParseResult <IN> okResult = null; int greaterIndex = 0; bool allRulesInError = true; while (i < rules.Count) { Rule <IN> innerrule = rules[i]; SyntaxParseResult <IN> innerRuleRes = Parse(tokens, innerrule, startPosition, nonTermClause.NonTerminalName); if (!innerRuleRes.IsError && okResult == null || (okResult != null && innerRuleRes.EndingPosition > okResult.EndingPosition)) { okResult = innerRuleRes; okResult.Errors = innerRuleRes.Errors; endingPosition = innerRuleRes.EndingPosition; } bool other = greaterIndex == 0 && innerRuleRes.EndingPosition == 0; if ((innerRuleRes.EndingPosition > greaterIndex && innerRuleRes.Errors != null && !innerRuleRes.Errors.Any()) || other) { greaterIndex = innerRuleRes.EndingPosition; innerRuleErrors.Clear(); innerRuleErrors.AddRange(innerRuleRes.Errors); } innerRuleErrors.AddRange(innerRuleRes.Errors); allRulesInError = allRulesInError && innerRuleRes.IsError; i++; } errors.AddRange(innerRuleErrors); SyntaxParseResult <IN> result = new SyntaxParseResult <IN>(); result.Errors = errors; if (okResult != null) { result.Root = okResult.Root; result.IsError = false; result.EndingPosition = okResult.EndingPosition; result.IsEnded = okResult.IsEnded; result.Errors = errors; } else { result.IsError = true; result.Errors = errors; greaterIndex = errors.Select(e => e.UnexpectedToken.PositionInTokenFlow).Max(); result.EndingPosition = greaterIndex; } return(result); }
public SyntaxParseResult <IN> ParseZeroOrMore(IList <Token <IN> > tokens, ZeroOrMoreClause <IN> clause, int position) { var result = new SyntaxParseResult <IN>(); var manyNode = new ManySyntaxNode <IN>(""); var currentPosition = position; var innerClause = clause.Clause; var stillOk = true; SyntaxParseResult <IN> lastInnerResult = null; var innerErrors = new List <UnexpectedTokenSyntaxError <IN> >(); while (stillOk) { SyntaxParseResult <IN> innerResult = null; if (innerClause is TerminalClause <IN> ) { manyNode.IsManyTokens = true; innerResult = ParseTerminal(tokens, innerClause as TerminalClause <IN>, currentPosition); } else if (innerClause is NonTerminalClause <IN> nonTerm) { innerResult = ParseNonTerminal(tokens, nonTerm, currentPosition); if (nonTerm.IsGroup) { manyNode.IsManyGroups = true; } else { manyNode.IsManyValues = true; } } else if (innerClause is GroupClause <IN> ) { manyNode.IsManyGroups = true; innerResult = ParseNonTerminal(tokens, innerClause as NonTerminalClause <IN>, currentPosition); } else { throw new InvalidOperationException("unable to apply repeater to " + innerClause.GetType().Name); } if (innerResult != null && !innerResult.IsError) { manyNode.Add(innerResult.Root); currentPosition = innerResult.EndingPosition; lastInnerResult = innerResult; } else { if (innerResult != null) { innerErrors.AddRange(innerResult.Errors); } } stillOk = stillOk && innerResult != null && !innerResult.IsError && currentPosition < tokens.Count; } result.EndingPosition = currentPosition; result.IsError = false; result.Errors = innerErrors; result.Root = manyNode; result.IsEnded = lastInnerResult != null && lastInnerResult.IsEnded; return(result); }