public delegate void RuleHandler(ParserContext context);

public class ParseHandler
{
    [Rule("S", "S", "+", "n")]
    public void Rule1(ParserContext context)
    {
        ...
    }
    
    [Rule("S", "n")]
    public void Rule2(ParserContext context)
    {
        ...
    }
}

...

Grammar g = new Grammar(typeof (ParseHandler));

Проходим по списку S0:
в ситуации [S --> * S + n, 0] после точки стоит символ S, он не равен текущему символу n входной строки, поэтому пропускаем эту ситуацию. Следующая ситуация — это [S --> * n, 0]. Вот у нее символ после точки равен n. Поэтому, добавляем эту ситуацию в список S1, сдвинув точку на символ правее, имеем ситуацию [S --> n *, 0] в списке S1.

S1
[S --> * n, 0]
[S --> S * + n, 0]

+        [0]    State: "([S : *S + n , 0], [S : *n , 0])"    EarleyParser.State
+        [1]    State: "([S : n *, 0], [S : S *+ n , 0])"    EarleyParser.State
+        [2]    State: "([S : S + *n , 0])"    EarleyParser.State
+        [3]    State: "()"    EarleyParser.State
+        [4]    State: "()"    EarleyParser.State

+        [0]    State: "([S : *S + n , 0], [S : *n , 0])"    EarleyParser.State
+        [1]    State: "()"    EarleyParser.State
+        [2]    State: "()"    EarleyParser.State
+        [3]    State: "()"    EarleyParser.State
+        [4]    State: "()"    EarleyParser.State

+        [0]    State: "([S : *S + n , 0], [S : *n , 0])"    EarleyParser.State
+        [1]    State: "([S : n *, 0], [S : S *+ n , 0])"    EarleyParser.State
+        [2]    State: "([S : S + *n , 0])"    EarleyParser.State
+        [3]    State: "([S : S + n *, 0], [S : S *+ n , 0])"    EarleyParser.State
+        [4]    State: "([S : S + *n , 0])"    EarleyParser.State

+        [0]    State: "([S : *S + n , 0], [S : *n , 0])"    EarleyParser.State
+        [1]    State: "([S : n *, 0], [S : S *+ n , 0])"    EarleyParser.State
+        [2]    State: "([S : S + *n , 0])"    EarleyParser.State
+        [3]    State: "([S : S + n *, 0], [S : S *+ n , 0])"    EarleyParser.State
+        [4]    State: "([S : S + *n , 0])"    EarleyParser.State
+        [5]    State: "([S : S + n *, 0], [S : S *+ n , 0])"    EarleyParser.State

void AddRule(string leftMymbolName, params string[] rightMymbolNames);
void AddTerminal(string name);
void AddTerminal(string name, int id);
void AddTerminals(params string[] names);

Parser GetParser(RSParser.Engine.Scanner lexer);

bool Parse(int startNonterminalId);
bool Parse(string startNonterminalName)

Rules
    : Rule
    | Rules Rule
    ;
    
Rule
    : Symbol ":" Symbols
    ;

Symbols
    : Symbol
    | Symbols Symbol
    ;

public bool Parse(int startNonterminalId)
{
    PrepareToParse(startNonterminalId);

    State state = AddState();

    // Получаем индексы правил соотвествующих нетерминалу startNonterminalId.
    // и добавляем их в список "нулевого" состояния.
    AddPredictions(startNonterminalId, state, 0);

    do
    {
        // ! Количество ситуаций в стостянии может измениться в процессе
        // их просмотра . По этому кэшируем их число и делаем перебор простым
        // for-ом.
        int count = state.Count;

        for (int i = 0; i < count; i++)
        {
            Situation sit = state[i];

            if (IsComplete(sit))
                Completer(sit, state);
            else
                Predictor(sit, state, 0);
        }
    }
    while (Scanner(ref state));

    // Если последнее состояние содержит "законченную" ситуацию, т.е.
    // ситукациювида [A --> X1...Xk *], значит строка соответствует 
    // грамматике.
    return GetLastState().Exists(IsComplete);
}


