languages/go
languages/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-05 18:36:08 +00:00
Code Issues Projects Releases Packages Wiki Activity

src/cmd/compile/internal/gc: remove now unnecessary restriction on float exponent parsing

Browse source 
https://go-review.googlesource.com/#/c/13778/ fixed this issue in math/big.
Remove restriction in compiler.

Fixes #11326.

Change-Id: I1429d0dd0d79431706c65616413373fff58f081e
Reviewed-on: https://go-review.googlesource.com/14830
Reviewed-by: Rob Pike <r@golang.org>
This commit is contained in:
Robert Griesemer 2015-09-21 15:58:19 -07:00
parent 66c25fa9be
commit c396c047c6
3 changed files with 29 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
src/cmd/compile/internal/gc/mparith3.go
View file

@ -9,7 +9,6 @@ import (
"cmd/internal/obj"
"fmt"
"math"
"strings"
)
/// implements float arihmetic
@ -154,30 +153,6 @@ func mpatoflt(a *Mpflt, as string) {
as = as[1:]
}
// The spec requires accepting exponents that fit in int32.
// Don't accept much more than that.
// Count digits in exponent and stop early if there are too many.
if i := strings.Index(as, "e"); i >= 0 {
i++
if i < len(as) && (as[i] == '-' || as[i] == '+') {
i++
}
for i < len(as) && as[i] == '0' {
i++
}
// TODO(rsc): This should be > 10, because we're supposed
// to accept any signed 32-bit int as an exponent.
// But that's not working terribly well, so we deviate from the
// spec in order to make sure that what we accept works.
// We can remove this restriction once those larger exponents work.
// See golang.org/issue/11326 and test/fixedbugs/issue11326*.go.
if len(as)-i > 8 {
Yyerror("malformed constant: %s (exponent too large)", as)
a.Val.SetUint64(0)
return
}
}
f, ok := a.Val.SetString(as)
if !ok {
// At the moment we lose precise error cause;

31
test/fixedbugs/issue11326.go
View file

@ -4,25 +4,20 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Tests for golang.org/issue/11326.
package main
import "fmt"
func main() {
var g = 1e81391777742999 // ERROR "exponent too large"
// The next should only cause a problem when converted to float64
// by the assignment, but instead the compiler rejects it outright,
// rather than mishandle it. Specifically, when handled, 'var h' prints:
// issue11326.go:N: constant 0.93342e+536870911 overflows float64
// The rejection of 'var i' is just insurance. It seems to work correctly.
// See golang.org/issue/11326.
// var h = 1e2147483647 // should be "1.00000e+2147483647 overflows float64"
var h = 1e2147483647 // ERROR "exponent too large"
// var i = 1e214748364 // should be "1.00000e\+214748364 overflows float64"
var i = 1e214748364 // ERROR "exponent too large"
var j = 1e21474836 // ERROR "1.00000e\+21474836 overflows float64"
var k = 1e2147483 // ERROR "1.00000e\+2147483 overflows float64"
var l = 1e214748 // ERROR "1.00000e\+214748 overflows float64"
var m = 1e21474 // ERROR "1.00000e\+21474 overflows float64"
fmt.Println(g)
var _ = 1e2147483647 // ERROR "constant too large"
var _ = 1e646456993 // ERROR "constant too large"
var _ = 1e646456992 // ERROR "1.00000e\+646456992 overflows float64"
var _ = 1e64645699 // ERROR "1.00000e\+64645699 overflows float64"
var _ = 1e6464569 // ERROR "1.00000e\+6464569 overflows float64"
var _ = 1e646456 // ERROR "1.00000e\+646456 overflows float64"
var _ = 1e64645 // ERROR "1.00000e\+64645 overflows float64"
var _ = 1e6464 // ERROR "1.00000e\+6464 overflows float64"
var _ = 1e646 // ERROR "1.00000e\+646 overflows float64"
var _ = 1e309 // ERROR "1.00000e\+309 overflows float64"
var _ = 1e308
}

32
test/fixedbugs/issue11326b.go
View file

@ -6,36 +6,36 @@
package main
// Tests for golang.org/issue/11326.
func main() {
/* TODO(rsc): Should work but does not. See golang.org/issue/11326.
{
const n = 1e2147483647
const d = 1e2147483646
const n = 1e646456992
const d = 1e646456991
x := n / d
if x != 10.0 {
println("incorrect value:", x)
}
}
{
const n = 1e214748364
const d = 1e214748363
x := n / d
if x != 10.0 {
println("incorrect value:", x)
}
}
*/
{
const n = 1e21474836
const d = 1e21474835
const n = 1e64645699
const d = 1e64645698
x := n / d
if x != 10.0 {
println("incorrect value:", x)
}
}
{
const n = 1e2147483
const d = 1e2147482
const n = 1e6464569
const d = 1e6464568
x := n / d
if x != 10.0 {
println("incorrect value:", x)
}
}
{
const n = 1e646456
const d = 1e646455
x := n / d
if x != 10.0 {
println("incorrect value:", x)