// if both are addressable, move
if n.Addable != 0 && res.Addable != 0 {
- if gc.Is64(n.Type) || gc.Is64(res.Type) || n.Op == gc.OREGISTER || res.Op == gc.OREGISTER || gc.Iscomplex[n.Type.Etype] != 0 || gc.Iscomplex[res.Type.Etype] != 0 {
+ if gc.Is64(n.Type) || gc.Is64(res.Type) || n.Op == gc.OREGISTER || res.Op == gc.OREGISTER || gc.Iscomplex[n.Type.Etype] || gc.Iscomplex[res.Type.Etype] {
gmove(n, res)
} else {
var n1 gc.Node
}
// if n is sudoaddable generate addr and move
- if !gc.Is64(n.Type) && !gc.Is64(res.Type) && gc.Iscomplex[n.Type.Etype] == 0 && gc.Iscomplex[res.Type.Etype] == 0 {
+ if !gc.Is64(n.Type) && !gc.Is64(res.Type) && !gc.Iscomplex[n.Type.Etype] && !gc.Iscomplex[res.Type.Etype] {
a := optoas(gc.OAS, n.Type)
var w int
var addr obj.Addr
var f0 gc.Node
var n1 gc.Node
var n2 gc.Node
- if nl != nil && gc.Isfloat[n.Type.Etype] != 0 && gc.Isfloat[nl.Type.Etype] != 0 {
+ if nl != nil && gc.Isfloat[n.Type.Etype] && gc.Isfloat[nl.Type.Etype] {
// floating-point.
regalloc(&f0, nl.Type, res)
regalloc(&n1, nl.Type, res)
gmove(nl, &n1)
} else {
- if n.Type.Width > int64(gc.Widthptr) || gc.Is64(nl.Type) || gc.Isfloat[nl.Type.Etype] != 0 {
+ if n.Type.Width > int64(gc.Widthptr) || gc.Is64(nl.Type) || gc.Isfloat[nl.Type.Etype] {
gc.Tempname(&n1, nl.Type)
} else {
regalloc(&n1, nl.Type, res)
}
var n2 gc.Node
- if n.Type.Width > int64(gc.Widthptr) || gc.Is64(n.Type) || gc.Isfloat[n.Type.Etype] != 0 {
+ if n.Type.Width > int64(gc.Widthptr) || gc.Is64(n.Type) || gc.Isfloat[n.Type.Etype] {
gc.Tempname(&n2, n.Type)
} else {
regalloc(&n2, n.Type, nil)
gc.OGE:
a := int(n.Op)
if !true_ {
- if gc.Isfloat[nl.Type.Etype] != 0 {
+ if gc.Isfloat[nl.Type.Etype] {
// brcom is not valid on floats when NaN is involved.
p1 := gc.Gbranch(arm.AB, nil, 0)
break
}
- if gc.Iscomplex[nl.Type.Etype] != 0 {
+ if gc.Iscomplex[nl.Type.Etype] {
gc.Complexbool(a, nl, nr, true_, likely, to)
break
}
gmove(&tmp, &n2)
gcmp(optoas(gc.OCMP, nr.Type), &n1, &n2)
- if gc.Isfloat[nl.Type.Etype] != 0 {
+ if gc.Isfloat[nl.Type.Etype] {
if n.Op == gc.ONE {
p1 := gc.Gbranch(arm.ABVS, nr.Type, likely)
gc.Patch(gc.Gbranch(a, nr.Type, likely), to)
case gc.ODOT:
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
break
}
off := stkof(n.Left)
gc.OCALLINTER,
gc.OCALLFUNC:
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
t = t.Type
}
*/
func cgen_aret(n *gc.Node, res *gc.Node) {
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
t = t.Type
}
case gc.TINT32,
gc.TUINT32:
var p *obj.Prog
- if gc.Issigned[t.Etype] != 0 {
+ if gc.Issigned[t.Etype] {
p = gins(arm.AMULL, &n2, nil)
} else {
p = gins(arm.AMULLU, &n2, nil)
if sc == 0 {
} else // nothing to do
if sc >= uint64(nl.Type.Width*8) {
- if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] {
gshift(arm.AMOVW, &n1, arm.SHIFT_AR, int32(w), &n1)
} else {
gins(arm.AEOR, &n1, &n1)
}
} else {
- if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] {
gshift(arm.AMOVW, &n1, arm.SHIFT_AR, int32(sc), &n1)
} else if op == gc.ORSH {
gshift(arm.AMOVW, &n1, arm.SHIFT_LR, int32(sc), &n1) // OLSH
if op == gc.ORSH {
var p1 *obj.Prog
var p2 *obj.Prog
- if gc.Issigned[nl.Type.Etype] != 0 {
+ if gc.Issigned[nl.Type.Etype] {
p1 = gshift(arm.AMOVW, &n2, arm.SHIFT_AR, int32(w)-1, &n2)
p2 = gregshift(arm.AMOVW, &n2, arm.SHIFT_AR, &n1, &n2)
} else {
tt := gc.Simsimtype(t.Type)
cvt := t.Type
- if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 {
+ if gc.Iscomplex[ft] || gc.Iscomplex[tt] {
gc.Complexmove(f, t)
return
}
f = 0
}
- if gc.Iscomplex[n.Type.Etype] == 0 {
+ if !gc.Iscomplex[n.Type.Etype] {
a := optoas(gc.OAS, res.Type)
var addr obj.Addr
if sudoaddable(a, res, &addr) {
}
}
- if gc.Iscomplex[n.Type.Etype] == 0 {
+ if !gc.Iscomplex[n.Type.Etype] {
a := optoas(gc.OAS, n.Type)
var addr obj.Addr
if sudoaddable(a, n, &addr) {
return
case gc.OMINUS:
- if gc.Isfloat[nl.Type.Etype] != 0 {
+ if gc.Isfloat[nl.Type.Etype] {
nr = gc.Nodintconst(-1)
gc.Convlit(&nr, n.Type)
a = optoas(gc.OMUL, nl.Type)
case gc.OMOD,
gc.ODIV:
- if gc.Isfloat[n.Type.Etype] != 0 {
+ if gc.Isfloat[n.Type.Etype] {
a = optoas(int(n.Op), nl.Type)
goto abop
}
// type of the index
t := gc.Types[gc.TUINT64]
- if gc.Issigned[n1.Type.Etype] != 0 {
+ if gc.Issigned[n1.Type.Etype] {
t = gc.Types[gc.TINT64]
}
// Could do the same for slice except that we need
// to use the real index for the bounds checking.
case gc.OINDEX:
- if gc.Isfixedarray(n.Left.Type) || (gc.Isptr[n.Left.Type.Etype] != 0 && gc.Isfixedarray(n.Left.Left.Type)) {
+ if gc.Isfixedarray(n.Left.Type) || (gc.Isptr[n.Left.Type.Etype] && gc.Isfixedarray(n.Left.Left.Type)) {
if gc.Isconst(n.Right, gc.CTINT) {
// Compute &a.
- if gc.Isptr[n.Left.Type.Etype] == 0 {
+ if !gc.Isptr[n.Left.Type.Etype] {
igen(n.Left, a, res)
} else {
var n1 gc.Node
gc.OGE:
a := int(n.Op)
if !true_ {
- if gc.Isfloat[nr.Type.Etype] != 0 {
+ if gc.Isfloat[nr.Type.Etype] {
// brcom is not valid on floats when NaN is involved.
p1 := gc.Gbranch(obj.AJMP, nil, 0)
break
}
- if gc.Iscomplex[nl.Type.Etype] != 0 {
+ if gc.Iscomplex[nl.Type.Etype] {
gc.Complexbool(a, nl, nr, true_, likely, to)
break
}
l := &n1
r := &n2
- if gc.Isfloat[nl.Type.Etype] != 0 && (a == gc.OGT || a == gc.OGE) {
+ if gc.Isfloat[nl.Type.Etype] && (a == gc.OGT || a == gc.OGE) {
l = &n2
r = &n1
a = gc.Brrev(a)
gins(optoas(gc.OCMP, nr.Type), l, r)
- if gc.Isfloat[nr.Type.Etype] != 0 && (n.Op == gc.OEQ || n.Op == gc.ONE) {
+ if gc.Isfloat[nr.Type.Etype] && (n.Op == gc.OEQ || n.Op == gc.ONE) {
if n.Op == gc.OEQ {
// neither NE nor P
p1 := gc.Gbranch(x86.AJNE, nil, -likely)
case gc.ODOT:
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
break
}
off := stkof(n.Left)
gc.OCALLINTER,
gc.OCALLFUNC:
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
t = t.Type
}
*/
func cgen_aret(n *gc.Node, res *gc.Node) {
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
t = t.Type
}
t0 := t
check := 0
- if gc.Issigned[t.Etype] != 0 {
+ if gc.Issigned[t.Etype] {
check = 1
if gc.Isconst(nl, gc.CTINT) && gc.Mpgetfix(nl.Val.U.Xval) != -(1<<uint64(t.Width*8-1)) {
check = 0
}
if t.Width < 4 {
- if gc.Issigned[t.Etype] != 0 {
+ if gc.Issigned[t.Etype] {
t = gc.Types[gc.TINT32]
} else {
t = gc.Types[gc.TUINT32]
var olddx gc.Node
var dx gc.Node
savex(x86.REG_DX, &dx, &olddx, res, t)
- if gc.Issigned[t.Etype] == 0 {
+ if !gc.Issigned[t.Etype] {
gc.Nodconst(&n4, t, 0)
gmove(&n4, &dx)
} else {
gc.Nodconst(&n3, tcount, nl.Type.Width*8)
gins(optoas(gc.OCMP, tcount), &n1, &n3)
p1 := gc.Gbranch(optoas(gc.OLT, tcount), nil, +1)
- if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] {
gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1)
gins(a, &n3, &n2)
} else {
// perform full-width multiplication.
t := gc.Types[gc.TUINT64]
- if gc.Issigned[nl.Type.Etype] != 0 {
+ if gc.Issigned[nl.Type.Etype] {
t = gc.Types[gc.TINT64]
}
var n1 gc.Node
tt := gc.Simsimtype(t.Type)
cvt := t.Type
- if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 {
+ if gc.Iscomplex[ft] || gc.Iscomplex[tt] {
gc.Complexmove(f, t)
return
}
// some constants can't move directly to memory.
if gc.Ismem(t) {
// float constants come from memory.
- if gc.Isfloat[tt] != 0 {
+ if gc.Isfloat[tt] {
goto hard
}
// 64-bit immediates are really 32-bit sign-extended
// unless moving into a register.
- if gc.Isint[tt] != 0 {
+ if gc.Isint[tt] {
if gc.Mpcmpfixfix(con.Val.U.Xval, gc.Minintval[gc.TINT32]) < 0 {
goto hard
}
gc.Tempname(n1, n.Type)
cgen(n, n1)
- if n.Type.Width <= int64(gc.Widthptr) || gc.Isfloat[n.Type.Etype] != 0 {
+ if n.Type.Width <= int64(gc.Widthptr) || gc.Isfloat[n.Type.Etype] {
n2 := *n1
regalloc(n1, n.Type, rg)
gmove(&n2, n1)
}
}
- if nl != nil && gc.Isfloat[n.Type.Etype] != 0 && gc.Isfloat[nl.Type.Etype] != 0 {
+ if nl != nil && gc.Isfloat[n.Type.Etype] && gc.Isfloat[nl.Type.Etype] {
cgen_float(n, res)
return
}
// i is in register n1, extend to 32 bits.
t := gc.Types[gc.TUINT32]
- if gc.Issigned[n1.Type.Etype] != 0 {
+ if gc.Issigned[n1.Type.Etype] {
t = gc.Types[gc.TINT32]
}
case gc.ODOTPTR:
t := nl.Type
- if gc.Isptr[t.Etype] == 0 {
+ if !gc.Isptr[t.Etype] {
gc.Fatal("agen: not ptr %v", gc.Nconv(n, 0))
}
cgen(nl, res)
// Could do the same for slice except that we need
// to use the real index for the bounds checking.
case gc.OINDEX:
- if gc.Isfixedarray(n.Left.Type) || (gc.Isptr[n.Left.Type.Etype] != 0 && gc.Isfixedarray(n.Left.Left.Type)) {
+ if gc.Isfixedarray(n.Left.Type) || (gc.Isptr[n.Left.Type.Etype] && gc.Isfixedarray(n.Left.Left.Type)) {
if gc.Isconst(n.Right, gc.CTINT) {
// Compute &a.
- if gc.Isptr[n.Left.Type.Etype] == 0 {
+ if !gc.Isptr[n.Left.Type.Etype] {
igen(n.Left, a, res)
} else {
var n1 gc.Node
nl := n.Left
nr := (*gc.Node)(nil)
- if nl != nil && gc.Isfloat[nl.Type.Etype] != 0 {
+ if nl != nil && gc.Isfloat[nl.Type.Etype] {
bgen_float(n, bool2int(true_), likely, to)
return
}
break
}
- if gc.Iscomplex[nl.Type.Etype] != 0 {
+ if gc.Iscomplex[nl.Type.Etype] {
gc.Complexbool(a, nl, nr, true_, likely, to)
break
}
case gc.ODOT:
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
break
}
off := stkof(n.Left)
gc.OCALLINTER,
gc.OCALLFUNC:
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
t = t.Type
}
*/
func cgen_aret(n *gc.Node, res *gc.Node) {
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
t = t.Type
}
t0 := t
check := 0
- if gc.Issigned[t.Etype] != 0 {
+ if gc.Issigned[t.Etype] {
check = 1
if gc.Isconst(nl, gc.CTINT) && gc.Mpgetfix(nl.Val.U.Xval) != -1<<uint64(t.Width*8-1) {
check = 0
}
if t.Width < 4 {
- if gc.Issigned[t.Etype] != 0 {
+ if gc.Issigned[t.Etype] {
t = gc.Types[gc.TINT32]
} else {
t = gc.Types[gc.TUINT32]
gc.Patch(p1, gc.Pc)
}
- if gc.Issigned[t.Etype] == 0 {
+ if !gc.Issigned[t.Etype] {
var nz gc.Node
gc.Nodconst(&nz, t, 0)
gmove(&nz, dx)
}
var t *gc.Type
- if gc.Issigned[nl.Type.Etype] != 0 {
+ if gc.Issigned[nl.Type.Etype] {
t = gc.Types[gc.TINT32]
} else {
t = gc.Types[gc.TUINT32]
p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
}
- if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] {
gins(a, ncon(uint32(w)-1), &n2)
} else {
gmove(ncon(0), &n2)
// copy from byte to full registers
t := gc.Types[gc.TUINT32]
- if gc.Issigned[nl.Type.Etype] != 0 {
+ if gc.Issigned[nl.Type.Etype] {
t = gc.Types[gc.TINT32]
}
tt := gc.Simsimtype(t.Type)
cvt := t.Type
- if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 {
+ if gc.Iscomplex[ft] || gc.Iscomplex[tt] {
gc.Complexmove(f, t)
return
}
- if gc.Isfloat[ft] != 0 || gc.Isfloat[tt] != 0 {
+ if gc.Isfloat[ft] || gc.Isfloat[tt] {
floatmove(f, t)
return
}
// except 64-bit, which always copies via registers anyway.
var r1 gc.Node
var a int
- if gc.Isint[ft] != 0 && gc.Isint[tt] != 0 && !gc.Is64(f.Type) && !gc.Is64(t.Type) && gc.Ismem(f) && gc.Ismem(t) {
+ if gc.Isint[ft] && gc.Isint[tt] && !gc.Is64(f.Type) && !gc.Is64(t.Type) && gc.Ismem(f) && gc.Ismem(t) {
goto hard
}
cvt := t.Type
// cannot have two floating point memory operands.
- if gc.Isfloat[ft] != 0 && gc.Isfloat[tt] != 0 && gc.Ismem(f) && gc.Ismem(t) {
+ if gc.Isfloat[ft] && gc.Isfloat[tt] && gc.Ismem(f) && gc.Ismem(t) {
goto hard
}
// some constants can't move directly to memory.
if gc.Ismem(t) {
// float constants come from memory.
- if gc.Isfloat[tt] != 0 {
+ if gc.Isfloat[tt] {
goto hard
}
}
f = 0
}
- if gc.Iscomplex[n.Type.Etype] == 0 {
+ if !gc.Iscomplex[n.Type.Etype] {
a := optoas(gc.OAS, res.Type)
var addr obj.Addr
if sudoaddable(a, res, &addr) {
}
}
- if gc.Iscomplex[n.Type.Etype] == 0 {
+ if !gc.Iscomplex[n.Type.Etype] {
a := optoas(gc.OAS, n.Type)
var addr obj.Addr
if sudoaddable(a, n, &addr) {
return
case gc.OMINUS:
- if gc.Isfloat[nl.Type.Etype] != 0 {
+ if gc.Isfloat[nl.Type.Etype] {
nr = gc.Nodintconst(-1)
gc.Convlit(&nr, n.Type)
a = optoas(gc.OMUL, nl.Type)
case gc.OMOD,
gc.ODIV:
- if gc.Isfloat[n.Type.Etype] != 0 {
+ if gc.Isfloat[n.Type.Etype] {
a = optoas(int(n.Op), nl.Type)
goto abop
}
// Could do the same for slice except that we need
// to use the real index for the bounds checking.
case gc.OINDEX:
- if gc.Isfixedarray(n.Left.Type) || (gc.Isptr[n.Left.Type.Etype] != 0 && gc.Isfixedarray(n.Left.Left.Type)) {
+ if gc.Isfixedarray(n.Left.Type) || (gc.Isptr[n.Left.Type.Etype] && gc.Isfixedarray(n.Left.Left.Type)) {
if gc.Isconst(n.Right, gc.CTINT) {
// Compute &a.
- if gc.Isptr[n.Left.Type.Etype] == 0 {
+ if !gc.Isptr[n.Left.Type.Etype] {
igen(n.Left, a, res)
} else {
var n1 gc.Node
gc.OGE:
a := int(n.Op)
if !true_ {
- if gc.Isfloat[nr.Type.Etype] != 0 {
+ if gc.Isfloat[nr.Type.Etype] {
// brcom is not valid on floats when NaN is involved.
p1 := gc.Gbranch(ppc64.ABR, nil, 0)
break
}
- if gc.Iscomplex[nl.Type.Etype] != 0 {
+ if gc.Iscomplex[nl.Type.Etype] {
gc.Complexbool(a, nl, nr, true_, likely, to)
break
}
l := &n1
r := &n2
gins(optoas(gc.OCMP, nr.Type), l, r)
- if gc.Isfloat[nr.Type.Etype] != 0 && (a == gc.OLE || a == gc.OGE) {
+ if gc.Isfloat[nr.Type.Etype] && (a == gc.OLE || a == gc.OGE) {
// To get NaN right, must rewrite x <= y into separate x < y or x = y.
switch a {
case gc.OLE:
case gc.ODOT:
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
break
}
off := stkof(n.Left)
gc.OCALLINTER,
gc.OCALLFUNC:
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
t = t.Type
}
*/
func cgen_aret(n *gc.Node, res *gc.Node) {
t := n.Left.Type
- if gc.Isptr[t.Etype] != 0 {
+ if gc.Isptr[t.Etype] {
t = t.Type
}
t0 := t
check := 0
- if gc.Issigned[t.Etype] != 0 {
+ if gc.Issigned[t.Etype] {
check = 1
if gc.Isconst(nl, gc.CTINT) && gc.Mpgetfix(nl.Val.U.Xval) != -(1<<uint64(t.Width*8-1)) {
check = 0
}
if t.Width < 8 {
- if gc.Issigned[t.Etype] != 0 {
+ if gc.Issigned[t.Etype] {
t = gc.Types[gc.TINT64]
} else {
t = gc.Types[gc.TUINT64]
case gc.TINT64,
gc.TUINT64:
- if gc.Issigned[t.Etype] != 0 {
+ if gc.Issigned[t.Etype] {
gins(ppc64.AMULHD, &n2, &n1)
} else {
gins(ppc64.AMULHDU, &n2, &n1)
gc.Nodconst(&n3, tcount, nl.Type.Width*8)
gins(optoas(gc.OCMP, tcount), &n1, &n3)
p1 := (*obj.Prog)(gc.Gbranch(optoas(gc.OLT, tcount), nil, +1))
- if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] {
gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1)
gins(a, &n3, &n2)
} else {
tt := int(gc.Simsimtype(t.Type))
cvt := (*gc.Type)(t.Type)
- if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 {
+ if gc.Iscomplex[ft] || gc.Iscomplex[tt] {
gc.Complexmove(f, t)
return
}
}
for i := TINT8; i <= TUINT64; i++ {
- Isint[i] = 1
+ Isint[i] = true
}
- Isint[TINT] = 1
- Isint[TUINT] = 1
- Isint[TUINTPTR] = 1
+ Isint[TINT] = true
+ Isint[TUINT] = true
+ Isint[TUINTPTR] = true
- Isfloat[TFLOAT32] = 1
- Isfloat[TFLOAT64] = 1
+ Isfloat[TFLOAT32] = true
+ Isfloat[TFLOAT64] = true
- Iscomplex[TCOMPLEX64] = 1
- Iscomplex[TCOMPLEX128] = 1
+ Iscomplex[TCOMPLEX64] = true
+ Iscomplex[TCOMPLEX128] = true
- Isptr[TPTR32] = 1
- Isptr[TPTR64] = 1
+ Isptr[TPTR32] = true
+ Isptr[TPTR64] = true
- isforw[TFORW] = 1
+ isforw[TFORW] = true
- Issigned[TINT] = 1
- Issigned[TINT8] = 1
- Issigned[TINT16] = 1
- Issigned[TINT32] = 1
- Issigned[TINT64] = 1
+ Issigned[TINT] = true
+ Issigned[TINT8] = true
+ Issigned[TINT16] = true
+ Issigned[TINT32] = true
+ Issigned[TINT64] = true
/*
* initialize okfor
*/
for i := 0; i < NTYPE; i++ {
- if Isint[i] != 0 || i == TIDEAL {
- okforeq[i] = 1
- okforcmp[i] = 1
- okforarith[i] = 1
- okforadd[i] = 1
- okforand[i] = 1
- okforconst[i] = 1
- issimple[i] = 1
+ if Isint[i] || i == TIDEAL {
+ okforeq[i] = true
+ okforcmp[i] = true
+ okforarith[i] = true
+ okforadd[i] = true
+ okforand[i] = true
+ okforconst[i] = true
+ issimple[i] = true
Minintval[i] = new(Mpint)
Maxintval[i] = new(Mpint)
}
- if Isfloat[i] != 0 {
- okforeq[i] = 1
- okforcmp[i] = 1
- okforadd[i] = 1
- okforarith[i] = 1
- okforconst[i] = 1
- issimple[i] = 1
+ if Isfloat[i] {
+ okforeq[i] = true
+ okforcmp[i] = true
+ okforadd[i] = true
+ okforarith[i] = true
+ okforconst[i] = true
+ issimple[i] = true
minfltval[i] = new(Mpflt)
maxfltval[i] = new(Mpflt)
}
- if Iscomplex[i] != 0 {
- okforeq[i] = 1
- okforadd[i] = 1
- okforarith[i] = 1
- okforconst[i] = 1
- issimple[i] = 1
+ if Iscomplex[i] {
+ okforeq[i] = true
+ okforadd[i] = true
+ okforarith[i] = true
+ okforconst[i] = true
+ issimple[i] = true
}
}
- issimple[TBOOL] = 1
+ issimple[TBOOL] = true
- okforadd[TSTRING] = 1
+ okforadd[TSTRING] = true
- okforbool[TBOOL] = 1
+ okforbool[TBOOL] = true
- okforcap[TARRAY] = 1
- okforcap[TCHAN] = 1
+ okforcap[TARRAY] = true
+ okforcap[TCHAN] = true
- okforconst[TBOOL] = 1
- okforconst[TSTRING] = 1
+ okforconst[TBOOL] = true
+ okforconst[TSTRING] = true
- okforlen[TARRAY] = 1
- okforlen[TCHAN] = 1
- okforlen[TMAP] = 1
- okforlen[TSTRING] = 1
+ okforlen[TARRAY] = true
+ okforlen[TCHAN] = true
+ okforlen[TMAP] = true
+ okforlen[TSTRING] = true
- okforeq[TPTR32] = 1
- okforeq[TPTR64] = 1
- okforeq[TUNSAFEPTR] = 1
- okforeq[TINTER] = 1
- okforeq[TCHAN] = 1
- okforeq[TSTRING] = 1
- okforeq[TBOOL] = 1
- okforeq[TMAP] = 1 // nil only; refined in typecheck
- okforeq[TFUNC] = 1 // nil only; refined in typecheck
- okforeq[TARRAY] = 1 // nil slice only; refined in typecheck
- okforeq[TSTRUCT] = 1 // it's complicated; refined in typecheck
+ okforeq[TPTR32] = true
+ okforeq[TPTR64] = true
+ okforeq[TUNSAFEPTR] = true
+ okforeq[TINTER] = true
+ okforeq[TCHAN] = true
+ okforeq[TSTRING] = true
+ okforeq[TBOOL] = true
+ okforeq[TMAP] = true // nil only; refined in typecheck
+ okforeq[TFUNC] = true // nil only; refined in typecheck
+ okforeq[TARRAY] = true // nil slice only; refined in typecheck
+ okforeq[TSTRUCT] = true // it's complicated; refined in typecheck
- okforcmp[TSTRING] = 1
+ okforcmp[TSTRING] = true
var i int
for i = 0; i < len(okfor); i++ {
okfor[OLEN] = okforlen[:]
// comparison
- iscmp[OLT] = 1
+ iscmp[OLT] = true
- iscmp[OGT] = 1
- iscmp[OGE] = 1
- iscmp[OLE] = 1
- iscmp[OEQ] = 1
- iscmp[ONE] = 1
+ iscmp[OGT] = true
+ iscmp[OGE] = true
+ iscmp[OLE] = true
+ iscmp[OEQ] = true
+ iscmp[ONE] = true
mpatofix(Maxintval[TINT8], "0x7f")
mpatofix(Minintval[TINT8], "-0x80")
p = fmt.Sprintf("(%v).(%v)-fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), Sconv(meth.Sym, obj.FmtLeft))
}
basetype := rcvrtype
- if Isptr[rcvrtype.Etype] != 0 {
+ if Isptr[rcvrtype.Etype] {
basetype = basetype.Type
}
if basetype.Etype != TINTER && basetype.Sym == nil {
ptr.Used = 1
ptr.Curfn = xfunc
xfunc.Dcl = list(xfunc.Dcl, ptr)
- if Isptr[rcvrtype.Etype] != 0 || Isinter(rcvrtype) {
+ if Isptr[rcvrtype.Etype] || Isinter(rcvrtype) {
ptr.Ntype = typenod(rcvrtype)
body = list(body, Nod(OAS, ptr, cv))
} else {
// target is invalid type for a constant? leave alone.
case OLITERAL:
- if okforconst[t.Etype] == 0 && n.Type.Etype != TNIL {
+ if !okforconst[t.Etype] && n.Type.Etype != TNIL {
defaultlit(&n, nil)
*np = n
return
if t != nil && t.Etype == TIDEAL && n.Val.Ctype != CTINT {
n.Val = toint(n.Val)
}
- if t != nil && Isint[t.Etype] == 0 {
+ if t != nil && !Isint[t.Etype] {
Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
t = nil
}
CTFLT,
CTCPLX:
ct := int(n.Val.Ctype)
- if Isint[et] != 0 {
+ if Isint[et] {
switch ct {
default:
goto bad
case CTINT:
overflow(n.Val, t)
}
- } else if Isfloat[et] != 0 {
+ } else if Isfloat[et] {
switch ct {
default:
goto bad
case CTFLT:
n.Val.U.Fval = truncfltlit(n.Val.U.Fval, t)
}
- } else if Iscomplex[et] != 0 {
+ } else if Iscomplex[et] {
switch ct {
default:
goto bad
switch v.Ctype {
case CTINT,
CTRUNE:
- if Isint[t.Etype] == 0 {
+ if !Isint[t.Etype] {
Fatal("overflow: %v integer constant", Tconv(t, 0))
}
if Mpcmpfixfix(v.U.Xval, Minintval[t.Etype]) < 0 || Mpcmpfixfix(v.U.Xval, Maxintval[t.Etype]) > 0 {
}
case CTFLT:
- if Isfloat[t.Etype] == 0 {
+ if !Isfloat[t.Etype] {
Fatal("overflow: %v floating-point constant", Tconv(t, 0))
}
if mpcmpfltflt(v.U.Fval, minfltval[t.Etype]) <= 0 || mpcmpfltflt(v.U.Fval, maxfltval[t.Etype]) >= 0 {
}
case CTCPLX:
- if Iscomplex[t.Etype] == 0 {
+ if !Iscomplex[t.Etype] {
Fatal("overflow: %v complex constant", Tconv(t, 0))
}
if mpcmpfltflt(&v.U.Cval.Real, minfltval[t.Etype]) <= 0 || mpcmpfltflt(&v.U.Cval.Real, maxfltval[t.Etype]) >= 0 || mpcmpfltflt(&v.U.Cval.Imag, minfltval[t.Etype]) <= 0 || mpcmpfltflt(&v.U.Cval.Imag, maxfltval[t.Etype]) >= 0 {
if n.Type == nil {
return
}
- if okforconst[n.Type.Etype] == 0 && n.Type.Etype != TNIL {
+ if !okforconst[n.Type.Etype] && n.Type.Etype != TNIL {
return
}
return
}
wl := int(nl.Type.Etype)
- if Isint[wl] != 0 || Isfloat[wl] != 0 || Iscomplex[wl] != 0 {
+ if Isint[wl] || Isfloat[wl] || Iscomplex[wl] {
wl = TIDEAL
}
return
}
wr = int(nr.Type.Etype)
- if Isint[wr] != 0 || Isfloat[wr] != 0 || Iscomplex[wr] != 0 {
+ if Isint[wr] || Isfloat[wr] || Iscomplex[wr] {
wr = TIDEAL
}
defaultlit(&nr, Types[TUINT])
n.Right = nr
- if nr.Type != nil && (Issigned[nr.Type.Etype] != 0 || Isint[nr.Type.Etype] == 0) {
+ if nr.Type != nil && (Issigned[nr.Type.Etype] || !Isint[nr.Type.Etype]) {
goto illegal
}
if nl.Val.Ctype != CTRUNE {
num:
if t != nil {
- if Isint[t.Etype] != 0 {
+ if Isint[t.Etype] {
t1 = t
n.Val = toint(n.Val)
- } else if Isfloat[t.Etype] != 0 {
+ } else if Isfloat[t.Etype] {
t1 = t
n.Val = toflt(n.Val)
- } else if Iscomplex[t.Etype] != 0 {
+ } else if Iscomplex[t.Etype] {
t1 = t
n.Val = tocplx(n.Val)
}
con.Type = t
con.Val = *val
- if Isint[tt] != 0 {
+ if Isint[tt] {
con.Val.Ctype = CTINT
con.Val.U.Xval = new(Mpint)
var i int64
return
}
- if Isfloat[tt] != 0 {
+ if Isfloat[tt] {
con.Val = toflt(con.Val)
if con.Val.Ctype != CTFLT {
Fatal("convconst ctype=%d %v", con.Val.Ctype, Tconv(t, 0))
return
}
- if Iscomplex[tt] != 0 {
+ if Iscomplex[tt] {
con.Val = tocplx(con.Val)
if tt == TCOMPLEX64 {
con.Val.U.Cval.Real = *truncfltlit(&con.Val.U.Cval.Real, Types[TFLOAT32])
}
case OCONV:
- if okforconst[n.Type.Etype] != 0 && isgoconst(n.Left) {
+ if okforconst[n.Type.Etype] && isgoconst(n.Left) {
return true
}
// function calls or channel receive operations.
t := l.Type
- if t != nil && Isptr[t.Etype] != 0 {
+ if t != nil && Isptr[t.Etype] {
t = t.Type
}
if Isfixedarray(t) && !hascallchan(l) {
n.Val.Ctype = CTFLT
n.Type = t
- if Isfloat[t.Etype] == 0 {
+ if !Isfloat[t.Etype] {
Fatal("nodfconst: bad type %v", Tconv(t, 0))
}
}
*/
func Complexop(n *Node, res *Node) bool {
if n != nil && n.Type != nil {
- if Iscomplex[n.Type.Etype] != 0 {
+ if Iscomplex[n.Type.Etype] {
goto maybe
}
}
if res != nil && res.Type != nil {
- if Iscomplex[res.Type.Etype] != 0 {
+ if Iscomplex[res.Type.Etype] {
goto maybe
}
}
return
}
- if t.Sym == nil && Isptr[t.Etype] != 0 {
+ if t.Sym == nil && Isptr[t.Etype] {
t = t.Type
if t.Etype == TINTER {
Yyerror("embedded type cannot be a pointer to interface")
}
}
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
Yyerror("embedded type cannot be a pointer")
} else if t.Etype == TFORW && t.Embedlineno == 0 {
t.Embedlineno = lineno
return false
}
t := rcvr.Type
- if Isptr[t.Etype] == 0 {
+ if !Isptr[t.Etype] {
return false
}
t = t.Type
goto bad
}
s = t.Sym
- if s == nil && Isptr[t.Etype] != 0 {
+ if s == nil && Isptr[t.Etype] {
t = t.Type
if t == nil {
goto bad
}
if (spkg == nil || nsym.Pkg != spkg) && !exportname(nsym.Name) {
- if t0.Sym == nil && Isptr[t0.Etype] != 0 {
+ if t0.Sym == nil && Isptr[t0.Etype] {
p = fmt.Sprintf("(%v).%s.%s%s", Tconv(t0, obj.FmtLeft|obj.FmtShort), nsym.Pkg.Prefix, nsym.Name, suffix)
} else {
p = fmt.Sprintf("%v.%s.%s%s", Tconv(t0, obj.FmtLeft|obj.FmtShort), nsym.Pkg.Prefix, nsym.Name, suffix)
}
} else {
- if t0.Sym == nil && Isptr[t0.Etype] != 0 {
+ if t0.Sym == nil && Isptr[t0.Etype] {
p = fmt.Sprintf("(%v).%s%s", Tconv(t0, obj.FmtLeft|obj.FmtShort), nsym.Name, suffix)
} else {
p = fmt.Sprintf("%v.%s%s", Tconv(t0, obj.FmtLeft|obj.FmtShort), nsym.Name, suffix)
return
}
if t != nil {
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
if t.Sym != nil {
Yyerror("invalid receiver type %v (%v is a pointer type)", Tconv(pa, 0), Tconv(t, 0))
return
return
}
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
Yyerror("invalid receiver type %v (%v is a pointer type)", Tconv(pa, 0), Tconv(t, 0))
return
}
t := n.Left.Type
if t != Types[t.Etype] && t != idealbool && t != idealstring {
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
t = t.Type
}
if t != nil && t.Sym != nil && t.Sym.Def != nil && !exportedsym(t.Sym) {
case OLITERAL:
t := n.Type
if t != Types[n.Type.Etype] && t != idealbool && t != idealstring {
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
t = t.Type
}
if t != nil && t.Sym != nil && t.Sym.Def != nil && !exportedsym(t.Sym) {
if n.Type != nil && n.Type != Types[n.Type.Etype] && n.Type != idealbool && n.Type != idealstring {
// Need parens when type begins with what might
// be misinterpreted as a unary operator: * or <-.
- if Isptr[n.Type.Etype] != 0 || (n.Type.Etype == TCHAN && n.Type.Chan == Crecv) {
+ if Isptr[n.Type.Etype] || (n.Type.Etype == TCHAN && n.Type.Chan == Crecv) {
return fmt.Sprintf("(%v)(%v)", Tconv(n.Type, 0), Vconv(&n.Val, 0))
} else {
return fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Vconv(&n.Val, 0))
// but for export, this should be rendered as (*pkg.T).meth.
// These nodes have the special property that they are names with a left OTYPE and a right ONAME.
if fmtmode == FExp && n.Left != nil && n.Left.Op == OTYPE && n.Right != nil && n.Right.Op == ONAME {
- if Isptr[n.Left.Type.Etype] != 0 {
+ if Isptr[n.Left.Type.Etype] {
return fmt.Sprintf("(%v).%v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte))
} else {
return fmt.Sprintf("%v.%v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte))
return f
case OCOMPLIT:
- ptrlit := n.Right != nil && n.Right.Implicit != 0 && n.Right.Type != nil && Isptr[n.Right.Type.Etype] != 0
+ ptrlit := n.Right != nil && n.Right.Implicit != 0 && n.Right.Type != nil && Isptr[n.Right.Type.Etype]
if fmtmode == FErr {
if n.Right != nil && n.Right.Type != nil && n.Implicit == 0 {
if ptrlit {
}
if n.Op == OSLICEARR || n.Op == OSLICE3ARR {
- if Isptr[n.Left.Type.Etype] == 0 {
+ if !Isptr[n.Left.Type.Etype] {
Fatal("slicearr is supposed to work on pointer: %v\n", Nconv(n, obj.FmtSign))
}
Thearch.Cgen(&src, base)
var Simtype [NTYPE]uint8
-var Isptr [NTYPE]uint8
-
-var isforw [NTYPE]uint8
-
-var Isint [NTYPE]uint8
-
-var Isfloat [NTYPE]uint8
-
-var Iscomplex [NTYPE]uint8
-
-var Issigned [NTYPE]uint8
-
-var issimple [NTYPE]uint8
-
-var okforeq [NTYPE]uint8
-
-var okforadd [NTYPE]uint8
-
-var okforand [NTYPE]uint8
-
-var okfornone [NTYPE]uint8
-
-var okforcmp [NTYPE]uint8
-
-var okforbool [NTYPE]uint8
-
-var okforcap [NTYPE]uint8
-
-var okforlen [NTYPE]uint8
-
-var okforarith [NTYPE]uint8
-
-var okforconst [NTYPE]uint8
+var (
+ Isptr [NTYPE]bool
+ isforw [NTYPE]bool
+ Isint [NTYPE]bool
+ Isfloat [NTYPE]bool
+ Iscomplex [NTYPE]bool
+ Issigned [NTYPE]bool
+ issimple [NTYPE]bool
+)
-var okfor [OEND][]byte
+var (
+ okforeq [NTYPE]bool
+ okforadd [NTYPE]bool
+ okforand [NTYPE]bool
+ okfornone [NTYPE]bool
+ okforcmp [NTYPE]bool
+ okforbool [NTYPE]bool
+ okforcap [NTYPE]bool
+ okforlen [NTYPE]bool
+ okforarith [NTYPE]bool
+ okforconst [NTYPE]bool
+)
-var iscmp [OEND]uint8
+var (
+ okfor [OEND][]bool
+ iscmp [OEND]bool
+)
var Minintval [NTYPE]*Mpint
$$.Val = $3;
} else {
s = $2.Sym;
- if s == nil && Isptr[$2.Etype] != 0 {
+ if s == nil && Isptr[$2.Etype] {
s = $2.Type.Sym;
}
p = importpkg;
// method
rcvr := getthisx(fn.Type).Type.Type
- if Isptr[rcvr.Etype] != 0 {
+ if Isptr[rcvr.Etype] {
rcvr = rcvr.Type
}
if rcvr.Sym == nil {
}
// Ideally we wouldn't see any integer types here, but we do.
- if n.Type == nil || (Isptr[n.Type.Etype] == 0 && Isint[n.Type.Etype] == 0 && n.Type.Etype != TUNSAFEPTR) {
+ if n.Type == nil || (!Isptr[n.Type.Etype] && !Isint[n.Type.Etype] && n.Type.Etype != TUNSAFEPTR) {
Dump("checknil", n)
Fatal("bad checknil")
}
}
}
- if Isptr[t.Etype] != 0 && Isfixedarray(t.Type) {
+ if Isptr[t.Etype] && Isfixedarray(t.Type) {
t = t.Type
}
n.Type = t
// method does not apply.
this = getthisx(f.Type).Type.Type
- if Isptr[this.Etype] != 0 && this.Type == t {
+ if Isptr[this.Etype] && this.Type == t {
continue
}
- if Isptr[this.Etype] != 0 && Isptr[t.Etype] == 0 && f.Embedded != 2 && !isifacemethod(f.Type) {
+ if Isptr[this.Etype] && !Isptr[t.Etype] && f.Embedded != 2 && !isifacemethod(f.Type) {
continue
}
}
var sptr *Sym
- if t.Sym != nil && Isptr[t.Etype] == 0 {
+ if t.Sym != nil && !Isptr[t.Etype] {
sptr = dtypesym(Ptrto(t))
} else {
sptr = weaktypesym(Ptrto(t))
}
func typenamesym(t *Type) *Sym {
- if t == nil || (Isptr[t.Etype] != 0 && t.Type == nil) || isideal(t) {
+ if t == nil || (Isptr[t.Etype] && t.Type == nil) || isideal(t) {
Fatal("typename %v", Tconv(t, 0))
}
s := typesym(t)
// emit the type structures for int, float, etc.
tbase := t
- if Isptr[t.Etype] != 0 && t.Sym == nil && t.Type.Sym != nil {
+ if Isptr[t.Etype] && t.Sym == nil && t.Type.Sym != nil {
tbase = t.Type
}
dupok := 0
if tbase.Sym != nil && tbase.Local == 0 {
return s
}
- if isforw[tbase.Etype] != 0 {
+ if isforw[tbase.Etype] {
return s
}
Fatal("anylit: not lit")
case OPTRLIT:
- if Isptr[t.Etype] == 0 {
+ if !Isptr[t.Etype] {
Fatal("anylit: not ptr")
}
n.Val.Ctype = CTINT
n.Type = t
- if Isfloat[t.Etype] != 0 {
+ if Isfloat[t.Etype] {
Fatal("nodconst: bad type %v", Tconv(t, 0))
}
}
if t == nil {
return false
}
- if Isptr[t.Etype] == 0 {
+ if !Isptr[t.Etype] {
return false
}
t = t.Type
}
// strip away pointer if it's there
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
if t.Sym != nil {
return nil
}
}
// check types
- if issimple[t.Etype] == 0 {
+ if !issimple[t.Etype] {
switch t.Etype {
default:
return nil
// 3. src and dst are unnamed pointer types
// and their base types have identical underlying types.
- if Isptr[src.Etype] != 0 && Isptr[dst.Etype] != 0 && src.Sym == nil && dst.Sym == nil {
+ if Isptr[src.Etype] && Isptr[dst.Etype] && src.Sym == nil && dst.Sym == nil {
if Eqtype(src.Type.Orig, dst.Type.Orig) {
return OCONVNOP
}
}
// 4. src and dst are both integer or floating point types.
- if (Isint[src.Etype] != 0 || Isfloat[src.Etype] != 0) && (Isint[dst.Etype] != 0 || Isfloat[dst.Etype] != 0) {
+ if (Isint[src.Etype] || Isfloat[src.Etype]) && (Isint[dst.Etype] || Isfloat[dst.Etype]) {
if Simtype[src.Etype] == Simtype[dst.Etype] {
return OCONVNOP
}
}
// 5. src and dst are both complex types.
- if Iscomplex[src.Etype] != 0 && Iscomplex[dst.Etype] != 0 {
+ if Iscomplex[src.Etype] && Iscomplex[dst.Etype] {
if Simtype[src.Etype] == Simtype[dst.Etype] {
return OCONVNOP
}
// 6. src is an integer or has type []byte or []rune
// and dst is a string type.
- if Isint[src.Etype] != 0 && dst.Etype == TSTRING {
+ if Isint[src.Etype] && dst.Etype == TSTRING {
return ORUNESTR
}
}
// 8. src is a pointer or uintptr and dst is unsafe.Pointer.
- if (Isptr[src.Etype] != 0 || src.Etype == TUINTPTR) && dst.Etype == TUNSAFEPTR {
+ if (Isptr[src.Etype] || src.Etype == TUINTPTR) && dst.Etype == TUNSAFEPTR {
return OCONVNOP
}
// 9. src is unsafe.Pointer and dst is a pointer or uintptr.
- if src.Etype == TUNSAFEPTR && (Isptr[dst.Etype] != 0 || dst.Etype == TUINTPTR) {
+ if src.Etype == TUNSAFEPTR && (Isptr[dst.Etype] || dst.Etype == TUINTPTR) {
return OCONVNOP
}
}
// common mistake: *struct and *interface.
- if tl != nil && tr != nil && Isptr[tl.Etype] != 0 && Isptr[tr.Etype] != 0 {
+ if tl != nil && tr != nil && Isptr[tl.Etype] && Isptr[tr.Etype] {
if tl.Type.Etype == TSTRUCT && tr.Type.Etype == TINTER {
fmt_ += "\n\t(*struct vs *interface)"
} else if tl.Type.Etype == TINTER && tr.Type.Etype == TSTRUCT {
// found with a given name
func lookdot0(s *Sym, t *Type, save **Type, ignorecase int) int {
u := t
- if Isptr[u.Etype] != 0 {
+ if Isptr[u.Etype] {
u = u.Type
}
c = 0
u = t
- if Isptr[u.Etype] != 0 {
+ if Isptr[u.Etype] {
u = u.Type
}
if u.Etype != TSTRUCT && u.Etype != TINTER {
// rebuild elided dots
for c := d - 1; c >= 0; c-- {
- if n.Left.Type != nil && Isptr[n.Left.Type.Etype] != 0 {
+ if n.Left.Type != nil && Isptr[n.Left.Type.Etype] {
n.Left.Implicit = 1
}
n.Left = Nod(ODOT, n.Left, newname(dotlist[c].field.Sym))
func expand0(t *Type, followptr int) {
u := t
- if Isptr[u.Etype] != 0 {
+ if Isptr[u.Etype] {
followptr = 1
u = u.Type
}
}
u := t
- if Isptr[u.Etype] != 0 {
+ if Isptr[u.Etype] {
followptr = 1
u = u.Type
}
methodrcvr := getthisx(method.Type).Type.Type
// generate nil pointer check for better error
- if Isptr[rcvr.Etype] != 0 && rcvr.Type == methodrcvr {
+ if Isptr[rcvr.Etype] && rcvr.Type == methodrcvr {
// generating wrapper from *T to T.
n := Nod(OIF, nil, nil)
dot := adddot(Nod(OXDOT, this.Left, newname(method.Sym)))
// generate call
- if flag_race == 0 && Isptr[rcvr.Etype] != 0 && Isptr[methodrcvr.Etype] != 0 && method.Embedded != 0 && !isifacemethod(method.Type) {
+ if flag_race == 0 && Isptr[rcvr.Etype] && Isptr[methodrcvr.Etype] && method.Embedded != 0 && !isifacemethod(method.Type) {
// generate tail call: adjust pointer receiver and jump to embedded method.
dot = dot.Left // skip final .M
- if Isptr[dotlist[0].field.Type.Etype] == 0 {
+ if !Isptr[dotlist[0].field.Type.Etype] {
dot = Nod(OADDR, dot, nil)
}
as := Nod(OAS, this.Left, Nod(OCONVNOP, dot, nil))
Curfn = fn
// wrappers where T is anonymous (struct or interface) can be duplicated.
- if rcvr.Etype == TSTRUCT || rcvr.Etype == TINTER || Isptr[rcvr.Etype] != 0 && rcvr.Type.Etype == TSTRUCT {
+ if rcvr.Etype == TSTRUCT || rcvr.Etype == TINTER || Isptr[rcvr.Etype] && rcvr.Type.Etype == TSTRUCT {
fn.Dupok = 1
}
typecheck(&fn, Etop)
if c == 1 {
for i = 0; i < d; i++ {
- if Isptr[dotlist[i].field.Type.Etype] != 0 {
+ if Isptr[dotlist[i].field.Type.Etype] {
*followptr = 1
break
}
// the method does not exist for value types.
rcvr = getthisx(tm.Type).Type.Type
- if Isptr[rcvr.Etype] != 0 && Isptr[t0.Etype] == 0 && followptr == 0 && !isifacemethod(tm.Type) {
+ if Isptr[rcvr.Etype] && !Isptr[t0.Etype] && followptr == 0 && !isifacemethod(tm.Type) {
if false && Debug['r'] != 0 {
Yyerror("interface pointer mismatch")
}
if n == nil || n.Op != OLITERAL || n.Type == nil {
return -1
}
- if Isint[n.Type.Etype] == 0 {
+ if !Isint[n.Type.Etype] {
return -1
}
b = b << 1
}
- if Issigned[n.Type.Etype] == 0 {
+ if !Issigned[n.Type.Etype] {
return -1
}
if t != nil {
var badtype *Type
switch {
- case okforeq[t.Etype] == 0:
+ case !okforeq[t.Etype]:
Yyerror("cannot switch on %v", Nconv(n.Ntest, obj.FmtLong))
case t.Etype == TARRAY && !Isfixedarray(t):
nilonly = "slice"
// handle the cases in order
for len(cc) > 0 {
// deal with expressions one at a time
- if okforcmp[t.Etype] == 0 || cc[0].typ != caseKindExprConst {
+ if !okforcmp[t.Etype] || cc[0].typ != caseKindExprConst {
a := s.walkCases(cc[:1])
cas = list(cas, a)
cc = cc[1:]
v = toint(l.Val)
default:
- if l.Type != nil && Isint[l.Type.Etype] != 0 && l.Op != OLITERAL {
+ if l.Type != nil && Isint[l.Type.Etype] && l.Op != OLITERAL {
Yyerror("non-constant array bound %v", Nconv(l, 0))
} else {
Yyerror("invalid array bound %v", Nconv(l, 0))
goto ret
}
- if Isptr[t.Etype] == 0 {
+ if !Isptr[t.Etype] {
if top&(Erv|Etop) != 0 {
Yyerror("invalid indirect of %v", Nconv(n.Left, obj.FmtLong))
goto error
if t == nil {
goto error
}
- if okfor[n.Op][t.Etype] == 0 {
+ if !okfor[n.Op][t.Etype] {
Yyerror("invalid operation: %v %v", Oconv(int(n.Op), 0), Tconv(t, 0))
goto error
}
goto ret
}
- if Isptr[t.Etype] != 0 && t.Type.Etype != TINTER {
+ if Isptr[t.Etype] && t.Type.Etype != TINTER {
t = t.Type
if t == nil {
goto error
}
}
- if n.Right.Type != nil && Isint[n.Right.Type.Etype] == 0 {
+ if n.Right.Type != nil && !Isint[n.Right.Type.Etype] {
Yyerror("non-integer %s index %v", why, Nconv(n.Right, 0))
break
}
if Istype(t, TSTRING) {
n.Type = t
n.Op = OSLICESTR
- } else if Isptr[t.Etype] != 0 && Isfixedarray(t.Type) {
+ } else if Isptr[t.Etype] && Isfixedarray(t.Type) {
tp = t.Type
n.Type = typ(TARRAY)
n.Type.Type = tp.Type
goto error
}
- if Isptr[t.Etype] != 0 && Isfixedarray(t.Type) {
+ if Isptr[t.Etype] && Isfixedarray(t.Type) {
tp = t.Type
n.Type = typ(TARRAY)
n.Type.Type = tp.Type
}
switch n.Op {
case OCAP:
- if okforcap[t.Etype] == 0 {
+ if !okforcap[t.Etype] {
goto badcall1
}
case OLEN:
- if okforlen[t.Etype] == 0 {
+ if !okforlen[t.Etype] {
goto badcall1
}
case OREAL,
OIMAG:
- if Iscomplex[t.Etype] == 0 {
+ if !Iscomplex[t.Etype] {
goto badcall1
}
if Isconst(l, CTCPLX) {
defaultlit(&r, Types[TUINT])
n.Right = r
t := r.Type
- if Isint[t.Etype] == 0 || Issigned[t.Etype] != 0 {
+ if !Isint[t.Etype] || Issigned[t.Etype] {
Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", Nconv(n, 0), Tconv(r.Type, 0))
goto error
}
t = l.Type
- if t != nil && t.Etype != TIDEAL && Isint[t.Etype] == 0 {
+ if t != nil && t.Etype != TIDEAL && !Isint[t.Etype] {
Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
goto error
}
et = TINT
}
aop = 0
- if iscmp[n.Op] != 0 && t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
+ if iscmp[n.Op] && t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
// comparison is okay as long as one side is
// assignable to the other. convert so they have
// the same type.
}
}
- if okfor[op][et] == 0 {
+ if !okfor[op][et] {
Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(t))
goto error
}
}
t = l.Type
- if iscmp[n.Op] != 0 {
+ if iscmp[n.Op] {
evconst(n)
t = idealbool
if n.Op != OLITERAL {
}
if et == TSTRING {
- if iscmp[n.Op] != 0 {
+ if iscmp[n.Op] {
n.Etype = n.Op
n.Op = OCMPSTR
} else if n.Op == OADD {
if t == nil {
return -1
}
- if Isint[t.Etype] == 0 {
+ if !Isint[t.Etype] {
Yyerror("invalid slice index %v (type %v)", Nconv(r, 0), Tconv(t, 0))
return -1
}
n := *nn
t := n.Type
- if t == nil || Isptr[t.Etype] == 0 {
+ if t == nil || !Isptr[t.Etype] {
return
}
t = t.Type
if r != nil {
if errnode != nil {
Yyerror("ambiguous selector %v", Nconv(errnode, 0))
- } else if Isptr[t.Etype] != 0 {
+ } else if Isptr[t.Etype] {
Yyerror("ambiguous selector (%v).%v", Tconv(t, 0), Sconv(s, 0))
} else {
Yyerror("ambiguous selector %v.%v", Tconv(t, 0), Sconv(s, 0))
}
// disallow T.m if m requires *T receiver
- if Isptr[getthisx(f2.Type).Type.Type.Etype] != 0 && Isptr[t.Etype] == 0 && f2.Embedded != 2 && !isifacemethod(f2.Type) {
+ if Isptr[getthisx(f2.Type).Type.Type.Etype] && !Isptr[t.Etype] && f2.Embedded != 2 && !isifacemethod(f2.Type) {
Yyerror("invalid method expression %v (needs pointer receiver: (*%v).%v)", Nconv(n, 0), Tconv(t, 0), Sconv(f2.Sym, obj.FmtShort))
return false
}
n.Type = f1.Type
n.Paramfld = f1
if t.Etype == TINTER {
- if Isptr[n.Left.Type.Etype] != 0 {
+ if Isptr[n.Left.Type.Etype] {
n.Left = Nod(OIND, n.Left, nil) // implicitstar
n.Left.Implicit = 1
typecheck(&n.Left, Erv)
ll = ll.Left
}
if ll.Implicit != 0 {
- if Isptr[ll.Type.Etype] != 0 && ll.Type.Sym != nil && ll.Type.Sym.Def != nil && ll.Type.Sym.Def.Op == OTYPE {
+ if Isptr[ll.Type.Etype] && ll.Type.Sym != nil && ll.Type.Sym.Def != nil && ll.Type.Sym.Def.Op == OTYPE {
// It is invalid to automatically dereference a named pointer type when selecting a method.
// Make n->left == ll to clarify error message.
n.Left = ll
nerr = nerrors
n.Type = t
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
// For better or worse, we don't allow pointers as the composite literal type,
// except when using the &T syntax, which sets implicit on the OIND.
if n.Right.Implicit == 0 {
}
n.Orig = norig
- if Isptr[n.Type.Etype] != 0 {
+ if Isptr[n.Type.Etype] {
n = Nod(OPTRLIT, n, nil)
n.Typecheck = 1
n.Type = n.Left.Type
if embedlineno != 0 {
lineno = int32(embedlineno)
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
Yyerror("embedded type cannot be a pointer")
}
}
t := n.Type
if t != nil {
- if okforconst[t.Etype] == 0 {
+ if !okforconst[t.Etype] {
Yyerror("invalid constant type %v", Tconv(t, 0))
goto ret
}
}
}
- if Isint[n.Type.Etype] == 0 && n.Type.Etype != TIDEAL {
+ if !Isint[n.Type.Etype] && n.Type.Etype != TIDEAL {
Yyerror("non-integer %s argument in make(%v) - %v", arg, Tconv(t, 0), Tconv(n.Type, 0))
return -1
}
// delayed until now to preserve side effects.
t := n.Left.Type
- if Isptr[t.Etype] != 0 {
+ if Isptr[t.Etype] {
t = t.Type
}
if Isfixedarray(t) {
case OCONV,
OCONVNOP:
if Thearch.Thechar == '5' {
- if Isfloat[n.Left.Type.Etype] != 0 {
+ if Isfloat[n.Left.Type.Etype] {
if n.Type.Etype == TINT64 {
n = mkcall("float64toint64", n.Type, init, conv(n.Left, Types[TFLOAT64]))
goto ret
}
}
- if Isfloat[n.Type.Etype] != 0 {
+ if Isfloat[n.Type.Etype] {
if n.Left.Type.Etype == TINT64 {
n = mkcall("int64tofloat64", n.Type, init, conv(n.Left, Types[TINT64]))
goto ret
*/
et := int(n.Left.Type.Etype)
- if Iscomplex[et] != 0 && n.Op == ODIV {
+ if Iscomplex[et] && n.Op == ODIV {
t := n.Type
n = mkcall("complex128div", Types[TCOMPLEX128], init, conv(n.Left, Types[TCOMPLEX128]), conv(n.Right, Types[TCOMPLEX128]))
n = conv(n, t)
}
// Nothing to do for float divisions.
- if Isfloat[et] != 0 {
+ if Isfloat[et] {
goto ret
}
goto ret
}
t := n.Left.Type
- if t != nil && Isptr[t.Etype] != 0 {
+ if t != nil && Isptr[t.Etype] {
t = t.Type
}
if Isfixedarray(t) {
on = syslook("printiface", 1)
}
argtype(on, n.Type) // any-1
- } else if Isptr[et] != 0 || et == TCHAN || et == TMAP || et == TFUNC || et == TUNSAFEPTR {
+ } else if Isptr[et] || et == TCHAN || et == TMAP || et == TFUNC || et == TUNSAFEPTR {
on = syslook("printpointer", 1)
argtype(on, n.Type) // any-1
} else if Isslice(n.Type) {
on = syslook("printslice", 1)
argtype(on, n.Type) // any-1
- } else if Isint[et] != 0 {
+ } else if Isint[et] {
if et == TUINT64 {
if (t.Sym.Pkg == Runtimepkg || compiling_runtime != 0) && t.Sym.Name == "hex" {
on = syslook("printhex", 0)
} else {
on = syslook("printint", 0)
}
- } else if Isfloat[et] != 0 {
+ } else if Isfloat[et] {
on = syslook("printfloat", 0)
- } else if Iscomplex[et] != 0 {
+ } else if Iscomplex[et] {
on = syslook("printcomplex", 0)
} else if et == TBOOL {
on = syslook("printbool", 0)
andor = OOROR
}
- if t.Etype == TARRAY && t.Bound <= 4 && issimple[t.Type.Etype] != 0 {
+ if t.Etype == TARRAY && t.Bound <= 4 && issimple[t.Type.Etype] {
// Four or fewer elements of a basic type.
// Unroll comparisons.
var li *Node
l := n.Left
r := n.Right
- if (n.Op != OOR && n.Op != OXOR) || (l.Op != OLSH && l.Op != ORSH) || (r.Op != OLSH && r.Op != ORSH) || n.Type == nil || Issigned[n.Type.Etype] != 0 || l.Op == r.Op {
+ if (n.Op != OOR && n.Op != OXOR) || (l.Op != OLSH && l.Op != ORSH) || (r.Op != OLSH && r.Op != ORSH) || n.Type == nil || Issigned[n.Type.Etype] || l.Op == r.Op {
return
}
*/
func walkmul(np **Node, init **NodeList) {
n := *np
- if Isint[n.Type.Etype] == 0 {
+ if !Isint[n.Type.Etype] {
return
}
var m Magic
m.W = w
- if Issigned[nl.Type.Etype] != 0 {
+ if Issigned[nl.Type.Etype] {
m.Sd = Mpgetfix(nr.Val.U.Xval)
Smagic(&m)
} else {
}
default:
- if Issigned[n.Type.Etype] != 0 {
+ if Issigned[n.Type.Etype] {
if n.Op == OMOD {
// signed modulo 2^pow is like ANDing
// with the last pow bits, but if nl < 0,
// return 1 if integer n must be in range [0, max), 0 otherwise
func bounded(n *Node, max int64) bool {
- if n.Type == nil || Isint[n.Type.Etype] == 0 {
+ if n.Type == nil || !Isint[n.Type.Etype] {
return false
}
- sign := int(Issigned[n.Type.Etype])
+ sign := Issigned[n.Type.Etype]
bits := int32(8 * n.Type.Width)
if Smallintconst(n) {
}
case OMOD:
- if sign == 0 && Smallintconst(n.Right) {
+ if !sign && Smallintconst(n.Right) {
v := Mpgetfix(n.Right.Val.U.Xval)
if 0 <= v && v <= max {
return true
}
case ODIV:
- if sign == 0 && Smallintconst(n.Right) {
+ if !sign && Smallintconst(n.Right) {
v := Mpgetfix(n.Right.Val.U.Xval)
for bits > 0 && v >= 2 {
bits--
}
case ORSH:
- if sign == 0 && Smallintconst(n.Right) {
+ if !sign && Smallintconst(n.Right) {
v := Mpgetfix(n.Right.Val.U.Xval)
if v > int64(bits) {
return true
}
}
- if sign == 0 && bits <= 62 && 1<<uint(bits) <= max {
+ if !sign && bits <= 62 && 1<<uint(bits) <= max {
return true
}
}
field.Lastfn = Curfn
field.Outer = n.Left.Type
- if Isptr[field.Outer.Etype] != 0 {
+ if Isptr[field.Outer.Etype] {
field.Outer = field.Outer.Type
}
if field.Outer.Sym == nil {
yyVAL.node.Val = yyDollar[3].val
} else {
s = yyDollar[2].typ.Sym
- if s == nil && Isptr[yyDollar[2].typ.Etype] != 0 {
+ if s == nil && Isptr[yyDollar[2].typ.Etype] {
s = yyDollar[2].typ.Type.Sym
}
p = importpkg