Your IP : 172.28.240.42
// 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
)