public void NotSetActionDefaultsToError() { var t = new ParserTable(1, 1, 1); var a = t.GetAction(0, 0); Assert.Equal(ParserTable.ActionType.Error, a.Type); Assert.Equal(0, a.Argument); }
public void CreateWithValidDimensions() { var t = new ParserTable(1, 2, 3); Assert.NotNull(t); Assert.Equal(1, t.StateCount); Assert.Equal(2, t.TerminalCount); Assert.Equal(3, t.GrammaticalCount); }
public void SetGetAction( int state_count, int terminal_count, int grammatical_count, int state_index, int terminal_index, ParserTable.Action action) { var t = new ParserTable(state_count, terminal_count, grammatical_count); t.SetAction(state_index, terminal_index, action); Assert.Equal(action, t.GetAction(state_index, terminal_index)); }
public void NotSetGotoDefaultsToError() { var t = new ParserTable(1, 1, 1); Assert.Equal(-1, t.GetGoto(0, 0)); }
public void SetGetGoto( int state_count, int terminal_count, int grammatical_count, int state_index, int grammatical_index, int goto_arg) { var t = new ParserTable(state_count, terminal_count, grammatical_count); t.SetGoto(state_index, grammatical_index, goto_arg); Assert.Equal(goto_arg, t.GetGoto(state_index, grammatical_index)); }
/// <summary> /// Starts the syntactic parsing of <paramref name="input"/> using the given <paramref name="grammar"/>, /// <paramref name="table"/> /// </summary> /// <param name="grammar">The grammar to be used for parsing.</param> /// <param name="table">The parser table to be used for parsing.</param> /// <param name="input">The input to be parsed.</param> /// <exception cref="ArgumentNullException"> if any of the parameters is <c>null</c>.</exception> /// <exception cref="InvalidOperationException"> if <see cref="IsParsing"/> is <c>true</c>.</exception> /// <exception cref="UnexpectedEndOfSourceException"> if the <paramref name="input"/> contains no /// <see cref="TerminalSymbol"/>s.</exception> public void Start( ExtendedGrammar grammar, ParserTable table, IEnumerable<TerminalSymbol> input ) { if( this.IsParsing ) throw new InvalidOperationException("Parser is already parsing."); if( grammar == null ) throw new ArgumentNullException("grammar"); if( table == null ) throw new ArgumentNullException("table"); if( input == null ) throw new ArgumentNullException("input"); // Get grammar and table this.grammar = grammar; this.table = table; // Get input this.input = input.GetEnumerator(); this.input.Reset(); if( !this.input.MoveNext() ) throw new UnexpectedEndOfSourceException("Input must contain at least the EndOfSource symbol."); // Start the actual parsing this.step_count = -1; this.stack.Clear(); this.stack.Push(0, this.grammar.EndOfSourceSymbol); this.BeginNewPhase(); this.OnPhaseChanged(); }
/// <summary> /// Builds and return an SLR(1) <see cref="ParserTable"/> based on the given paramaters. /// </summary> /// <param name="grammar">The grammar.</param> /// <param name="canonical_sets">LR(0) canonical sets generated from the <paramref name="grammar"/>.</param> /// <param name="follow_sets">Follow sets of all the <paramref name="grammar"/>'s grammaticals /// (see <see cref="FollowSets"/>).</param> /// <returns>An SLR(1) parser table.</returns> public static ParserTable Build( ExtendedGrammar grammar, LR0CanonicalSets canonical_sets, IDictionary<GrammaticalSymbol, ISet<TerminalSymbol>> follow_sets) { if( object.ReferenceEquals(grammar, null) ) throw new ArgumentNullException("grammar"); if( object.ReferenceEquals(canonical_sets, null) ) throw new ArgumentNullException("canonical_sets"); if( object.ReferenceEquals(follow_sets, null) ) throw new ArgumentNullException("follow_sets"); var table = new ParserTable(canonical_sets.Sets.Count, grammar.Terminals.Count, grammar.Grammaticals.Count); for( int state_index = 0; state_index < canonical_sets.Sets.Count; ++state_index ) { // Steps foreach( var term in grammar.Terminals ) { int next_state_index = canonical_sets.GetTransition(state_index, term); if( next_state_index != -1 ) { if( table.GetAction(state_index, grammar.IndexOf(term)).Type != ParserTable.ActionType.Error ) throw new ArgumentException("Grammar is not SLR(1)."); //TODO: custom exception with conflict info table.SetAction(state_index, grammar.IndexOf(term), ParserTable.Action.Step(next_state_index)); } } // Gotos foreach( var gram in grammar.Grammaticals ) { int next_state_index = canonical_sets.GetTransition(state_index, gram); if( next_state_index != -1 ) { if( table.GetGoto(state_index, grammar.IndexOf(gram)) != -1 ) throw new ArgumentException("Grammar is not SLR(1)."); //TODO: custom exception with conflict info table.SetGoto(state_index, grammar.IndexOf(gram), next_state_index); } } // Reductions foreach( var item in canonical_sets.Sets[state_index] ) if( item.CursorPosition == item.Rule.RightHandSide.Count ) { // Is it [S'->S.] ? if( item.Rule.LeftHandSide == grammar.StartSymbol ) { if( table.GetAction(state_index, grammar.IndexOf(grammar.EndOfSourceSymbol)).Type != ParserTable.ActionType.Error ) throw new ArgumentException("Grammar is not SLR(1)."); //TODO: custom exception with conflict info table.SetAction( state_index, grammar.IndexOf(grammar.EndOfSourceSymbol), ParserTable.Action.Accept()); } // ... no, it's [A->alpha.] else { int rule_index = grammar.Rules.IndexOf(item.Rule); foreach( var follow_term in follow_sets[item.Rule.LeftHandSide] ) { if( table.GetAction(state_index, grammar.IndexOf(follow_term)).Type != ParserTable.ActionType.Error ) throw new ArgumentException("Grammar is not SLR(1)."); //TODO: custom exception with conflict info table.SetAction( state_index, grammar.IndexOf(follow_term), ParserTable.Action.Reduction(rule_index)); } } } } return table; }
static Grammar2() { var terminals = new TerminalSymbol[] { new TerminalSymbol("+"), new TerminalSymbol("*"), new TerminalSymbol("("), new TerminalSymbol(")"), new TerminalSymbol("i"), }; var grammaticals = new GrammaticalSymbol[] { new GrammaticalSymbol("S"), new GrammaticalSymbol("E"), new GrammaticalSymbol("E'"), new GrammaticalSymbol("T"), new GrammaticalSymbol("T'"), new GrammaticalSymbol("F"), }; var rules = new Rule[] { // S->E new Rule( grammaticals[0], new Symbol[] { grammaticals[1], }), // E->TE' new Rule( grammaticals[1], new Symbol[] { grammaticals[3], grammaticals[2], }), // E'->+TE' new Rule( grammaticals[2], new Symbol[] { terminals[0], grammaticals[3], grammaticals[2], }), // E'-> new Rule( grammaticals[2], new Symbol[] { }), // T->FT' new Rule( grammaticals[3], new Symbol[] { grammaticals[5], grammaticals[4], }), // T'->*FT' new Rule( grammaticals[4], new Symbol[] { terminals[1], grammaticals[5], grammaticals[4], }), // T'-> new Rule( grammaticals[4], new Symbol[] { }), // F->(E) new Rule( grammaticals[5], new Symbol[] { terminals[2], grammaticals[1], terminals[3], }), // F->i new Rule( grammaticals[5], new Symbol[] { terminals[4], }), }; BaseGrammar = new Grammar(terminals, grammaticals, rules, 0); RestrictedGrammar = new RestrictedStartSymbolGrammar(BaseGrammar); ExtendedGrammar = new ExtendedGrammar(RestrictedGrammar); EpsilonGrammaticals = new HashSet<GrammaticalSymbol>( new GrammaticalSymbol[] { grammaticals[2], grammaticals[4] }); FirstSets = new Dictionary<GrammaticalSymbol, ISet<TerminalSymbol>>(); // S: (,i FirstSets[BaseGrammar.Grammaticals[0]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { BaseGrammar.Terminals[2], BaseGrammar.Terminals[4], }); // E: (,i FirstSets[BaseGrammar.Grammaticals[1]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { BaseGrammar.Terminals[2], BaseGrammar.Terminals[4], }); // E': +,Eps FirstSets[BaseGrammar.Grammaticals[2]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { BaseGrammar.Terminals[0], EpsilonSymbol.Instance, }); // T: (,i FirstSets[BaseGrammar.Grammaticals[3]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { BaseGrammar.Terminals[2], BaseGrammar.Terminals[4], }); // T': *,Eps FirstSets[BaseGrammar.Grammaticals[4]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { BaseGrammar.Terminals[1], EpsilonSymbol.Instance, }); // F: (,i FirstSets[BaseGrammar.Grammaticals[5]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { BaseGrammar.Terminals[2], BaseGrammar.Terminals[4], }); FollowSets = new Dictionary<GrammaticalSymbol, ISet<TerminalSymbol>>(); // S: FollowSets[ExtendedGrammar.Grammaticals[0]] = new HashSet<TerminalSymbol>(); // E: ),EoS FollowSets[ExtendedGrammar.Grammaticals[1]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { ExtendedGrammar.Terminals[3], ExtendedGrammar.Terminals[5], }); // E': ),EoS FollowSets[ExtendedGrammar.Grammaticals[2]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { ExtendedGrammar.Terminals[3], ExtendedGrammar.Terminals[5], }); // T: +,),EoS FollowSets[ExtendedGrammar.Grammaticals[3]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { ExtendedGrammar.Terminals[0], ExtendedGrammar.Terminals[3], ExtendedGrammar.Terminals[5], }); // T': +,),EoS FollowSets[ExtendedGrammar.Grammaticals[4]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { ExtendedGrammar.Terminals[0], ExtendedGrammar.Terminals[3], ExtendedGrammar.Terminals[5], }); // F: +,*,),EoS FollowSets[ExtendedGrammar.Grammaticals[5]] = new HashSet<TerminalSymbol>(new TerminalSymbol[] { ExtendedGrammar.Terminals[0], ExtendedGrammar.Terminals[1], ExtendedGrammar.Terminals[3], ExtendedGrammar.Terminals[5], }); //TODO: Use real fixture!! LR0CanonicalSets = LR0CanonicalSets.Build(RestrictedGrammar); //TODO: Use real fixtures!! SLR1ParserTable = SLR1ParserTableBuilder.Build(ExtendedGrammar, LR0CanonicalSets, FollowSets); }