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

runtime: use internal/strconv

Browse source 
Runtime doing its own number formatting dates back to
when runtime was the bottom-most Go package.
Those days are long gone. Use internal/strconv to avoid
duplicating code and also to get better floating-point
formatting:

% go1.24.6 run x.go
+1.234568e+004
% go run x.go
12345.678
%

With accurate floating point it becomes necessary to
introduce separate printers for float32 vs float64 and
for complex64 vs complex128. Otherwise float32(93.7)
prints as 93.69999694824219.

Change-Id: I25ae3f09519342dc3d1dcabf4711651423e00128
Reviewed-on: https://go-review.googlesource.com/c/go/+/716002
Reviewed-by: David Chase <drchase@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
This commit is contained in:
Russ Cox 2025-10-28 22:00:26 -04:00
parent 49c1da474d
commit 9035f7aea5
16 changed files with 381 additions and 423 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/cmd/compile/internal/typecheck/_builtin/runtime.go
View file

@ -49,11 +49,13 @@ func goPanicSlice3CU(x uint, y int)
func goPanicSliceConvert(x int, y int) func goPanicSliceConvert(x int, y int)
func printbool(bool) func printbool(bool)
func printfloat(float64) func printfloat64(float64)
func printfloat32(float32)
func printint(int64) func printint(int64)
func printhex(uint64) func printhex(uint64)
func printuint(uint64) func printuint(uint64)
func printcomplex(complex128) func printcomplex128(complex128)
func printcomplex64(complex64)
func printstring(string) func printstring(string)
func printpointer(any) func printpointer(any)
func printuintptr(uintptr) func printuintptr(uintptr)

607
src/cmd/compile/internal/typecheck/builtin.go
View file

