public void AddReduceShiftPattern(AssociativityEnum assoc, SymbolChunk <SYMBOL_ENUM> inputChunk, SYMBOL_ENUM reduceProduction, IEnumerable <SYMBOL_ENUM> stackOperators, SYMBOL_ENUM shiftProduction, params SYMBOL_ENUM[] restShiftProductions) { addPatternMatch(SymbolPrecedence.ModeEnum.ShiftReduceConflict, assoc, inputChunk, shiftProductions: restShiftProductions.Concat(shiftProduction).ToArray(), reduceProductions: new SYMBOL_ENUM[] { reduceProduction }, stackOperators: stackOperators); }
public Precedence(SymbolCoordinates coords, AssociativityEnum associativity, IEnumerable <PrecedenceWord> usedTokens) { this.Coords = coords; this.Associativity = associativity; this.usedTokens = usedTokens.ToArray(); // each entry is its own micro group this.PriorityGroupStart = true; this.PriorityGroupEnd = true; }
public void AddReduceReducePattern(AssociativityEnum assoc, SymbolChunk <SYMBOL_ENUM> inputChunk, SYMBOL_ENUM production, params SYMBOL_ENUM[] restProductions) { addPatternMatch(SymbolPrecedence.ModeEnum.ReduceReduceConflict, assoc, inputChunk, shiftProductions: new SYMBOL_ENUM[] { }, reduceProductions: production.Concat(restProductions).ToArray(), stackOperators: null); }
/// <summary> /// Add from lower to highest, symbols in single call are equal /// </summary> public void AddOperator(AssociativityEnum assoc, params SYMBOL_ENUM[] opSymbols) { if (priorityGroupCounter == 0) { ++runningPriority; } foreach (SYMBOL_ENUM op_symbol in opSymbols) { addEntry(this.operators, new SymbolPrecedence <SYMBOL_ENUM>(SymbolPrecedence.ModeEnum.BasicOperatorSearch) { Symbols = SymbolChunk.Create(op_symbol), Associativity = assoc, Priority = runningPriority }, symbolsRep); } }
public static Precedence Create(SymbolCoordinates coords, string mode, string associativity, IEnumerable <string> inputSymbols, IEnumerable <PrecedenceWord> conflictProds) { precedenceMode prec = getPrec(mode); AssociativityEnum assoc = getAssoc(associativity); switch (prec) { case precedenceMode.Operator: return(new OperatorPrecedence(coords, assoc, inputSymbols.Select(it => new PrecedenceWord(it)), conflictProds)); case precedenceMode.ReduceShift: return(new ReduceShiftPrecedence(coords, assoc, inputSymbols.Select(it => new PrecedenceWord(it)), conflictProds)); case precedenceMode.ReduceReduce: return(new ReduceReducePrecedence(coords, assoc, inputSymbols.Select(it => new PrecedenceWord(it)), conflictProds)); } throw ParseControlException.NewAndRun("Not recognized precedence"); }
public ReduceReducePrecedence(SymbolCoordinates coords, AssociativityEnum associativity, IEnumerable <PrecedenceWord> inputTokens, IEnumerable <PrecedenceWord> conflictTokens) : base(coords, associativity, inputTokens.Concat(conflictTokens)) { try { InputSet = inputTokens.ToArray(); ReduceSymbols = conflictTokens.ToArray(); if (ReduceSymbols.Count() < 2) { throw new Exception(); } } catch { throw ParseControlException.NewAndRun("Incorrect reduce/reduce precedence rule"); } }
private void addPatternMatch(SymbolPrecedence.ModeEnum mode, AssociativityEnum assoc, SymbolChunk <SYMBOL_ENUM> inputChunk, SYMBOL_ENUM[] shiftProductions, SYMBOL_ENUM[] reduceProductions, IEnumerable <SYMBOL_ENUM> stackOperators) { if (priorityGroupCounter == 0) { ++runningPriority; } var entry = new SymbolPrecedence <SYMBOL_ENUM>(mode) { Symbols = inputChunk, Associativity = assoc, Priority = runningPriority, ShiftProductions = new HashSet <SYMBOL_ENUM>(shiftProductions), ReduceProductions = new HashSet <SYMBOL_ENUM>(reduceProductions), StackOperators = new HashSet <SYMBOL_ENUM>(stackOperators ?? new SYMBOL_ENUM[] { }) }; addEntry(this.patterns, entry, symbolsRep); }
// in case of operator precedence -- it is just a list of tokens, not conflict resolution really // so we don't have do anything special public OperatorPrecedence(SymbolCoordinates coords, AssociativityEnum associativity, IEnumerable <PrecedenceWord> inputTokens, IEnumerable <PrecedenceWord> conflictTokens) : base(coords, associativity, inputTokens.Concat(conflictTokens)) { }
internal static IEnumerable <Precedence> CreateOperators(SymbolCoordinates coords, string mode, IEnumerable <Tuple <string, string> > __opPairs, // it can be single and then serves as both reduce production and shift production // or it can be many, but then remember to put reduce production as first one (exactly as in RS rule) IEnumerable <string> __conflictProds) { if (!__conflictProds.Any()) { throw ParseControlException.NewAndRun("There has to be at least one production given for operator precedence."); } string reduce_prod = __conflictProds.First(); IEnumerable <string> shift_prod = __conflictProds.Count() == 1 ? new [] { __conflictProds.Single() }: __conflictProds.Skip(1).ToArray(); precedenceMode prec = getPrec(mode); if (prec != precedenceMode.ReduceShift) { throw ParseControlException.NewAndRun("Only shift-reduce mode is supported with this syntax."); } Tuple <string, string>[] op_pairs = __opPairs.ToArray(); var result = new List <Precedence>(); for (int i = 0; i < op_pairs.Length; ++i) { string input_sym = op_pairs[i].Item2; var group = new List <Precedence>(); { // same vs same // here we go as given associativity, because priority is the same (of course) AssociativityEnum assoc = getAssoc(op_pairs[i].Item1); group.Add(new ReduceShiftPrecedence(coords, assoc, new[] { new PrecedenceWord(input_sym) }, PrecedenceWord.Create(reduce_prod, input_sym).Concat(shift_prod.Select(it => new PrecedenceWord(it)))) { PriorityGroupEnd = false, PriorityGroupStart = false }); } if (i > 0) { // higher priority means that if master is in input we shift, and when it is on stack we reduce group.Add(new ReduceShiftPrecedence(coords, AssociativityEnum.Reduce, op_pairs.Take(i).Select(it => new PrecedenceWord(it.Item2)), PrecedenceWord.Create(reduce_prod, input_sym).Concat(shift_prod.Select(it => new PrecedenceWord(it)))) { PriorityGroupEnd = false, PriorityGroupStart = false }); group.Add(new ReduceShiftPrecedence(coords, AssociativityEnum.Shift, new[] { new PrecedenceWord(input_sym) }, new PrecedenceWord(reduce_prod, op_pairs.Take(i).Select(it => it.Item2)).Concat(shift_prod.Select(it => new PrecedenceWord(it)))) { PriorityGroupEnd = false, PriorityGroupStart = false }); } group.First().PriorityGroupStart = true; group.Last().PriorityGroupEnd = true; result.AddRange(group); } return(result); }
public Operator(Func <double, double, double> execute, byte priority, AssociativityEnum associativity = AssociativityEnum.Left) { Priority = priority; Associativity = associativity; Execute = execute; }
public void AddReduceShiftPattern(AssociativityEnum assoc, SymbolChunk <SYMBOL_ENUM> inputChunk, SYMBOL_ENUM reduceProduction, SYMBOL_ENUM shiftProduction, params SYMBOL_ENUM[] restShiftProductions) { AddReduceShiftPattern(assoc, inputChunk, reduceProduction, null, shiftProduction, restShiftProductions); }
public void AddReduceShiftPattern(AssociativityEnum assoc, SYMBOL_ENUM inputSymbol, SYMBOL_ENUM reduceProduction, IEnumerable <SYMBOL_ENUM> stackOperators, SYMBOL_ENUM shiftProduction, params SYMBOL_ENUM[] restShiftProductions) { AddReduceShiftPattern(assoc, SymbolChunk.Create(inputSymbol), reduceProduction, stackOperators, shiftProduction, restShiftProductions); }
public void AddReduceReducePattern(AssociativityEnum assoc, SYMBOL_ENUM inputSymbol, SYMBOL_ENUM production, params SYMBOL_ENUM[] restProductions) { AddReduceReducePattern(assoc, SymbolChunk.Create(inputSymbol), production, restProductions); }