func buildBinaryOpExpr(b *builder, expr *tast.OpExpr) *ref {
op := expr.Op.Lit
A := b.buildExpr(expr.A)
atyp := A.Type()
if types.IsBasic(atyp, types.Bool) && (op == "&&" || op == "||") {
switch op {
case "&&":
return buildLogicAnd(b, A, expr.B)
case "||":
return buildLogicOr(b, A, expr.B)
}
panic("unreachable")
}
B := b.buildExpr(expr.B)
btyp := B.Type()
if types.IsConst(atyp) && types.IsConst(btyp) {
return binaryOpConst(b, op, A, B)
}
if op == ">>" || op == "<<" {
ret := b.newTemp(atyp)
buildShift(b, ret, A, B, op)
return ret
}
if ok, t := types.SameBasic(atyp, btyp); ok {
switch t {
case types.Int, types.Int8:
return binaryOpInt(b, op, A, B, t)
case types.Uint, types.Uint8:
return binaryOpUint(b, op, A, B, t)
case types.Bool:
return binaryOpBool(b, op, A, B)
}
panic("bug")
}
if types.IsNil(atyp) && types.IsNil(btyp) {
return binaryOpNil(b, op, A, B)
} else if types.BothPointer(atyp, btyp) {
return binaryOpPtr(b, op, A, B)
} else if types.BothFuncPointer(atyp, btyp) {
return binaryOpPtr(b, op, A, B)
} else if types.BothSlice(atyp, btyp) {
return binaryOpSlice(b, op, A, B)
}
panic("bug")
}
func buildBinaryOpExpr(b *builder, expr *ast.OpExpr) tast.Expr {
opTok := expr.Op
op := opTok.Lit
opPos := opTok.Pos
A := b.buildExpr(expr.A)
if A == nil {
return nil
}
aref := A.R()
if !aref.IsSingle() {
b.Errorf(opPos, "%q on %s", op, aref)
return nil
}
atyp := aref.T
B := b.buildExpr(expr.B)
if B == nil {
return nil
}
bref := B.R()
if !bref.IsSingle() {
b.Errorf(opPos, "%q on %s", op, bref)
return nil
}
btyp := bref.T
if types.IsConst(atyp) && types.IsConst(btyp) {
return binaryOpConst(b, opTok, A, B)
}
if op == ">>" || op == "<<" {
if v, ok := types.NumConst(btyp); ok {
B = constCast(b, opPos, v, B, types.Uint)
if B == nil {
return nil
}
btyp = types.Uint
}
if v, ok := types.NumConst(atyp); ok {
A = constCast(b, opPos, v, A, types.Int)
if A == nil {
return nil
}
atyp = types.Int
}
if !canShift(b, atyp, btyp, opPos, op) {
return nil
}
r := tast.NewRef(atyp)
return &tast.OpExpr{A, opTok, B, r}
}
if v, ok := types.NumConst(atyp); ok {
A = constCast(b, opPos, v, A, btyp)
if A == nil {
return nil
}
atyp = btyp
} else if c, ok := atyp.(*types.Const); ok {
atyp = c.Type
}
if v, ok := types.NumConst(btyp); ok {
B = constCast(b, opPos, v, B, atyp)
if B == nil {
return nil
}
btyp = atyp
} else if c, ok := btyp.(*types.Const); ok {
btyp = c.Type
}
if ok, t := types.SameBasic(atyp, btyp); ok {
switch t {
case types.Int, types.Int8, types.Uint, types.Uint8:
return binaryOpInt(b, opTok, A, B, t)
case types.Bool:
return binaryOpBool(b, opTok, A, B)
case types.Float32:
b.Errorf(opPos, "floating point operations not implemented")
return nil
}
}
if types.IsNil(atyp) && types.IsNil(btyp) {
return binaryOpNil(b, opTok, A, B)
} else if types.BothPointer(atyp, btyp) {
return binaryOpPtr(b, opTok, A, B)
} else if types.BothFuncPointer(atyp, btyp) {
return binaryOpPtr(b, opTok, A, B)
} else if types.BothSlice(atyp, btyp) {
return binaryOpSlice(b, opTok, A, B)
}
b.Errorf(opPos, "invalid operation of %s %s %s", atyp, op, btyp)
if types.IsInteger(atyp) && types.IsInteger(btyp) {
switch op {
case "+", "-", "*", "&", "|", "^", "%", "/",
"==", "!=", ">", "<", ">=", "<=":
b.Errorf(
opPos,
"operation %s needs the same type on both sides",
op,
)
}
}
return nil
}