public Term(NonTerminalToken caller, Production production)
{
Caller = caller;
Productions = new List <Production> {
production
};
}
public NonTerminalPath(NonTerminalToken token, int n)
{
id = token.Id(n);
path = token.Path(n);
name = token.Name;
isExplicit = token.IsExplicit(n);
}
public Follow(NonTerminalToken nonTerminal, ICollection <TerminalToken> terminals) : base(nonTerminal, terminals)
{
}
public IGrammarParser Build()
{
var nameToToken = new Dictionary <string, LLnToken>();
var nonTerminalTokens = new List <NonTerminalPair>(roots.Count + nonTerminals.Count);
foreach (var kv in terminals)
{
nameToToken.Add(
kv.Key,
new TerminalToken(
kv.Value.Id,
kv.Value.Explicit,
kv.Key,
kv.Value.Token,
kv.Value.Pattern
)
);
}
foreach (var kv in nonTerminals)
{
var token = new NonTerminalToken(kv.Key, kv.Value.Count);
nameToToken.Add(kv.Key, token);
nonTerminalTokens.Add(new NonTerminalPair
{
Token = token,
Paths = kv.Value,
});
}
foreach (var pair in nonTerminalTokens)
{
var token = pair.Token;
foreach (var path in pair.Paths)
{
var len = path.Path.Length;
var tokens = new LLnToken[len];
for (int i = 0; i < len; i++)
{
if (!nameToToken.TryGetValue(path.Path[i], out var refToken))
{
throw GrammarDefineException.NonTerminalRefTokenNotFound(token.Name, path.Path[i]);
}
tokens[i] = refToken;
}
token.AddPath(path.Id, path.Explicit, tokens);
}
}
var rootToken = new RootToken(roots.Count);
foreach (var path in roots)
{
var len = path.Path.Length;
var tokens = new LLnToken[len + 1];
for (int i = 0; i < len; i++)
{
if (!nameToToken.TryGetValue(path.Path[i], out var refToken))
{
throw GrammarDefineException.NonTerminalRefTokenNotFound(rootToken.Name, path.Path[i]);
}
tokens[i] = refToken;
}
tokens[len] = EOFToken.Instance;
rootToken.AddPath(path.Id, false, tokens);
}
var parser = new LLnParser(rootToken);
return(parser);
}
public Token GetToken()
{
State = LexicAnalyserState.Initial;
Value = HasNext ? Character.ToString() : "";
Token token = null;
while (HasNext && token == null)
{
switch (State)
{
case LexicAnalyserState.Initial:
HandleInitial();
break;
case LexicAnalyserState.NonTerminal:
token = new NonTerminalToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Space:
token = new SpaceToken();
CurrentIndex++;
break;
case LexicAnalyserState.Terminal:
token = new TerminalToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Empty:
token = new EmptyToken();
CurrentIndex++;
break;
case LexicAnalyserState.NewLine:
token = new NewLineToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Identifier:
token = new IdentifierToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Number:
token = new NumberToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Var:
token = new VarToken();
CurrentIndex++;
break;
case LexicAnalyserState.Write:
token = new WriteToken();
CurrentIndex++;
break;
case LexicAnalyserState.Read:
token = new ReadToken();
CurrentIndex++;
break;
case LexicAnalyserState.If:
token = new IfToken();
CurrentIndex++;
break;
case LexicAnalyserState.End:
token = new EndToken();
CurrentIndex++;
break;
case LexicAnalyserState.Then:
token = new ThenToken();
CurrentIndex++;
break;
case LexicAnalyserState.Begin:
token = new BeginToken();
CurrentIndex++;
break;
case LexicAnalyserState.While:
token = new WhileToken();
CurrentIndex++;
break;
case LexicAnalyserState.Do:
token = new DoToken();
CurrentIndex++;
break;
case LexicAnalyserState.SemiColon:
token = new SemiColonToken();
CurrentIndex++;
break;
case LexicAnalyserState.OpenParentheses:
token = new OpenParenthesesToken();
CurrentIndex++;
break;
case LexicAnalyserState.CloseParentheses:
token = new CloseParenthesesToken();
CurrentIndex++;
break;
case LexicAnalyserState.Plus:
token = new PlusToken();
CurrentIndex++;
break;
case LexicAnalyserState.Sub:
token = new SubToken();
CurrentIndex++;
break;
case LexicAnalyserState.Great:
token = new GreatToken();
CurrentIndex++;
break;
case LexicAnalyserState.Less:
token = new LessToken();
CurrentIndex++;
break;
case LexicAnalyserState.Equal:
token = new EqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.Repeat:
token = new RepeatToken();
CurrentIndex++;
break;
case LexicAnalyserState.Until:
token = new UntilToken();
CurrentIndex++;
break;
case LexicAnalyserState.Attribution:
token = new AttributionToken();
CurrentIndex++;
break;
case LexicAnalyserState.NotEqual:
token = new NotEqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.GreatOrEqual:
token = new GreatOrEqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.LessOrEqual:
token = new LessOrEqualToken();
CurrentIndex++;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(token);
}
public NonTerminalNode(NonTerminalToken token)
{
this.token = token;
}
public Base(NonTerminalToken nonTerminal, ICollection <TerminalToken> terminals)
{
NonTerminal = nonTerminal;
Terminals = terminals;
}
public Term(NonTerminalToken caller, IEnumerable <Production> productions)
{
Caller = caller;
Productions = productions;
}
