/// <summary>
/// expression → terme [opérateur-additif terme]*
/// </summary>
static double ComputeExpression(StringTokenizer t)
{
var expr = ComputeTerm(t);
while (t.CurrentToken == TokenType.Plus ||
t.CurrentToken == TokenType.Minus)
{
if (t.Match(TokenType.Plus))
{
expr += ComputeTerm(t);
}
if (t.Match(TokenType.Minus))
{
expr -= ComputeTerm(t);
}
}
return(expr);
//
// expression → terme | terme opérateur-additif terme
// ==> only ONE primary/root addition/substraction is handled here!
//
//var expr = ComputeTerm( t );
//if( t.Match( TokenType.Plus ) ) expr += ComputeTerm( t );
//else if( t.Match( TokenType.Minus ) ) expr -= ComputeTerm( t );
//return expr;
}
/// <summary>
/// condExpression → expression [? condExpression : condExpression]
/// </summary>
static double ComputeCondExpression(StringTokenizer t)
{
var expr = ComputeExpression(t);
if (t.Match(TokenType.QuestionMark))
{
var then = ComputeCondExpression(t);
if (!t.Match(TokenType.Colon))
{
throw new Exception("Expected : of ternary operator.");
}
var @else = ComputeCondExpression(t);
expr = expr > 0 ? then : @else;
}
return(expr);
}
/// <summary>
/// positiveFacteur → nombre | ‘(’ expression ‘)’
/// </summary>
static double ComputePositiveFactor(StringTokenizer t)
{
if (!t.MatchDouble(out var f))
{
if (!t.Match(TokenType.OpenPar))
{
throw new Exception("Expected number or (.");
}
f = ComputeExpression(t);
if (!t.Match(TokenType.ClosePar))
{
throw new Exception("Expected ).");
}
}
return(f);
}
Node ParseCondExpression(StringTokenizer t)
{
var condition = ParseExpression(t);
if (t.Match(TokenType.QuestionMark))
{
var then = ParseCondExpression(t);
if (!t.Match(TokenType.Colon))
{
return(new ErrorNode("Expected : of ternary operator."));
}
var @else = ParseCondExpression(t);
condition = new IfNode(condition, then, @else);
}
return(condition);
}
/// <summary>
/// facteur ==> PositiveFacteur | '-' PositiveFacteur
/// </summary>
static double ComputeFactor(StringTokenizer t)
{
if (t.Match(TokenType.Minus))
{
return(-ComputePositiveFactor(t));
}
return(ComputePositiveFactor(t));
}
Node ParseFactor(StringTokenizer t)
{
if (t.Match(TokenType.Minus))
{
return(new UnaryNode(TokenType.Minus, ParsePositiveFactor(t)));
}
return(ParsePositiveFactor(t));
}
/// <summary>
/// terme → facteur [opérateur-multiplicatif facteur]*
/// </summary>
static double ComputeTerm(StringTokenizer t)
{
var fact = ComputeFactor(t);
while (t.CurrentToken == TokenType.Mult ||
t.CurrentToken == TokenType.Div)
{
if (t.Match(TokenType.Mult))
{
fact *= ComputeFactor(t);
}
if (t.Match(TokenType.Div))
{
fact /= ComputeFactor(t);
}
}
return(fact);
}
Node ParsePositiveFactor(StringTokenizer t)
{
if (t.MatchDouble(out var f))
{
return(new ConstantNode(f));
}
if (t.MatchIdentifier(out var id))
{
return(new IdentifierNode(id));
}
if (t.Match(TokenType.OpenPar))
{
Node expr = ParseCondExpression(t);
if (!t.Match(TokenType.ClosePar))
{
return(new ErrorNode("Expected )."));
}
return(expr);
}
return(new ErrorNode("Expected ( or number."));
}