@ -56,182 +56,184 @@ var runtimeDecls = [...]struct {
{"goPanicSlice3CU", funcTag, 16}, {"goPanicSlice3CU", funcTag, 16},
{"goPanicSliceConvert", funcTag, 14}, {"goPanicSliceConvert", funcTag, 14},
{"printbool", funcTag, 17}, {"printbool", funcTag, 17},
{"printfloat", funcTag, 19}, {"printfloat64", funcTag, 19},
{"printint", funcTag, 21}, {"printfloat32", funcTag, 21},
{"printhex", funcTag, 23}, {"printint", funcTag, 23},
{"printuint", funcTag, 23}, {"printhex", funcTag, 25},
{"printcomplex", funcTag, 25}, {"printuint", funcTag, 25},
{"printstring", funcTag, 27}, {"printcomplex128", funcTag, 27},
{"printpointer", funcTag, 28}, {"printcomplex64", funcTag, 29},
{"printuintptr", funcTag, 29}, {"printstring", funcTag, 31},
{"printiface", funcTag, 28}, {"printpointer", funcTag, 32},
{"printeface", funcTag, 28}, {"printuintptr", funcTag, 33},
{"printslice", funcTag, 28}, {"printiface", funcTag, 32},
{"printeface", funcTag, 32},
{"printslice", funcTag, 32},
{"printnl", funcTag, 9}, {"printnl", funcTag, 9},
{"printsp", funcTag, 9}, {"printsp", funcTag, 9},
{"printlock", funcTag, 9}, {"printlock", funcTag, 9},
{"printunlock", funcTag, 9}, {"printunlock", funcTag, 9},
{"concatstring2", funcTag, 32}, {"concatstring2", funcTag, 36},
{"concatstring3", funcTag, 33}, {"concatstring3", funcTag, 37},
{"concatstring4", funcTag, 34}, {"concatstring4", funcTag, 38},
{"concatstring5", funcTag, 35}, {"concatstring5", funcTag, 39},
{"concatstrings", funcTag, 37}, {"concatstrings", funcTag, 41},
{"concatbyte2", funcTag, 39}, {"concatbyte2", funcTag, 43},
{"concatbyte3", funcTag, 40}, {"concatbyte3", funcTag, 44},
{"concatbyte4", funcTag, 41}, {"concatbyte4", funcTag, 45},
{"concatbyte5", funcTag, 42}, {"concatbyte5", funcTag, 46},
{"concatbytes", funcTag, 43}, {"concatbytes", funcTag, 47},
{"cmpstring", funcTag, 44}, {"cmpstring", funcTag, 48},
{"intstring", funcTag, 47}, {"intstring", funcTag, 51},
{"slicebytetostring", funcTag, 48}, {"slicebytetostring", funcTag, 52},
{"slicebytetostringtmp", funcTag, 49}, {"slicebytetostringtmp", funcTag, 53},
{"slicerunetostring", funcTag, 52}, {"slicerunetostring", funcTag, 56},
{"stringtoslicebyte", funcTag, 53}, {"stringtoslicebyte", funcTag, 57},
{"stringtoslicerune", funcTag, 56}, {"stringtoslicerune", funcTag, 60},
{"slicecopy", funcTag, 57}, {"slicecopy", funcTag, 61},
{"decoderune", funcTag, 58}, {"decoderune", funcTag, 62},
{"countrunes", funcTag, 59}, {"countrunes", funcTag, 63},
{"convT", funcTag, 60}, {"convT", funcTag, 64},
{"convTnoptr", funcTag, 60}, {"convTnoptr", funcTag, 64},
{"convT16", funcTag, 62}, {"convT16", funcTag, 66},
{"convT32", funcTag, 64}, {"convT32", funcTag, 68},
{"convT64", funcTag, 65}, {"convT64", funcTag, 69},
{"convTstring", funcTag, 66}, {"convTstring", funcTag, 70},
{"convTslice", funcTag, 69}, {"convTslice", funcTag, 73},
{"assertE2I", funcTag, 70}, {"assertE2I", funcTag, 74},
{"assertE2I2", funcTag, 70}, {"assertE2I2", funcTag, 74},
{"panicdottypeE", funcTag, 71}, {"panicdottypeE", funcTag, 75},
{"panicdottypeI", funcTag, 71}, {"panicdottypeI", funcTag, 75},
{"panicnildottype", funcTag, 72}, {"panicnildottype", funcTag, 76},
{"typeAssert", funcTag, 70}, {"typeAssert", funcTag, 74},
{"interfaceSwitch", funcTag, 73}, {"interfaceSwitch", funcTag, 77},
{"ifaceeq", funcTag, 75}, {"ifaceeq", funcTag, 79},
{"efaceeq", funcTag, 75}, {"efaceeq", funcTag, 79},
{"panicrangestate", funcTag, 76}, {"panicrangestate", funcTag, 80},
{"deferrangefunc", funcTag, 12}, {"deferrangefunc", funcTag, 12},
{"rand", funcTag, 77}, {"rand", funcTag, 81},
{"rand32", funcTag, 78}, {"rand32", funcTag, 82},
{"makemap64", funcTag, 80}, {"makemap64", funcTag, 84},
{"makemap", funcTag, 81}, {"makemap", funcTag, 85},
{"makemap_small", funcTag, 82}, {"makemap_small", funcTag, 86},
{"mapaccess1", funcTag, 83}, {"mapaccess1", funcTag, 87},
{"mapaccess1_fast32", funcTag, 84}, {"mapaccess1_fast32", funcTag, 88},
{"mapaccess1_fast64", funcTag, 85}, {"mapaccess1_fast64", funcTag, 89},
{"mapaccess1_faststr", funcTag, 86}, {"mapaccess1_faststr", funcTag, 90},
{"mapaccess1_fat", funcTag, 87}, {"mapaccess1_fat", funcTag, 91},
{"mapaccess2", funcTag, 88}, {"mapaccess2", funcTag, 92},
{"mapaccess2_fast32", funcTag, 89}, {"mapaccess2_fast32", funcTag, 93},
{"mapaccess2_fast64", funcTag, 90}, {"mapaccess2_fast64", funcTag, 94},
{"mapaccess2_faststr", funcTag, 91}, {"mapaccess2_faststr", funcTag, 95},
{"mapaccess2_fat", funcTag, 92}, {"mapaccess2_fat", funcTag, 96},
{"mapassign", funcTag, 83}, {"mapassign", funcTag, 87},
{"mapassign_fast32", funcTag, 84}, {"mapassign_fast32", funcTag, 88},
{"mapassign_fast32ptr", funcTag, 93}, {"mapassign_fast32ptr", funcTag, 97},
{"mapassign_fast64", funcTag, 85}, {"mapassign_fast64", funcTag, 89},
{"mapassign_fast64ptr", funcTag, 93}, {"mapassign_fast64ptr", funcTag, 97},
{"mapassign_faststr", funcTag, 86}, {"mapassign_faststr", funcTag, 90},
{"mapIterStart", funcTag, 94}, {"mapIterStart", funcTag, 98},
{"mapdelete", funcTag, 94}, {"mapdelete", funcTag, 98},
{"mapdelete_fast32", funcTag, 95}, {"mapdelete_fast32", funcTag, 99},
{"mapdelete_fast64", funcTag, 96}, {"mapdelete_fast64", funcTag, 100},
{"mapdelete_faststr", funcTag, 97}, {"mapdelete_faststr", funcTag, 101},
{"mapIterNext", funcTag, 98}, {"mapIterNext", funcTag, 102},
{"mapclear", funcTag, 99}, {"mapclear", funcTag, 103},
{"makechan64", funcTag, 101}, {"makechan64", funcTag, 105},
{"makechan", funcTag, 102}, {"makechan", funcTag, 106},
{"chanrecv1", funcTag, 104}, {"chanrecv1", funcTag, 108},
{"chanrecv2", funcTag, 105}, {"chanrecv2", funcTag, 109},
{"chansend1", funcTag, 107}, {"chansend1", funcTag, 111},
{"closechan", funcTag, 108}, {"closechan", funcTag, 112},
{"chanlen", funcTag, 109}, {"chanlen", funcTag, 113},
{"chancap", funcTag, 109}, {"chancap", funcTag, 113},
{"writeBarrier", varTag, 111}, {"writeBarrier", varTag, 115},
{"typedmemmove", funcTag, 112}, {"typedmemmove", funcTag, 116},
{"typedmemclr", funcTag, 113}, {"typedmemclr", funcTag, 117},
{"typedslicecopy", funcTag, 114}, {"typedslicecopy", funcTag, 118},
{"selectnbsend", funcTag, 115}, {"selectnbsend", funcTag, 119},
{"selectnbrecv", funcTag, 116}, {"selectnbrecv", funcTag, 120},
{"selectsetpc", funcTag, 117}, {"selectsetpc", funcTag, 121},
{"selectgo", funcTag, 118}, {"selectgo", funcTag, 122},
{"block", funcTag, 9}, {"block", funcTag, 9},
{"makeslice", funcTag, 119}, {"makeslice", funcTag, 123},
{"makeslice64", funcTag, 120}, {"makeslice64", funcTag, 124},
{"makeslicecopy", funcTag, 121}, {"makeslicecopy", funcTag, 125},
{"growslice", funcTag, 123}, {"growslice", funcTag, 127},
{"unsafeslicecheckptr", funcTag, 124}, {"unsafeslicecheckptr", funcTag, 128},
{"panicunsafeslicelen", funcTag, 9}, {"panicunsafeslicelen", funcTag, 9},
{"panicunsafeslicenilptr", funcTag, 9}, {"panicunsafeslicenilptr", funcTag, 9},
{"unsafestringcheckptr", funcTag, 125}, {"unsafestringcheckptr", funcTag, 129},
{"panicunsafestringlen", funcTag, 9}, {"panicunsafestringlen", funcTag, 9},
{"panicunsafestringnilptr", funcTag, 9}, {"panicunsafestringnilptr", funcTag, 9},
{"memmove", funcTag, 126}, {"memmove", funcTag, 130},
{"memclrNoHeapPointers", funcTag, 127}, {"memclrNoHeapPointers", funcTag, 131},
{"memclrHasPointers", funcTag, 127}, {"memclrHasPointers", funcTag, 131},
{"memequal", funcTag, 128}, {"memequal", funcTag, 132},
{"memequal0", funcTag, 129}, {"memequal0", funcTag, 133},
{"memequal8", funcTag, 129}, {"memequal8", funcTag, 133},
{"memequal16", funcTag, 129}, {"memequal16", funcTag, 133},
{"memequal32", funcTag, 129}, {"memequal32", funcTag, 133},
{"memequal64", funcTag, 129}, {"memequal64", funcTag, 133},
{"memequal128", funcTag, 129}, {"memequal128", funcTag, 133},
{"f32equal", funcTag, 130}, {"f32equal", funcTag, 134},
{"f64equal", funcTag, 130}, {"f64equal", funcTag, 134},
{"c64equal", funcTag, 130}, {"c64equal", funcTag, 134},
{"c128equal", funcTag, 130}, {"c128equal", funcTag, 134},
{"strequal", funcTag, 130}, {"strequal", funcTag, 134},
{"interequal", funcTag, 130}, {"interequal", funcTag, 134},
{"nilinterequal", funcTag, 130}, {"nilinterequal", funcTag, 134},
{"memhash", funcTag, 131}, {"memhash", funcTag, 135},
{"memhash0", funcTag, 132}, {"memhash0", funcTag, 136},
{"memhash8", funcTag, 132}, {"memhash8", funcTag, 136},
{"memhash16", funcTag, 132}, {"memhash16", funcTag, 136},
{"memhash32", funcTag, 132}, {"memhash32", funcTag, 136},
{"memhash64", funcTag, 132}, {"memhash64", funcTag, 136},
{"memhash128", funcTag, 132}, {"memhash128", funcTag, 136},
{"f32hash", funcTag, 133}, {"f32hash", funcTag, 137},
{"f64hash", funcTag, 133}, {"f64hash", funcTag, 137},
{"c64hash", funcTag, 133}, {"c64hash", funcTag, 137},
{"c128hash", funcTag, 133}, {"c128hash", funcTag, 137},
{"strhash", funcTag, 133}, {"strhash", funcTag, 137},
{"interhash", funcTag, 133}, {"interhash", funcTag, 137},
{"nilinterhash", funcTag, 133}, {"nilinterhash", funcTag, 137},
{"int64div", funcTag, 134}, {"int64div", funcTag, 138},
{"uint64div", funcTag, 135}, {"uint64div", funcTag, 139},
{"int64mod", funcTag, 134}, {"int64mod", funcTag, 138},
{"uint64mod", funcTag, 135}, {"uint64mod", funcTag, 139},
{"float64toint64", funcTag, 136}, {"float64toint64", funcTag, 140},
{"float64touint64", funcTag, 137}, {"float64touint64", funcTag, 141},
{"float64touint32", funcTag, 138}, {"float64touint32", funcTag, 142},
{"int64tofloat64", funcTag, 139}, {"int64tofloat64", funcTag, 143},
{"int64tofloat32", funcTag, 141}, {"int64tofloat32", funcTag, 144},
{"uint64tofloat64", funcTag, 142}, {"uint64tofloat64", funcTag, 145},
{"uint64tofloat32", funcTag, 143}, {"uint64tofloat32", funcTag, 146},
{"uint32tofloat64", funcTag, 144}, {"uint32tofloat64", funcTag, 147},
{"complex128div", funcTag, 145}, {"complex128div", funcTag, 148},
{"racefuncenter", funcTag, 29}, {"racefuncenter", funcTag, 33},
{"racefuncexit", funcTag, 9}, {"racefuncexit", funcTag, 9},
{"raceread", funcTag, 29}, {"raceread", funcTag, 33},
{"racewrite", funcTag, 29}, {"racewrite", funcTag, 33},
{"racereadrange", funcTag, 146}, {"racereadrange", funcTag, 149},
{"racewriterange", funcTag, 146}, {"racewriterange", funcTag, 149},
{"msanread", funcTag, 146}, {"msanread", funcTag, 149},
{"msanwrite", funcTag, 146}, {"msanwrite", funcTag, 149},
{"msanmove", funcTag, 147}, {"msanmove", funcTag, 150},
{"asanread", funcTag, 146}, {"asanread", funcTag, 149},
{"asanwrite", funcTag, 146}, {"asanwrite", funcTag, 149},
{"checkptrAlignment", funcTag, 148}, {"checkptrAlignment", funcTag, 151},
{"checkptrArithmetic", funcTag, 150}, {"checkptrArithmetic", funcTag, 153},
{"libfuzzerTraceCmp1", funcTag, 151}, {"libfuzzerTraceCmp1", funcTag, 154},
{"libfuzzerTraceCmp2", funcTag, 152}, {"libfuzzerTraceCmp2", funcTag, 155},
{"libfuzzerTraceCmp4", funcTag, 153}, {"libfuzzerTraceCmp4", funcTag, 156},
{"libfuzzerTraceCmp8", funcTag, 154}, {"libfuzzerTraceCmp8", funcTag, 157},
{"libfuzzerTraceConstCmp1", funcTag, 151}, {"libfuzzerTraceConstCmp1", funcTag, 154},
{"libfuzzerTraceConstCmp2", funcTag, 152}, {"libfuzzerTraceConstCmp2", funcTag, 155},
{"libfuzzerTraceConstCmp4", funcTag, 153}, {"libfuzzerTraceConstCmp4", funcTag, 156},
{"libfuzzerTraceConstCmp8", funcTag, 154}, {"libfuzzerTraceConstCmp8", funcTag, 157},
{"libfuzzerHookStrCmp", funcTag, 155}, {"libfuzzerHookStrCmp", funcTag, 158},
{"libfuzzerHookEqualFold", funcTag, 155}, {"libfuzzerHookEqualFold", funcTag, 158},
{"addCovMeta", funcTag, 157}, {"addCovMeta", funcTag, 160},
{"x86HasPOPCNT", varTag, 6}, {"x86HasPOPCNT", varTag, 6},
{"x86HasSSE41", varTag, 6}, {"x86HasSSE41", varTag, 6},
{"x86HasFMA", varTag, 6}, {"x86HasFMA", varTag, 6},
@ -241,11 +243,11 @@ var runtimeDecls = [...]struct {
{"loong64HasLAM_BH", varTag, 6}, {"loong64HasLAM_BH", varTag, 6},
{"loong64HasLSX", varTag, 6}, {"loong64HasLSX", varTag, 6},
{"riscv64HasZbb", varTag, 6}, {"riscv64HasZbb", varTag, 6},
{"asanregisterglobals", funcTag, 127}, {"asanregisterglobals", funcTag, 131},
} }
func runtimeTypes() []*types.Type { func runtimeTypes() []*types.Type {
var typs [158]*types.Type var typs [161]*types.Type
typs[0] = types.ByteType typs[0] = types.ByteType
typs[1] = types.NewPtr(typs[0]) typs[1] = types.NewPtr(typs[0])
typs[2] = types.Types[types.TANY] typs[2] = types.Types[types.TANY]
@ -266,144 +268,147 @@ func runtimeTypes() []*types.Type {
typs[17] = newSig(params(typs[6]), nil) typs[17] = newSig(params(typs[6]), nil)
typs[18] = types.Types[types.TFLOAT64] typs[18] = types.Types[types.TFLOAT64]
typs[19] = newSig(params(typs[18]), nil) typs[19] = newSig(params(typs[18]), nil)
typs[20] = types.Types[types.TINT64] typs[20] = types.Types[types.TFLOAT32]
typs[21] = newSig(params(typs[20]), nil) typs[21] = newSig(params(typs[20]), nil)
typs[22] = types.Types[types.TUINT64] typs[22] = types.Types[types.TINT64]
typs[23] = newSig(params(typs[22]), nil) typs[23] = newSig(params(typs[22]), nil)
typs[24] = types.Types[types.TCOMPLEX128] typs[24] = types.Types[types.TUINT64]
typs[25] = newSig(params(typs[24]), nil) typs[25] = newSig(params(typs[24]), nil)
typs[26] = types.Types[types.TSTRING] typs[26] = types.Types[types.TCOMPLEX128]
typs[27] = newSig(params(typs[26]), nil) typs[27] = newSig(params(typs[26]), nil)
typs[28] = newSig(params(typs[2]), nil) typs[28] = types.Types[types.TCOMPLEX64]
typs[29] = newSig(params(typs[5]), nil) typs[29] = newSig(params(typs[28]), nil)
typs[30] = types.NewArray(typs[0], 32) typs[30] = types.Types[types.TSTRING]
typs[31] = types.NewPtr(typs[30]) typs[31] = newSig(params(typs[30]), nil)
typs[32] = newSig(params(typs[31], typs[26], typs[26]), params(typs[26])) typs[32] = newSig(params(typs[2]), nil)
typs[33] = newSig(params(typs[31], typs[26], typs[26], typs[26]), params(typs[26])) typs[33] = newSig(params(typs[5]), nil)
typs[34] = newSig(params(typs[31], typs[26], typs[26], typs[26], typs[26]), params(typs[26])) typs[34] = types.NewArray(typs[0], 32)
typs[35] = newSig(params(typs[31], typs[26], typs[26], typs[26], typs[26], typs[26]), params(typs[26])) typs[35] = types.NewPtr(typs[34])
typs[36] = types.NewSlice(typs[26]) typs[36] = newSig(params(typs[35], typs[30], typs[30]), params(typs[30]))
typs[37] = newSig(params(typs[31], typs[36]), params(typs[26])) typs[37] = newSig(params(typs[35], typs[30], typs[30], typs[30]), params(typs[30]))
typs[38] = types.NewSlice(typs[0]) typs[38] = newSig(params(typs[35], typs[30], typs[30], typs[30], typs[30]), params(typs[30]))
typs[39] = newSig(params(typs[31], typs[26], typs[26]), params(typs[38])) typs[39] = newSig(params(typs[35], typs[30], typs[30], typs[30], typs[30], typs[30]), params(typs[30]))
typs[40] = newSig(params(typs[31], typs[26], typs[26], typs[26]), params(typs[38])) typs[40] = types.NewSlice(typs[30])
typs[41] = newSig(params(typs[31], typs[26], typs[26], typs[26], typs[26]), params(typs[38])) typs[41] = newSig(params(typs[35], typs[40]), params(typs[30]))
typs[42] = newSig(params(typs[31], typs[26], typs[26], typs[26], typs[26], typs[26]), params(typs[38])) typs[42] = types.NewSlice(typs[0])
typs[43] = newSig(params(typs[31], typs[36]), params(typs[38])) typs[43] = newSig(params(typs[35], typs[30], typs[30]), params(typs[42]))
typs[44] = newSig(params(typs[26], typs[26]), params(typs[13])) typs[44] = newSig(params(typs[35], typs[30], typs[30], typs[30]), params(typs[42]))
typs[45] = types.NewArray(typs[0], 4) typs[45] = newSig(params(typs[35], typs[30], typs[30], typs[30], typs[30]), params(typs[42]))
typs[46] = types.NewPtr(typs[45]) typs[46] = newSig(params(typs[35], typs[30], typs[30], typs[30], typs[30], typs[30]), params(typs[42]))
typs[47] = newSig(params(typs[46], typs[20]), params(typs[26])) typs[47] = newSig(params(typs[35], typs[40]), params(typs[42]))
typs[48] = newSig(params(typs[31], typs[1], typs[13]), params(typs[26])) typs[48] = newSig(params(typs[30], typs[30]), params(typs[13]))
typs[49] = newSig(params(typs[1], typs[13]), params(typs[26])) typs[49] = types.NewArray(typs[0], 4)
typs[50] = types.RuneType typs[50] = types.NewPtr(typs[49])
typs[51] = types.NewSlice(typs[50]) typs[51] = newSig(params(typs[50], typs[22]), params(typs[30]))
typs[52] = newSig(params(typs[31], typs[51]), params(typs[26])) typs[52] = newSig(params(typs[35], typs[1], typs[13]), params(typs[30]))
typs[53] = newSig(params(typs[31], typs[26]), params(typs[38])) typs[53] = newSig(params(typs[1], typs[13]), params(typs[30]))
typs[54] = types.NewArray(typs[50], 32) typs[54] = types.RuneType
typs[55] = types.NewPtr(typs[54]) typs[55] = types.NewSlice(typs[54])
typs[56] = newSig(params(typs[55], typs[26]), params(typs[51])) typs[56] = newSig(params(typs[35], typs[55]), params(typs[30]))
typs[57] = newSig(params(typs[3], typs[13], typs[3], typs[13], typs[5]), params(typs[13])) typs[57] = newSig(params(typs[35], typs[30]), params(typs[42]))
typs[58] = newSig(params(typs[26], typs[13]), params(typs[50], typs[13])) typs[58] = types.NewArray(typs[54], 32)
typs[59] = newSig(params(typs[26]), params(typs[13])) typs[59] = types.NewPtr(typs[58])
typs[60] = newSig(params(typs[1], typs[3]), params(typs[7])) typs[60] = newSig(params(typs[59], typs[30]), params(typs[55]))
typs[61] = types.Types[types.TUINT16] typs[61] = newSig(params(typs[3], typs[13], typs[3], typs[13], typs[5]), params(typs[13]))
typs[62] = newSig(params(typs[61]), params(typs[7])) typs[62] = newSig(params(typs[30], typs[13]), params(typs[54], typs[13]))
typs[63] = types.Types[types.TUINT32] typs[63] = newSig(params(typs[30]), params(typs[13]))
typs[64] = newSig(params(typs[63]), params(typs[7])) typs[64] = newSig(params(typs[1], typs[3]), params(typs[7]))
typs[65] = newSig(params(typs[22]), params(typs[7])) typs[65] = types.Types[types.TUINT16]
typs[66] = newSig(params(typs[26]), params(typs[7])) typs[66] = newSig(params(typs[65]), params(typs[7]))
typs[67] = types.Types[types.TUINT8] typs[67] = types.Types[types.TUINT32]
typs[68] = types.NewSlice(typs[67]) typs[68] = newSig(params(typs[67]), params(typs[7]))
typs[69] = newSig(params(typs[68]), params(typs[7])) typs[69] = newSig(params(typs[24]), params(typs[7]))
typs[70] = newSig(params(typs[1], typs[1]), params(typs[1])) typs[70] = newSig(params(typs[30]), params(typs[7]))
typs[71] = newSig(params(typs[1], typs[1], typs[1]), nil) typs[71] = types.Types[types.TUINT8]
typs[72] = newSig(params(typs[1]), nil) typs[72] = types.NewSlice(typs[71])
typs[73] = newSig(params(typs[1], typs[1]), params(typs[13], typs[1])) typs[73] = newSig(params(typs[72]), params(typs[7]))
typs[74] = types.NewPtr(typs[5]) typs[74] = newSig(params(typs[1], typs[1]), params(typs[1]))
typs[75] = newSig(params(typs[74], typs[7], typs[7]), params(typs[6])) typs[75] = newSig(params(typs[1], typs[1], typs[1]), nil)
typs[76] = newSig(params(typs[13]), nil) typs[76] = newSig(params(typs[1]), nil)
typs[77] = newSig(nil, params(typs[22])) typs[77] = newSig(params(typs[1], typs[1]), params(typs[13], typs[1]))
typs[78] = newSig(nil, params(typs[63])) typs[78] = types.NewPtr(typs[5])
typs[79] = types.NewMap(typs[2], typs[2]) typs[79] = newSig(params(typs[78], typs[7], typs[7]), params(typs[6]))
typs[80] = newSig(params(typs[1], typs[20], typs[3]), params(typs[79])) typs[80] = newSig(params(typs[13]), nil)
typs[81] = newSig(params(typs[1], typs[13], typs[3]), params(typs[79])) typs[81] = newSig(nil, params(typs[24]))
typs[82] = newSig(nil, params(typs[79])) typs[82] = newSig(nil, params(typs[67]))
typs[83] = newSig(params(typs[1], typs[79], typs[3]), params(typs[3])) typs[83] = types.NewMap(typs[2], typs[2])
typs[84] = newSig(params(typs[1], typs[79], typs[63]), params(typs[3])) typs[84] = newSig(params(typs[1], typs[22], typs[3]), params(typs[83]))
typs[85] = newSig(params(typs[1], typs[79], typs[22]), params(typs[3])) typs[85] = newSig(params(typs[1], typs[13], typs[3]), params(typs[83]))
typs[86] = newSig(params(typs[1], typs[79], typs[26]), params(typs[3])) typs[86] = newSig(nil, params(typs[83]))
typs[87] = newSig(params(typs[1], typs[79], typs[3], typs[1]), params(typs[3])) typs[87] = newSig(params(typs[1], typs[83], typs[3]), params(typs[3]))
typs[88] = newSig(params(typs[1], typs[79], typs[3]), params(typs[3], typs[6])) typs[88] = newSig(params(typs[1], typs[83], typs[67]), params(typs[3]))
typs[89] = newSig(params(typs[1], typs[79], typs[63]), params(typs[3], typs[6])) typs[89] = newSig(params(typs[1], typs[83], typs[24]), params(typs[3]))
typs[90] = newSig(params(typs[1], typs[79], typs[22]), params(typs[3], typs[6])) typs[90] = newSig(params(typs[1], typs[83], typs[30]), params(typs[3]))
typs[91] = newSig(params(typs[1], typs[79], typs[26]), params(typs[3], typs[6])) typs[91] = newSig(params(typs[1], typs[83], typs[3], typs[1]), params(typs[3]))
typs[92] = newSig(params(typs[1], typs[79], typs[3], typs[1]), params(typs[3], typs[6])) typs[92] = newSig(params(typs[1], typs[83], typs[3]), params(typs[3], typs[6]))
typs[93] = newSig(params(typs[1], typs[79], typs[7]), params(typs[3])) typs[93] = newSig(params(typs[1], typs[83], typs[67]), params(typs[3], typs[6]))
typs[94] = newSig(params(typs[1], typs[79], typs[3]), nil) typs[94] = newSig(params(typs[1], typs[83], typs[24]), params(typs[3], typs[6]))
typs[95] = newSig(params(typs[1], typs[79], typs[63]), nil) typs[95] = newSig(params(typs[1], typs[83], typs[30]), params(typs[3], typs[6]))
typs[96] = newSig(params(typs[1], typs[79], typs[22]), nil) typs[96] = newSig(params(typs[1], typs[83], typs[3], typs[1]), params(typs[3], typs[6]))
typs[97] = newSig(params(typs[1], typs[79], typs[26]), nil) typs[97] = newSig(params(typs[1], typs[83], typs[7]), params(typs[3]))
typs[98] = newSig(params(typs[3]), nil) typs[98] = newSig(params(typs[1], typs[83], typs[3]), nil)
typs[99] = newSig(params(typs[1], typs[79]), nil) typs[99] = newSig(params(typs[1], typs[83], typs[67]), nil)
typs[100] = types.NewChan(typs[2], types.Cboth) typs[100] = newSig(params(typs[1], typs[83], typs[24]), nil)
typs[101] = newSig(params(typs[1], typs[20]), params(typs[100])) typs[101] = newSig(params(typs[1], typs[83], typs[30]), nil)
typs[102] = newSig(params(typs[1], typs[13]), params(typs[100])) typs[102] = newSig(params(typs[3]), nil)
typs[103] = types.NewChan(typs[2], types.Crecv) typs[103] = newSig(params(typs[1], typs[83]), nil)
typs[104] = newSig(params(typs[103], typs[3]), nil) typs[104] = types.NewChan(typs[2], types.Cboth)
typs[105] = newSig(params(typs[103], typs[3]), params(typs[6])) typs[105] = newSig(params(typs[1], typs[22]), params(typs[104]))
typs[106] = types.NewChan(typs[2], types.Csend) typs[106] = newSig(params(typs[1], typs[13]), params(typs[104]))
typs[107] = newSig(params(typs[106], typs[3]), nil) typs[107] = types.NewChan(typs[2], types.Crecv)
typs[108] = newSig(params(typs[106]), nil) typs[108] = newSig(params(typs[107], typs[3]), nil)
typs[109] = newSig(params(typs[2]), params(typs[13])) typs[109] = newSig(params(typs[107], typs[3]), params(typs[6]))
typs[110] = types.NewArray(typs[0], 3) typs[110] = types.NewChan(typs[2], types.Csend)
typs[111] = types.NewStruct([]*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[110]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[22])}) typs[111] = newSig(params(typs[110], typs[3]), nil)
typs[112] = newSig(params(typs[1], typs[3], typs[3]), nil) typs[112] = newSig(params(typs[110]), nil)
typs[113] = newSig(params(typs[1], typs[3]), nil) typs[113] = newSig(params(typs[2]), params(typs[13]))
typs[114] = newSig(params(typs[1], typs[3], typs[13], typs[3], typs[13]), params(typs[13])) typs[114] = types.NewArray(typs[0], 3)
typs[115] = newSig(params(typs[106], typs[3]), params(typs[6])) typs[115] = types.NewStruct([]*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[114]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
typs[116] = newSig(params(typs[3], typs[103]), params(typs[6], typs[6])) typs[116] = newSig(params(typs[1], typs[3], typs[3]), nil)
typs[117] = newSig(params(typs[74]), nil) typs[117] = newSig(params(typs[1], typs[3]), nil)
typs[118] = newSig(params(typs[1], typs[1], typs[74], typs[13], typs[13], typs[6]), params(typs[13], typs[6])) typs[118] = newSig(params(typs[1], typs[3], typs[13], typs[3], typs[13]), params(typs[13]))
typs[119] = newSig(params(typs[1], typs[13], typs[13]), params(typs[7])) typs[119] = newSig(params(typs[110], typs[3]), params(typs[6]))
typs[120] = newSig(params(typs[1], typs[20], typs[20]), params(typs[7])) typs[120] = newSig(params(typs[3], typs[107]), params(typs[6], typs[6]))
typs[121] = newSig(params(typs[1], typs[13], typs[13], typs[7]), params(typs[7])) typs[121] = newSig(params(typs[78]), nil)
typs[122] = types.NewSlice(typs[2]) typs[122] = newSig(params(typs[1], typs[1], typs[78], typs[13], typs[13], typs[6]), params(typs[13], typs[6]))
typs[123] = newSig(params(typs[3], typs[13], typs[13], typs[13], typs[1]), params(typs[122])) typs[123] = newSig(params(typs[1], typs[13], typs[13]), params(typs[7]))
typs[124] = newSig(params(typs[1], typs[7], typs[20]), nil) typs[124] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
typs[125] = newSig(params(typs[7], typs[20]), nil) typs[125] = newSig(params(typs[1], typs[13], typs[13], typs[7]), params(typs[7]))
typs[126] = newSig(params(typs[3], typs[3], typs[5]), nil) typs[126] = types.NewSlice(typs[2])
typs[127] = newSig(params(typs[7], typs[5]), nil) typs[127] = newSig(params(typs[3], typs[13], typs[13], typs[13], typs[1]), params(typs[126]))
typs[128] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6])) typs[128] = newSig(params(typs[1], typs[7], typs[22]), nil)
typs[129] = newSig(params(typs[3], typs[3]), params(typs[6])) typs[129] = newSig(params(typs[7], typs[22]), nil)
typs[130] = newSig(params(typs[7], typs[7]), params(typs[6])) typs[130] = newSig(params(typs[3], typs[3], typs[5]), nil)
typs[131] = newSig(params(typs[3], typs[5], typs[5]), params(typs[5])) typs[131] = newSig(params(typs[7], typs[5]), nil)
typs[132] = newSig(params(typs[7], typs[5]), params(typs[5])) typs[132] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
typs[133] = newSig(params(typs[3], typs[5]), params(typs[5])) typs[133] = newSig(params(typs[3], typs[3]), params(typs[6]))
typs[134] = newSig(params(typs[20], typs[20]), params(typs[20])) typs[134] = newSig(params(typs[7], typs[7]), params(typs[6]))
typs[135] = newSig(params(typs[22], typs[22]), params(typs[22])) typs[135] = newSig(params(typs[3], typs[5], typs[5]), params(typs[5]))
typs[136] = newSig(params(typs[18]), params(typs[20])) typs[136] = newSig(params(typs[7], typs[5]), params(typs[5]))
typs[137] = newSig(params(typs[18]), params(typs[22])) typs[137] = newSig(params(typs[3], typs[5]), params(typs[5]))
typs[138] = newSig(params(typs[18]), params(typs[63])) typs[138] = newSig(params(typs[22], typs[22]), params(typs[22]))
typs[139] = newSig(params(typs[20]), params(typs[18])) typs[139] = newSig(params(typs[24], typs[24]), params(typs[24]))
typs[140] = types.Types[types.TFLOAT32] typs[140] = newSig(params(typs[18]), params(typs[22]))
typs[141] = newSig(params(typs[20]), params(typs[140])) typs[141] = newSig(params(typs[18]), params(typs[24]))
typs[142] = newSig(params(typs[22]), params(typs[18])) typs[142] = newSig(params(typs[18]), params(typs[67]))
typs[143] = newSig(params(typs[22]), params(typs[140])) typs[143] = newSig(params(typs[22]), params(typs[18]))
typs[144] = newSig(params(typs[63]), params(typs[18])) typs[144] = newSig(params(typs[22]), params(typs[20]))
typs[145] = newSig(params(typs[24], typs[24]), params(typs[24])) typs[145] = newSig(params(typs[24]), params(typs[18]))
typs[146] = newSig(params(typs[5], typs[5]), nil) typs[146] = newSig(params(typs[24]), params(typs[20]))
typs[147] = newSig(params(typs[5], typs[5], typs[5]), nil) typs[147] = newSig(params(typs[67]), params(typs[18]))
typs[148] = newSig(params(typs[7], typs[1], typs[5]), nil) typs[148] = newSig(params(typs[26], typs[26]), params(typs[26]))
typs[149] = types.NewSlice(typs[7]) typs[149] = newSig(params(typs[5], typs[5]), nil)
typs[150] = newSig(params(typs[7], typs[149]), nil) typs[150] = newSig(params(typs[5], typs[5], typs[5]), nil)
typs[151] = newSig(params(typs[67], typs[67], typs[15]), nil) typs[151] = newSig(params(typs[7], typs[1], typs[5]), nil)
typs[152] = newSig(params(typs[61], typs[61], typs[15]), nil) typs[152] = types.NewSlice(typs[7])
typs[153] = newSig(params(typs[63], typs[63], typs[15]), nil) typs[153] = newSig(params(typs[7], typs[152]), nil)
typs[154] = newSig(params(typs[22], typs[22], typs[15]), nil) typs[154] = newSig(params(typs[71], typs[71], typs[15]), nil)
typs[155] = newSig(params(typs[26], typs[26], typs[15]), nil) typs[155] = newSig(params(typs[65], typs[65], typs[15]), nil)
typs[156] = types.NewArray(typs[0], 16) typs[156] = newSig(params(typs[67], typs[67], typs[15]), nil)
typs[157] = newSig(params(typs[7], typs[63], typs[156], typs[26], typs[13], typs[67], typs[67]), params(typs[63])) typs[157] = newSig(params(typs[24], typs[24], typs[15]), nil)
typs[158] = newSig(params(typs[30], typs[30], typs[15]), nil)
typs[159] = types.NewArray(typs[0], 16)
typs[160] = newSig(params(typs[7], typs[67], typs[159], typs[30], typs[13], typs[71], typs[71]), params(typs[67]))
return typs[:] return typs[:]
} }

