public bool VisitExprMul(ExprMul expr, TCtx arg)
{
var res = this.Visit(expr, "Mul", arg, out var argOut) && this.Accept("Left", expr.Left, argOut) && this.Accept("Right", expr.Right, argOut);
this._visitor.EndVisitExpr(expr, arg);
return(res);
}
public bool VisitExprMul(ExprMul exprMul, IExpr?parent)
{
this.CheckPlusMinusParenthesizes(exprMul.Left, exprMul);
this.Builder.Append('*');
this.CheckPlusMinusParenthesizes(exprMul.Right, exprMul);
return(true);
}
public Expr VisitExprMul(ExprMul expr)
{
//x*(z+y) = x*z+x*y
if (ExtractPlus(expr.Right, out var plus))
{
return(new ExprPlus(new ExprMul(expr.Left, plus !.Left).ToSubExprIfComplex(), new ExprMul(expr.Left, plus.Right).ToSubExprIfComplex()).ToSubExprIfComplex());
}
//(z+y)*x = z*x+y*x
if (ExtractPlus(expr.Left, out var plusL))
{
return(new ExprPlus(new ExprMul(plusL !.Left, expr.Right).ToSubExprIfComplex(), new ExprMul(plusL.Right, expr.Right).ToSubExprIfComplex()).ToSubExprIfComplex());
}
//x*(z-y) = x*z-x*y
if (ExtractMinus(expr.Right, out var minus))
{
return(new ExprMinus(new ExprMul(expr.Left, minus !.Left).ToSubExprIfComplex(), new ExprMul(expr.Left, minus.Right).ToSubExprIfComplex()).ToSubExprIfComplex());
}
//(z-y)*x = z*x-y*x
if (ExtractMinus(expr.Left, out var minusL))
{
return(new ExprMinus(new ExprMul(minusL !.Left, expr.Right).ToSubExprIfComplex(), new ExprMul(minusL.Right, expr.Right).ToSubExprIfComplex()).ToSubExprIfComplex());
}
//x*(z*y) = x*z*y
if (expr.Right is ExprSubExpr subExprMul && subExprMul.SubExpression is ExprMul mul)
{
return(new ExprMul(expr.Left, mul));
}
//(x*z)*y = x*z*y
if (expr.Left is ExprSubExpr subExprMulL && subExprMulL.SubExpression is ExprMul mulL)
{
return(new ExprMul(mulL, expr.Right));
}
return(expr);
}
public Node ExprMul()
{
var n1 = ExprUnary();
while (firstOfExprMul.Contains(CurrentToken))
{
var n2 = new ExprMul();
switch (CurrentToken)
{
case TokenCategory.MULTIPLICATION:
n2.AnchorToken = Expect(TokenCategory.MULTIPLICATION);
break;
case TokenCategory.MODULO:
n2.AnchorToken = Expect(TokenCategory.MODULO);
break;
case TokenCategory.DIVIDE:
n2.AnchorToken = Expect(TokenCategory.DIVIDE);
break;
default:
throw new SyntaxError(firstOfExprMul, tokenStream.Current);
}
n2.Add(n1);
n2.Add(ExprUnary());
n1 = n2;
}
return(n1);
}
public Expr VisitExprMul(ExprMul expr)
{
var newLeft = expr.Left.Accept(this).Accept(this._modifier);
var newRight = expr.Right.Accept(this).Accept(this._modifier);
if (!ReferenceEquals(newLeft, expr.Left) || !ReferenceEquals(newRight, expr.Right))
{
return(new ExprMul(newLeft, newRight));
}
return(expr);
}
public string Visit(ExprMul node)
{
switch (node.AnchorToken.Category)
{
case TokenCategory.MODULO:
return(VisitChildren(node) +
Line(Indent() + "rem"));
case TokenCategory.MULTIPLICATION:
return(VisitChildren(node) +
Line(Indent() + "mul.ovf"));
case TokenCategory.DIVIDE:
return(VisitChildren(node) +
Line(Indent() + "div"));
default:
return(null);
}
}
public static ExprMul WithRight(this ExprMul original, ExprValue newRight) => new ExprMul(left: original.Left, right: newRight);
public string VisitExprMul(ExprMul expr)
=> $"{this.CheckPlusMinusParenthesizes(expr.Left)}*{this.CheckPlusMinusParenthesizes(expr.Right)}";
public void Visit(ExprMul node)
{
VisitChildren(node);
}
public int VisitExprMul(ExprMul expr) => expr.Left.Accept(this) * expr.Right.Accept(this);
public TRes VisitExprMul(ExprMul exprMul, ExprValueTypeAnalyzerCtx <TRes, TCtx> ctx)
{
return(exprMul.Left.Accept(this, ctx));
}
