Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

make safe for new package local defaults

Browse source 
R=r
DELTA=462  (9 added, 33 deleted, 420 changed)
OCL=22879
CL=22885
This commit is contained in:
Russ Cox 2009-01-15 16:16:42 -08:00
parent 1d74892178
commit b54133d200
17 changed files with 406 additions and 403 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/lib/fmt/format.go
View file

@ -464,28 +464,28 @@ func (f *Fmt) Fmt_fb32(a float32) *Fmt {
// float // float
func (x *Fmt) f(a float) *Fmt { func (x *Fmt) f(a float) *Fmt {
if strconv.floatsize == 32 { if strconv.FloatSize == 32 {
return x.Fmt_f32(float32(a)) return x.Fmt_f32(float32(a))
} }
return x.Fmt_f64(float64(a)) return x.Fmt_f64(float64(a))
} }
func (x *Fmt) e(a float) *Fmt { func (x *Fmt) e(a float) *Fmt {
if strconv.floatsize == 32 { if strconv.FloatSize == 32 {
return x.Fmt_e32(float32(a)) return x.Fmt_e32(float32(a))
} }
return x.Fmt_e64(float64(a)) return x.Fmt_e64(float64(a))
} }
func (x *Fmt) g(a float) *Fmt { func (x *Fmt) g(a float) *Fmt {
if strconv.floatsize == 32 { if strconv.FloatSize == 32 {
return x.Fmt_g32(float32(a)) return x.Fmt_g32(float32(a))
} }
return x.Fmt_g64(float64(a)) return x.Fmt_g64(float64(a))
} }
func (x *Fmt) fb(a float) *Fmt { func (x *Fmt) fb(a float) *Fmt {
if strconv.floatsize == 32 { if strconv.FloatSize == 32 {
return x.Fmt_fb32(float32(a)) return x.Fmt_fb32(float32(a))
} }
return x.Fmt_fb64(float64(a)) return x.Fmt_fb64(float64(a))

11
src/lib/math/Makefile
View file

@ -38,33 +38,34 @@ O1=\
floor.$O\ floor.$O\
fmod.$O\ fmod.$O\
hypot.$O\ hypot.$O\
log.$O\
pow10.$O\ pow10.$O\
sin.$O\ sin.$O\
sqrt.$O\ sqrt.$O\
tan.$O\ tan.$O\
const.$O\
O2=\ O2=\
asin.$O\ asin.$O\
atan2.$O\ atan2.$O\
pow.$O\ log.$O\
sinh.$O\ sinh.$O\
O3=\ O3=\
pow.$O\
tanh.$O\ tanh.$O\
math.a: a1 a2 a3 math.a: a1 a2 a3
a1: $(O1) a1: $(O1)
$(AR) grc math.a atan.$O exp.$O fabs.$O floor.$O fmod.$O hypot.$O log.$O pow10.$O sin.$O sqrt.$O tan.$O $(AR) grc math.a atan.$O exp.$O fabs.$O floor.$O fmod.$O hypot.$O pow10.$O sin.$O sqrt.$O tan.$O const.$O
rm -f $(O1) rm -f $(O1)
a2: $(O2) a2: $(O2)
$(AR) grc math.a asin.$O atan2.$O pow.$O sinh.$O $(AR) grc math.a asin.$O atan2.$O log.$O sinh.$O
rm -f $(O2) rm -f $(O2)
a3: $(O3) a3: $(O3)
$(AR) grc math.a tanh.$O $(AR) grc math.a pow.$O tanh.$O
rm -f $(O3) rm -f $(O3)
newpkg: clean newpkg: clean

50
src/lib/math/atan.go
View file

@ -15,30 +15,30 @@ package math
const const
( (
p4 = .161536412982230228262e2; ap4 = .161536412982230228262e2;
p3 = .26842548195503973794141e3; ap3 = .26842548195503973794141e3;
p2 = .11530293515404850115428136e4; ap2 = .11530293515404850115428136e4;
p1 = .178040631643319697105464587e4; ap1 = .178040631643319697105464587e4;
p0 = .89678597403663861959987488e3; ap0 = .89678597403663861959987488e3;
q4 = .5895697050844462222791e2; aq4 = .5895697050844462222791e2;
q3 = .536265374031215315104235e3; aq3 = .536265374031215315104235e3;
q2 = .16667838148816337184521798e4; aq2 = .16667838148816337184521798e4;
q1 = .207933497444540981287275926e4; aq1 = .207933497444540981287275926e4;
q0 = .89678597403663861962481162e3; aq0 = .89678597403663861962481162e3;
pio2 = .15707963267948966192313216e1; apio2 = .15707963267948966192313216e1;
pio4 = .7853981633974483096156608e0; apio4 = .7853981633974483096156608e0;
sq2p1 = .2414213562373095048802e1; // sqrt(2)+1 asq2p1 = .2414213562373095048802e1; // sqrt(2)+1
sq2m1 = .414213562373095048802e0; // sqrt(2)-1 asq2m1 = .414213562373095048802e0; // sqrt(2)-1
) )
/* /*
* xatan evaluates a series valid in the * xatan evaluates a series valid in the
* range [-0.414...,+0.414...]. (tan(pi/8)) * range [-0.414...,+0.414...]. (tan(pi/8))
*/ */
func Xatan(arg float64) float64 { func xatan(arg float64) float64 {
argsq := arg*arg; argsq := arg*arg;
value := ((((p4*argsq + p3)*argsq + p2)*argsq + p1)*argsq + p0); value := ((((ap4*argsq + ap3)*argsq + ap2)*argsq + ap1)*argsq + ap0);
value = value/(((((argsq + q4)*argsq + q3)*argsq + q2)*argsq + q1)*argsq + q0); value = value/(((((argsq + aq4)*argsq + aq3)*argsq + aq2)*argsq + aq1)*argsq + aq0);
return value*arg; return value*arg;
} }
@ -46,14 +46,14 @@ func Xatan(arg float64) float64 {
* satan reduces its argument (known to be positive) * satan reduces its argument (known to be positive)
* to the range [0,0.414...] and calls xatan. * to the range [0,0.414...] and calls xatan.
*/ */
func Satan(arg float64) float64 { func satan(arg float64) float64 {
if arg < sq2m1 { if arg < asq2m1 {
return Xatan(arg); return xatan(arg);
} }
if arg > sq2p1 { if arg > asq2p1 {
return pio2 - Xatan(1/arg); return apio2 - xatan(1/arg);
} }
return pio4 + Xatan((arg-1)/(arg+1)); return apio4 + xatan((arg-1)/(arg+1));
} }
/* /*
@ -62,7 +62,7 @@ func Satan(arg float64) float64 {
*/ */
export func Atan(arg float64) float64 { export func Atan(arg float64) float64 {
if arg > 0 { if arg > 0 {
return Satan(arg); return satan(arg);
} }
return -Satan(-arg); return -satan(-arg);
} }

9
src/lib/math/const.go Normal file
View file

@ -0,0 +1,9 @@
// Copyright 2009 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.
package math
export const (
Sqrt2 = 1.41421356237309504880168872420969808;
)

37
src/lib/math/log.go
View file

@ -4,6 +4,8 @@
package math package math
import "math"
// The original C code, the long comment, and the constants // The original C code, the long comment, and the constants
// below are from FreeBSD's /usr/src/lib/msun/src/e_log.c // below are from FreeBSD's /usr/src/lib/msun/src/e_log.c
// and came with this notice. The go code is a simpler // and came with this notice. The go code is a simpler
@ -35,11 +37,11 @@ package math
// of this polynomial approximation is bounded by 2**-58.45. In // of this polynomial approximation is bounded by 2**-58.45. In
// other words, // other words,
// 2 4 6 8 10 12 14 // 2 4 6 8 10 12 14
// R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s +Lg6*s +Lg7*s // R(z) ~ lg1*s +lg2*s +lg3*s +lg4*s +lg5*s +lg6*s +lg7*s
// (the values of Lg1 to Lg7 are listed in the program) // (the values of lg1 to lg7 are listed in the program)
// and // and
// | 2 14 | -58.45 // | 2 14 | -58.45
// | Lg1*s +...+Lg7*s - R(z) | <= 2 // | lg1*s +...+lg7*s - R(z) | <= 2
// | | // | |
// Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2. // Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
// In order to guarantee error in log below 1ulp, we compute log // In order to guarantee error in log below 1ulp, we compute log
@ -69,20 +71,15 @@ package math
// to produce the hexadecimal values shown. // to produce the hexadecimal values shown.
const ( const (
Ln2Hi = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */ ln2Hi = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */
Ln2Lo = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */ ln2Lo = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */
Lg1 = 6.666666666666735130e-01; /* 3FE55555 55555593 */ lg1 = 6.666666666666735130e-01; /* 3FE55555 55555593 */
Lg2 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */ lg2 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */
Lg3 = 2.857142874366239149e-01; /* 3FD24924 94229359 */ lg3 = 2.857142874366239149e-01; /* 3FD24924 94229359 */
Lg4 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */ lg4 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */
Lg5 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */ lg5 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */
Lg6 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */ lg6 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */
Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */ lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
Two54 = 1<<54; // 2^54
TwoM20 = 1.0/(1<<20); // 2^-20
TwoM1022 = 2.2250738585072014e-308; // 2^-1022
Sqrt2 = 1.41421356237309504880168872420969808;
) )
export func Log(x float64) float64 { export func Log(x float64) float64 {
@ -109,11 +106,11 @@ export func Log(x float64) float64 {
s := f/(2+f); s := f/(2+f);
s2 := s*s; s2 := s*s;
s4 := s2*s2; s4 := s2*s2;
t1 := s2*(Lg1 + s4*(Lg3 + s4*(Lg5 + s4*Lg7))); t1 := s2*(lg1 + s4*(lg3 + s4*(lg5 + s4*lg7)));
t2 := s4*(Lg2 + s4*(Lg4 + s4*Lg6)); t2 := s4*(lg2 + s4*(lg4 + s4*lg6));
R := t1 + t2; R := t1 + t2;
hfsq := 0.5*f*f; hfsq := 0.5*f*f;
return k*Ln2Hi - ((hfsq-(s*(hfsq+R)+k*Ln2Lo)) - f); return k*ln2Hi - ((hfsq-(s*(hfsq+R)+k*ln2Lo)) - f);
} }
const const

36
src/lib/math/sin.go
View file

@ -9,32 +9,32 @@ package math
*/ */
const const
( (
p0 = .1357884097877375669092680e8; sp0 = .1357884097877375669092680e8;
p1 = -.4942908100902844161158627e7; sp1 = -.4942908100902844161158627e7;
p2 = .4401030535375266501944918e6; sp2 = .4401030535375266501944918e6;
p3 = -.1384727249982452873054457e5; sp3 = -.1384727249982452873054457e5;
p4 = .1459688406665768722226959e3; sp4 = .1459688406665768722226959e3;
q0 = .8644558652922534429915149e7; sq0 = .8644558652922534429915149e7;
q1 = .4081792252343299749395779e6; sq1 = .4081792252343299749395779e6;
q2 = .9463096101538208180571257e4; sq2 = .9463096101538208180571257e4;
q3 = .1326534908786136358911494e3; sq3 = .1326534908786136358911494e3;
piu2 = .6366197723675813430755350e0; // 2/pi spiu2 = .6366197723675813430755350e0; // 2/pi
) )
func Sinus(arg float64, quad int) float64 { func sinus(arg float64, quad int) float64 {
x := arg; x := arg;
if(x < 0) { if(x < 0) {
x = -x; x = -x;
quad = quad+2; quad = quad+2;
} }
x = x * piu2; /* underflow? */ x = x * spiu2; /* underflow? */
var y float64; var y float64;
if x > 32764 { if x > 32764 {
var e float64; var e float64;
e, y = sys.modf(x); e, y = sys.modf(x);
e = e + float64(quad); e = e + float64(quad);
temp1, f := sys.modf(0.25*e); temsp1, f := sys.modf(0.25*e);
quad = int(e - 4*f); quad = int(e - 4*f);
} else { } else {
k := int32(x); k := int32(x);
@ -50,18 +50,18 @@ func Sinus(arg float64, quad int) float64 {
} }
ysq := y*y; ysq := y*y;
temp1 := ((((p4*ysq+p3)*ysq+p2)*ysq+p1)*ysq+p0)*y; temsp1 := ((((sp4*ysq+sp3)*ysq+sp2)*ysq+sp1)*ysq+sp0)*y;
temp2 := ((((ysq+q3)*ysq+q2)*ysq+q1)*ysq+q0); temsp2 := ((((ysq+sq3)*ysq+sq2)*ysq+sq1)*ysq+sq0);
return temp1/temp2; return temsp1/temsp2;
} }
export func Cos(arg float64) float64 { export func Cos(arg float64) float64 {
if arg < 0 { if arg < 0 {
arg = -arg; arg = -arg;
} }
return Sinus(arg, 1); return sinus(arg, 1);
} }
export func Sin(arg float64) float64 { export func Sin(arg float64) float64 {
return Sinus(arg, 0); return sinus(arg, 0);
} }

18
src/lib/math/sinh.go
View file

@ -22,13 +22,13 @@ import "math"
const const
( (
p0 = -0.6307673640497716991184787251e+6; shp0 = -0.6307673640497716991184787251e+6;
p1 = -0.8991272022039509355398013511e+5; shp1 = -0.8991272022039509355398013511e+5;
p2 = -0.2894211355989563807284660366e+4; shp2 = -0.2894211355989563807284660366e+4;
p3 = -0.2630563213397497062819489e+2; shp3 = -0.2630563213397497062819489e+2;
q0 = -0.6307673640497716991212077277e+6; shq0 = -0.6307673640497716991212077277e+6;
q1 = 0.1521517378790019070696485176e+5; shq1 = 0.1521517378790019070696485176e+5;
q2 = -0.173678953558233699533450911e+3; shq2 = -0.173678953558233699533450911e+3;
) )
export func Sinh(arg float64) float64 { export func Sinh(arg float64) float64 {
@ -48,8 +48,8 @@ export func Sinh(arg float64) float64 {
default: default:
argsq := arg*arg; argsq := arg*arg;
temp = (((p3*argsq+p2)*argsq+p1)*argsq+p0)*arg; temp = (((shp3*argsq+shp2)*argsq+shp1)*argsq+shp0)*arg;
temp = temp/(((argsq+q2)*argsq+q1)*argsq+q0); temp = temp/(((argsq+shq2)*argsq+shq1)*argsq+shq0);
} }
if sign { if sign {

2
src/lib/reflect/tostring.go
View file

@ -153,7 +153,7 @@ func ValueToString(val Value) string {
case Uint64Kind: case Uint64Kind:
return integer(int64(val.(Uint64Value).Get())); return integer(int64(val.(Uint64Value).Get()));
case FloatKind: case FloatKind:
if strconv.floatsize == 32 { if strconv.FloatSize == 32 {
return strconv.ftoa32(float32(val.(FloatValue).Get()), 'g', -1); return strconv.ftoa32(float32(val.(FloatValue).Get()), 'g', -1);
} else { } else {
return strconv.ftoa64(float64(val.(FloatValue).Get()), 'g', -1); return strconv.ftoa64(float64(val.(FloatValue).Get()), 'g', -1);

42
src/lib/reflect/type.go
View file

@ -59,22 +59,22 @@ export type Type interface {
} }
// Fields and methods common to all types // Fields and methods common to all types
type Common struct { type commonType struct {
kind int; kind int;
str string; str string;
name string; name string;
size int; size int;
} }
func (c *Common) Kind() int { func (c *commonType) Kind() int {
return c.kind return c.kind
} }
func (c *Common) Name() string { func (c *commonType) Name() string {
return c.name return c.name
} }
func (c *Common) String() string { func (c *commonType) String() string {
// If there is a name, show that instead of its expansion. // If there is a name, show that instead of its expansion.
// This is important for reflection: a named type // This is important for reflection: a named type
// might have methods that the unnamed type does not. // might have methods that the unnamed type does not.
@ -84,18 +84,18 @@ func (c *Common) String() string {
return c.str return c.str
} }
func (c *Common) Size() int { func (c *commonType) Size() int {
return c.size return c.size
} }
// -- Basic // -- Basic
type BasicType struct { type BasicType struct {
Common commonType
} }
func NewBasicType(name string, kind int, size int) Type { func NewBasicType(name string, kind int, size int) Type {
return &BasicType{ Common{kind, name, name, size} } return &BasicType{ commonType{kind, name, name, size} }
} }
// Prebuilt basic types // Prebuilt basic types
@ -147,12 +147,12 @@ export type PtrType interface {
} }
type PtrTypeStruct struct { type PtrTypeStruct struct {
Common; commonType;
sub *StubType; sub *StubType;
} }
func NewPtrTypeStruct(name, typestring string, sub *StubType) *PtrTypeStruct { func NewPtrTypeStruct(name, typestring string, sub *StubType) *PtrTypeStruct {
return &PtrTypeStruct{ Common{PtrKind, typestring, name, ptrsize}, sub} return &PtrTypeStruct{ commonType{PtrKind, typestring, name, ptrsize}, sub}
} }
func (t *PtrTypeStruct) Sub() Type { func (t *PtrTypeStruct) Sub() Type {
@ -168,14 +168,14 @@ export type ArrayType interface {
} }
type ArrayTypeStruct struct { type ArrayTypeStruct struct {
Common; commonType;
elem *StubType; elem *StubType;
open bool; // otherwise fixed size open bool; // otherwise fixed size
len int; len int;
} }
func NewArrayTypeStruct(name, typestring string, open bool, len int, elem *StubType) *ArrayTypeStruct { func NewArrayTypeStruct(name, typestring string, open bool, len int, elem *StubType) *ArrayTypeStruct {
return &ArrayTypeStruct{ Common{ArrayKind, typestring, name, 0}, elem, open, len} return &ArrayTypeStruct{ commonType{ArrayKind, typestring, name, 0}, elem, open, len}
} }
func (t *ArrayTypeStruct) Size() int { func (t *ArrayTypeStruct) Size() int {
@ -206,13 +206,13 @@ export type MapType interface {
} }
type MapTypeStruct struct { type MapTypeStruct struct {
Common; commonType;
key *StubType; key *StubType;
elem *StubType; elem *StubType;
} }
func NewMapTypeStruct(name, typestring string, key, elem *StubType) *MapTypeStruct { func NewMapTypeStruct(name, typestring string, key, elem *StubType) *MapTypeStruct {
return &MapTypeStruct{ Common{MapKind, typestring, name, ptrsize}, key, elem} return &MapTypeStruct{ commonType{MapKind, typestring, name, ptrsize}, key, elem}
} }
func (t *MapTypeStruct) Key() Type { func (t *MapTypeStruct) Key() Type {
@ -237,13 +237,13 @@ export const ( // channel direction
) )
type ChanTypeStruct struct { type ChanTypeStruct struct {
Common; commonType;
elem *StubType; elem *StubType;
dir int; dir int;
} }
func NewChanTypeStruct(name, typestring string, dir int, elem *StubType) *ChanTypeStruct { func NewChanTypeStruct(name, typestring string, dir int, elem *StubType) *ChanTypeStruct {
return &ChanTypeStruct{ Common{ChanKind, typestring, name, ptrsize}, elem, dir} return &ChanTypeStruct{ commonType{ChanKind, typestring, name, ptrsize}, elem, dir}
} }
func (t *ChanTypeStruct) Dir() int { func (t *ChanTypeStruct) Dir() int {
@ -270,12 +270,12 @@ type Field struct {
} }
type StructTypeStruct struct { type StructTypeStruct struct {
Common; commonType;
field []Field; field []Field;
} }
func NewStructTypeStruct(name, typestring string, field []Field) *StructTypeStruct { func NewStructTypeStruct(name, typestring string, field []Field) *StructTypeStruct {
return &StructTypeStruct{ Common{StructKind, typestring, name, 0}, field} return &StructTypeStruct{ commonType{StructKind, typestring, name, 0}, field}
} }
// TODO: not portable; depends on 6g // TODO: not portable; depends on 6g
@ -322,12 +322,12 @@ export type InterfaceType interface {
} }
type InterfaceTypeStruct struct { type InterfaceTypeStruct struct {
Common; commonType;
field []Field; field []Field;
} }
func NewInterfaceTypeStruct(name, typestring string, field []Field) *InterfaceTypeStruct { func NewInterfaceTypeStruct(name, typestring string, field []Field) *InterfaceTypeStruct {
return &InterfaceTypeStruct{ Common{InterfaceKind, typestring, name, interfacesize}, field } return &InterfaceTypeStruct{ commonType{InterfaceKind, typestring, name, interfacesize}, field }
} }
func (t *InterfaceTypeStruct) Field(i int) (name string, typ Type, tag string, offset int) { func (t *InterfaceTypeStruct) Field(i int) (name string, typ Type, tag string, offset int) {
@ -348,13 +348,13 @@ export type FuncType interface {
} }
type FuncTypeStruct struct { type FuncTypeStruct struct {
Common; commonType;
in *StructTypeStruct; in *StructTypeStruct;
out *StructTypeStruct; out *StructTypeStruct;
} }
func NewFuncTypeStruct(name, typestring string, in, out *StructTypeStruct) *FuncTypeStruct { func NewFuncTypeStruct(name, typestring string, in, out *StructTypeStruct) *FuncTypeStruct {
return &FuncTypeStruct{ Common{FuncKind, typestring, name, 0}, in, out } return &FuncTypeStruct{ commonType{FuncKind, typestring, name, 0}, in, out }
} }
func (t *FuncTypeStruct) Size() int { func (t *FuncTypeStruct) Size() int {

112
src/lib/reflect/value.go
View file

@ -25,27 +25,27 @@ export type Value interface {
Interface() interface {}; Interface() interface {};
} }
// Common fields and functionality for all values // commonValue fields and functionality for all values
type Common struct { type commonValue struct {
kind int; kind int;
typ Type; typ Type;
addr Addr; addr Addr;
} }
func (c *Common) Kind() int { func (c *commonValue) Kind() int {
return c.kind return c.kind
} }
func (c *Common) Type() Type { func (c *commonValue) Type() Type {
return c.typ return c.typ
} }
func (c *Common) Addr() Addr { func (c *commonValue) Addr() Addr {
return c.addr return c.addr
} }
func (c *Common) Interface() interface {} { func (c *commonValue) Interface() interface {} {
var i interface {}; var i interface {};
if c.typ.Size() > 8 { // TODO(rsc): how do we know it is 8? if c.typ.Size() > 8 { // TODO(rsc): how do we know it is 8?
i = sys.unreflect(c.addr.(uintptr).(uint64), c.typ.String(), true); i = sys.unreflect(c.addr.(uintptr).(uint64), c.typ.String(), true);
@ -72,11 +72,11 @@ export type MissingValue interface {
} }
type MissingValueStruct struct { type MissingValueStruct struct {
Common commonValue
} }
func MissingCreator(typ Type, addr Addr) Value { func MissingCreator(typ Type, addr Addr) Value {
return &MissingValueStruct{ Common{MissingKind, typ, addr} } return &MissingValueStruct{ commonValue{MissingKind, typ, addr} }
} }
// -- Int // -- Int
@ -89,11 +89,11 @@ export type IntValue interface {
} }
type IntValueStruct struct { type IntValueStruct struct {
Common commonValue
} }
func IntCreator(typ Type, addr Addr) Value { func IntCreator(typ Type, addr Addr) Value {
return &IntValueStruct{ Common{IntKind, typ, addr} } return &IntValueStruct{ commonValue{IntKind, typ, addr} }
} }
func (v *IntValueStruct) Get() int { func (v *IntValueStruct) Get() int {
@ -114,11 +114,11 @@ export type Int8Value interface {
} }
type Int8ValueStruct struct { type Int8ValueStruct struct {
Common commonValue
} }
func Int8Creator(typ Type, addr Addr) Value { func Int8Creator(typ Type, addr Addr) Value {
return &Int8ValueStruct{ Common{Int8Kind, typ, addr} } return &Int8ValueStruct{ commonValue{Int8Kind, typ, addr} }
} }
func (v *Int8ValueStruct) Get() int8 { func (v *Int8ValueStruct) Get() int8 {
@ -139,11 +139,11 @@ export type Int16Value interface {
} }
type Int16ValueStruct struct { type Int16ValueStruct struct {
Common commonValue
} }
func Int16Creator(typ Type, addr Addr) Value { func Int16Creator(typ Type, addr Addr) Value {
return &Int16ValueStruct{ Common{Int16Kind, typ, addr} } return &Int16ValueStruct{ commonValue{Int16Kind, typ, addr} }
} }
func (v *Int16ValueStruct) Get() int16 { func (v *Int16ValueStruct) Get() int16 {
@ -164,11 +164,11 @@ export type Int32Value interface {
} }
type Int32ValueStruct struct { type Int32ValueStruct struct {
Common commonValue
} }
func Int32Creator(typ Type, addr Addr) Value { func Int32Creator(typ Type, addr Addr) Value {
return &Int32ValueStruct{ Common{Int32Kind, typ, addr} } return &Int32ValueStruct{ commonValue{Int32Kind, typ, addr} }
} }
func (v *Int32ValueStruct) Get() int32 { func (v *Int32ValueStruct) Get() int32 {
@ -189,11 +189,11 @@ export type Int64Value interface {
} }
type Int64ValueStruct struct { type Int64ValueStruct struct {
Common commonValue
} }
func Int64Creator(typ Type, addr Addr) Value { func Int64Creator(typ Type, addr Addr) Value {
return &Int64ValueStruct{ Common{Int64Kind, typ, addr} } return &Int64ValueStruct{ commonValue{Int64Kind, typ, addr} }
} }
func (v *Int64ValueStruct) Get() int64 { func (v *Int64ValueStruct) Get() int64 {
@ -214,11 +214,11 @@ export type UintValue interface {
} }
type UintValueStruct struct { type UintValueStruct struct {
Common commonValue
} }
func UintCreator(typ Type, addr Addr) Value { func UintCreator(typ Type, addr Addr) Value {
return &UintValueStruct{ Common{UintKind, typ, addr} } return &UintValueStruct{ commonValue{UintKind, typ, addr} }
} }
func (v *UintValueStruct) Get() uint { func (v *UintValueStruct) Get() uint {
@ -239,11 +239,11 @@ export type Uint8Value interface {
} }
type Uint8ValueStruct struct { type Uint8ValueStruct struct {
Common commonValue
} }
func Uint8Creator(typ Type, addr Addr) Value { func Uint8Creator(typ Type, addr Addr) Value {
return &Uint8ValueStruct{ Common{Uint8Kind, typ, addr} } return &Uint8ValueStruct{ commonValue{Uint8Kind, typ, addr} }
} }
func (v *Uint8ValueStruct) Get() uint8 { func (v *Uint8ValueStruct) Get() uint8 {
@ -264,11 +264,11 @@ export type Uint16Value interface {
} }
type Uint16ValueStruct struct { type Uint16ValueStruct struct {
Common commonValue
} }
func Uint16Creator(typ Type, addr Addr) Value { func Uint16Creator(typ Type, addr Addr) Value {
return &Uint16ValueStruct{ Common{Uint16Kind, typ, addr} } return &Uint16ValueStruct{ commonValue{Uint16Kind, typ, addr} }
} }
func (v *Uint16ValueStruct) Get() uint16 { func (v *Uint16ValueStruct) Get() uint16 {
@ -289,11 +289,11 @@ export type Uint32Value interface {
} }
type Uint32ValueStruct struct { type Uint32ValueStruct struct {
Common commonValue
} }
func Uint32Creator(typ Type, addr Addr) Value { func Uint32Creator(typ Type, addr Addr) Value {
return &Uint32ValueStruct{ Common{Uint32Kind, typ, addr} } return &Uint32ValueStruct{ commonValue{Uint32Kind, typ, addr} }
} }
func (v *Uint32ValueStruct) Get() uint32 { func (v *Uint32ValueStruct) Get() uint32 {
@ -314,11 +314,11 @@ export type Uint64Value interface {
} }
type Uint64ValueStruct struct { type Uint64ValueStruct struct {
Common commonValue
} }
func Uint64Creator(typ Type, addr Addr) Value { func Uint64Creator(typ Type, addr Addr) Value {
return &Uint64ValueStruct{ Common{Uint64Kind, typ, addr} } return &Uint64ValueStruct{ commonValue{Uint64Kind, typ, addr} }
} }
func (v *Uint64ValueStruct) Get() uint64 { func (v *Uint64ValueStruct) Get() uint64 {
@ -339,11 +339,11 @@ export type UintptrValue interface {
} }
type UintptrValueStruct struct { type UintptrValueStruct struct {
Common commonValue
} }
func UintptrCreator(typ Type, addr Addr) Value { func UintptrCreator(typ Type, addr Addr) Value {
return &UintptrValueStruct{ Common{UintptrKind, typ, addr} } return &UintptrValueStruct{ commonValue{UintptrKind, typ, addr} }
} }
func (v *UintptrValueStruct) Get() uintptr { func (v *UintptrValueStruct) Get() uintptr {
@ -364,11 +364,11 @@ export type FloatValue interface {
} }
type FloatValueStruct struct { type FloatValueStruct struct {
Common commonValue
} }
func FloatCreator(typ Type, addr Addr) Value { func FloatCreator(typ Type, addr Addr) Value {
return &FloatValueStruct{ Common{FloatKind, typ, addr} } return &FloatValueStruct{ commonValue{FloatKind, typ, addr} }
} }
func (v *FloatValueStruct) Get() float { func (v *FloatValueStruct) Get() float {
@ -389,11 +389,11 @@ export type Float32Value interface {
} }
type Float32ValueStruct struct { type Float32ValueStruct struct {
Common commonValue
} }
func Float32Creator(typ Type, addr Addr) Value { func Float32Creator(typ Type, addr Addr) Value {
return &Float32ValueStruct{ Common{Float32Kind, typ, addr} } return &Float32ValueStruct{ commonValue{Float32Kind, typ, addr} }
} }
func (v *Float32ValueStruct) Get() float32 { func (v *Float32ValueStruct) Get() float32 {
@ -414,11 +414,11 @@ export type Float64Value interface {
} }
type Float64ValueStruct struct { type Float64ValueStruct struct {
Common commonValue
} }
func Float64Creator(typ Type, addr Addr) Value { func Float64Creator(typ Type, addr Addr) Value {
return &Float64ValueStruct{ Common{Float64Kind, typ, addr} } return &Float64ValueStruct{ commonValue{Float64Kind, typ, addr} }
} }
func (v *Float64ValueStruct) Get() float64 { func (v *Float64ValueStruct) Get() float64 {
@ -439,11 +439,11 @@ export type Float80Value interface {
} }
type Float80ValueStruct struct { type Float80ValueStruct struct {
Common commonValue
} }
func Float80Creator(typ Type, addr Addr) Value { func Float80Creator(typ Type, addr Addr) Value {
return &Float80ValueStruct{ Common{Float80Kind, typ, addr} } return &Float80ValueStruct{ commonValue{Float80Kind, typ, addr} }
} }
/* /*
@ -467,11 +467,11 @@ export type StringValue interface {
} }
type StringValueStruct struct { type StringValueStruct struct {
Common commonValue
} }
func StringCreator(typ Type, addr Addr) Value { func StringCreator(typ Type, addr Addr) Value {
return &StringValueStruct{ Common{StringKind, typ, addr} } return &StringValueStruct{ commonValue{StringKind, typ, addr} }
} }
func (v *StringValueStruct) Get() string { func (v *StringValueStruct) Get() string {
@ -492,11 +492,11 @@ export type BoolValue interface {
} }
type BoolValueStruct struct { type BoolValueStruct struct {
Common commonValue
} }
func BoolCreator(typ Type, addr Addr) Value { func BoolCreator(typ Type, addr Addr) Value {
return &BoolValueStruct{ Common{BoolKind, typ, addr} } return &BoolValueStruct{ commonValue{BoolKind, typ, addr} }
} }
func (v *BoolValueStruct) Get() bool { func (v *BoolValueStruct) Get() bool {
@ -518,7 +518,7 @@ export type PtrValue interface {
} }
type PtrValueStruct struct { type PtrValueStruct struct {
Common commonValue
} }
func (v *PtrValueStruct) Get() Addr { func (v *PtrValueStruct) Get() Addr {
@ -540,7 +540,7 @@ func (v *PtrValueStruct) SetSub(subv Value) {
} }
func PtrCreator(typ Type, addr Addr) Value { func PtrCreator(typ Type, addr Addr) Value {
return &PtrValueStruct{ Common{PtrKind, typ, addr} }; return &PtrValueStruct{ commonValue{PtrKind, typ, addr} };
} }
// -- Array // -- Array
@ -570,7 +570,7 @@ type RuntimeArray struct {
} }
type OpenArrayValueStruct struct { type OpenArrayValueStruct struct {
Common; commonValue;
elemtype Type; elemtype Type;
elemsize int; elemsize int;
array *RuntimeArray; array *RuntimeArray;
@ -601,7 +601,7 @@ func (v *OpenArrayValueStruct) Elem(i int) Value {
} }
type FixedArrayValueStruct struct { type FixedArrayValueStruct struct {
Common; commonValue;
elemtype Type; elemtype Type;
elemsize int; elemsize int;
len int; len int;
@ -660,11 +660,11 @@ export type MapValue interface {
} }
type MapValueStruct struct { type MapValueStruct struct {
Common commonValue
} }
func MapCreator(typ Type, addr Addr) Value { func MapCreator(typ Type, addr Addr) Value {
return &MapValueStruct{ Common{MapKind, typ, addr} } return &MapValueStruct{ commonValue{MapKind, typ, addr} }
} }
func (v *MapValueStruct) Len() int { func (v *MapValueStruct) Len() int {
@ -684,11 +684,11 @@ export type ChanValue interface {
} }
type ChanValueStruct struct { type ChanValueStruct struct {
Common commonValue
} }
func ChanCreator(typ Type, addr Addr) Value { func ChanCreator(typ Type, addr Addr) Value {
return &ChanValueStruct{ Common{ChanKind, typ, addr} } return &ChanValueStruct{ commonValue{ChanKind, typ, addr} }
} }
// -- Struct // -- Struct
@ -701,7 +701,7 @@ export type StructValue interface {
} }
type StructValueStruct struct { type StructValueStruct struct {
Common; commonValue;
field []Value; field []Value;
} }
@ -716,7 +716,7 @@ func (v *StructValueStruct) Field(i int) Value {
func StructCreator(typ Type, addr Addr) Value { func StructCreator(typ Type, addr Addr) Value {
t := typ.(StructType); t := typ.(StructType);
nfield := t.Len(); nfield := t.Len();
v := &StructValueStruct{ Common{StructKind, typ, addr}, make([]Value, nfield) }; v := &StructValueStruct{ commonValue{StructKind, typ, addr}, make([]Value, nfield) };
for i := 0; i < nfield; i++ { for i := 0; i < nfield; i++ {
name, ftype, str, offset := t.Field(i); name, ftype, str, offset := t.Field(i);
addr_uint := uintptr(addr) + uintptr(offset); addr_uint := uintptr(addr) + uintptr(offset);
@ -735,7 +735,7 @@ export type InterfaceValue interface {
} }
type InterfaceValueStruct struct { type InterfaceValueStruct struct {
Common commonValue
} }
func (v *InterfaceValueStruct) Get() interface{} { func (v *InterfaceValueStruct) Get() interface{} {
@ -743,7 +743,7 @@ func (v *InterfaceValueStruct) Get() interface{} {
} }
func InterfaceCreator(typ Type, addr Addr) Value { func InterfaceCreator(typ Type, addr Addr) Value {
return &InterfaceValueStruct{ Common{InterfaceKind, typ, addr} } return &InterfaceValueStruct{ commonValue{InterfaceKind, typ, addr} }
} }
// -- Func // -- Func
@ -754,11 +754,11 @@ export type FuncValue interface {
} }
type FuncValueStruct struct { type FuncValueStruct struct {
Common commonValue
} }
func FuncCreator(typ Type, addr Addr) Value { func FuncCreator(typ Type, addr Addr) Value {
return &FuncValueStruct{ Common{FuncKind, typ, addr} } return &FuncValueStruct{ commonValue{FuncKind, typ, addr} }
} }
var creator = map[int] Creator { var creator = map[int] Creator {

2
src/lib/strconv/atof.go
View file

@ -355,7 +355,7 @@ export func atof32(s string) (f float32, err *os.Error) {
} }
export func atof(s string) (f float, err *os.Error) { export func atof(s string) (f float, err *os.Error) {
if floatsize == 32 { if FloatSize == 32 {
f1, err1 := atof32(s); f1, err1 := atof32(s);
return float(f1), err1; return float(f1), err1;
} }

116
src/lib/strconv/atof_test.go
View file

@ -10,92 +10,92 @@ import (
"testing" "testing"
) )
type Test struct { type AtofTest struct {
in string; in string;
out string; out string;
err *os.Error; err *os.Error;
} }
var tests = []Test { var atoftests = []AtofTest {
Test{ "", "0", os.EINVAL }, AtofTest{ "", "0", os.EINVAL },
Test{ "1", "1", nil }, AtofTest{ "1", "1", nil },
Test{ "+1", "1", nil }, AtofTest{ "+1", "1", nil },
Test{ "1x", "0", os.EINVAL }, AtofTest{ "1x", "0", os.EINVAL },
Test{ "1.1.", "0", os.EINVAL }, AtofTest{ "1.1.", "0", os.EINVAL },
Test{ "1e23", "1e+23", nil }, AtofTest{ "1e23", "1e+23", nil },
Test{ "100000000000000000000000", "1e+23", nil }, AtofTest{ "100000000000000000000000", "1e+23", nil },
Test{ "1e-100", "1e-100", nil }, AtofTest{ "1e-100", "1e-100", nil },
Test{ "123456700", "1.234567e+08", nil }, AtofTest{ "123456700", "1.234567e+08", nil },
Test{ "99999999999999974834176", "9.999999999999997e+22", nil }, AtofTest{ "99999999999999974834176", "9.999999999999997e+22", nil },
Test{ "100000000000000000000001", "1.0000000000000001e+23", nil }, AtofTest{ "100000000000000000000001", "1.0000000000000001e+23", nil },
Test{ "100000000000000008388608", "1.0000000000000001e+23", nil }, AtofTest{ "100000000000000008388608", "1.0000000000000001e+23", nil },
Test{ "100000000000000016777215", "1.0000000000000001e+23", nil }, AtofTest{ "100000000000000016777215", "1.0000000000000001e+23", nil },
Test{ "100000000000000016777216", "1.0000000000000003e+23", nil }, AtofTest{ "100000000000000016777216", "1.0000000000000003e+23", nil },
Test{ "-1", "-1", nil }, AtofTest{ "-1", "-1", nil },
Test{ "-0", "-0", nil }, AtofTest{ "-0", "-0", nil },
Test{ "1e-20", "1e-20", nil }, AtofTest{ "1e-20", "1e-20", nil },
Test{ "625e-3", "0.625", nil }, AtofTest{ "625e-3", "0.625", nil },
// largest float64 // largest float64
Test{ "1.7976931348623157e308", "1.7976931348623157e+308", nil }, AtofTest{ "1.7976931348623157e308", "1.7976931348623157e+308", nil },
Test{ "-1.7976931348623157e308", "-1.7976931348623157e+308", nil }, AtofTest{ "-1.7976931348623157e308", "-1.7976931348623157e+308", nil },
// next float64 - too large // next float64 - too large
Test{ "1.7976931348623159e308", "+Inf", os.ERANGE }, AtofTest{ "1.7976931348623159e308", "+Inf", os.ERANGE },
Test{ "-1.7976931348623159e308", "-Inf", os.ERANGE }, AtofTest{ "-1.7976931348623159e308", "-Inf", os.ERANGE },
// the border is ...158079 // the border is ...158079
// borderline - okay // borderline - okay
Test{ "1.7976931348623158e308", "1.7976931348623157e+308", nil }, AtofTest{ "1.7976931348623158e308", "1.7976931348623157e+308", nil },
Test{ "-1.7976931348623158e308", "-1.7976931348623157e+308", nil }, AtofTest{ "-1.7976931348623158e308", "-1.7976931348623157e+308", nil },
// borderline - too large // borderline - too large
Test{ "1.797693134862315808e308", "+Inf", os.ERANGE }, AtofTest{ "1.797693134862315808e308", "+Inf", os.ERANGE },
Test{ "-1.797693134862315808e308", "-Inf", os.ERANGE }, AtofTest{ "-1.797693134862315808e308", "-Inf", os.ERANGE },
// a little too large // a little too large
Test{ "1e308", "1e+308", nil }, AtofTest{ "1e308", "1e+308", nil },
Test{ "2e308", "+Inf", os.ERANGE }, AtofTest{ "2e308", "+Inf", os.ERANGE },
Test{ "1e309", "+Inf", os.ERANGE }, AtofTest{ "1e309", "+Inf", os.ERANGE },
// way too large // way too large
Test{ "1e310", "+Inf", os.ERANGE }, AtofTest{ "1e310", "+Inf", os.ERANGE },
Test{ "-1e310", "-Inf", os.ERANGE }, AtofTest{ "-1e310", "-Inf", os.ERANGE },
Test{ "1e400", "+Inf", os.ERANGE }, AtofTest{ "1e400", "+Inf", os.ERANGE },
Test{ "-1e400", "-Inf", os.ERANGE }, AtofTest{ "-1e400", "-Inf", os.ERANGE },
Test{ "1e400000", "+Inf", os.ERANGE }, AtofTest{ "1e400000", "+Inf", os.ERANGE },
Test{ "-1e400000", "-Inf", os.ERANGE }, AtofTest{ "-1e400000", "-Inf", os.ERANGE },
// denormalized // denormalized
Test{ "1e-305", "1e-305", nil }, AtofTest{ "1e-305", "1e-305", nil },
Test{ "1e-306", "1e-306", nil }, AtofTest{ "1e-306", "1e-306", nil },
Test{ "1e-307", "1e-307", nil }, AtofTest{ "1e-307", "1e-307", nil },
Test{ "1e-308", "1e-308", nil }, AtofTest{ "1e-308", "1e-308", nil },
Test{ "1e-309", "1e-309", nil }, AtofTest{ "1e-309", "1e-309", nil },
Test{ "1e-310", "1e-310", nil }, AtofTest{ "1e-310", "1e-310", nil },
Test{ "1e-322", "1e-322", nil }, AtofTest{ "1e-322", "1e-322", nil },
// smallest denormal // smallest denormal
Test{ "5e-324", "5e-324", nil }, AtofTest{ "5e-324", "5e-324", nil },
// too small // too small
Test{ "4e-324", "0", nil }, AtofTest{ "4e-324", "0", nil },
// way too small // way too small
Test{ "1e-350", "0", nil }, AtofTest{ "1e-350", "0", nil },
Test{ "1e-400000", "0", nil }, AtofTest{ "1e-400000", "0", nil },
// try to overflow exponent // try to overflow exponent
Test{ "1e-4294967296", "0", nil }, AtofTest{ "1e-4294967296", "0", nil },
Test{ "1e+4294967296", "+Inf", os.ERANGE }, AtofTest{ "1e+4294967296", "+Inf", os.ERANGE },
Test{ "1e-18446744073709551616", "0", nil }, AtofTest{ "1e-18446744073709551616", "0", nil },
Test{ "1e+18446744073709551616", "+Inf", os.ERANGE }, AtofTest{ "1e+18446744073709551616", "+Inf", os.ERANGE },
// Parse errors // Parse errors
Test{ "1e", "0", os.EINVAL }, AtofTest{ "1e", "0", os.EINVAL },
Test{ "1e-", "0", os.EINVAL }, AtofTest{ "1e-", "0", os.EINVAL },
Test{ ".e-1", "0", os.EINVAL }, AtofTest{ ".e-1", "0", os.EINVAL },
} }
func XTestAtof(t *testing.T, opt bool) { func XTestAtof(t *testing.T, opt bool) {
oldopt := strconv.optimize; oldopt := strconv.optimize;
strconv.optimize = opt; strconv.optimize = opt;
for i := 0; i < len(tests); i++ { for i := 0; i < len(atoftests); i++ {
test := &tests[i]; test := &atoftests[i];
out, err := strconv.atof64(test.in); out, err := strconv.atof64(test.in);
outs := strconv.ftoa64(out, 'g', -1); outs := strconv.ftoa64(out, 'g', -1);
if outs != test.out || err != test.err { if outs != test.out || err != test.err {
@ -112,7 +112,7 @@ func XTestAtof(t *testing.T, opt bool) {
} }
} }
if floatsize == 64 || float64(float32(out)) == out { if FloatSize == 64 || float64(float32(out)) == out {
outf, err := strconv.atof(test.in); outf, err := strconv.atof(test.in);
outs := strconv.ftoa(outf, 'g', -1); outs := strconv.ftoa(outf, 'g', -1);
if outs != test.out || err != test.err { if outs != test.out || err != test.err {

154
src/lib/strconv/atoi_test.go
View file

@ -10,102 +10,102 @@ import (
"testing" "testing"
) )
type Uint64Test struct { type Atoui64Test struct {
in string; in string;
out uint64; out uint64;
err *os.Error; err *os.Error;
} }
var uint64tests = []Uint64Test { var atoui64tests = []Atoui64Test {
Uint64Test{ "", 0, os.EINVAL }, Atoui64Test{ "", 0, os.EINVAL },
Uint64Test{ "0", 0, nil }, Atoui64Test{ "0", 0, nil },
Uint64Test{ "1", 1, nil }, Atoui64Test{ "1", 1, nil },
Uint64Test{ "12345", 12345, nil }, Atoui64Test{ "12345", 12345, nil },
Uint64Test{ "012345", 0, os.EINVAL }, Atoui64Test{ "012345", 0, os.EINVAL },
Uint64Test{ "12345x", 0, os.EINVAL }, Atoui64Test{ "12345x", 0, os.EINVAL },
Uint64Test{ "98765432100", 98765432100, nil }, Atoui64Test{ "98765432100", 98765432100, nil },
Uint64Test{ "18446744073709551615", 1<<64-1, nil }, Atoui64Test{ "18446744073709551615", 1<<64-1, nil },
Uint64Test{ "18446744073709551616", 1<<64-1, os.ERANGE }, Atoui64Test{ "18446744073709551616", 1<<64-1, os.ERANGE },
Uint64Test{ "18446744073709551620", 1<<64-1, os.ERANGE }, Atoui64Test{ "18446744073709551620", 1<<64-1, os.ERANGE },
} }
type Int64Test struct { type Atoi64Test struct {
in string; in string;
out int64; out int64;
err *os.Error; err *os.Error;
} }
var int64tests = []Int64Test { var atoi64test = []Atoi64Test {
Int64Test{ "", 0, os.EINVAL }, Atoi64Test{ "", 0, os.EINVAL },
Int64Test{ "0", 0, nil }, Atoi64Test{ "0", 0, nil },
Int64Test{ "-0", 0, nil }, Atoi64Test{ "-0", 0, nil },
Int64Test{ "1", 1, nil }, Atoi64Test{ "1", 1, nil },
Int64Test{ "-1", -1, nil }, Atoi64Test{ "-1", -1, nil },
Int64Test{ "12345", 12345, nil }, Atoi64Test{ "12345", 12345, nil },
Int64Test{ "-12345", -12345, nil }, Atoi64Test{ "-12345", -12345, nil },
Int64Test{ "012345", 0, os.EINVAL }, Atoi64Test{ "012345", 0, os.EINVAL },
Int64Test{ "-012345", 0, os.EINVAL }, Atoi64Test{ "-012345", 0, os.EINVAL },
Int64Test{ "12345x", 0, os.EINVAL }, Atoi64Test{ "12345x", 0, os.EINVAL },
Int64Test{ "-12345x", 0, os.EINVAL }, Atoi64Test{ "-12345x", 0, os.EINVAL },
Int64Test{ "98765432100", 98765432100, nil }, Atoi64Test{ "98765432100", 98765432100, nil },
Int64Test{ "-98765432100", -98765432100, nil }, Atoi64Test{ "-98765432100", -98765432100, nil },
Int64Test{ "9223372036854775807", 1<<63-1, nil }, Atoi64Test{ "9223372036854775807", 1<<63-1, nil },
Int64Test{ "-9223372036854775807", -(1<<63-1), nil }, Atoi64Test{ "-9223372036854775807", -(1<<63-1), nil },
Int64Test{ "9223372036854775808", 1<<63-1, os.ERANGE }, Atoi64Test{ "9223372036854775808", 1<<63-1, os.ERANGE },
Int64Test{ "-9223372036854775808", -1<<63, nil }, Atoi64Test{ "-9223372036854775808", -1<<63, nil },
Int64Test{ "9223372036854775809", 1<<63-1, os.ERANGE }, Atoi64Test{ "9223372036854775809", 1<<63-1, os.ERANGE },
Int64Test{ "-9223372036854775809", -1<<63, os.ERANGE }, Atoi64Test{ "-9223372036854775809", -1<<63, os.ERANGE },
} }
type Uint32Test struct { type Atoui32Test struct {
in string; in string;
out uint32; out uint32;
err *os.Error; err *os.Error;
} }
var uint32tests = []Uint32Test { var atoui32tests = []Atoui32Test {
Uint32Test{ "", 0, os.EINVAL }, Atoui32Test{ "", 0, os.EINVAL },
Uint32Test{ "0", 0, nil }, Atoui32Test{ "0", 0, nil },
Uint32Test{ "1", 1, nil }, Atoui32Test{ "1", 1, nil },
Uint32Test{ "12345", 12345, nil }, Atoui32Test{ "12345", 12345, nil },
Uint32Test{ "012345", 0, os.EINVAL }, Atoui32Test{ "012345", 0, os.EINVAL },
Uint32Test{ "12345x", 0, os.EINVAL }, Atoui32Test{ "12345x", 0, os.EINVAL },
Uint32Test{ "987654321", 987654321, nil }, Atoui32Test{ "987654321", 987654321, nil },
Uint32Test{ "4294967295", 1<<32-1, nil }, Atoui32Test{ "4294967295", 1<<32-1, nil },
Uint32Test{ "4294967296", 1<<32-1, os.ERANGE }, Atoui32Test{ "4294967296", 1<<32-1, os.ERANGE },
} }
type Int32Test struct { type Atoi32Test struct {
in string; in string;
out int32; out int32;
err *os.Error; err *os.Error;
} }
var int32tests = []Int32Test { var atoi32tests = []Atoi32Test {
Int32Test{ "", 0, os.EINVAL }, Atoi32Test{ "", 0, os.EINVAL },
Int32Test{ "0", 0, nil }, Atoi32Test{ "0", 0, nil },
Int32Test{ "-0", 0, nil }, Atoi32Test{ "-0", 0, nil },
Int32Test{ "1", 1, nil }, Atoi32Test{ "1", 1, nil },
Int32Test{ "-1", -1, nil }, Atoi32Test{ "-1", -1, nil },
Int32Test{ "12345", 12345, nil }, Atoi32Test{ "12345", 12345, nil },
Int32Test{ "-12345", -12345, nil }, Atoi32Test{ "-12345", -12345, nil },
Int32Test{ "012345", 0, os.EINVAL }, Atoi32Test{ "012345", 0, os.EINVAL },
Int32Test{ "-012345", 0, os.EINVAL }, Atoi32Test{ "-012345", 0, os.EINVAL },
Int32Test{ "12345x", 0, os.EINVAL }, Atoi32Test{ "12345x", 0, os.EINVAL },
Int32Test{ "-12345x", 0, os.EINVAL }, Atoi32Test{ "-12345x", 0, os.EINVAL },
Int32Test{ "987654321", 987654321, nil }, Atoi32Test{ "987654321", 987654321, nil },
Int32Test{ "-987654321", -987654321, nil }, Atoi32Test{ "-987654321", -987654321, nil },
Int32Test{ "2147483647", 1<<31-1, nil }, Atoi32Test{ "2147483647", 1<<31-1, nil },
Int32Test{ "-2147483647", -(1<<31-1), nil }, Atoi32Test{ "-2147483647", -(1<<31-1), nil },
Int32Test{ "2147483648", 1<<31-1, os.ERANGE }, Atoi32Test{ "2147483648", 1<<31-1, os.ERANGE },
Int32Test{ "-2147483648", -1<<31, nil }, Atoi32Test{ "-2147483648", -1<<31, nil },
Int32Test{ "2147483649", 1<<31-1, os.ERANGE }, Atoi32Test{ "2147483649", 1<<31-1, os.ERANGE },
Int32Test{ "-2147483649", -1<<31, os.ERANGE }, Atoi32Test{ "-2147483649", -1<<31, os.ERANGE },
} }
export func TestAtoui64(t *testing.T) { export func TestAtoui64(t *testing.T) {
for i := 0; i < len(uint64tests); i++ { for i := 0; i < len(atoui64tests); i++ {
test := &uint64tests[i]; test := &atoui64tests[i];
out, err := strconv.atoui64(test.in); out, err := strconv.atoui64(test.in);
if test.out != out || test.err != err { if test.out != out || test.err != err {
t.Errorf("strconv.atoui64(%v) = %v, %v want %v, %v\n", t.Errorf("strconv.atoui64(%v) = %v, %v want %v, %v\n",
@ -115,8 +115,8 @@ export func TestAtoui64(t *testing.T) {
} }
export func TestAtoi64(t *testing.T) { export func TestAtoi64(t *testing.T) {
for i := 0; i < len(int64tests); i++ { for i := 0; i < len(atoi64test); i++ {
test := &int64tests[i]; test := &atoi64test[i];
out, err := strconv.atoi64(test.in); out, err := strconv.atoi64(test.in);
if test.out != out || test.err != err { if test.out != out || test.err != err {
t.Errorf("strconv.atoi64(%v) = %v, %v want %v, %v\n", t.Errorf("strconv.atoi64(%v) = %v, %v want %v, %v\n",
@ -136,8 +136,8 @@ func IntSize1() uint {
export func TestAtoui(t *testing.T) { export func TestAtoui(t *testing.T) {
switch IntSize1() { switch IntSize1() {
case 32: case 32:
for i := 0; i < len(uint32tests); i++ { for i := 0; i < len(atoui32tests); i++ {
test := &uint32tests[i]; test := &atoui32tests[i];
out, err := strconv.atoui(test.in); out, err := strconv.atoui(test.in);
if test.out != uint32(out) || test.err != err { if test.out != uint32(out) || test.err != err {
t.Errorf("strconv.atoui(%v) = %v, %v want %v, %v\n", t.Errorf("strconv.atoui(%v) = %v, %v want %v, %v\n",
@ -145,8 +145,8 @@ export func TestAtoui(t *testing.T) {
} }
} }
case 64: case 64:
for i := 0; i < len(uint64tests); i++ { for i := 0; i < len(atoui64tests); i++ {
test := &uint64tests[i]; test := &atoui64tests[i];
out, err := strconv.atoui(test.in); out, err := strconv.atoui(test.in);
if test.out != uint64(out) || test.err != err { if test.out != uint64(out) || test.err != err {
t.Errorf("strconv.atoui(%v) = %v, %v want %v, %v\n", t.Errorf("strconv.atoui(%v) = %v, %v want %v, %v\n",
@ -159,8 +159,8 @@ export func TestAtoui(t *testing.T) {
export func TestAtoi(t *testing.T) { export func TestAtoi(t *testing.T) {
switch IntSize1() { switch IntSize1() {
case 32: case 32:
for i := 0; i < len(int32tests); i++ { for i := 0; i < len(atoi32tests); i++ {
test := &int32tests[i]; test := &atoi32tests[i];
out, err := strconv.atoi(test.in); out, err := strconv.atoi(test.in);
if test.out != int32(out) || test.err != err { if test.out != int32(out) || test.err != err {
t.Errorf("strconv.atoi(%v) = %v, %v want %v, %v\n", t.Errorf("strconv.atoi(%v) = %v, %v want %v, %v\n",
@ -168,8 +168,8 @@ export func TestAtoi(t *testing.T) {
} }
} }
case 64: case 64:
for i := 0; i < len(int64tests); i++ { for i := 0; i < len(atoi64test); i++ {
test := &int64tests[i]; test := &atoi64test[i];
out, err := strconv.atoi(test.in); out, err := strconv.atoi(test.in);
if test.out != int64(out) || test.err != err { if test.out != int64(out) || test.err != err {
t.Errorf("strconv.atoi(%v) = %v, %v want %v, %v\n", t.Errorf("strconv.atoi(%v) = %v, %v want %v, %v\n",

6
src/lib/strconv/ftoa.go
View file

@ -28,7 +28,7 @@ func GenericFtoa(bits uint64, fmt byte, prec int, flt *FloatInfo) string
func Max(a, b int) int func Max(a, b int) int
func RoundShortest(d *Decimal, mant uint64, exp int, flt *FloatInfo) func RoundShortest(d *Decimal, mant uint64, exp int, flt *FloatInfo)
func FloatSize() int { func floatsize() int {
// Figure out whether float is float32 or float64. // Figure out whether float is float32 or float64.
// 1e-35 is representable in both, but 1e-70 // 1e-35 is representable in both, but 1e-70
// is too small for a float32. // is too small for a float32.
@ -38,7 +38,7 @@ func FloatSize() int {
} }
return 64; return 64;
} }
export var floatsize = FloatSize() export var FloatSize = floatsize()
export func ftoa32(f float32, fmt byte, prec int) string { export func ftoa32(f float32, fmt byte, prec int) string {
return GenericFtoa(uint64(sys.float32bits(f)), fmt, prec, &float32info); return GenericFtoa(uint64(sys.float32bits(f)), fmt, prec, &float32info);
@ -49,7 +49,7 @@ export func ftoa64(f float64, fmt byte, prec int) string {
} }
export func ftoa(f float, fmt byte, prec int) string { export func ftoa(f float, fmt byte, prec int) string {
if floatsize == 32 { if FloatSize == 32 {
return ftoa32(float32(f), fmt, prec); return ftoa32(float32(f), fmt, prec);
} }
return ftoa64(float64(f), fmt, prec); return ftoa64(float64(f), fmt, prec);

125
src/lib/strconv/ftoa_test.go
View file

@ -9,7 +9,7 @@ import (
"testing" "testing"
) )
type Test struct { type FtoaTest struct {
f float64; f float64;
fmt byte; fmt byte;
prec int; prec int;
@ -23,88 +23,87 @@ const (
Above1e23 = 100000000000000008388608; Above1e23 = 100000000000000008388608;
) )
// TODO: Should be able to call this tests but it conflicts with testatof.go var ftoatests = []FtoaTest {
var ftests = []Test { FtoaTest{ 1, 'e', 5, "1.00000e+00" },
Test{ 1, 'e', 5, "1.00000e+00" }, FtoaTest{ 1, 'f', 5, "1.00000" },
Test{ 1, 'f', 5, "1.00000" }, FtoaTest{ 1, 'g', 5, "1" },
Test{ 1, 'g', 5, "1" }, FtoaTest{ 1, 'g', -1, "1" },
Test{ 1, 'g', -1, "1" }, FtoaTest{ 20, 'g', -1, "20" },
Test{ 20, 'g', -1, "20" }, FtoaTest{ 1234567.8, 'g', -1, "1.2345678e+06" },
Test{ 1234567.8, 'g', -1, "1.2345678e+06" }, FtoaTest{ 200000, 'g', -1, "200000" },
Test{ 200000, 'g', -1, "200000" }, FtoaTest{ 2000000, 'g', -1, "2e+06" },
Test{ 2000000, 'g', -1, "2e+06" },
Test{ 0, 'e', 5, "0.00000e+00" }, FtoaTest{ 0, 'e', 5, "0.00000e+00" },
Test{ 0, 'f', 5, "0.00000" }, FtoaTest{ 0, 'f', 5, "0.00000" },
Test{ 0, 'g', 5, "0" }, FtoaTest{ 0, 'g', 5, "0" },
Test{ 0, 'g', -1, "0" }, FtoaTest{ 0, 'g', -1, "0" },
Test{ -1, 'e', 5, "-1.00000e+00" }, FtoaTest{ -1, 'e', 5, "-1.00000e+00" },
Test{ -1, 'f', 5, "-1.00000" }, FtoaTest{ -1, 'f', 5, "-1.00000" },
Test{ -1, 'g', 5, "-1" }, FtoaTest{ -1, 'g', 5, "-1" },
Test{ -1, 'g', -1, "-1" }, FtoaTest{ -1, 'g', -1, "-1" },
Test{ 12, 'e', 5, "1.20000e+01" }, FtoaTest{ 12, 'e', 5, "1.20000e+01" },
Test{ 12, 'f', 5, "12.00000" }, FtoaTest{ 12, 'f', 5, "12.00000" },
Test{ 12, 'g', 5, "12" }, FtoaTest{ 12, 'g', 5, "12" },
Test{ 12, 'g', -1, "12" }, FtoaTest{ 12, 'g', -1, "12" },
Test{ 123456700, 'e', 5, "1.23457e+08" }, FtoaTest{ 123456700, 'e', 5, "1.23457e+08" },
Test{ 123456700, 'f', 5, "123456700.00000" }, FtoaTest{ 123456700, 'f', 5, "123456700.00000" },
Test{ 123456700, 'g', 5, "1.2346e+08" }, FtoaTest{ 123456700, 'g', 5, "1.2346e+08" },
Test{ 123456700, 'g', -1, "1.234567e+08" }, FtoaTest{ 123456700, 'g', -1, "1.234567e+08" },
Test{ 1.2345e6, 'e', 5, "1.23450e+06" }, FtoaTest{ 1.2345e6, 'e', 5, "1.23450e+06" },
Test{ 1.2345e6, 'f', 5, "1234500.00000" }, FtoaTest{ 1.2345e6, 'f', 5, "1234500.00000" },
Test{ 1.2345e6, 'g', 5, "1.2345e+06" }, FtoaTest{ 1.2345e6, 'g', 5, "1.2345e+06" },
Test{ 1e23, 'e', 17, "9.99999999999999916e+22" }, FtoaTest{ 1e23, 'e', 17, "9.99999999999999916e+22" },
Test{ 1e23, 'f', 17, "99999999999999991611392.00000000000000000" }, FtoaTest{ 1e23, 'f', 17, "99999999999999991611392.00000000000000000" },
Test{ 1e23, 'g', 17, "9.9999999999999992e+22" }, FtoaTest{ 1e23, 'g', 17, "9.9999999999999992e+22" },
Test{ 1e23, 'e', -1, "1e+23" }, FtoaTest{ 1e23, 'e', -1, "1e+23" },
Test{ 1e23, 'f', -1, "100000000000000000000000" }, FtoaTest{ 1e23, 'f', -1, "100000000000000000000000" },
Test{ 1e23, 'g', -1, "1e+23" }, FtoaTest{ 1e23, 'g', -1, "1e+23" },
Test{ Below1e23, 'e', 17, "9.99999999999999748e+22" }, FtoaTest{ Below1e23, 'e', 17, "9.99999999999999748e+22" },
Test{ Below1e23, 'f', 17, "99999999999999974834176.00000000000000000" }, FtoaTest{ Below1e23, 'f', 17, "99999999999999974834176.00000000000000000" },
Test{ Below1e23, 'g', 17, "9.9999999999999975e+22" }, FtoaTest{ Below1e23, 'g', 17, "9.9999999999999975e+22" },
Test{ Below1e23, 'e', -1, "9.999999999999997e+22" }, FtoaTest{ Below1e23, 'e', -1, "9.999999999999997e+22" },
Test{ Below1e23, 'f', -1, "99999999999999970000000" }, FtoaTest{ Below1e23, 'f', -1, "99999999999999970000000" },
Test{ Below1e23, 'g', -1, "9.999999999999997e+22" }, FtoaTest{ Below1e23, 'g', -1, "9.999999999999997e+22" },
Test{ Above1e23, 'e', 17, "1.00000000000000008e+23" }, FtoaTest{ Above1e23, 'e', 17, "1.00000000000000008e+23" },
Test{ Above1e23, 'f', 17, "100000000000000008388608.00000000000000000" }, FtoaTest{ Above1e23, 'f', 17, "100000000000000008388608.00000000000000000" },
Test{ Above1e23, 'g', 17, "1.0000000000000001e+23" }, FtoaTest{ Above1e23, 'g', 17, "1.0000000000000001e+23" },
Test{ Above1e23, 'e', -1, "1.0000000000000001e+23" }, FtoaTest{ Above1e23, 'e', -1, "1.0000000000000001e+23" },
Test{ Above1e23, 'f', -1, "100000000000000010000000" }, FtoaTest{ Above1e23, 'f', -1, "100000000000000010000000" },
Test{ Above1e23, 'g', -1, "1.0000000000000001e+23" }, FtoaTest{ Above1e23, 'g', -1, "1.0000000000000001e+23" },
Test{ fdiv(5e-304, 1e20), 'g', -1, "5e-324" }, FtoaTest{ fdiv(5e-304, 1e20), 'g', -1, "5e-324" },
Test{ fdiv(-5e-304, 1e20), 'g', -1, "-5e-324" }, FtoaTest{ fdiv(-5e-304, 1e20), 'g', -1, "-5e-324" },
Test{ 32, 'g', -1, "32" }, FtoaTest{ 32, 'g', -1, "32" },
Test{ 32, 'g', 0, "3e+01" }, FtoaTest{ 32, 'g', 0, "3e+01" },
Test{ 100, 'x', -1, "%x" }, FtoaTest{ 100, 'x', -1, "%x" },
Test{ sys.NaN(), 'g', -1, "NaN" }, FtoaTest{ sys.NaN(), 'g', -1, "NaN" },
Test{ -sys.NaN(), 'g', -1, "NaN" }, FtoaTest{ -sys.NaN(), 'g', -1, "NaN" },
Test{ sys.Inf(0), 'g', -1, "+Inf" }, FtoaTest{ sys.Inf(0), 'g', -1, "+Inf" },
Test{ sys.Inf(-1), 'g', -1, "-Inf" }, FtoaTest{ sys.Inf(-1), 'g', -1, "-Inf" },
Test{ -sys.Inf(0), 'g', -1, "-Inf" }, FtoaTest{ -sys.Inf(0), 'g', -1, "-Inf" },
Test{ -1, 'b', -1, "-4503599627370496p-52" }, FtoaTest{ -1, 'b', -1, "-4503599627370496p-52" },
} }
export func TestFtoa(t *testing.T) { export func TestFtoa(t *testing.T) {
if strconv.floatsize != 32 { if strconv.FloatSize != 32 {
panic("floatsize: ", strconv.floatsize); panic("floatsize: ", strconv.FloatSize);
} }
for i := 0; i < len(ftests); i++ { for i := 0; i < len(ftoatests); i++ {
test := &ftests[i]; test := &ftoatests[i];
s := strconv.ftoa64(test.f, test.fmt, test.prec); s := strconv.ftoa64(test.f, test.fmt, test.prec);
if s != test.s { if s != test.s {
t.Error("test", test.f, string(test.fmt), test.prec, "want", test.s, "got", s); t.Error("test", test.f, string(test.fmt), test.prec, "want", test.s, "got", s);

68
src/lib/strconv/itoa_test.go
View file

@ -11,40 +11,38 @@ import (
"testing"; "testing";
) )
type Int64Test struct { type Itoa64Test struct {
in int64; in int64;
out string; out string;
} }
// TODO: should be called int64tests var itoa64tests = []Itoa64Test {
Itoa64Test{ 0, "0" },
var xint64tests = []Int64Test { Itoa64Test{ 1, "1" },
Int64Test{ 0, "0" }, Itoa64Test{ -1, "-1" },
Int64Test{ 1, "1" }, Itoa64Test{ 12345678, "12345678" },
Int64Test{ -1, "-1" }, Itoa64Test{ -987654321, "-987654321" },
Int64Test{ 12345678, "12345678" }, Itoa64Test{ 1<<31-1, "2147483647" },
Int64Test{ -987654321, "-987654321" }, Itoa64Test{ -1<<31+1, "-2147483647" },
Int64Test{ 1<<31-1, "2147483647" }, Itoa64Test{ 1<<31, "2147483648" },
Int64Test{ -1<<31+1, "-2147483647" }, Itoa64Test{ -1<<31, "-2147483648" },
Int64Test{ 1<<31, "2147483648" }, Itoa64Test{ 1<<31+1, "2147483649" },
Int64Test{ -1<<31, "-2147483648" }, Itoa64Test{ -1<<31-1, "-2147483649" },
Int64Test{ 1<<31+1, "2147483649" }, Itoa64Test{ 1<<32-1, "4294967295" },
Int64Test{ -1<<31-1, "-2147483649" }, Itoa64Test{ -1<<32+1, "-4294967295" },
Int64Test{ 1<<32-1, "4294967295" }, Itoa64Test{ 1<<32, "4294967296" },
Int64Test{ -1<<32+1, "-4294967295" }, Itoa64Test{ -1<<32, "-4294967296" },
Int64Test{ 1<<32, "4294967296" }, Itoa64Test{ 1<<32+1, "4294967297" },
Int64Test{ -1<<32, "-4294967296" }, Itoa64Test{ -1<<32-1, "-4294967297" },
Int64Test{ 1<<32+1, "4294967297" }, Itoa64Test{ 1<<50, "1125899906842624" },
Int64Test{ -1<<32-1, "-4294967297" }, Itoa64Test{ 1<<63-1, "9223372036854775807" },
Int64Test{ 1<<50, "1125899906842624" }, Itoa64Test{ -1<<63+1, "-9223372036854775807" },
Int64Test{ 1<<63-1, "9223372036854775807" }, Itoa64Test{ -1<<63, "-9223372036854775808" },
Int64Test{ -1<<63+1, "-9223372036854775807" },
Int64Test{ -1<<63, "-9223372036854775808" },
} }
export func TestItoa(t *testing.T) { export func TestItoa(t *testing.T) {
for i := 0; i < len(xint64tests); i++ { for i := 0; i < len(itoa64tests); i++ {
test := xint64tests[i]; test := itoa64tests[i];
s := strconv.itoa64(test.in); s := strconv.itoa64(test.in);
if s != test.out { if s != test.out {
t.Error("strconv.itoa64(%v) = %v want %v\n", t.Error("strconv.itoa64(%v) = %v want %v\n",
@ -61,17 +59,17 @@ export func TestItoa(t *testing.T) {
} }
// TODO: Use once there is a strconv.uitoa // TODO: Use once there is a strconv.uitoa
type Uint64Test struct { type Uitoa64Test struct {
in uint64; in uint64;
out string; out string;
} }
// TODO: should be able to call this uint64tests. // TODO: should be able to call this atoui64tests.
var xuint64tests = []Uint64Test { var uitoa64tests = []Uitoa64Test {
Uint64Test{ 1<<63-1, "9223372036854775807" }, Uitoa64Test{ 1<<63-1, "9223372036854775807" },
Uint64Test{ 1<<63, "9223372036854775808" }, Uitoa64Test{ 1<<63, "9223372036854775808" },
Uint64Test{ 1<<63+1, "9223372036854775809" }, Uitoa64Test{ 1<<63+1, "9223372036854775809" },
Uint64Test{ 1<<64-2, "18446744073709551614" }, Uitoa64Test{ 1<<64-2, "18446744073709551614" },
Uint64Test{ 1<<64-1, "18446744073709551615" }, Uitoa64Test{ 1<<64-1, "18446744073709551615" },
} }

13
src/lib/strconv/quote.go
View file

@ -8,8 +8,7 @@ import (
"utf8"; "utf8";
) )
const ldigits = "0123456789abcdef" const lowerhex = "0123456789abcdef"
const udigits = "0123456789ABCDEF"
export func Quote(s string) string { export func Quote(s string) string {
t := `"`; t := `"`;
@ -37,7 +36,7 @@ export func Quote(s string) string {
t += `\v`; t += `\v`;
case s[i] < utf8.RuneSelf: case s[i] < utf8.RuneSelf:
t += `\x` + string(ldigits[s[i]>>4]) + string(ldigits[s[i]&0xF]); t += `\x` + string(lowerhex[s[i]>>4]) + string(lowerhex[s[i]&0xF]);
case utf8.FullRuneInString(s, i): case utf8.FullRuneInString(s, i):
r, size := utf8.DecodeRuneInString(s, i); r, size := utf8.DecodeRuneInString(s, i);
@ -48,20 +47,20 @@ export func Quote(s string) string {
if r < 0x10000 { if r < 0x10000 {
t += `\u`; t += `\u`;
for j:=uint(0); j<4; j++ { for j:=uint(0); j<4; j++ {
t += string(ldigits[(r>>(12-4*j))&0xF]); t += string(lowerhex[(r>>(12-4*j))&0xF]);
} }
} else { } else {
t += `\U`; t += `\U`;
for j:=uint(0); j<8; j++ { for j:=uint(0); j<8; j++ {
t += string(ldigits[(r>>(28-4*j))&0xF]); t += string(lowerhex[(r>>(28-4*j))&0xF]);
} }
} }
default: default:
EscX: EscX:
t += `\x`; t += `\x`;
t += string(ldigits[s[i]>>4]); t += string(lowerhex[s[i]>>4]);
t += string(ldigits[s[i]&0xF]); t += string(lowerhex[s[i]&0xF]);
} }
} }
t += `"`; t += `"`;