12
src/cmd/compile/internal/walk/builtin.go
View file

@ -714,10 +714,14 @@ func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
} }
case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64: case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64:
on = typecheck.LookupRuntime("printint") on = typecheck.LookupRuntime("printint")
case types.TFLOAT32, types.TFLOAT64: case types.TFLOAT32:
on = typecheck.LookupRuntime("printfloat") on = typecheck.LookupRuntime("printfloat32")
case types.TCOMPLEX64, types.TCOMPLEX128: case types.TFLOAT64:
on = typecheck.LookupRuntime("printcomplex") on = typecheck.LookupRuntime("printfloat64")
case types.TCOMPLEX64:
on = typecheck.LookupRuntime("printcomplex64")
case types.TCOMPLEX128:
on = typecheck.LookupRuntime("printcomplex128")
case types.TBOOL: case types.TBOOL:
on = typecheck.LookupRuntime("printbool") on = typecheck.LookupRuntime("printbool")
case types.TSTRING: case types.TSTRING:

8
src/cmd/internal/goobj/builtinlist.go
View file

@ -35,11 +35,13 @@ var builtins = [...]struct {
{"runtime.goPanicSlice3CU", 1}, {"runtime.goPanicSlice3CU", 1},
{"runtime.goPanicSliceConvert", 1}, {"runtime.goPanicSliceConvert", 1},
{"runtime.printbool", 1}, {"runtime.printbool", 1},
{"runtime.printfloat", 1}, {"runtime.printfloat64", 1},
{"runtime.printfloat32", 1},
{"runtime.printint", 1}, {"runtime.printint", 1},
{"runtime.printhex", 1}, {"runtime.printhex", 1},
{"runtime.printuint", 1}, {"runtime.printuint", 1},
{"runtime.printcomplex", 1}, {"runtime.printcomplex128", 1},
{"runtime.printcomplex64", 1},
{"runtime.printstring", 1}, {"runtime.printstring", 1},
{"runtime.printpointer", 1}, {"runtime.printpointer", 1},
{"runtime.printuintptr", 1}, {"runtime.printuintptr", 1},
@ -109,13 +111,11 @@ var builtins = [...]struct {
{"runtime.mapassign_fast64", 1}, {"runtime.mapassign_fast64", 1},
{"runtime.mapassign_fast64ptr", 1}, {"runtime.mapassign_fast64ptr", 1},
{"runtime.mapassign_faststr", 1}, {"runtime.mapassign_faststr", 1},
{"runtime.mapiterinit", 1},
{"runtime.mapIterStart", 1}, {"runtime.mapIterStart", 1},
{"runtime.mapdelete", 1}, {"runtime.mapdelete", 1},
{"runtime.mapdelete_fast32", 1}, {"runtime.mapdelete_fast32", 1},
{"runtime.mapdelete_fast64", 1}, {"runtime.mapdelete_fast64", 1},
{"runtime.mapdelete_faststr", 1}, {"runtime.mapdelete_faststr", 1},
{"runtime.mapiternext", 1},
{"runtime.mapIterNext", 1}, {"runtime.mapIterNext", 1},
{"runtime.mapclear", 1}, {"runtime.mapclear", 1},
{"runtime.makechan64", 1}, {"runtime.makechan64", 1},

23
src/internal/strconv/ctoa.go
View file

@ -12,16 +12,29 @@ package strconv
// It rounds the result assuming that the original was obtained from a complex // It rounds the result assuming that the original was obtained from a complex
// value of bitSize bits, which must be 64 for complex64 and 128 for complex128. // value of bitSize bits, which must be 64 for complex64 and 128 for complex128.
func FormatComplex(c complex128, fmt byte, prec, bitSize int) string { func FormatComplex(c complex128, fmt byte, prec, bitSize int) string {
var buf [64]byte
return string(AppendComplex(buf[:0], c, fmt, prec, bitSize))
}
// AppendComplex appends the result of FormatComplex to dst.
// It is here for the runtime.
// There is no public strconv.AppendComplex.
func AppendComplex(dst []byte, c complex128, fmt byte, prec, bitSize int) []byte {
if bitSize != 64 && bitSize != 128 { if bitSize != 64 && bitSize != 128 {
panic("invalid bitSize") panic("invalid bitSize")
} }
bitSize >>= 1 // complex64 uses float32 internally bitSize >>= 1 // complex64 uses float32 internally
dst = append(dst, '(')
dst = AppendFloat(dst, real(c), fmt, prec, bitSize)
i := len(dst)
dst = AppendFloat(dst, imag(c), fmt, prec, bitSize)
// Check if imaginary part has a sign. If not, add one. // Check if imaginary part has a sign. If not, add one.
im := FormatFloat(imag(c), fmt, prec, bitSize) if dst[i] != '+' && dst[i] != '-' {
if im[0] != '+' && im[0] != '-' { dst = append(dst, 0)
im = "+" + im copy(dst[i+1:], dst[i:])
dst[i] = '+'
} }
dst = append(dst, "i)"...)
return "(" + FormatFloat(real(c), fmt, prec, bitSize) + im + "i)" return dst
} }

8
src/runtime/panic_test.go
View file

@ -18,10 +18,10 @@ func TestPanicWithDirectlyPrintableCustomTypes(t *testing.T) {
wantPanicPrefix string wantPanicPrefix string
}{ }{
{"panicCustomBool", `panic: main.MyBool(true)`}, {"panicCustomBool", `panic: main.MyBool(true)`},
{"panicCustomComplex128", `panic: main.MyComplex128(+3.210000e+001+1.000000e+001i)`}, {"panicCustomComplex128", `panic: main.MyComplex128(32.1+10i)`},
{"panicCustomComplex64", `panic: main.MyComplex64(+1.100000e-001+3.000000e+000i)`}, {"panicCustomComplex64", `panic: main.MyComplex64(0.11+3i)`},
{"panicCustomFloat32", `panic: main.MyFloat32(-9.370000e+001)`}, {"panicCustomFloat32", `panic: main.MyFloat32(-93.7)`},
{"panicCustomFloat64", `panic: main.MyFloat64(-9.370000e+001)`}, {"panicCustomFloat64", `panic: main.MyFloat64(-93.7)`},
{"panicCustomInt", `panic: main.MyInt(93)`}, {"panicCustomInt", `panic: main.MyInt(93)`},
{"panicCustomInt8", `panic: main.MyInt8(93)`}, {"panicCustomInt8", `panic: main.MyInt8(93)`},
{"panicCustomInt16", `panic: main.MyInt16(93)`}, {"panicCustomInt16", `panic: main.MyInt16(93)`},

108
src/runtime/print.go
View file

@ -6,6 +6,7 @@ package runtime
import ( import (
"internal/goarch" "internal/goarch"
"internal/strconv"
"unsafe" "unsafe"
) )
@ -118,101 +119,34 @@ func printbool(v bool) {
} }
} }
func printfloat(v float64) { func printfloat64(v float64) {
switch { var buf [20]byte
case v != v: gwrite(strconv.AppendFloat(buf[:0], v, 'g', -1, 64))
printstring("NaN")
return
case v+v == v && v > 0:
printstring("+Inf")
return
case v+v == v && v < 0:
printstring("-Inf")
return
}
const n = 7 // digits printed
var buf [n + 7]byte
buf[0] = '+'
e := 0 // exp
if v == 0 {
if 1/v < 0 {
buf[0] = '-'
}
} else {
if v < 0 {
v = -v
buf[0] = '-'
}
// normalize
for v >= 10 {
e++
v /= 10
}
for v < 1 {
e--
v *= 10
}
// round
h := 5.0
for i := 0; i < n; i++ {
h /= 10
}
v += h
if v >= 10 {
e++
v /= 10
}
}
// format +d.dddd+edd
for i := 0; i < n; i++ {
s := int(v)
buf[i+2] = byte(s + '0')
v -= float64(s)
v *= 10
}
buf[1] = buf[2]
buf[2] = '.'
buf[n+2] = 'e'
buf[n+3] = '+'
if e < 0 {
e = -e
buf[n+3] = '-'
}
buf[n+4] = byte(e/100) + '0'
buf[n+5] = byte(e/10)%10 + '0'
buf[n+6] = byte(e%10) + '0'
gwrite(buf[:])
} }
func printcomplex(c complex128) { func printfloat32(v float32) {
print("(", real(c), imag(c), "i)") var buf [20]byte
gwrite(strconv.AppendFloat(buf[:0], float64(v), 'g', -1, 32))
}
func printcomplex128(c complex128) {
var buf [44]byte
gwrite(strconv.AppendComplex(buf[:0], c, 'g', -1, 128))
}
func printcomplex64(c complex64) {
var buf [44]byte
gwrite(strconv.AppendComplex(buf[:0], complex128(c), 'g', -1, 64))
} }
func printuint(v uint64) { func printuint(v uint64) {
var buf [100]byte var buf [20]byte
i := len(buf) gwrite(strconv.AppendUint(buf[:0], v, 10))
for i--; i > 0; i-- {
buf[i] = byte(v%10 + '0')
if v < 10 {
break
}
v /= 10
}
gwrite(buf[i:])
} }
func printint(v int64) { func printint(v int64) {
if v < 0 { var buf [20]byte
printstring("-") gwrite(strconv.AppendInt(buf[:0], v, 10))
v = -v
}
printuint(uint64(v))
} }
var minhexdigits = 0 // protected by printlock var minhexdigits = 0 // protected by printlock

