private ParseFunctionResult ExpressionDash(TokenStream ts)
{
var node = new SyntaxTreeNode(MyNonterminals.EXPRESSION_DASH);
ParseFunctionResult result = new ParseFunctionResult(node);
if (ts.Current != null)
{
switch (ts.Current.Value)
{
case "+":
node.AddChild(new SyntaxTreeNode(new ConcreteTerminal(ts.Pop())));
if (!Resolve(ts, node, Term, out result))
{
return(result);
}
if (!Resolve(ts, node, ExpressionDash, out result))
{
return(result);
}
break;
case "-": goto case "+";
default: break;
}
}
return(result);
}
private ParseFunctionResult ParamListDash(TokenStream ts)
{
var node = new SyntaxTreeNode(MyNonterminals.PARAM_LIST_DASH);
ParseFunctionResult result = new ParseFunctionResult(node);
if (!CheckNotEndOfTokens(ts, node, out result))
{
return(result);
}
if (ts.Current.Value == ",")
{
node.AddChild(new SyntaxTreeNode(new ConcreteTerminal(ts.Pop())));
if (!Resolve(ts, node, Param, out result))
{
return(result);
}
if (!Resolve(ts, node, ParamListDash, out result))
{
return(result);
}
}
return(result);
}
private ParseFunctionResult ParamList(TokenStream ts)
{
var node = new SyntaxTreeNode(MyNonterminals.PARAM_LIST);
ParseFunctionResult result = new ParseFunctionResult(node);
if (!CheckNotEndOfTokens(ts, node, out result))
{
return(result);
}
if (ts.Current.Value != ")")
{
var param = Param(ts);
if (param.HasError)
{
return(new ParseFunctionResult(node, param.Error));
}
if (!param.Node.HasNoChildren)
{
node.AddChild(param.Node);
Resolve(ts, node, ParamListDash, out result);
}
}
return(result);
}
private void ConstructSyntaxTree(Production usedProduction)
{
Nonterminal nonterminal = usedProduction.LeftPart;
SyntaxTreeNode node = _syntaxTree.FindFirst(n => n.HasNoChildren && n.Value.Equals(nonterminal));
foreach (var symbol in usedProduction.RightPart)
{
node.AddChild(new SyntaxTreeNode(symbol.CreateCopy()));
}
}
private ParseFunctionResult Factor(TokenStream ts)
{
var node = new SyntaxTreeNode(MyNonterminals.FACTOR);
ParseFunctionResult result = new ParseFunctionResult(node);
if (!CheckNotEndOfTokens(ts, node, out result))
{
return(result);
}
if (ts.Current.Value == "(")
{
node.AddChild(new SyntaxTreeNode(new ConcreteTerminal(ts.Pop())));
if (!Resolve(ts, node, Expression, out result))
{
return(result);
}
ExpectValue(ts, node, ")", out result);
}
else if (ts.Current.HasOneOfTypes(TokenType.IntegerConstant, TokenType.FloatConstant, TokenType.Identifier))
{
node.AddChild(new SyntaxTreeNode(new ConcreteTerminal(ts.Pop())));
}
else if (ts.Current.HasType(TokenType.Function))
{
Resolve(ts, node, FunctionCall, out result);
}
else
{
return(new ParseFunctionResult(node, ts.Current, "Factor expected"));
}
return(result);
}
private bool Resolve(TokenStream ts, SyntaxTreeNode node, Func <TokenStream, ParseFunctionResult> resolutionFunction, out ParseFunctionResult result)
{
var resolved = resolutionFunction(ts);
if (resolved.HasError)
{
result = new ParseFunctionResult(node, resolved.Error);
return(false);
}
resolved.Node.Parent = node;
node.AddChild(resolved.Node);
result = new ParseFunctionResult(node);
return(true);
}
private bool ExpectValues(TokenStream ts, SyntaxTreeNode node, IEnumerable <string> values, out ParseFunctionResult result)
{
if (!CheckNotEndOfTokens(ts, node, out result))
{
return(false);
}
if (values.All(val => val != ts.Current.Value))
{
result = new ParseFunctionResult(node, ts.Current, string.Format("{0} expected", string.Join(" or ", values)));
return(false);
}
result = new ParseFunctionResult(node);
node.AddChild(new SyntaxTreeNode(new ConcreteTerminal(ts.Pop())));
return(true);
}
private bool ExpectTokenType(TokenStream ts, SyntaxTreeNode node, TokenType tokenType, out ParseFunctionResult result)
{
if (!CheckNotEndOfTokens(ts, node, out result))
{
return(false);
}
if (!ts.Current.HasType(tokenType))
{
result = new ParseFunctionResult(node, ts.Current, string.Format("{0} expected", tokenType));
return(false);
}
result = new ParseFunctionResult(node);
node.AddChild(new SyntaxTreeNode(new ConcreteTerminal(ts.Pop())));
return(true);
}