/// <summary>
/// Обрабатывает следующий терминал входной строки добавляя в новое 
/// состояние все правила из предыдущего состояния у которых символ 
/// за точкой совпадает со считанный терминальным символом.
/// </summary>
/// <remarks>
/// Описание mefrill: 
/// Scanner — работает только с терминальными символами. Scanner работает
/// на некотором списке state когда тот уже заполнен плностью, т.е. туда 
/// больше ничего добавить нельзя. Поэтому настает время перейти к 
/// заполнению следующего списка nextState. Т.е. Scanner вызывается для 
/// инициализации каждого списка S1...Sn, а список S0 инициализируется
/// особым образом. Что делает Scanner? Он сравнивает символ Next() во 
/// входной терминальной строке с символом после точки в каждой ситуации
/// из state и, если символ после точки совпадает с символом Next(), то
/// Scanner добавляет эту ситуацию в список nextState, преварительно 
/// передвинув точку в правой части правила ситуации на символ правее.
/// </remarks>
/// <param name="state">Текущее состояние.</param>
/// <returns>Нужно ли продолжать сканирование.</returns>
bool Scanner(ref State state)
{
    Token token = Next(); // Считываем следующий треминал входной строки.

    if (token.kind == Tokens.EOF)
        return false; // Если это конец строки, то прекращаем парсинг.

    State nextState = AddState(); // Создаем следующее состоянеие.

    foreach (Situation sit in state)
        if (DotSymId(sit) == token.kind) 
            // Если символ за точкой совпадает со считанный терминальным символом,
            // добавляем символ в новое состояние продвигая в нем точку вперед.
            nextState.Add(sit.CloneWithMoveDot());

    state = nextState; // Делаем следующее состояние текущем.

    return true;
}


/// <summary>
/// Операция Predictor, примененная к ситуации 
/// [B --> alpha * A beta, j], принадлежащей списку Si, делает следующее:
/// 1. Проходит по правилам грамматики.
/// 2. Для каждого правила вида A --> delta, где символ в левой части 
/// совпадает с символом после точки, добаляет в список Si ситуацию 
/// [A --> * delta, i].
/// </summary>
/// <param name="sit">Обрабатываемая ситуация.</param>
/// <param name="state">Текущее состояние.</param>
/// <param name="stateIndex">Индекс текущего состояния.</param>
void Predictor(Situation sit, State state, int stateIndex)
{
    Debug.Assert(!IsComplete(sit));

    // Получаем символ на идущий после точки.
    int dotSymId = DotSymId(sit);
    // Если символ после точки в ситуации является нетерминальным
    // и он не является самым левым символом правила этой ситуации...
    if (IsNonterminal(dotSymId) && dotSymId != Rule(sit).LeftSymbol)
        // то добавляем правила для нетерминала dotSymId в текущее состояние.
        AddPredictions(dotSymId, state, stateIndex);

}

private void AddPredictions(int nonterminalId, State state, int stateIndex)
{
    Debug.Assert(IsNonterminal(nonterminalId));

    foreach (int ruleId in _grammar.NontermRules[nonterminalId])
        state.Add(new Situation(ruleId, 0, 0));
}


/// <summary>
/// Операция Completer, примененная к ситуации [A --> X1...Xk *, j],
/// принадлежащей списку Si, делает следующее:
/// </summary>
/// <param name="sit">Ситуация [A --> X1...Xk *, j]</param>
/// <param name="state">Si</param>
void Completer(Situation sit, State state)
{
    Debug.Assert(IsComplete(sit));

    int leftSymbol = GetLeftSymbol(sit);

    // 1. Проходит по всем ситуациям списка Sj.
    foreach (Situation sit2 in _states[sit.CreationState])
    {
        // 2. Если в ситуации символ 
        // /* VladD2: видимо речь идет о текущем ситуации из Sj, t.e. sit2 */
        // после точки есть символ A, 
        // то добавляет эту ситуацию в список Si, сдвинув предварительно
        // точку в правой части на символ правее.
        if (leftSymbol == DotSymId(sit2))
            state.Add(sit2.CloneWithMoveDot());
    }
}

M>>struct symbol{
M>>   std::string name_;
M>>   bool is_terminal_;

M>>   symbol(){}
M>>   symbol( const std::string& _name, bool _is_terminal )
M>>   :
M>>   name_(_name),
M>>   is_terminal_(_is_terminal)
M>>   {}
M>>};
M>>

string[] _symbols;

VD>А вообще — это же математики. У них указателей в логике нет.

   unsigned int add_symbol( const std::string& _name, bool _is_terminal, bool _is_start = false )
   {
      unsigned int _cur_index = symbols_.size();
      symbols_.push_back( symbol( _name, _is_terminal ) );

        bool IsNonterminal(int sym)
        {
            return sym >= FirstNonterminal && sym <= LastNonterminal;
        }

        bool IsTerminal(int sym)
        {
            return sym >= FirstTerminal && sym <= LastTerminal;
        }