func opAssign(b *builder, dest, src *ref, op string) {
opOp := op[:len(op)-1]
if opOp == ">>" || opOp == "<<" {
buildShift(b, dest, dest, src, opOp)
return
}
ok, t := types.SameBasic(src.Type(), dest.Type())
if !ok {
panic("bug")
}
switch t {
case types.Int, types.Int8:
buildBasicArith(b, dest, dest, src, opOp)
return
case types.Uint, types.Uint8:
switch opOp {
case "*", "/", "%":
opOp = "u" + opOp
}
buildBasicArith(b, dest, dest, src, opOp)
return
}
panic("bug")
}
func opAssign(b *builder, dest, src tast.Expr, op *lex8.Token) tast.Stmt {
destRef := dest.R()
srcRef := src.R()
if !destRef.IsSingle() || !srcRef.IsSingle() {
b.Errorf(op.Pos, "%s %s %s", destRef, op.Lit, srcRef)
return nil
} else if !destRef.Addressable {
b.Errorf(op.Pos, "assign to non-addressable")
return nil
}
opLit := parseAssignOp(op.Lit)
destType := destRef.Type()
srcType := srcRef.Type()
if opLit == ">>" || opLit == "<<" {
if v, ok := types.NumConst(srcType); ok {
src = constCast(b, op.Pos, v, src, types.Uint)
if src == nil {
return nil
}
srcRef = src.R()
srcType = types.Uint
}
if !canShift(b, destType, srcType, op.Pos, opLit) {
return nil
}
return &tast.AssignStmt{dest, op, src}
}
if v, ok := types.NumConst(srcType); ok {
src = constCast(b, op.Pos, v, src, destType)
if src == nil {
return nil
}
srcRef = src.R()
srcType = destType
}
if ok, t := types.SameBasic(destType, srcType); ok {
switch t {
case types.Int, types.Int8, types.Uint, types.Uint8:
return &tast.AssignStmt{dest, op, src}
}
}
b.Errorf(op.Pos, "invalid %s %s %s", destType, opLit, srcType)
return nil
}
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
}