| // Copyright 2012 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // constant conversions |
| |
| package const1 |
| |
| import "math" |
| |
| const( |
| mi = ^int(0) |
| mu = ^uint(0) |
| mp = ^uintptr(0) |
| |
| logSizeofInt = uint(mi>>8&1 + mi>>16&1 + mi>>32&1) |
| logSizeofUint = uint(mu>>8&1 + mu>>16&1 + mu>>32&1) |
| logSizeofUintptr = uint(mp>>8&1 + mp>>16&1 + mp>>32&1) |
| ) |
| |
| const ( |
| minInt8 = -1<<(8<<iota - 1) |
| minInt16 |
| minInt32 |
| minInt64 |
| minInt = -1<<(8<<logSizeofInt - 1) |
| ) |
| |
| const ( |
| maxInt8 = 1<<(8<<iota - 1) - 1 |
| maxInt16 |
| maxInt32 |
| maxInt64 |
| maxInt = 1<<(8<<logSizeofInt - 1) - 1 |
| ) |
| |
| const ( |
| maxUint8 = 1<<(8<<iota) - 1 |
| maxUint16 |
| maxUint32 |
| maxUint64 |
| maxUint = 1<<(8<<logSizeofUint) - 1 |
| maxUintptr = 1<<(8<<logSizeofUintptr) - 1 |
| ) |
| |
| const ( |
| smallestFloat32 = 1.0 / (1<<(127 - 1 + 23)) |
| // TODO(gri) The compiler limits integers to 512 bit and thus |
| // we cannot compute the value (1<<(1023 - 1 + 52)) |
| // without overflow. For now we match the compiler. |
| // See also issue #44057. |
| // smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52)) |
| smallestFloat64 = math.SmallestNonzeroFloat64 |
| ) |
| |
| const ( |
| _ = assert(smallestFloat32 > 0) |
| _ = assert(smallestFloat64 > 0) |
| ) |
| |
| const ( |
| maxFloat32 = 1<<127 * (1<<24 - 1) / (1.0<<23) |
| // TODO(gri) The compiler limits integers to 512 bit and thus |
| // we cannot compute the value 1<<1023 |
| // without overflow. For now we match the compiler. |
| // See also issue #44057. |
| // maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52) |
| maxFloat64 = math.MaxFloat64 |
| ) |
| |
| const ( |
| _ int8 = minInt8 /* ERROR "overflows" */ - 1 |
| _ int8 = minInt8 |
| _ int8 = maxInt8 |
| _ int8 = maxInt8 /* ERROR "overflows" */ + 1 |
| _ int8 = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = int8(minInt8 /* ERROR "cannot convert" */ - 1) |
| _ = int8(minInt8) |
| _ = int8(maxInt8) |
| _ = int8(maxInt8 /* ERROR "cannot convert" */ + 1) |
| _ = int8(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ int16 = minInt16 /* ERROR "overflows" */ - 1 |
| _ int16 = minInt16 |
| _ int16 = maxInt16 |
| _ int16 = maxInt16 /* ERROR "overflows" */ + 1 |
| _ int16 = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = int16(minInt16 /* ERROR "cannot convert" */ - 1) |
| _ = int16(minInt16) |
| _ = int16(maxInt16) |
| _ = int16(maxInt16 /* ERROR "cannot convert" */ + 1) |
| _ = int16(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ int32 = minInt32 /* ERROR "overflows" */ - 1 |
| _ int32 = minInt32 |
| _ int32 = maxInt32 |
| _ int32 = maxInt32 /* ERROR "overflows" */ + 1 |
| _ int32 = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = int32(minInt32 /* ERROR "cannot convert" */ - 1) |
| _ = int32(minInt32) |
| _ = int32(maxInt32) |
| _ = int32(maxInt32 /* ERROR "cannot convert" */ + 1) |
| _ = int32(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ int64 = minInt64 /* ERROR "overflows" */ - 1 |
| _ int64 = minInt64 |
| _ int64 = maxInt64 |
| _ int64 = maxInt64 /* ERROR "overflows" */ + 1 |
| _ int64 = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = int64(minInt64 /* ERROR "cannot convert" */ - 1) |
| _ = int64(minInt64) |
| _ = int64(maxInt64) |
| _ = int64(maxInt64 /* ERROR "cannot convert" */ + 1) |
| _ = int64(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ int = minInt /* ERROR "overflows" */ - 1 |
| _ int = minInt |
| _ int = maxInt |
| _ int = maxInt /* ERROR "overflows" */ + 1 |
| _ int = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = int(minInt /* ERROR "cannot convert" */ - 1) |
| _ = int(minInt) |
| _ = int(maxInt) |
| _ = int(maxInt /* ERROR "cannot convert" */ + 1) |
| _ = int(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ uint8 = 0 /* ERROR "overflows" */ - 1 |
| _ uint8 = 0 |
| _ uint8 = maxUint8 |
| _ uint8 = maxUint8 /* ERROR "overflows" */ + 1 |
| _ uint8 = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = uint8(0 /* ERROR "cannot convert" */ - 1) |
| _ = uint8(0) |
| _ = uint8(maxUint8) |
| _ = uint8(maxUint8 /* ERROR "cannot convert" */ + 1) |
| _ = uint8(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ uint16 = 0 /* ERROR "overflows" */ - 1 |
| _ uint16 = 0 |
| _ uint16 = maxUint16 |
| _ uint16 = maxUint16 /* ERROR "overflows" */ + 1 |
| _ uint16 = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = uint16(0 /* ERROR "cannot convert" */ - 1) |
| _ = uint16(0) |
| _ = uint16(maxUint16) |
| _ = uint16(maxUint16 /* ERROR "cannot convert" */ + 1) |
| _ = uint16(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ uint32 = 0 /* ERROR "overflows" */ - 1 |
| _ uint32 = 0 |
| _ uint32 = maxUint32 |
| _ uint32 = maxUint32 /* ERROR "overflows" */ + 1 |
| _ uint32 = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = uint32(0 /* ERROR "cannot convert" */ - 1) |
| _ = uint32(0) |
| _ = uint32(maxUint32) |
| _ = uint32(maxUint32 /* ERROR "cannot convert" */ + 1) |
| _ = uint32(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ uint64 = 0 /* ERROR "overflows" */ - 1 |
| _ uint64 = 0 |
| _ uint64 = maxUint64 |
| _ uint64 = maxUint64 /* ERROR "overflows" */ + 1 |
| _ uint64 = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = uint64(0 /* ERROR "cannot convert" */ - 1) |
| _ = uint64(0) |
| _ = uint64(maxUint64) |
| _ = uint64(maxUint64 /* ERROR "cannot convert" */ + 1) |
| _ = uint64(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ uint = 0 /* ERROR "overflows" */ - 1 |
| _ uint = 0 |
| _ uint = maxUint |
| _ uint = maxUint /* ERROR "overflows" */ + 1 |
| _ uint = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = uint(0 /* ERROR "cannot convert" */ - 1) |
| _ = uint(0) |
| _ = uint(maxUint) |
| _ = uint(maxUint /* ERROR "cannot convert" */ + 1) |
| _ = uint(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ uintptr = 0 /* ERROR "overflows" */ - 1 |
| _ uintptr = 0 |
| _ uintptr = maxUintptr |
| _ uintptr = maxUintptr /* ERROR "overflows" */ + 1 |
| _ uintptr = smallestFloat64 /* ERROR "truncated" */ |
| |
| _ = uintptr(0 /* ERROR "cannot convert" */ - 1) |
| _ = uintptr(0) |
| _ = uintptr(maxUintptr) |
| _ = uintptr(maxUintptr /* ERROR "cannot convert" */ + 1) |
| _ = uintptr(smallestFloat64 /* ERROR "cannot convert" */) |
| ) |
| |
| const ( |
| _ float32 = minInt64 |
| _ float64 = minInt64 |
| _ complex64 = minInt64 |
| _ complex128 = minInt64 |
| |
| _ = float32(minInt64) |
| _ = float64(minInt64) |
| _ = complex64(minInt64) |
| _ = complex128(minInt64) |
| ) |
| |
| const ( |
| _ float32 = maxUint64 |
| _ float64 = maxUint64 |
| _ complex64 = maxUint64 |
| _ complex128 = maxUint64 |
| |
| _ = float32(maxUint64) |
| _ = float64(maxUint64) |
| _ = complex64(maxUint64) |
| _ = complex128(maxUint64) |
| ) |
| |
| // TODO(gri) find smaller deltas below |
| |
| const delta32 = maxFloat32/(1 << 23) |
| |
| const ( |
| _ float32 = - /* ERROR "overflow" */ (maxFloat32 + delta32) |
| _ float32 = -maxFloat32 |
| _ float32 = maxFloat32 |
| _ float32 = maxFloat32 /* ERROR "overflow" */ + delta32 |
| |
| _ = float32(- /* ERROR "cannot convert" */ (maxFloat32 + delta32)) |
| _ = float32(-maxFloat32) |
| _ = float32(maxFloat32) |
| _ = float32(maxFloat32 /* ERROR "cannot convert" */ + delta32) |
| |
| _ = assert(float32(smallestFloat32) == smallestFloat32) |
| _ = assert(float32(smallestFloat32/2) == 0) |
| _ = assert(float32(smallestFloat64) == 0) |
| _ = assert(float32(smallestFloat64/2) == 0) |
| ) |
| |
| const delta64 = maxFloat64/(1 << 52) |
| |
| const ( |
| _ float64 = - /* ERROR "overflow" */ (maxFloat64 + delta64) |
| _ float64 = -maxFloat64 |
| _ float64 = maxFloat64 |
| _ float64 = maxFloat64 /* ERROR "overflow" */ + delta64 |
| |
| _ = float64(- /* ERROR "cannot convert" */ (maxFloat64 + delta64)) |
| _ = float64(-maxFloat64) |
| _ = float64(maxFloat64) |
| _ = float64(maxFloat64 /* ERROR "cannot convert" */ + delta64) |
| |
| _ = assert(float64(smallestFloat32) == smallestFloat32) |
| _ = assert(float64(smallestFloat32/2) == smallestFloat32/2) |
| _ = assert(float64(smallestFloat64) == smallestFloat64) |
| _ = assert(float64(smallestFloat64/2) == 0) |
| ) |
| |
| const ( |
| _ complex64 = - /* ERROR "overflow" */ (maxFloat32 + delta32) |
| _ complex64 = -maxFloat32 |
| _ complex64 = maxFloat32 |
| _ complex64 = maxFloat32 /* ERROR "overflow" */ + delta32 |
| |
| _ = complex64(- /* ERROR "cannot convert" */ (maxFloat32 + delta32)) |
| _ = complex64(-maxFloat32) |
| _ = complex64(maxFloat32) |
| _ = complex64(maxFloat32 /* ERROR "cannot convert" */ + delta32) |
| ) |
| |
| const ( |
| _ complex128 = - /* ERROR "overflow" */ (maxFloat64 + delta64) |
| _ complex128 = -maxFloat64 |
| _ complex128 = maxFloat64 |
| _ complex128 = maxFloat64 /* ERROR "overflow" */ + delta64 |
| |
| _ = complex128(- /* ERROR "cannot convert" */ (maxFloat64 + delta64)) |
| _ = complex128(-maxFloat64) |
| _ = complex128(maxFloat64) |
| _ = complex128(maxFloat64 /* ERROR "cannot convert" */ + delta64) |
| ) |
| |
| // Initialization of typed constant and conversion are the same: |
| const ( |
| f32 = 1 + smallestFloat32 |
| x32 float32 = f32 |
| y32 = float32(f32) |
| _ = assert(x32 - y32 == 0) |
| ) |
| |
| const ( |
| f64 = 1 + smallestFloat64 |
| x64 float64 = f64 |
| y64 = float64(f64) |
| _ = assert(x64 - y64 == 0) |
| ) |
| |
| const ( |
| _ = int8(-1) << 7 |
| _ = int8 /* ERROR "overflows" */ (-1) << 8 |
| |
| _ = uint32(1) << 31 |
| _ = uint32 /* ERROR "overflows" */ (1) << 32 |
| ) |
