public override void VisitBinOpNode(BinOpNode binop)
{
var toBrL = binop.ToBracketLeft;
var toBrR = binop.ToBracketRight;
if (toBrL)
{
Text.Append("( ");
}
binop.Left.Visit(this);
if (toBrL)
{
Text.Append(" )");
}
Text.Append($" {binop.Op} ");
if (toBrR)
{
Text.Append("( ");
}
binop.Right.Visit(this);
if (toBrR)
{
Text.Append(" )");
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
base.VisitBinOpNode(binop);
if (binop.Left is IntNumNode left && binop.Right is IntNumNode right)
{
var num = 0;
switch (binop.Op)
{
case "+":
num = left.Num + right.Num;
break;
case "-":
num = left.Num - right.Num;
break;
case "*":
num = left.Num * right.Num;
break;
case "/":
num = left.Num / right.Num;
break;
}
var newInt = new IntNumNode(num);
ReplaceExpr(binop, newInt);
}
}
public ParseResult BinaryOp(string methodName, Token.TokenType[] ops)
{
MethodInfo method = this.GetType().GetMethod(methodName);
var result = new ParseResult();
Node left = result.Register((ParseResult)method.Invoke(this, null));
if (result.error)
{
return(result);
}
Token opToken;
Node right;
while (ops.Contains(this.currentToken.type))
{
opToken = this.currentToken;
result.Register(this.Advance());
right = result.Register((ParseResult)method.Invoke(this, null));
if (result.error)
{
return(result);
}
left = new BinOpNode(opToken, left, right);
}
return(result.Success(left));
}
public override void VisitBinOpNode(BinOpNode binop)
{
binop.Left.Visit(this);
binop.Right.Visit(this);
switch (binop.Op)
{
case '+':
genc.Emit(OpCodes.Add);
break;
case '-':
genc.Emit(OpCodes.Sub);
break;
case '*':
genc.Emit(OpCodes.Mul);
break;
case '/':
genc.Emit(OpCodes.Div);
break;
case '%':
genc.Emit(OpCodes.Rem);
break;
}
}
public Code List(params Code[] values) {
Node list = null;
for (int i = 0; i < values.Length; i++) {
list = new BinOpNode(NodeType.tpList, NodeTag.opNop, list, (Node)values[i]);
}
return list;
}
public override void VisitBinOpNode(BinOpNode binop)
{
binop.Left.Visit(this);
binop.Right.Visit(this);
switch (binop.Op)
{
case "+":
genc.Emit(OpCodes.Add);
break;
case "-":
genc.Emit(OpCodes.Sub);
break;
case "*":
genc.Emit(OpCodes.Mul);
break;
case "/":
genc.Emit(OpCodes.Div);
break;
case "div":
genc.Emit(OpCodes.Div);
break;
case "%":
case "mod":
genc.Emit(OpCodes.Rem);
break;
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
if (depth > 0)
{
Count += 1;
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
binop.Parent = st.Peek();
st.Push(binop);
base.VisitBinOpNode(binop);
st.Pop();
}
private ThreeAddressValueType GenVariable(ExprNode expr)
{
if (expr is IdNode)
{
return(new ThreeAddressStringValue((expr as IdNode).Name));
}
if (expr is DoubleNumNode)
{
return(new ThreeAddressDoubleValue((expr as DoubleNumNode).Num));
}
if (expr is IntNumNode)
{
return(new ThreeAddressIntValue((expr as IntNumNode).Num));
}
if (expr is BinOpNode)
{
BinOpNode op = expr as BinOpNode;
string res = GenTempVariable();
ThreeAddressValueType arg1 = GenVariable(op.Left);
ThreeAddressValueType arg2 = GenVariable(op.Right);
ThreeOperator p = ThreeCode.ParseOperator(op.Op);
AddCode(new ThreeCode(res, p, arg1, arg2));
return(new ThreeAddressStringValue(res));
}
throw new Exception("UNKNOW VALUE. Send autors of ThreeAddressCode");
}
public override void VisitBinOpNode(BinOpNode binop)
{
PreVisit(binop);
binop.Left.Visit(this);
binop.Right.Visit(this);
PostVisit(binop);
}
public override void VisitBinOpNode(BinOpNode binop)
{
if (depth < 0)
{
++opCnt;
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
switch (binop.Op)
{
case OpType.MULT:
if (binop.Left is IntNumNode && (binop.Left as IntNumNode).Num == 1)
{
binop.Right.Visit(this);
ReplaceExpr(binop, binop.Right);
}
else if (binop.Right is IntNumNode && (binop.Right as IntNumNode).Num == 1)
{
binop.Left.Visit(this);
ReplaceExpr(binop, binop.Left);
}
else
{
base.VisitBinOpNode(binop);
}
break;
case OpType.DIV:
if (binop.Right is IntNumNode && (binop.Right as IntNumNode).Num == 1)
{
binop.Left.Visit(this);
ReplaceExpr(binop, binop.Left);
}
break;
default:
base.VisitBinOpNode(binop);
break;
}
}
public ObjectBase VisitBinOpNode(BinOpNode node)
{
var left = this.Visit(node.leftNode);
var right = this.Visit(node.rightNode);
ObjectBase result;
switch (node.token.type)
{
case Token.TokenType.TokenPlus:
result = left.AddTo(right);
break;
case Token.TokenType.TokenMinus:
result = left.SubBy(right);
break;
case Token.TokenType.TokenMul:
result = left.MulBy(right);
break;
case Token.TokenType.TokenDiv:
result = left.DivBy(right);
break;
default:
result = null;
break;
}
result.SetPosition(node.start, node.end);
return(result);
}
public override void VisitBinOpNode(BinOpNode binop)
{
depth++;
switch (binop.Op)
{
case '+':
sum++;
break;
case '-':
sum++;
break;
case '*':
sum += 3;
break;
default:
sum += 3;
break;
}
base.VisitBinOpNode(binop);
depth--;
if (depth == 0)
{
compList.Add(sum);
sum = 0;
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
Text += "(";
binop.Left.Visit(this);
Text += " " + binop.Op + " ";
binop.Right.Visit(this);
Text += ")";
}
public override void VisitBinOpNode(BinOpNode binop)
{
int count = GetOpCountBinOpNode(binop);
if (count > MaxCount)
{
MaxCount = count;
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
if (CycleDepth > 0)
{
OpCount++;
}
binop.Left.Visit(this);
binop.Right.Visit(this);
}
public override void VisitBinOpNode(BinOpNode binop)
{
Node parent = st.Pop();
st.Push(parent);
binop.Parent = parent;
st.Push(binop);
base.VisitBinOpNode(binop);
st.Pop();
}
/// <summary>
/// Посещает узлы <paramref name="binop"/> и применяет оптимизацию по
/// замене выражений вида: 1 * ex, ex * 1, ex / 1 на ex
/// </summary>
/// <param name="binop"></param>
public override void VisitBinOpNode(BinOpNode binop)
{
IsPerformed = false;
if (binop.Op[0] == '*' && binop.Right is IntNumNode innRight &&
innRight.Num == 1)
{
binop.Left.Visit(this);
ReplaceExpr(binop, binop.Left);
IsPerformed = true;
}
public Code List(params Code[] values)
{
Node list = null;
for (int i = 0; i < values.Length; i++)
{
list = new BinOpNode(NodeType.tpList, NodeTag.opNop, list, (Node)values[i]);
}
return(list);
}
/// <summary>
/// Create multiplication tree for nodes in list
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
private static Node CreateMultiplicationTree(List <Node> list)
{
switch (list.Count)
{
case 0:
return(new EmptyNode());
case 1:
return(list[0]);
default:
Node result = new EmptyNode();
int notEmptyIndex = -1;
for (int i = 1; i < list.Count; i++)
{
if (result is EmptyNode)
{
if (list[i] is EmptyNode) // If current node is empty
{
if (notEmptyIndex == -1 && !(list[i - 1] is EmptyNode)) // If previous node is not empty and no waiting nodes
{
notEmptyIndex = i - 1;
}
continue;
}
if (notEmptyIndex > -1) // If we have a non empty node waiting
{
result = ParseMO(list[notEmptyIndex], "*", list[i]);
notEmptyIndex = -1;
}
else // If no nodes are waiting
{
if (list[i - 1] is EmptyNode) // If previous node is empty
{
continue;
}
result = ParseMO(list[i - 1], "*", list[i]);
}
}
else
{
if (list[i] is EmptyNode) // Remove empty nodes
{
continue;
}
BinOpNode temp = result as BinOpNode;
temp.right = ParseMO(temp.right, "*", list[i]);
result = temp;
}
}
return(result);
}
}
public override void VisitBinOpNode(BinOpNode binOpNode)
{
base.VisitBinOpNode(binOpNode);
var operationIsMult = binOpNode.Op == OpType.MULT;
var leftIsZero = binOpNode.Left is IntNumNode && (binOpNode.Left as IntNumNode).Num == 0;
var rightIsZero = binOpNode.Right is IntNumNode && (binOpNode.Right as IntNumNode).Num == 0;
if (operationIsMult && (leftIsZero || rightIsZero))
{
ReplaceExpr(binOpNode, new IntNumNode(0));
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
binop.Left.Visit(this);
binop.Right.Visit(this);
switch (binop.Op)
{
case '*':
case '/': CurrentComplexity += 3; break;
case '+':
case '-': CurrentComplexity += 1; break;
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
binop.Left.Visit(this);
if (binop.Op == '+' || binop.Op == '-')
{
++ComplexityExprs[ComplexityExprs.Count - 1];
}
else if (binop.Op == '*' || binop.Op == '/')
{
ComplexityExprs[ComplexityExprs.Count - 1] += 3;
}
binop.Right.Visit(this);
}
public override void VisitBinOpNode(BinOpNode binop)
{
if (binop.Left is IntNumNode && (binop.Left as IntNumNode).Num == 0 &&
binop.Op[0] == '+')
{
binop.Right.Visit(this);
ReplaceExpr(binop, binop.Right);
}
else
{
base.VisitBinOpNode(binop);
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
if (binop.Op.Equals('+') || binop.Op.Equals('-'))
{
Complexity[Complexity.Count - 1] += 1;
}
if (binop.Op.Equals('/') || binop.Op.Equals('*'))
{
Complexity[Complexity.Count - 1] += 3;
}
binop.Left.Visit(this);
binop.Right.Visit(this);
}
public override void VisitBinOpNode(BinOpNode binop)
{
if ((binop.Left is IdNode) && (binop.Right is IdNode) &&
String.Equals((binop.Left as IdNode).Name, (binop.Right as IdNode).Name) &&
(binop.Op == "-"))
{
ReplaceExpr(binop, new IntNumNode(0));
}
else
{
base.VisitBinOpNode(binop); // Обойти потомков обычным образом
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
var left = binop.Left as UnOpNode;
var right = binop.Right as UnOpNode;
if (left != null && right != null && left.Op == right.Op &&
left.Op == OpType.NOT && left.Expr is IdNode idl)
{
if (right.Expr is IdNode idr && idl.Name == idr.Name)
{
if (binop.Op == OpType.EQUAL)
{
ReplaceExpr(binop, new BoolValNode(true));
}
if (binop.Op == OpType.NOTEQUAL)
{
ReplaceExpr(binop, new BoolValNode(false));
}
}
}
else
if (left != null && left.Op == OpType.NOT && left.Expr is IdNode &&
binop.Right is IdNode && (left.Expr as IdNode).Name == (binop.Right as IdNode).Name)
{
if (binop.Op == OpType.EQUAL)
{
ReplaceExpr(binop, new BoolValNode(false));
}
if (binop.Op == OpType.NOTEQUAL)
{
ReplaceExpr(binop, new BoolValNode(true));
}
}
else
if (right != null && right.Op == OpType.NOT && right.Expr is IdNode &&
binop.Left is IdNode && (right.Expr as IdNode).Name == (binop.Left as IdNode).Name)
{
if (binop.Op == OpType.EQUAL)
{
ReplaceExpr(binop, new BoolValNode(false));
}
if (binop.Op == OpType.NOTEQUAL)
{
ReplaceExpr(binop, new BoolValNode(true));
}
}
else
{
base.VisitBinOpNode(binop);
}
}
public override void VisitBinOpNode(BinOpNode binop)
{
if (binop.Left is ExprNode el)
{
el.Visit(this);
}
if (binop.Right is ExprNode er)
{
er.Visit(this);
}
if (binop.Left is IntNumNode l && binop.Right is IntNumNode r && binop.Op == "*")
{
ReplaceExpr(binop, new IntNumNode(l.Num * r.Num));
}
public override void VisitBinOpNode(BinOpNode binop)
{
var isZeroLeft = binop.Left is IntNumNode && (binop.Left as IntNumNode).Num == 0;
var isZeroRight = binop.Right is IntNumNode && (binop.Right as IntNumNode).Num == 0;
if (string.Equals(binop.Op, "*") && (isZeroRight || isZeroLeft))
{
ReplaceExpr(binop, new IntNumNode(0));
}
else
{
base.VisitBinOpNode(binop);
}
}
private int GetOpCountBinOpNode(BinOpNode binop)
{
int res = 1;
if (binop.Left is BinOpNode)
{
res += GetOpCountBinOpNode(binop.Left as BinOpNode);
}
if (binop.Right is BinOpNode)
{
res += GetOpCountBinOpNode(binop.Right as BinOpNode);
}
return(res);
}
private static Node listToTree(Node expr, BinOpNode list)
{
BinOpNode tree = null;
do {
Node elem = list.right;
NodeTag cop = NodeTag.opNop;
if (elem.type == NodeType.tpUnknown) {
elem.type = expr.type;
}
if (expr.type == NodeType.tpInt) {
if (elem.type == NodeType.tpReal) {
expr = new UnaryOpNode(NodeType.tpReal, NodeTag.opIntToReal, expr);
cop = NodeTag.opRealEq;
} else if (elem.type == NodeType.tpInt) {
cop = NodeTag.opIntEq;
}
} else if (expr.type == NodeType.tpReal) {
if (elem.type == NodeType.tpReal) {
cop = NodeTag.opRealEq;
} else if (elem.type == NodeType.tpInt) {
cop = NodeTag.opRealEq;
elem = QueryImpl.int2real(elem);
}
} else if (expr.type == NodeType.tpDate && elem.type == NodeType.tpDate) {
cop = NodeTag.opDateEq;
} else if (expr.type == NodeType.tpStr && elem.type == NodeType.tpStr) {
cop = NodeTag.opStrEq;
} else if (expr.type == NodeType.tpObj && elem.type == NodeType.tpObj) {
cop = NodeTag.opObjEq;
} else if (expr.type == NodeType.tpBool && elem.type == NodeType.tpBool) {
cop = NodeTag.opBoolEq;
}
if (cop == NodeTag.opNop) {
throw new CodeGeneratorException("Invalid argument types");
}
BinOpNode cmp = new BinOpNode(NodeType.tpBool, cop, expr, elem);
if (tree == null) {
tree = cmp;
} else {
tree = new BinOpNode(NodeType.tpBool, NodeTag.opBoolOr, cmp, tree);
}
} while ((list = (BinOpNode)list.left) != null);
return tree;
}
