mirror of
https://github.com/golang/go
synced 2024-09-04 23:44:16 +00:00
ceb849dd97
This CL introduces compiler support for the new binary and octal integer
literals, hexadecimal floats, and digit separators for all number literals.
The new Go 2 number literal scanner accepts the following liberal format:
number = [ prefix ] digits [ "." digits ] [ exponent ] [ "i" ] .
prefix = "0" [ "b" |"B" | "o" | "O" | "x" | "X" ] .
digits = { digit | "_" } .
exponent = ( "e" | "E" | "p" | "P" ) [ "+" | "-" ] digits .
If the number starts with "0x" or "0X", digit is any hexadecimal digit;
otherwise, digit is any decimal digit. If the accepted number is not valid,
errors are reported accordingly.
See the new test cases in scanner_test.go for a selection of valid and
invalid numbers and the respective error messages.
R=Go1.13
Updates #12711.
Updates #19308.
Updates #28493.
Updates #29008.
Change-Id: Ic8febc7bd4dc5186b16a8c8897691e81125cf0ca
Reviewed-on: https://go-review.googlesource.com/c/157677
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
89 lines
1.9 KiB
Go
89 lines
1.9 KiB
Go
// run
|
|
|
|
// Copyright 2019 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.
|
|
|
|
// Test Go2 literal syntax for basic types.
|
|
// TODO add more tests
|
|
|
|
package main
|
|
|
|
import "fmt"
|
|
|
|
func assert(cond bool) {
|
|
if !cond {
|
|
panic("assertion failed")
|
|
}
|
|
}
|
|
|
|
func equal(x, y float64) bool {
|
|
if x != y {
|
|
fmt.Printf("%g != %g\n", x, y)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func main() {
|
|
// 0-octals
|
|
assert(0_1 == 01)
|
|
assert(012 == 012)
|
|
assert(0_1_2 == 012)
|
|
|
|
// decimals
|
|
assert(1_000_000 == 1000000)
|
|
|
|
// hexadecimals
|
|
assert(0x_1 == 0x1)
|
|
assert(0x1_2 == 0x12)
|
|
assert(0X_cafe_f00d == 0xcafef00d)
|
|
|
|
// octals
|
|
assert(0o_1 == 01)
|
|
assert(0o12 == 012)
|
|
assert(0O_1_2 == 012)
|
|
|
|
// binaries
|
|
assert(0b_1 == 1)
|
|
assert(0b10 == 2)
|
|
assert(0b_1_0 == 2)
|
|
|
|
// decimal floats
|
|
assert(0. == 0.0)
|
|
assert(.0 == 0.0)
|
|
assert(1_0. == 10.0)
|
|
assert(.0_1 == 0.01)
|
|
assert(1_0.0_1 == 10.01)
|
|
|
|
assert(0.e1_0 == 0.0e10)
|
|
assert(.0e1_0 == 0.0e10)
|
|
assert(1_0.e1_0 == 10.0e10)
|
|
assert(.0_1e1_0 == 0.01e10)
|
|
assert(1_0.0_1e1_0 == 10.01e10)
|
|
|
|
// hexadecimal floats
|
|
assert(equal(0x1p-2, 0.25))
|
|
assert(equal(0x2.p10, 2048.0))
|
|
assert(equal(0x1.Fp+0, 1.9375))
|
|
assert(equal(0X.8p-0, 0.5))
|
|
assert(equal(0X1FFFP-16, 0.1249847412109375))
|
|
assert(equal(0x1.fffffffffffffp1023, 1.7976931348623157e308))
|
|
|
|
assert(equal(0x_1p-2, 0.25))
|
|
assert(equal(0x2.p1_0, 2048.0))
|
|
assert(equal(0x1_0.Fp+0, 16.9375))
|
|
assert(equal(0X_0.8p-0, 0.5))
|
|
assert(equal(0X_1FF_FP-16, 0.1249847412109375))
|
|
assert(equal(0x1.f_ffff_ffff_ffffP1_023, 1.7976931348623157e308))
|
|
|
|
// imaginaries
|
|
assert(0i == complex(0, 0))
|
|
assert(09i == complex(0, 9)) // "09i" is a decimal int followed by "i"
|
|
assert(1.2e+3i == complex(0, 1.2e+3))
|
|
|
|
assert(0_0i == complex(0, 0))
|
|
assert(0_9i == complex(0, 9)) // "0_9i" is a decimal int followed by "i"
|
|
assert(1.2_0e+0_3i == complex(0, 1.2e+3))
|
|
}
|