2
test/deferprint.out
View file

@ -1,2 +1,2 @@
printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255 42 true false true 1.5 world 0x0 [0/0]0x0 0x0 0x0 255

2
test/fixedbugs/bug409.out
View file

@ -1 +1 @@
+1.000000e+000 +2.000000e+000 +3.000000e+000 +4.000000e+000 1 2 3 4

4
test/fixedbugs/issue19658.go
View file

@ -64,8 +64,8 @@ func main() {
{"uint64", "8", "panic: 8"}, {"uint64", "8", "panic: 8"},
{"uintptr", "8", "panic: 8"}, {"uintptr", "8", "panic: 8"},
{"bool", "true", "panic: true"}, {"bool", "true", "panic: true"},
{"complex64", "8 + 16i", "panic: (+8.000000e+000+1.600000e+001i)"}, {"complex64", "8 + 16i", "panic: (8+16i)"},
{"complex128", "8+16i", "panic: (+8.000000e+000+1.600000e+001i)"}, {"complex128", "8+16i", "panic: (8+16i)"},
{"string", `"test"`, "panic: test"}} { {"string", `"test"`, "panic: test"}} {
b := bytes.Buffer{} b := bytes.Buffer{}

2
test/fixedbugs/issue35576.out
View file

@ -1 +1 @@
-42+4.200000e+001x-42 +4.200000e+001 x -4242x-42 42 x

2
test/fixedbugs/issue6899.out
View file

@ -1 +1 @@
-0.000000e+000 -0

2
test/goprint.out
View file

@ -1 +1 @@
42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255 42 true false true 1.5 world 0x0 [0/0]0x0 0x0 0x0 255

8
test/ken/cplx0.out
View file

@ -1,4 +1,4 @@
(+5.000000e+000+6.000000e+000i) (5+6i)
(+5.000000e+000+6.000000e+000i) (5+6i)
(+5.000000e+000+6.000000e+000i) (5+6i)
(+5.000000e+000+6.000000e+000i) (5+6i)

8
test/print.out
View file

@ -9,8 +9,8 @@
7 7
7 7
7 7
+8.000000e+000 8
(+9.000000e+000+1.000000e+001i) (9+10i)
true true
false false
hello hello
@ -19,8 +19,8 @@ one two
hello hello
false false
true true
(+1.400000e+001+1.500000e+001i) (14+15i)
+1.300000e+001 13
12 12
12 12
12 12

2
test/typeparam/typeswitch5.out
View file

@ -1,4 +1,4 @@
fooer 6 fooer 6
other other
other other
fooer +9.000000e+000 fooer 9