public CodeExpression VisitBinExp(BinExp bin)
{
if (bin.op == Op.Mod &&
(bin.r is PyTuple || bin.l is Str))
{
return(TranslateFormatExpression(bin.l, bin.r));
}
var l = bin.l.Accept(this);
var r = bin.r.Accept(this);
if (mppyoptocsop.TryGetValue(bin.op, out var opDst))
{
return(m.BinOp(l, opDst, r));
}
if (bin.op == Op.Is)
{
if (bin.r is NoneExp)
{
return(m.BinOp(l, CodeOperatorType.IdentityEquality, r));
}
}
if (bin.op == Op.IsNot)
{
return(m.BinOp(l, CodeOperatorType.IdentityInequality, r));
}
if (bin.op == Op.In)
{
return(m.Appl(
m.MethodRef(r, "Contains"),
l));
}
if (bin.op == Op.NotIn)
{
return(new CodeUnaryOperatorExpression(
CodeOperatorType.Not,
m.Appl(
m.MethodRef(r, "Contains"),
l)));
}
if (bin.op == Op.Is)
{
return(m.Appl(
m.MethodRef(
m.TypeRefExpr("object"),
"ReferenceEquals"),
l,
r));
}
if (bin.op == Op.Exp)
{
m.EnsureImport("System");
return(m.Appl(
new CodeVariableReferenceExpression("Math.Pow"), l, r));
}
return(m.BinOp(l, mppyoptocsop[bin.op], r));
}
public DataType VisitBinExp(BinExp b)
{
DataType ltype = b.l.Accept(this);
DataType rtype = b.r.Accept(this);
if (b.op.IsBoolean())
{
return(DataType.Bool);
}
else
{
return(UnionType.Union(ltype, rtype));
}
}
Exp parseMulDiv()
{
Token opToken;
Exp resultExpr = parseCall();
while (CurrentToken.Kind == TokenKind.MUL || CurrentToken.Kind == TokenKind.DIV)
{
opToken = CurrentToken;
MoveNext();
Exp rightExpr = parseMulDiv();
resultExpr = new BinExp()
{
LeftExp = resultExpr, OpToken = opToken, RightExp = rightExpr
};
}
return(resultExpr);
}
public Exp parseAddSub()
{
Token opToken;
Exp resultExpr = parseMulDiv();
while (CurrentToken.Kind == TokenKind.ADD || CurrentToken.Kind == TokenKind.SUB)
{
opToken = CurrentToken;
MoveNext();
Exp rightExpr = parseAddSub();
resultExpr = new BinExp()
{
LeftExp = resultExpr, OpToken = opToken, RightExp = rightExpr
};
}
return(resultExpr);
}
Exp parseExp()
{
Token opToken;
Exp resultExpr = parseCompareExpr();
while (CurrentToken.Kind == TokenKind.AND || CurrentToken.Kind == TokenKind.OR)
{
opToken = CurrentToken;
MoveNext();
Exp rightExpr = parseCompareExpr();
resultExpr = new BinExp()
{
LeftExp = resultExpr, OpToken = opToken, RightExp = rightExpr
};
}
return(resultExpr);
}
protected Exp parseCompareExpr()
{
Token opToken;
Exp resultExpr = parseAddSub();
while (CurrentToken.Kind == TokenKind.GT || CurrentToken.Kind == TokenKind.LT || CurrentToken.Kind == TokenKind.GE ||
CurrentToken.Kind == TokenKind.LE || CurrentToken.Kind == TokenKind.NE || CurrentToken.Kind == TokenKind.EQ)
{
opToken = CurrentToken;
MoveNext();
Exp rightExpr = parseAddSub();
resultExpr = new BinExp()
{
LeftExp = resultExpr, OpToken = opToken, RightExp = rightExpr
};
}
return(resultExpr);
}
public Constant VisitBinExp(BinExp binExp)
{
var cLeft = binExp.Left.Accept(this);
if (!cLeft.IsValid)
{
return(cLeft);
}
var cRight = binExp.Right.Accept(this);
if (!cRight.IsValid)
{
return(cRight);
}
if (binExp.Op == TokenType.Minus)
{
return(Operator.ISub.ApplyConstants(cLeft, cRight));
}
throw new NotImplementedException();
}
public Constant VisitBinExp(BinExp binExp)
{
var cLeft = binExp.Left.Accept(this);
if (!cLeft.IsValid)
{
return(cLeft);
}
var cRight = binExp.Right.Accept(this);
if (!cRight.IsValid)
{
return(cRight);
}
return(binExp.Op switch
{
TokenType.Plus => Operator.ISub.ApplyConstants(cLeft, cRight),
TokenType.Minus => Operator.ISub.ApplyConstants(cLeft, cRight),
TokenType.Star => Operator.IMul.ApplyConstants(cLeft, cRight),
TokenType.Slash => Operator.FDiv.ApplyConstants(cLeft, cRight),
_ => throw new NotImplementedException(),
});
//shift_expr: arith_expr (('<<'|'>>') arith_expr)*
public Exp shift_expr()
{
var e = arith_expr();
if (e == null)
return null;
for (; ; )
{
Op op;
switch (lexer.Peek().Type)
{
case TokenType.OP_SHL: lexer.Get(); op = Op.Shl; break;
case TokenType.OP_SHR: lexer.Get(); op = Op.Shr; break;
default: return e;
}
var r = arith_expr();
if (r == null)
Unexpected();
e = new BinExp(op, e, r, filename, e.Start, r.End);
}
}
//and_expr: shift_expr ('&' shift_expr)*
public Exp and_expr()
{
var e = shift_expr();
if (e == null)
return null;
while (PeekAndDiscard(TokenType.OP_AMP))
{
var r = shift_expr();
if (r == null)
Unexpected();
e = new BinExp(Op.BitAnd, e, r, filename, e.Start, r.End);
}
return e;
}
//xor_expr: and_expr ('^' and_expr)*
public Exp xor_expr()
{
var e = and_expr();
if (e == null)
return null;
while (PeekAndDiscard(TokenType.OP_CARET))
{
var r = and_expr();
if (r == null)
Unexpected();
e = new BinExp(Op.Xor, e, r, filename, e.Start, r.End);
}
return e;
}
//expr: xor_expr ('|' xor_expr)*
public Exp expr()
{
var e = xor_expr();
if (e == null)
return e;
while (PeekAndDiscard(TokenType.OP_BAR))
{
var r = xor_expr();
if (r == null)
Unexpected();
e = new BinExp (Op.BitOr, e, r, filename, e.Start, r.End);
}
return e;
}
//comparison: expr (comp_op expr)*
public Exp comparison()
{
var e = expr();
if (e == null)
return e;
int posStart = e.Start;
Exp inner;
for (; ; )
{
Op op;
//'<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
switch (lexer.Peek().Type)
{
case TokenType.OP_LT: op = Op.Lt; break;
case TokenType.OP_LE: op = Op.Le; break;
case TokenType.OP_GE: op = Op.Ge; break;
case TokenType.OP_GT: op = Op.Gt; break;
case TokenType.OP_EQ: op = Op.Eq; break;
case TokenType.OP_NE: op = Op.Ne; break;
case TokenType.In: op = Op.In; break;
case TokenType.Not:
Expect(TokenType.Not);
Expect(TokenType.In);
inner = expr();
e = new BinExp(Op.NotIn, e, inner, filename, posStart, inner.End);
continue;
case TokenType.Is:
Expect(TokenType.Is);
op = PeekAndDiscard(TokenType.Not) ? Op.IsNot : Op.Is;
inner = expr();
e = new BinExp(op, e, inner, filename, posStart, inner.End);
continue;
default: return e;
}
lexer.Get();
inner = expr();
e = new BinExp(op, e, inner, filename, posStart, inner.End);
}
}
//and_test: not_test ('and' not_test)*
public Exp and_test()
{
Exp e = not_test();
if (e == null)
return e;
for (; ; )
{
if (Peek(TokenType.COMMENT))
{
e.Comment = (string)Expect(TokenType.COMMENT).Value;
continue;
}
if (!PeekAndDiscard(TokenType.And))
break;
var r = not_test();
if (r == null)
Unexpected();
e = new BinExp(Op.LogAnd, e, r, filename, e.Start, r.End);
}
return e;
}
//power: atom trailer* ['**' factor]
public Exp power()
{
var e = atom();
if (e == null)
return null;
while (Peek(trailer_first))
{
e = trailer(e);
}
if (PeekAndDiscard(TokenType.OP_STARSTAR))
{
var r = factor();
if (r == null)
Unexpected();
e = new BinExp(Op.Exp, e, r, filename, e.Start, r.End);
}
return e;
}
//arith_expr: term (('+'|'-') term)*
public Exp arith_expr()
{
var e = term();
if (e == null)
return null;
for (; ; )
{
Op op;
switch (lexer.Peek().Type)
{
case TokenType.OP_PLUS: op = Op.Add; break;
case TokenType.OP_MINUS: op = Op.Sub; break;
default: return e;
}
lexer.Get();
var r = term();
if (r == null)
Unexpected();
e = new BinExp(op, e, r, filename, e.Start, r.End);
}
}
public void VisitBinExp(BinExp bin)
{
throw new NotImplementedException();
}
public void VisitBinExp(BinExp bin)
{
throw new NotImplementedException();
}
//term: factor (('*'|'/'|'%'|'//') factor)*
public Exp term()
{
var e = factor();
if (e == null)
return null;
for (; ; )
{
Op op;
switch (lexer.Peek().Type)
{
case TokenType.OP_STAR: op = Op.Mul; break;
case TokenType.OP_SLASH: op = Op.Div; break;
case TokenType.OP_SLASHSLASH: op = Op.IDiv; break;
case TokenType.OP_PERCENT: op = Op.Mod; break;
default: return e;
}
lexer.Get();
var r = factor();
if (r == null)
Unexpected();
e = new BinExp(op, e, r, filename, e.Start, r.End);
}
}
public CodeExpression VisitBinExp(BinExp bin)
{
if (bin.op == Op.Mod &&
(bin.r is PyTuple || bin.l is Str))
{
return(TranslateFormatExpression(bin.l, bin.r));
}
var l = bin.l.Accept(this);
var r = bin.r.Accept(this);
switch (bin.op)
{
case Op.Add:
var cAdd = CondenseComplexConstant(l, r, 1);
if (cAdd != null)
{
return(cAdd);
}
break;
case Op.Sub:
var cSub = CondenseComplexConstant(l, r, -1);
if (cSub != null)
{
return(cSub);
}
break;
}
if (mppyoptocsop.TryGetValue(bin.op, out var opDst))
{
return(m.BinOp(l, opDst, r));
}
switch (bin.op)
{
case Op.Is:
if (bin.r is NoneExp)
{
return(m.BinOp(l, CodeOperatorType.IdentityEquality, r));
}
else
{
return(m.Appl(
m.MethodRef(
m.TypeRefExpr("object"),
"ReferenceEquals"),
l,
r));
}
case Op.IsNot:
return(m.BinOp(l, CodeOperatorType.IdentityInequality, r));
case Op.In:
return(m.Appl(
m.MethodRef(r, "Contains"),
l));
case Op.NotIn:
return(new CodeUnaryOperatorExpression(
CodeOperatorType.Not,
m.Appl(
m.MethodRef(r, "Contains"),
l)));
case Op.Exp:
m.EnsureImport("System");
return(m.Appl(
m.MethodRef(m.TypeRefExpr("Math"), "Pow"),
l, r));
}
return(m.BinOp(l, mppyoptocsop[bin.op], r));
}
public SerializedType VisitBinExp(BinExp binExp)
{
throw new NotImplementedException();
}
//or_test: and_test ('or' and_test)*
public Exp or_test()
{
Exp e = and_test();
if (e == null)
return e;
while (PeekAndDiscard(TokenType.Or))
{
var r = and_test();
if (r == null)
Unexpected();
e = new BinExp(Op.LogOr, e, r, filename, e.Start, r.End);
}
return e;
}
