From db62e99a735a036afda2098f1a721fe8dbf6ce76 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 6 Oct 2009 19:40:35 -0700 Subject: apply gofmt to malloc math once os R=gri DELTA=566 (4 added, 14 deleted, 548 changed) OCL=35410 CL=35419 --- src/pkg/malloc/malloc.go | 8 +- src/pkg/math/all_test.go | 274 ++++++++++++++++++++-------------------- src/pkg/math/atan.go | 9 +- src/pkg/math/atan2.go | 6 +- src/pkg/math/const.go | 50 ++++---- src/pkg/math/exp.go | 21 ++- src/pkg/math/fabs.go | 1 - src/pkg/math/fmod.go | 2 +- src/pkg/math/hypot.go | 2 +- src/pkg/math/log.go | 29 ++--- src/pkg/math/pow.go | 8 +- src/pkg/math/pow10.go | 8 +- src/pkg/math/sin.go | 29 ++--- src/pkg/math/sinh.go | 11 +- src/pkg/math/sqrt.go | 14 +- src/pkg/math/sqrt_decl.go | 1 - src/pkg/math/tan.go | 23 ++-- src/pkg/math/tanh.go | 2 +- src/pkg/once/once.go | 6 +- src/pkg/once/once_test.go | 5 +- src/pkg/os/dir_darwin_386.go | 20 +-- src/pkg/os/dir_darwin_amd64.go | 20 +-- src/pkg/os/dir_linux_386.go | 20 +-- src/pkg/os/dir_linux_amd64.go | 20 +-- src/pkg/os/dir_linux_arm.go | 20 +-- src/pkg/os/dir_nacl_386.go | 20 +-- src/pkg/os/env.go | 12 +- src/pkg/os/error.go | 94 +++++++------- src/pkg/os/exec.go | 28 ++-- src/pkg/os/file.go | 94 +++++++------- src/pkg/os/getwd.go | 16 +-- src/pkg/os/os_test.go | 88 ++++++------- src/pkg/os/path.go | 4 +- src/pkg/os/path_test.go | 18 +-- src/pkg/os/proc.go | 5 +- src/pkg/os/stat_darwin_386.go | 6 +- src/pkg/os/stat_darwin_amd64.go | 6 +- src/pkg/os/stat_linux_386.go | 6 +- src/pkg/os/stat_linux_amd64.go | 6 +- src/pkg/os/stat_linux_arm.go | 6 +- src/pkg/os/stat_nacl_386.go | 12 +- src/pkg/os/time.go | 3 +- src/pkg/os/types.go | 45 ++++--- 43 files changed, 534 insertions(+), 544 deletions(-) diff --git a/src/pkg/malloc/malloc.go b/src/pkg/malloc/malloc.go index fec53f08f..838b92f5f 100644 --- a/src/pkg/malloc/malloc.go +++ b/src/pkg/malloc/malloc.go @@ -9,11 +9,11 @@ package malloc type Stats struct { - Alloc uint64; - Sys uint64; - Stacks uint64; + Alloc uint64; + Sys uint64; + Stacks uint64; InusePages uint64; - NextGC uint64; + NextGC uint64; EnableGC bool; } diff --git a/src/pkg/math/all_test.go b/src/pkg/math/all_test.go index 9a7075899..9d899d1ce 100644 --- a/src/pkg/math/all_test.go +++ b/src/pkg/math/all_test.go @@ -5,156 +5,156 @@ package math_test import ( - . "math"; - "testing"; + . "math"; + "testing"; ) -var vf = []float64 { - 4.9790119248836735e+00, - 7.7388724745781045e+00, - -2.7688005719200159e-01, - -5.0106036182710749e+00, - 9.6362937071984173e+00, - 2.9263772392439646e+00, - 5.2290834314593066e+00, - 2.7279399104360102e+00, - 1.8253080916808550e+00, - -8.6859247685756013e+00, +var vf = []float64{ + 4.9790119248836735e+00, + 7.7388724745781045e+00, + -2.7688005719200159e-01, + -5.0106036182710749e+00, + 9.6362937071984173e+00, + 2.9263772392439646e+00, + 5.2290834314593066e+00, + 2.7279399104360102e+00, + 1.8253080916808550e+00, + -8.6859247685756013e+00, } -var asin = []float64 { - 5.2117697218417440e-01, - 8.8495619865825236e-01, - -2.7691544662819413e-02, - -5.2482360935268932e-01, - 1.3002662421166553e+00, - 2.9698415875871901e-01, - 5.5025938468083364e-01, - 2.7629597861677200e-01, - 1.8355989225745148e-01, - -1.0523547536021498e+00, +var asin = []float64{ + 5.2117697218417440e-01, + 8.8495619865825236e-01, + -2.7691544662819413e-02, + -5.2482360935268932e-01, + 1.3002662421166553e+00, + 2.9698415875871901e-01, + 5.5025938468083364e-01, + 2.7629597861677200e-01, + 1.8355989225745148e-01, + -1.0523547536021498e+00, } -var atan = []float64 { - 1.3725902621296217e+00, - 1.4422906096452980e+00, - -2.7011324359471755e-01, - -1.3738077684543379e+00, - 1.4673921193587666e+00, - 1.2415173565870167e+00, - 1.3818396865615167e+00, - 1.2194305844639670e+00, - 1.0696031952318783e+00, - -1.4561721938838085e+00, +var atan = []float64{ + 1.3725902621296217e+00, + 1.4422906096452980e+00, + -2.7011324359471755e-01, + -1.3738077684543379e+00, + 1.4673921193587666e+00, + 1.2415173565870167e+00, + 1.3818396865615167e+00, + 1.2194305844639670e+00, + 1.0696031952318783e+00, + -1.4561721938838085e+00, } -var exp = []float64 { - 1.4533071302642137e+02, - 2.2958822575694450e+03, - 7.5814542574851666e-01, - 6.6668778421791010e-03, - 1.5310493273896035e+04, - 1.8659907517999329e+01, - 1.8662167355098713e+02, - 1.5301332413189379e+01, - 6.2047063430646876e+00, - 1.6894712385826522e-04, +var exp = []float64{ + 1.4533071302642137e+02, + 2.2958822575694450e+03, + 7.5814542574851666e-01, + 6.6668778421791010e-03, + 1.5310493273896035e+04, + 1.8659907517999329e+01, + 1.8662167355098713e+02, + 1.5301332413189379e+01, + 6.2047063430646876e+00, + 1.6894712385826522e-04, } -var floor = []float64 { - 4.0000000000000000e+00, - 7.0000000000000000e+00, - -1.0000000000000000e+00, - -6.0000000000000000e+00, - 9.0000000000000000e+00, - 2.0000000000000000e+00, - 5.0000000000000000e+00, - 2.0000000000000000e+00, - 1.0000000000000000e+00, - -9.0000000000000000e+00, +var floor = []float64{ + 4.0000000000000000e+00, + 7.0000000000000000e+00, + -1.0000000000000000e+00, + -6.0000000000000000e+00, + 9.0000000000000000e+00, + 2.0000000000000000e+00, + 5.0000000000000000e+00, + 2.0000000000000000e+00, + 1.0000000000000000e+00, + -9.0000000000000000e+00, } -var log = []float64 { - 1.6052314626930630e+00, - 2.0462560018708768e+00, - -1.2841708730962657e+00, - 1.6115563905281544e+00, - 2.2655365644872018e+00, - 1.0737652208918380e+00, - 1.6542360106073545e+00, - 1.0035467127723465e+00, - 6.0174879014578053e-01, - 2.1617038728473527e+00, +var log = []float64{ + 1.6052314626930630e+00, + 2.0462560018708768e+00, + -1.2841708730962657e+00, + 1.6115563905281544e+00, + 2.2655365644872018e+00, + 1.0737652208918380e+00, + 1.6542360106073545e+00, + 1.0035467127723465e+00, + 6.0174879014578053e-01, + 2.1617038728473527e+00, } -var pow = []float64 { - 9.5282232631648415e+04, - 5.4811599352999900e+07, - 5.2859121715894400e-01, - 9.7587991957286472e-06, - 4.3280643293460450e+09, - 8.4406761805034551e+02, - 1.6946633276191194e+05, - 5.3449040147551940e+02, - 6.6881821384514159e+01, - 2.0609869004248744e-09, +var pow = []float64{ + 9.5282232631648415e+04, + 5.4811599352999900e+07, + 5.2859121715894400e-01, + 9.7587991957286472e-06, + 4.3280643293460450e+09, + 8.4406761805034551e+02, + 1.6946633276191194e+05, + 5.3449040147551940e+02, + 6.6881821384514159e+01, + 2.0609869004248744e-09, } -var sin = []float64 { - -9.6466616586009283e-01, - 9.9338225271646543e-01, - -2.7335587039794395e-01, - 9.5586257685042800e-01, - -2.0994210667799692e-01, - 2.1355787807998605e-01, - -8.6945689711673619e-01, - 4.0195666811555783e-01, - 9.6778633541688000e-01, - -6.7344058690503452e-01, +var sin = []float64{ + -9.6466616586009283e-01, + 9.9338225271646543e-01, + -2.7335587039794395e-01, + 9.5586257685042800e-01, + -2.0994210667799692e-01, + 2.1355787807998605e-01, + -8.6945689711673619e-01, + 4.0195666811555783e-01, + 9.6778633541688000e-01, + -6.7344058690503452e-01, } -var sinh = []float64 { - 7.2661916084208533e+01, - 1.1479409110035194e+03, - -2.8043136512812520e-01, - -7.4994290911815868e+01, - 7.6552466042906761e+03, - 9.3031583421672010e+00, - 9.3308157558281088e+01, - 7.6179893137269143e+00, - 3.0217691805496156e+00, - -2.9595057572444951e+03, +var sinh = []float64{ + 7.2661916084208533e+01, + 1.1479409110035194e+03, + -2.8043136512812520e-01, + -7.4994290911815868e+01, + 7.6552466042906761e+03, + 9.3031583421672010e+00, + 9.3308157558281088e+01, + 7.6179893137269143e+00, + 3.0217691805496156e+00, + -2.9595057572444951e+03, } -var sqrt = []float64 { - 2.2313699659365484e+00, - 2.7818829009464263e+00, - 5.2619393496314792e-01, - 2.2384377628763938e+00, - 3.1042380236055380e+00, - 1.7106657298385224e+00, - 2.2867189227054791e+00, - 1.6516476350711160e+00, - 1.3510396336454586e+00, - 2.9471892997524950e+00, +var sqrt = []float64{ + 2.2313699659365484e+00, + 2.7818829009464263e+00, + 5.2619393496314792e-01, + 2.2384377628763938e+00, + 3.1042380236055380e+00, + 1.7106657298385224e+00, + 2.2867189227054791e+00, + 1.6516476350711160e+00, + 1.3510396336454586e+00, + 2.9471892997524950e+00, } -var tan = []float64 { - -3.6613165650402277e+00, - 8.6490023264859754e+00, - -2.8417941955033615e-01, - 3.2532901859747287e+00, - 2.1472756403802937e-01, - -2.1860091071106700e-01, - -1.7600028178723679e+00, - -4.3898089147528178e-01, - -3.8438855602011305e+00, - 9.1098879337768517e-01, +var tan = []float64{ + -3.6613165650402277e+00, + 8.6490023264859754e+00, + -2.8417941955033615e-01, + 3.2532901859747287e+00, + 2.1472756403802937e-01, + -2.1860091071106700e-01, + -1.7600028178723679e+00, + -4.3898089147528178e-01, + -3.8438855602011305e+00, + 9.1098879337768517e-01, } -var tanh = []float64 { - 9.9990531206936328e-01, - 9.9999962057085307e-01, - -2.7001505097318680e-01, - -9.9991110943061700e-01, - 9.9999999146798441e-01, - 9.9427249436125233e-01, - 9.9994257600983156e-01, - 9.9149409509772863e-01, - 9.4936501296239700e-01, - -9.9999994291374019e-01, +var tanh = []float64{ + 9.9990531206936328e-01, + 9.9999962057085307e-01, + -2.7001505097318680e-01, + -9.9991110943061700e-01, + 9.9999999146798441e-01, + 9.9427249436125233e-01, + 9.9994257600983156e-01, + 9.9149409509772863e-01, + 9.4936501296239700e-01, + -9.9999994291374019e-01, } -func tolerance(a,b,e float64) bool { +func tolerance(a, b, e float64) bool { d := a-b; if d < 0 { d = -d; @@ -168,10 +168,10 @@ func tolerance(a,b,e float64) bool { } return d < e; } -func close(a,b float64) bool { +func close(a, b float64) bool { return tolerance(a, b, 1e-14); } -func veryclose(a,b float64) bool { +func veryclose(a, b float64) bool { return tolerance(a, b, 4e-16); } diff --git a/src/pkg/math/atan.go b/src/pkg/math/atan.go index bc13b3bfa..37b49c784 100644 --- a/src/pkg/math/atan.go +++ b/src/pkg/math/atan.go @@ -19,8 +19,7 @@ package math * range [-0.414...,+0.414...]. (tan(pi/8)) */ func xatan(arg float64) float64 { - const - ( + const ( P4 = .161536412982230228262e2; P3 = .26842548195503973794141e3; P2 = .11530293515404850115428136e4; @@ -34,7 +33,7 @@ func xatan(arg float64) float64 { ) sq := arg*arg; value := ((((P4*sq + P3)*sq + P2)*sq + P1)*sq + P0); - value = value/(((((sq + Q4)*sq + Q3)*sq + Q2)*sq + Q1)*sq + Q0); + value = value/(((((sq+Q4)*sq + Q3)*sq + Q2)*sq + Q1)*sq + Q0); return value*arg; } @@ -43,10 +42,10 @@ func xatan(arg float64) float64 { * to the range [0,0.414...] and calls xatan. */ func satan(arg float64) float64 { - if arg < Sqrt2 - 1 { + if arg < Sqrt2-1 { return xatan(arg); } - if arg > Sqrt2 + 1 { + if arg > Sqrt2+1 { return Pi/2 - xatan(1/arg); } return Pi/4 + xatan((arg-1)/(arg+1)); diff --git a/src/pkg/math/atan2.go b/src/pkg/math/atan2.go index efd5cb926..5ded1a412 100644 --- a/src/pkg/math/atan2.go +++ b/src/pkg/math/atan2.go @@ -14,14 +14,14 @@ func Atan2(x, y float64) float64 { if x >= 0 { return Pi/2; } - return -Pi/2; + return -Pi / 2; } q := Atan(x/y); if y < 0 { if q <= 0 { - return q + Pi; + return q+Pi; } - return q - Pi; + return q-Pi; } return q; } diff --git a/src/pkg/math/const.go b/src/pkg/math/const.go index 13ecbcb08..19fa8fa7e 100644 --- a/src/pkg/math/const.go +++ b/src/pkg/math/const.go @@ -8,18 +8,18 @@ package math // Mathematical constants. // Reference: http://www.research.att.com/~njas/sequences/Axxxxxx const ( - E = 2.71828182845904523536028747135266249775724709369995957496696763; // A001113 - Pi = 3.14159265358979323846264338327950288419716939937510582097494459; // A000796 - Phi = 1.61803398874989484820458683436563811772030917980576286213544862; // A001622 + E = 2.71828182845904523536028747135266249775724709369995957496696763; // A001113 + Pi = 3.14159265358979323846264338327950288419716939937510582097494459; // A000796 + Phi = 1.61803398874989484820458683436563811772030917980576286213544862; // A001622 - Sqrt2 = 1.41421356237309504880168872420969807856967187537694807317667974; // A002193 - SqrtE = 1.64872127070012814684865078781416357165377610071014801157507931; // A019774 - SqrtPi = 1.77245385090551602729816748334114518279754945612238712821380779; // A002161 - SqrtPhi = 1.27201964951406896425242246173749149171560804184009624861664038; // A139339 + Sqrt2 = 1.41421356237309504880168872420969807856967187537694807317667974; // A002193 + SqrtE = 1.64872127070012814684865078781416357165377610071014801157507931; // A019774 + SqrtPi = 1.77245385090551602729816748334114518279754945612238712821380779; // A002161 + SqrtPhi = 1.27201964951406896425242246173749149171560804184009624861664038; // A139339 - Ln2 = 0.693147180559945309417232121458176568075500134360255254120680009; // A002162 + Ln2 = 0.693147180559945309417232121458176568075500134360255254120680009; // A002162 Log2E = 1/Ln2; - Ln10 = 2.30258509299404568401799145468436420760110148862877297603332790; // A002392 + Ln10 = 2.30258509299404568401799145468436420760110148862877297603332790; // A002392 Log10E = 1/Ln10; ) @@ -27,27 +27,27 @@ const ( // Max is the largest finite value representable by the type. // Min is the smallest nonzero value representable by the type. const ( - MaxFloat32 = 3.40282346638528859811704183484516925440e+38; /* 2^127 * (2^24 - 1) / 2^23 */ - MinFloat32 = 1.401298464324817070923729583289916131280e-45; /* 1 / 2^(127 - 1 + 23) */ + MaxFloat32 = 3.40282346638528859811704183484516925440e+38; /* 2^127 * (2^24 - 1) / 2^23 */ + MinFloat32 = 1.401298464324817070923729583289916131280e-45; /* 1 / 2^(127 - 1 + 23) */ - MaxFloat64 = 1.797693134862315708145274237317043567981e+308; /* 2^1023 * (2^53 - 1) / 2^52 */ - MinFloat64 = 4.940656458412465441765687928682213723651e-324; /* 1 / 2^(1023 - 1 + 52) */ + MaxFloat64 = 1.797693134862315708145274237317043567981e+308; /* 2^1023 * (2^53 - 1) / 2^52 */ + MinFloat64 = 4.940656458412465441765687928682213723651e-324; /* 1 / 2^(1023 - 1 + 52) */ ) // Integer limit values. const ( - MaxInt8 = 1<<7 - 1; - MinInt8 = -1<<7; - MaxInt16 = 1<<15 - 1; - MinInt16 = -1<<15; - MaxInt32 = 1<<31 - 1; - MinInt32 = -1<<31; - MaxInt64 = 1<<63 - 1; - MinInt64 = -1<<63; - MaxUint8 = 1<<8 - 1; - MaxUint16 = 1<<16 - 1; - MaxUint32 = 1<<32 - 1; - MaxUint64 = 1<<64 - 1; + MaxInt8 = 1<<7 - 1; + MinInt8 = -1 << 7; + MaxInt16 = 1<<15 - 1; + MinInt16 = -1 << 15; + MaxInt32 = 1<<31 - 1; + MinInt32 = -1 << 31; + MaxInt64 = 1<<63 - 1; + MinInt64 = -1 << 63; + MaxUint8 = 1<<8 - 1; + MaxUint16 = 1<<16 - 1; + MaxUint32 = 1<<32 - 1; + MaxUint64 = 1<<64 - 1; ) // BUG(rsc): The manual should define the special cases for all of these functions. diff --git a/src/pkg/math/exp.go b/src/pkg/math/exp.go index 22014daac..2bf80bcdd 100644 --- a/src/pkg/math/exp.go +++ b/src/pkg/math/exp.go @@ -93,16 +93,15 @@ func Exp(x float64) float64 { Ln2Hi = 6.93147180369123816490e-01; Ln2Lo = 1.90821492927058770002e-10; Log2e = 1.44269504088896338700e+00; - - P1 = 1.66666666666666019037e-01; /* 0x3FC55555; 0x5555553E */ - P2 = -2.77777777770155933842e-03; /* 0xBF66C16C; 0x16BEBD93 */ - P3 = 6.61375632143793436117e-05; /* 0x3F11566A; 0xAF25DE2C */ - P4 = -1.65339022054652515390e-06; /* 0xBEBBBD41; 0xC5D26BF1 */ - P5 = 4.13813679705723846039e-08; /* 0x3E663769; 0x72BEA4D0 */ + P1 = 1.66666666666666019037e-01; /* 0x3FC55555; 0x5555553E */ + P2 = -2.77777777770155933842e-03; /* 0xBF66C16C; 0x16BEBD93 */ + P3 = 6.61375632143793436117e-05; /* 0x3F11566A; 0xAF25DE2C */ + P4 = -1.65339022054652515390e-06; /* 0xBEBBBD41; 0xC5D26BF1 */ + P5 = 4.13813679705723846039e-08; /* 0x3E663769; 0x72BEA4D0 */ Overflow = 7.09782712893383973096e+02; Underflow = -7.45133219101941108420e+02; - NearZero = 1.0/(1<<28); // 2^-28 + NearZero = 1.0/(1<<28); // 2^-28 ) // special cases @@ -129,12 +128,12 @@ func Exp(x float64) float64 { } hi := x - float64(k)*Ln2Hi; lo := float64(k)*Ln2Lo; - r := hi - lo; + r := hi-lo; // compute - t := r * r; - c := r - t*(P1+t*(P2+t*(P3+t*(P4+t*P5)))); - y := 1 - ((lo - (r*c)/(2-c)) - hi); + t := r*r; + c := r - t*(P1 + t*(P2 + t*(P3 + t*(P4 + t*P5)))); + y := 1-((lo - (r*c)/(2-c))-hi); // TODO(rsc): make sure Ldexp can handle boundary k return Ldexp(y, k); } diff --git a/src/pkg/math/fabs.go b/src/pkg/math/fabs.go index 9427c5726..254756cc4 100644 --- a/src/pkg/math/fabs.go +++ b/src/pkg/math/fabs.go @@ -11,4 +11,3 @@ func Fabs(x float64) float64 { } return x; } - diff --git a/src/pkg/math/fmod.go b/src/pkg/math/fmod.go index 681c921bb..a01c257d9 100644 --- a/src/pkg/math/fmod.go +++ b/src/pkg/math/fmod.go @@ -29,7 +29,7 @@ func Fmod(x, y float64) float64 { for r >= y { rfr, rexp := Frexp(r); if rfr < yfr { - rexp = rexp - 1; + rexp = rexp-1; } r = r - Ldexp(y, rexp-yexp); } diff --git a/src/pkg/math/hypot.go b/src/pkg/math/hypot.go index 411f74e4f..6ba8fb794 100644 --- a/src/pkg/math/hypot.go +++ b/src/pkg/math/hypot.go @@ -45,5 +45,5 @@ func Hypot(p, q float64) float64 { q = q*r; r = q/p; } - panic("unreachable") + panic("unreachable"); } diff --git a/src/pkg/math/log.go b/src/pkg/math/log.go index 4f9a37606..22df7ac1b 100644 --- a/src/pkg/math/log.go +++ b/src/pkg/math/log.go @@ -43,7 +43,7 @@ package math // | | // 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 by -// log(1+f) = f - s*(f - R) (if f is not too large) +// log(1+f) = f - s*(f - R) (if f is not too large) // log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy) // // 3. Finally, log(x) = k*Ln2 + log(1+f). @@ -76,15 +76,15 @@ package math // Log(NaN) = NaN func Log(x float64) float64 { const ( - Ln2Hi = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */ - Ln2Lo = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */ - L1 = 6.666666666666735130e-01; /* 3FE55555 55555593 */ - L2 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */ - L3 = 2.857142874366239149e-01; /* 3FD24924 94229359 */ - L4 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */ - L5 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */ - L6 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */ - L7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */ + Ln2Hi = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */ + Ln2Lo = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */ + L1 = 6.666666666666735130e-01; /* 3FE55555 55555593 */ + L2 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */ + L3 = 2.857142874366239149e-01; /* 3FD24924 94229359 */ + L4 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */ + L5 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */ + L6 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */ + L7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */ ) // special cases @@ -103,7 +103,7 @@ func Log(x float64) float64 { f1 *= 2; ki--; } - f := f1 - 1; + f := f1-1; k := float64(ki); // compute @@ -112,9 +112,9 @@ func Log(x float64) float64 { s4 := s2*s2; t1 := s2*(L1 + s4*(L3 + s4*(L5 + s4*L7))); t2 := s4*(L2 + s4*(L4 + s4*L6)); - R := t1 + t2; + R := t1+t2; 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); } // Log10 returns the decimal logarithm of x. @@ -123,6 +123,5 @@ func Log10(x float64) float64 { if x <= 0 { return NaN(); } - return Log(x) * (1/Ln10); + return Log(x)*(1/Ln10); } - diff --git a/src/pkg/math/pow.go b/src/pkg/math/pow.go index 93f4fa8e9..b5364fe7f 100644 --- a/src/pkg/math/pow.go +++ b/src/pkg/math/pow.go @@ -20,7 +20,7 @@ func Pow(x, y float64) float64 { case y == 0.5: return Sqrt(x); case y == -0.5: - return 1 / Sqrt(x); + return 1/Sqrt(x); } absy := y; @@ -34,7 +34,7 @@ func Pow(x, y float64) float64 { return NaN(); } if yi >= 1<<63 { - return Exp(y * Log(x)); + return Exp(y*Log(x)); } // ans = a1 * 2^ae (= 1 for now). @@ -47,7 +47,7 @@ func Pow(x, y float64) float64 { yf--; yi++; } - a1 = Exp(yf * Log(x)); + a1 = Exp(yf*Log(x)); } // ans *= x^yi @@ -72,7 +72,7 @@ func Pow(x, y float64) float64 { // if flip { ans = 1 / ans } // but in the opposite order if flip { - a1 = 1 / a1; + a1 = 1/a1; ae = -ae; } return Ldexp(a1, ae); diff --git a/src/pkg/math/pow10.go b/src/pkg/math/pow10.go index fcdd6e0a1..72a6121cb 100644 --- a/src/pkg/math/pow10.go +++ b/src/pkg/math/pow10.go @@ -13,12 +13,12 @@ package math * than multipication of lower powers of 10. */ -var pow10tab [70]float64; +var pow10tab [70]float64 // Pow10 returns 10**x, the base-10 exponential of x. func Pow10(e int) float64 { if e < 0 { - return 1/Pow10(-e); + return 1 / Pow10(-e); } if e < len(pow10tab) { return pow10tab[e]; @@ -30,8 +30,8 @@ func Pow10(e int) float64 { func init() { pow10tab[0] = 1.0e0; pow10tab[1] = 1.0e1; - for i:=2; i 32764 { var e float64; e, y = Modf(x); - e = e + float64(quad); + e = e+float64(quad); _, f := Modf(0.25*e); quad = int(e - 4*f); } else { k := int32(x); - y = x - float64(k); - quad = (quad + int(k)) & 3; + y = x-float64(k); + quad = (quad+int(k))&3; } if quad&1 != 0 { @@ -45,8 +44,8 @@ func sinus(x float64, quad int) float64 { } yy := y*y; - temp1 := ((((P4*yy+P3)*yy+P2)*yy+P1)*yy+P0)*y; - temp2 := ((((yy+Q3)*yy+Q2)*yy+Q1)*yy+Q0); + temp1 := ((((P4*yy + P3)*yy + P2)*yy + P1)*yy + P0)*y; + temp2 := ((((yy+Q3)*yy + Q2)*yy + Q1)*yy + Q0); return temp1/temp2; } diff --git a/src/pkg/math/sinh.go b/src/pkg/math/sinh.go index 1e55f0ba5..255ea2851 100644 --- a/src/pkg/math/sinh.go +++ b/src/pkg/math/sinh.go @@ -20,14 +20,13 @@ package math // Sinh returns the hyperbolic sine of x. func Sinh(x float64) float64 { // The coefficients are #2029 from Hart & Cheney. (20.36D) - const - ( + const ( P0 = -0.6307673640497716991184787251e+6; P1 = -0.8991272022039509355398013511e+5; P2 = -0.2894211355989563807284660366e+4; P3 = -0.2630563213397497062819489e+2; Q0 = -0.6307673640497716991212077277e+6; - Q1 = 0.1521517378790019070696485176e+5; + Q1 = 0.1521517378790019070696485176e+5; Q2 = -0.173678953558233699533450911e+3; ) @@ -47,8 +46,8 @@ func Sinh(x float64) float64 { default: sq := x*x; - temp = (((P3*sq+P2)*sq+P1)*sq+P0)*x; - temp = temp/(((sq+Q2)*sq+Q1)*sq+Q0); + temp = (((P3*sq + P2)*sq + P1)*sq + P0)*x; + temp = temp/(((sq+Q2)*sq + Q1)*sq + Q0); } if sign { @@ -60,7 +59,7 @@ func Sinh(x float64) float64 { // Cosh returns the hyperbolic cosine of x. func Cosh(x float64) float64 { if x < 0 { - x = - x; + x = -x; } if x > 21 { return Exp(x)/2; diff --git a/src/pkg/math/sqrt.go b/src/pkg/math/sqrt.go index 09bdf6b4c..49ebc6c76 100644 --- a/src/pkg/math/sqrt.go +++ b/src/pkg/math/sqrt.go @@ -40,25 +40,25 @@ func Sqrt(x float64) float64 { y = y*2; exp = exp-1; } - temp := 0.5 * (1+y); + temp := 0.5*(1+y); for exp > 60 { temp = temp * float64(1<<30); - exp = exp - 60; + exp = exp-60; } for exp < -60 { temp = temp / float64(1<<30); - exp = exp + 60; + exp = exp+60; } if exp >= 0 { exp = 1 << uint(exp/2); - temp = temp * float64(exp); + temp = temp*float64(exp); } else { - exp = 1 << uint(-exp/2); - temp = temp / float64(exp); + exp = 1 << uint(-exp / 2); + temp = temp/float64(exp); } - for i:=0; i<=4; i++ { + for i := 0; i <= 4; i++ { temp = 0.5*(temp + x/temp); } return temp; diff --git a/src/pkg/math/sqrt_decl.go b/src/pkg/math/sqrt_decl.go index 4e9112d26..e50774645 100644 --- a/src/pkg/math/sqrt_decl.go +++ b/src/pkg/math/sqrt_decl.go @@ -5,4 +5,3 @@ package math func Sqrt(x float64) float64 - diff --git a/src/pkg/math/tan.go b/src/pkg/math/tan.go index a8e6b15c9..7287d80ef 100644 --- a/src/pkg/math/tan.go +++ b/src/pkg/math/tan.go @@ -12,15 +12,14 @@ package math // Tan returns the tangent of x. func Tan(x float64) float64 { // Coefficients are #4285 from Hart & Cheney. (19.74D) - const - ( + const ( P0 = -.1306820264754825668269611177e+5; - P1 = .1055970901714953193602353981e+4; + P1 = .1055970901714953193602353981e+4; P2 = -.1550685653483266376941705728e+2; - P3 = .3422554387241003435328470489e-1; - P4 = .3386638642677172096076369e-4; + P3 = .3422554387241003435328470489e-1; + P4 = .3386638642677172096076369e-4; Q0 = -.1663895238947119001851464661e+5; - Q1 = .4765751362916483698926655581e+4; + Q1 = .4765751362916483698926655581e+4; Q2 = -.1555033164031709966900124574e+3; ) @@ -30,14 +29,14 @@ func Tan(x float64) float64 { x = -x; sign = true; } - x = x * (4/Pi); /* overflow? */ + x = x*(4/Pi); /* overflow? */ var e float64; e, x = Modf(x); i := int32(e); - switch i & 3 { + switch i&3 { case 1: - x = 1 - x; + x = 1-x; flag = true; case 2: @@ -45,13 +44,13 @@ func Tan(x float64) float64 { flag = true; case 3: - x = 1 - x; + x = 1-x; sign = !sign; } xsq := x*x; - temp := ((((P4*xsq+P3)*xsq+P2)*xsq+P1)*xsq+P0)*x; - temp = temp/(((xsq+Q2)*xsq+Q1)*xsq+Q0); + temp := ((((P4*xsq + P3)*xsq + P2)*xsq + P1)*xsq + P0)*x; + temp = temp/(((xsq+Q2)*xsq + Q1)*xsq + Q0); if flag { if temp == 0 { diff --git a/src/pkg/math/tanh.go b/src/pkg/math/tanh.go index 20dc5b79d..dd403a4e0 100644 --- a/src/pkg/math/tanh.go +++ b/src/pkg/math/tanh.go @@ -20,7 +20,7 @@ func Tanh(x float64) float64 { if x > 21 { return -1; } - return -Sinh(x)/Cosh(x); + return -Sinh(x) / Cosh(x); } if x > 21 { return 1; diff --git a/src/pkg/once/once.go b/src/pkg/once/once.go index a87189ccc..3270f9aec 100644 --- a/src/pkg/once/once.go +++ b/src/pkg/once/once.go @@ -9,12 +9,12 @@ package once import "sync" type job struct { - done bool; + done bool; sync.Mutex; // should probably be sync.Notification or some such } var jobs = make(map[func()]*job) -var joblock sync.Mutex; +var joblock sync.Mutex // Do is the the only exported piece of the package. // For one-time initialization that is not done during init, @@ -27,7 +27,7 @@ var joblock sync.Mutex; // Since a func() expression typically evaluates to a differerent // function value each time it is evaluated, it is incorrect to // pass such values to Do. For example, -// func f(x int) { +// func f(x int) { // Do(func() { fmt.Println(x) }) // } // behaves the same as diff --git a/src/pkg/once/once_test.go b/src/pkg/once/once_test.go index 749805aea..e2e6c2c09 100644 --- a/src/pkg/once/once_test.go +++ b/src/pkg/once/once_test.go @@ -9,9 +9,10 @@ import ( "testing"; ) -var ncall int; +var ncall int + func call() { - ncall++ + ncall++; } func TestDo(t *testing.T) { diff --git a/src/pkg/os/dir_darwin_386.go b/src/pkg/os/dir_darwin_386.go index 0131ab1b0..c207a19fd 100644 --- a/src/pkg/os/dir_darwin_386.go +++ b/src/pkg/os/dir_darwin_386.go @@ -10,7 +10,7 @@ import ( ) const ( - blockSize = 4096 // TODO(r): use statfs + blockSize = 4096; // TODO(r): use statfs ) // Readdirnames reads the contents of the directory associated with file and @@ -29,7 +29,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { d := file.dirinfo; size := count; if size < 0 { - size = 100 + size = 100; } names = make([]string, 0, size); // Empty with room to grow. for count != 0 { @@ -44,7 +44,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { return names, NewSyscallError("getdirentries", errno); } if d.nbuf <= 0 { - break // EOF + break; // EOF } } // Drain the buffer @@ -52,28 +52,28 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp])); if dirent.Reclen == 0 { d.bufp = d.nbuf; - break + break; } d.bufp += int(dirent.Reclen); if dirent.Ino == 0 { // File absent in directory. - continue + continue; } bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0])); - var name = string(bytes[0:dirent.Namlen]); + var name = string(bytes[0 : dirent.Namlen]); if name == "." || name == ".." { // Useless names - continue + continue; } count--; if len(names) == cap(names) { nnames := make([]string, len(names), 2*len(names)); for i := 0; i < len(names); i++ { - nnames[i] = names[i] + nnames[i] = names[i]; } names = nnames; } - names = names[0:len(names)+1]; + names = names[0 : len(names)+1]; names[len(names)-1] = name; } } - return names, nil + return names, nil; } diff --git a/src/pkg/os/dir_darwin_amd64.go b/src/pkg/os/dir_darwin_amd64.go index 7701b7d0d..d42c59e91 100644 --- a/src/pkg/os/dir_darwin_amd64.go +++ b/src/pkg/os/dir_darwin_amd64.go @@ -10,7 +10,7 @@ import ( ) const ( - blockSize = 4096 // TODO(r): use statfs + blockSize = 4096; // TODO(r): use statfs ) func (file *File) Readdirnames(count int) (names []string, err Error) { @@ -24,7 +24,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { d := file.dirinfo; size := count; if size < 0 { - size = 100 + size = 100; } names = make([]string, 0, size); // Empty with room to grow. for count != 0 { @@ -39,7 +39,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { return names, NewSyscallError("getdirentries", errno); } if d.nbuf <= 0 { - break // EOF + break; // EOF } } // Drain the buffer @@ -47,28 +47,28 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp])); if dirent.Reclen == 0 { d.bufp = d.nbuf; - break + break; } d.bufp += int(dirent.Reclen); if dirent.Ino == 0 { // File absent in directory. - continue + continue; } bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0])); - var name = string(bytes[0:dirent.Namlen]); + var name = string(bytes[0 : dirent.Namlen]); if name == "." || name == ".." { // Useless names - continue + continue; } count--; if len(names) == cap(names) { nnames := make([]string, len(names), 2*len(names)); for i := 0; i < len(names); i++ { - nnames[i] = names[i] + nnames[i] = names[i]; } names = nnames; } - names = names[0:len(names)+1]; + names = names[0 : len(names)+1]; names[len(names)-1] = name; } } - return names, nil + return names, nil; } diff --git a/src/pkg/os/dir_linux_386.go b/src/pkg/os/dir_linux_386.go index 0e70f0ba0..64db8827b 100644 --- a/src/pkg/os/dir_linux_386.go +++ b/src/pkg/os/dir_linux_386.go @@ -14,16 +14,16 @@ import ( ) const ( - blockSize = 4096 // TODO(r): use statfs + blockSize = 4096; // TODO(r): use statfs ) func clen(n []byte) int { for i := 0; i < len(n); i++ { if n[i] == 0 { - return i + return i; } } - return len(n) + return len(n); } func (file *File) Readdirnames(count int) (names []string, err Error) { @@ -37,7 +37,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { d := file.dirinfo; size := count; if size < 0 { - size = 100 + size = 100; } names = make([]string, 0, size); // Empty with room to grow. for count != 0 { @@ -46,10 +46,10 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { var errno int; d.nbuf, errno = syscall.Getdents(file.fd, d.buf); if errno != 0 { - return names, NewSyscallError("getdents", errno) + return names, NewSyscallError("getdents", errno); } if d.nbuf <= 0 { - break // EOF + break; // EOF } d.bufp = 0; } @@ -58,22 +58,22 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp])); d.bufp += int(dirent.Reclen); if dirent.Ino == 0 { // File absent in directory. - continue + continue; } bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0])); var name = string(bytes[0:clen(bytes)]); if name == "." || name == ".." { // Useless names - continue + continue; } count--; if len(names) == cap(names) { nnames := make([]string, len(names), 2*len(names)); for i := 0; i < len(names); i++ { - nnames[i] = names[i] + nnames[i] = names[i]; } names = nnames; } - names = names[0:len(names)+1]; + names = names[0 : len(names)+1]; names[len(names)-1] = name; } } diff --git a/src/pkg/os/dir_linux_amd64.go b/src/pkg/os/dir_linux_amd64.go index 8bd29b27c..d6e77016c 100644 --- a/src/pkg/os/dir_linux_amd64.go +++ b/src/pkg/os/dir_linux_amd64.go @@ -10,16 +10,16 @@ import ( ) const ( - blockSize = 4096 // TODO(r): use statfs + blockSize = 4096; // TODO(r): use statfs ) func clen(n []byte) int { for i := 0; i < len(n); i++ { if n[i] == 0 { - return i + return i; } } - return len(n) + return len(n); } func (file *File) Readdirnames(count int) (names []string, err Error) { @@ -33,7 +33,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { d := file.dirinfo; size := count; if size < 0 { - size = 100 + size = 100; } names = make([]string, 0, size); // Empty with room to grow. for count != 0 { @@ -42,10 +42,10 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { var errno int; d.nbuf, errno = syscall.Getdents(file.fd, d.buf); if errno != 0 { - return names, NewSyscallError("getdents", errno) + return names, NewSyscallError("getdents", errno); } if d.nbuf <= 0 { - break // EOF + break; // EOF } d.bufp = 0; } @@ -54,22 +54,22 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp])); d.bufp += int(dirent.Reclen); if dirent.Ino == 0 { // File absent in directory. - continue + continue; } bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0])); var name = string(bytes[0:clen(bytes)]); if name == "." || name == ".." { // Useless names - continue + continue; } count--; if len(names) == cap(names) { nnames := make([]string, len(names), 2*len(names)); for i := 0; i < len(names); i++ { - nnames[i] = names[i] + nnames[i] = names[i]; } names = nnames; } - names = names[0:len(names)+1]; + names = names[0 : len(names)+1]; names[len(names)-1] = name; } } diff --git a/src/pkg/os/dir_linux_arm.go b/src/pkg/os/dir_linux_arm.go index 0e70f0ba0..64db8827b 100644 --- a/src/pkg/os/dir_linux_arm.go +++ b/src/pkg/os/dir_linux_arm.go @@ -14,16 +14,16 @@ import ( ) const ( - blockSize = 4096 // TODO(r): use statfs + blockSize = 4096; // TODO(r): use statfs ) func clen(n []byte) int { for i := 0; i < len(n); i++ { if n[i] == 0 { - return i + return i; } } - return len(n) + return len(n); } func (file *File) Readdirnames(count int) (names []string, err Error) { @@ -37,7 +37,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { d := file.dirinfo; size := count; if size < 0 { - size = 100 + size = 100; } names = make([]string, 0, size); // Empty with room to grow. for count != 0 { @@ -46,10 +46,10 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { var errno int; d.nbuf, errno = syscall.Getdents(file.fd, d.buf); if errno != 0 { - return names, NewSyscallError("getdents", errno) + return names, NewSyscallError("getdents", errno); } if d.nbuf <= 0 { - break // EOF + break; // EOF } d.bufp = 0; } @@ -58,22 +58,22 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp])); d.bufp += int(dirent.Reclen); if dirent.Ino == 0 { // File absent in directory. - continue + continue; } bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0])); var name = string(bytes[0:clen(bytes)]); if name == "." || name == ".." { // Useless names - continue + continue; } count--; if len(names) == cap(names) { nnames := make([]string, len(names), 2*len(names)); for i := 0; i < len(names); i++ { - nnames[i] = names[i] + nnames[i] = names[i]; } names = nnames; } - names = names[0:len(names)+1]; + names = names[0 : len(names)+1]; names[len(names)-1] = name; } } diff --git a/src/pkg/os/dir_nacl_386.go b/src/pkg/os/dir_nacl_386.go index 90072d54d..97767ddc0 100644 --- a/src/pkg/os/dir_nacl_386.go +++ b/src/pkg/os/dir_nacl_386.go @@ -14,16 +14,16 @@ import ( ) const ( - blockSize = 4096 // TODO(r): use statfs + blockSize = 4096; // TODO(r): use statfs ) func clen(n []byte) int { for i := 0; i < len(n); i++ { if n[i] == 0 { - return i + return i; } } - return len(n) + return len(n); } func (file *File) Readdirnames(count int) (names []string, err Error) { @@ -37,7 +37,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { d := file.dirinfo; size := count; if size < 0 { - size = 100 + size = 100; } names = make([]string, 0, size); // Empty with room to grow. for count != 0 { @@ -46,10 +46,10 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { var errno int; d.nbuf, errno = syscall.Getdents(file.fd, d.buf); if errno != 0 { - return names, NewSyscallError("getdents", errno) + return names, NewSyscallError("getdents", errno); } if d.nbuf <= 0 { - break // EOF + break; // EOF } d.bufp = 0; } @@ -58,22 +58,22 @@ func (file *File) Readdirnames(count int) (names []string, err Error) { dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp])); d.bufp += int(dirent.Reclen); if dirent.Ino == 0 { // File absent in directory. - continue + continue; } bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0])); var name = string(bytes[0:clen(bytes)]); if name == "." || name == ".." { // Useless names - continue + continue; } count--; if len(names) == cap(names) { nnames := make([]string, len(names), 2*len(names)); for i := 0; i < len(names); i++ { - nnames[i] = names[i] + nnames[i] = names[i]; } names = nnames; } - names = names[0:len(names)+1]; + names = names[0 : len(names)+1]; names[len(names)-1] = name; } } diff --git a/src/pkg/os/env.go b/src/pkg/os/env.go index 04d759128..3523f57e4 100644 --- a/src/pkg/os/env.go +++ b/src/pkg/os/env.go @@ -11,17 +11,17 @@ import ( ) // ENOENV is the Error indicating that an environment variable does not exist. -var ENOENV = NewError("no such environment variable"); +var ENOENV = NewError("no such environment variable") -var env map[string] string; +var env map[string]string func copyenv() { - env = make(map[string] string); + env = make(map[string]string); for _, s := range Envs { for j := 0; j < len(s); j++ { if s[j] == '=' { - env[s[0:j]] = s[j+1:len(s)]; + env[s[0:j]] = s[j+1 : len(s)]; break; } } @@ -65,7 +65,7 @@ func Setenv(key, value string) Error { // Clearenv deletes all environment variables. func Clearenv() { once.Do(copyenv); // prevent copyenv in Getenv/Setenv - env = make(map[string] string); + env = make(map[string]string); } // Environ returns an array of strings representing the environment, @@ -78,7 +78,7 @@ func Environ() []string { // check i < len(a) for safety, // in case env is changing underfoot. if i < len(a) { - a[i] = k + "=" + v; + a[i] = k+"="+v; i++; } } diff --git a/src/pkg/os/error.go b/src/pkg/os/error.go index 5430a4b30..eca45dd26 100644 --- a/src/pkg/os/error.go +++ b/src/pkg/os/error.go @@ -8,73 +8,75 @@ import syscall "syscall" // An Error can represent any printable error condition. type Error interface { - String() string + String() string; } // A helper type that can be embedded or wrapped to simplify satisfying // Error. type ErrorString string + func (e ErrorString) String() string { - return string(e) + return string(e); } // NewError converts s to an ErrorString, which satisfies the Error interface. func NewError(s string) Error { - return ErrorString(s) + return ErrorString(s); } // Errno is the Unix error number. Names such as EINVAL are simple // wrappers to convert the error number into an Error. type Errno int64 + func (e Errno) String() string { - return syscall.Errstr(int(e)) + return syscall.Errstr(int(e)); } // Commonly known Unix errors. var ( - EPERM Error = Errno(syscall.EPERM); - ENOENT Error = Errno(syscall.ENOENT); - ESRCH Error = Errno(syscall.ESRCH); - EINTR Error = Errno(syscall.EINTR); - EIO Error = Errno(syscall.EIO); - ENXIO Error = Errno(syscall.ENXIO); - E2BIG Error = Errno(syscall.E2BIG); - ENOEXEC Error = Errno(syscall.ENOEXEC); - EBADF Error = Errno(syscall.EBADF); - ECHILD Error = Errno(syscall.ECHILD); - EDEADLK Error = Errno(syscall.EDEADLK); - ENOMEM Error = Errno(syscall.ENOMEM); - EACCES Error = Errno(syscall.EACCES); - EFAULT Error = Errno(syscall.EFAULT); - EBUSY Error = Errno(syscall.EBUSY); - EEXIST Error = Errno(syscall.EEXIST); - EXDEV Error = Errno(syscall.EXDEV); - ENODEV Error = Errno(syscall.ENODEV); - ENOTDIR Error = Errno(syscall.ENOTDIR); - EISDIR Error = Errno(syscall.EISDIR); - EINVAL Error = Errno(syscall.EINVAL); - ENFILE Error = Errno(syscall.ENFILE); - EMFILE Error = Errno(syscall.EMFILE); - ENOTTY Error = Errno(syscall.ENOTTY); - EFBIG Error = Errno(syscall.EFBIG); - ENOSPC Error = Errno(syscall.ENOSPC); - ESPIPE Error = Errno(syscall.ESPIPE); - EROFS Error = Errno(syscall.EROFS); - EMLINK Error = Errno(syscall.EMLINK); - EPIPE Error = Errno(syscall.EPIPE); - EAGAIN Error = Errno(syscall.EAGAIN); - EDOM Error = Errno(syscall.EDOM); - ERANGE Error = Errno(syscall.ERANGE); - EADDRINUSE Error = Errno(syscall.EADDRINUSE); - ECONNREFUSED Error = Errno(syscall.ECONNREFUSED); - ENAMETOOLONG Error = Errno(syscall.ENAMETOOLONG); + EPERM Error = Errno(syscall.EPERM); + ENOENT Error = Errno(syscall.ENOENT); + ESRCH Error = Errno(syscall.ESRCH); + EINTR Error = Errno(syscall.EINTR); + EIO Error = Errno(syscall.EIO); + ENXIO Error = Errno(syscall.ENXIO); + E2BIG Error = Errno(syscall.E2BIG); + ENOEXEC Error = Errno(syscall.ENOEXEC); + EBADF Error = Errno(syscall.EBADF); + ECHILD Error = Errno(syscall.ECHILD); + EDEADLK Error = Errno(syscall.EDEADLK); + ENOMEM Error = Errno(syscall.ENOMEM); + EACCES Error = Errno(syscall.EACCES); + EFAULT Error = Errno(syscall.EFAULT); + EBUSY Error = Errno(syscall.EBUSY); + EEXIST Error = Errno(syscall.EEXIST); + EXDEV Error = Errno(syscall.EXDEV); + ENODEV Error = Errno(syscall.ENODEV); + ENOTDIR Error = Errno(syscall.ENOTDIR); + EISDIR Error = Errno(syscall.EISDIR); + EINVAL Error = Errno(syscall.EINVAL); + ENFILE Error = Errno(syscall.ENFILE); + EMFILE Error = Errno(syscall.EMFILE); + ENOTTY Error = Errno(syscall.ENOTTY); + EFBIG Error = Errno(syscall.EFBIG); + ENOSPC Error = Errno(syscall.ENOSPC); + ESPIPE Error = Errno(syscall.ESPIPE); + EROFS Error = Errno(syscall.EROFS); + EMLINK Error = Errno(syscall.EMLINK); + EPIPE Error = Errno(syscall.EPIPE); + EAGAIN Error = Errno(syscall.EAGAIN); + EDOM Error = Errno(syscall.EDOM); + ERANGE Error = Errno(syscall.ERANGE); + EADDRINUSE Error = Errno(syscall.EADDRINUSE); + ECONNREFUSED Error = Errno(syscall.ECONNREFUSED); + ENAMETOOLONG Error = Errno(syscall.ENAMETOOLONG); ) // PathError records an error and the operation and file path that caused it. type PathError struct { - Op string; - Path string; - Error Error; + Op string; + Path string; + Error Error; } func (e *PathError) String() string { @@ -83,8 +85,8 @@ func (e *PathError) String() string { // SyscallError records an error from a specific system call. type SyscallError struct { - Syscall string; - Errno Errno; + Syscall string; + Errno Errno; } func (e *SyscallError) String() string { @@ -98,5 +100,5 @@ func NewSyscallError(syscall string, errno int) Error { if errno == 0 { return nil; } - return &SyscallError{syscall, Errno(errno)} + return &SyscallError{syscall, Errno(errno)}; } diff --git a/src/pkg/os/exec.go b/src/pkg/os/exec.go index c80ef43cb..ac158c8d3 100644 --- a/src/pkg/os/exec.go +++ b/src/pkg/os/exec.go @@ -15,9 +15,7 @@ import ( // descriptor 0 (standard input), fd[1] descriptor 1, and so on. A nil entry // will cause the child to have no open file descriptor with that index. // If dir is not empty, the child chdirs into the directory before execing the program. -func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*File) - (pid int, err Error) -{ +func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*File) (pid int, err Error) { // Create array of integer (system) fds. intfd := make([]int, len(fd)); for i, f := range fd { @@ -59,17 +57,17 @@ func Exec(argv0 string, argv []string, envv []string) Error { // Waitmsg stores the information about an exited process as reported by Wait. type Waitmsg struct { - Pid int; // The process's id. + Pid int; // The process's id. syscall.WaitStatus; // System-dependent status info. - Rusage *syscall.Rusage; // System-dependent resource usage info. + Rusage *syscall.Rusage; // System-dependent resource usage info. } // Options for Wait. const ( - WNOHANG = syscall.WNOHANG; // Don't wait if no process has exited. - WSTOPPED = syscall.WSTOPPED; // If set, status of stopped subprocesses is also reported. - WUNTRACED = WSTOPPED; - WRUSAGE = 1<<20; // Record resource usage. + WNOHANG = syscall.WNOHANG; // Don't wait if no process has exited. + WSTOPPED = syscall.WSTOPPED; // If set, status of stopped subprocesses is also reported. + WUNTRACED = WSTOPPED; + WRUSAGE = 1<<20; // Record resource usage. ) // WRUSAGE must not be too high a bit, to avoid clashing with Linux's @@ -82,7 +80,7 @@ const ( func Wait(pid int, options int) (w *Waitmsg, err Error) { var status syscall.WaitStatus; var rusage *syscall.Rusage; - if options & WRUSAGE != 0 { + if options&WRUSAGE != 0 { rusage = new(syscall.Rusage); options ^= WRUSAGE; } @@ -100,7 +98,7 @@ func Wait(pid int, options int) (w *Waitmsg, err Error) { // Convert i to decimal string. func itod(i int) string { if i == 0 { - return "0" + return "0"; } u := uint64(i); @@ -113,15 +111,15 @@ func itod(i int) string { bp := len(b); for ; u > 0; u /= 10 { bp--; - b[bp] = byte(u%10) + '0' + b[bp] = byte(u%10) + '0'; } if i < 0 { bp--; - b[bp] = '-' + b[bp] = '-'; } - return string(b[bp:len(b)]) + return string(b[bp:len(b)]); } func (w Waitmsg) String() string { @@ -141,7 +139,7 @@ func (w Waitmsg) String() string { res = "continued"; } if w.CoreDump() { - res += " (core dumped)" + res += " (core dumped)"; } return res; } diff --git a/src/pkg/os/file.go b/src/pkg/os/file.go index c9c00788f..1f1d86f4e 100644 --- a/src/pkg/os/file.go +++ b/src/pkg/os/file.go @@ -19,52 +19,52 @@ type dirInfo struct { // File represents an open file descriptor. type File struct { - fd int; + fd int; name string; dirinfo *dirInfo; // nil unless directory being read - nepipe int; // number of consecutive EPIPE in Write + nepipe int; // number of consecutive EPIPE in Write } // Fd returns the integer Unix file descriptor referencing the open file. func (file *File) Fd() int { - return file.fd + return file.fd; } // Name returns the name of the file as presented to Open. func (file *File) Name() string { - return file.name + return file.name; } // NewFile returns a new File with the given file descriptor and name. func NewFile(fd int, name string) *File { if fd < 0 { - return nil + return nil; } - return &File{fd, name, nil, 0} + return &File{fd, name, nil, 0}; } // Stdin, Stdout, and Stderr are open Files pointing to the standard input, // standard output, and standard error file descriptors. var ( - Stdin = NewFile(0, "/dev/stdin"); - Stdout = NewFile(1, "/dev/stdout"); - Stderr = NewFile(2, "/dev/stderr"); + Stdin = NewFile(0, "/dev/stdin"); + Stdout = NewFile(1, "/dev/stdout"); + Stderr = NewFile(2, "/dev/stderr"); ) // Flags to Open wrapping those of the underlying system. Not all flags // may be implemented on a given system. const ( - O_RDONLY = syscall.O_RDONLY; // open the file read-only. - O_WRONLY = syscall.O_WRONLY; // open the file write-only. - O_RDWR = syscall.O_RDWR; // open the file read-write. - O_APPEND = syscall.O_APPEND; // open the file append-only. - O_ASYNC = syscall.O_ASYNC; // generate a signal when I/O is available. - O_CREAT = syscall.O_CREAT; // create a new file if none exists. - O_NOCTTY = syscall.O_NOCTTY; // do not make file the controlling tty. - O_NONBLOCK = syscall.O_NONBLOCK; // open in non-blocking mode. - O_NDELAY = O_NONBLOCK; // synonym for O_NONBLOCK - O_SYNC = syscall.O_SYNC; // open for synchronous I/O. - O_TRUNC = syscall.O_TRUNC; // if possible, truncate file when opened. + O_RDONLY = syscall.O_RDONLY; // open the file read-only. + O_WRONLY = syscall.O_WRONLY; // open the file write-only. + O_RDWR = syscall.O_RDWR; // open the file read-write. + O_APPEND = syscall.O_APPEND; // open the file append-only. + O_ASYNC = syscall.O_ASYNC; // generate a signal when I/O is available. + O_CREAT = syscall.O_CREAT; // create a new file if none exists. + O_NOCTTY = syscall.O_NOCTTY; // do not make file the controlling tty. + O_NONBLOCK = syscall.O_NONBLOCK; // open in non-blocking mode. + O_NDELAY = O_NONBLOCK; // synonym for O_NONBLOCK + O_SYNC = syscall.O_SYNC; // open for synchronous I/O. + O_TRUNC = syscall.O_TRUNC; // if possible, truncate file when opened. ) // Open opens the named file with specified flag (O_RDONLY etc.) and perm, (0666 etc.) @@ -89,19 +89,20 @@ func Open(name string, flag int, perm int) (file *File, err Error) { // It returns an Error, if any. func (file *File) Close() Error { if file == nil { - return EINVAL + return EINVAL; } var err Error; if e := syscall.Close(file.fd); e != 0 { err = &PathError{"close", file.name, Errno(e)}; } - file.fd = -1; // so it can't be closed again + file.fd = -1; // so it can't be closed again return err; } type eofError int + func (eofError) String() string { - return "EOF" + return "EOF"; } // EOF is the Error returned by Read when no more input is available. @@ -117,19 +118,19 @@ var EOF Error = eofError(0) // TODO(r): Add Pread, Pwrite (maybe ReadAt, WriteAt). func (file *File) Read(b []byte) (n int, err Error) { if file == nil { - return 0, EINVAL + return 0, EINVAL; } n, e := syscall.Read(file.fd, b); if n < 0 { n = 0; } if n == 0 && e == 0 { - return 0, EOF + return 0, EOF; } if e != 0 { err = &PathError{"read", file.name, Errno(e)}; } - return n, err + return n, err; } // ReadAt reads len(b) bytes from the File starting at byte offset off. @@ -158,11 +159,11 @@ func (file *File) ReadAt(b []byte, off int64) (n int, err Error) { // Write returns a non-nil Error when n != len(b). func (file *File) Write(b []byte) (n int, err Error) { if file == nil { - return 0, EINVAL + return 0, EINVAL; } n, e := syscall.Write(file.fd, b); if n < 0 { - n = 0 + n = 0; } if e == syscall.EPIPE { file.nepipe++; @@ -175,7 +176,7 @@ func (file *File) Write(b []byte) (n int, err Error) { if e != 0 { err = &PathError{"write", file.name, Errno(e)}; } - return n, err + return n, err; } // WriteAt writes len(b) bytes to the File starting at byte offset off. @@ -210,17 +211,17 @@ func (file *File) Seek(offset int64, whence int) (ret int64, err Error) { if e != 0 { return 0, &PathError{"seek", file.name, Errno(e)}; } - return r, nil + return r, nil; } // WriteString is like Write, but writes the contents of string s rather than // an array of bytes. func (file *File) WriteString(s string) (ret int, err Error) { if file == nil { - return 0, EINVAL + return 0, EINVAL; } b := syscall.StringByteSlice(s); - b = b[0:len(b)-1]; + b = b[0 : len(b)-1]; return file.Write(b); } @@ -240,7 +241,7 @@ func Pipe() (r *File, w *File, err Error) { syscall.CloseOnExec(p[1]); syscall.ForkLock.RUnlock(); - return NewFile(p[0], "|0"), NewFile(p[1], "|1"), nil + return NewFile(p[0], "|0"), NewFile(p[1], "|1"), nil; } // Mkdir creates a new directory with the specified name and permission bits. @@ -271,7 +272,7 @@ func Stat(name string) (dir *Dir, err Error) { statp = &stat; } } - return dirFromStat(name, new(Dir), &lstat, statp), nil + return dirFromStat(name, new(Dir), &lstat, statp), nil; } // Stat returns the Dir structure describing file. @@ -282,7 +283,7 @@ func (file *File) Stat() (dir *Dir, err Error) { if e != 0 { return nil, &PathError{"stat", file.name, Errno(e)}; } - return dirFromStat(file.name, new(Dir), &stat, &stat), nil + return dirFromStat(file.name, new(Dir), &stat, &stat), nil; } // Lstat returns the Dir structure describing the named file and an error, if any. @@ -294,7 +295,7 @@ func Lstat(name string) (dir *Dir, err Error) { if e != 0 { return nil, &PathError{"lstat", name, Errno(e)}; } - return dirFromStat(name, new(Dir), &stat, &stat), nil + return dirFromStat(name, new(Dir), &stat, &stat), nil; } // Readdir reads the contents of the directory associated with file and @@ -310,18 +311,18 @@ func (file *File) Readdir(count int) (dirs []Dir, err Error) { dirname += "/"; names, err1 := file.Readdirnames(count); if err1 != nil { - return nil, err1 + return nil, err1; } dirs = make([]Dir, len(names)); for i, filename := range names { - dirp, err := Stat(dirname + filename); - if dirp == nil || err != nil { - dirs[i].Name = filename // rest is already zeroed out + dirp, err := Stat(dirname+filename); + if dirp == nil || err != nil { + dirs[i].Name = filename; // rest is already zeroed out } else { - dirs[i] = *dirp + dirs[i] = *dirp; } } - return + return; } // Chdir changes the current working directory to the named directory. @@ -374,10 +375,10 @@ func Remove(name string) Error { // LinkError records an error during a link or symlink // system call and the paths that caused it. type LinkError struct { - Op string; - Old string; - New string; - Error Error; + Op string; + Old string; + New string; + Error Error; } func (e *LinkError) String() string { @@ -479,4 +480,3 @@ func (f *File) Truncate(size int64) Error { } return nil; } - diff --git a/src/pkg/os/getwd.go b/src/pkg/os/getwd.go index e23f74df0..bb8637b2b 100644 --- a/src/pkg/os/getwd.go +++ b/src/pkg/os/getwd.go @@ -5,7 +5,7 @@ package os import ( - "syscall" + "syscall"; ) // Getwd returns a rooted path name corresponding to the @@ -27,11 +27,11 @@ func Getwd() (string, Error) { // Clumsy but widespread kludge: // if $PWD is set and matches ".", use it. - pwd:= Getenv("PWD"); + pwd := Getenv("PWD"); if len(pwd) > 0 && pwd[0] == '/' { d, err := Stat(pwd); if err == nil && d.Dev == dot.Dev && d.Ino == dot.Ino { - return pwd, nil + return pwd, nil; } } @@ -43,14 +43,14 @@ func Getwd() (string, Error) { return "", err; } if root.Dev == dot.Dev && root.Ino == dot.Ino { - return "/", nil + return "/", nil; } // General algorithm: find name in parent // and then find name of parent. Each iteration // adds /name to the beginning of pwd. pwd = ""; - for parent := "..";; parent = "../" + parent { + for parent := ".."; ; parent = "../"+parent { if len(parent) >= 1024 { // Sanity check return "", ENAMETOOLONG; } @@ -66,9 +66,9 @@ func Getwd() (string, Error) { return "", err; } for _, name := range names { - d, _ := Lstat(parent + "/" + name); + d, _ := Lstat(parent+"/"+name); if d.Dev == dot.Dev && d.Ino == dot.Ino { - pwd = "/" + name + pwd; + pwd = "/"+name+pwd; goto Found; } } @@ -88,5 +88,5 @@ func Getwd() (string, Error) { // Set up for next round. dot = pd; } - return pwd, nil + return pwd, nil; } diff --git a/src/pkg/os/os_test.go b/src/pkg/os/os_test.go index f711f73a5..2f77db20c 100644 --- a/src/pkg/os/os_test.go +++ b/src/pkg/os/os_test.go @@ -5,12 +5,12 @@ package os_test import ( - "bytes"; - "fmt"; - "io"; - . "os"; - "strings"; - "testing"; + "bytes"; + "fmt"; + "io"; + . "os"; + "strings"; + "testing"; ) var dot = []string{ @@ -23,7 +23,7 @@ var dot = []string{ "time.go", "types.go", "stat_darwin_amd64.go", - "stat_linux_amd64.go" + "stat_linux_amd64.go", } var etc = []string{ @@ -44,13 +44,13 @@ func size(name string, t *testing.T) uint64 { n, e := file.Read(&buf); len += n; if e == EOF { - break + break; } if e != nil { t.Fatal("read failed:", err); } } - return uint64(len) + return uint64(len); } func TestStat(t *testing.T) { @@ -120,7 +120,7 @@ func testReaddirnames(dir string, contents []string, t *testing.T) { if found { t.Error("present twice:", m); } - found = true + found = true; } } if !found { @@ -146,7 +146,7 @@ func testReaddir(dir string, contents []string, t *testing.T) { if found { t.Error("present twice:", m); } - found = true + found = true; } } if !found { @@ -175,12 +175,12 @@ func smallReaddirnames(file *File, length int, t *testing.T) []string { t.Fatalf("readdir %q failed: %v", file.Name(), err); } if len(d) == 0 { - break + break; } names[count] = d[0]; count++; } - return names[0:count] + return names[0:count]; } // Check that reading a directory one entry at a time gives the same result @@ -210,8 +210,8 @@ func TestReaddirnamesOneAtATime(t *testing.T) { func TestHardLink(t *testing.T) { from, to := "hardlinktestfrom", "hardlinktestto"; - Remove(from); // Just in case. - file, err := Open(to, O_CREAT | O_WRONLY, 0666); + Remove(from); // Just in case. + file, err := Open(to, O_CREAT|O_WRONLY, 0666); if err != nil { t.Fatalf("open %q failed: %v", to, err); } @@ -239,8 +239,8 @@ func TestHardLink(t *testing.T) { func TestSymLink(t *testing.T) { from, to := "symlinktestfrom", "symlinktestto"; - Remove(from); // Just in case. - file, err := Open(to, O_CREAT | O_WRONLY, 0666); + Remove(from); // Just in case. + file, err := Open(to, O_CREAT|O_WRONLY, 0666); if err != nil { t.Fatalf("open %q failed: %v", to, err); } @@ -297,7 +297,7 @@ func TestSymLink(t *testing.T) { func TestLongSymlink(t *testing.T) { s := "0123456789abcdef"; - s = s + s + s + s + s + s + s + s + s + s + s + s + s + s + s + s + s; + s = s+s+s+s+s+s+s+s+s+s+s+s+s+s+s+s+s; from := "longsymlinktestfrom"; err := Symlink(s, from); if err != nil { @@ -347,7 +347,7 @@ func checkMode(t *testing.T, path string, mode uint32) { func TestChmod(t *testing.T) { MkdirAll("_obj", 0777); const Path = "_obj/_TestChmod_"; - fd, err := Open(Path, O_WRONLY | O_CREAT, 0666); + fd, err := Open(Path, O_WRONLY|O_CREAT, 0666); if err != nil { t.Fatalf("create %s: %s", Path, err); } @@ -386,7 +386,7 @@ func TestChown(t *testing.T) { // basically useless. const Path = "/tmp/_TestChown_"; - fd, err := Open(Path, O_WRONLY | O_CREAT, 0666); + fd, err := Open(Path, O_WRONLY|O_CREAT, 0666); if err != nil { t.Fatalf("create %s: %s", Path, err); } @@ -439,7 +439,7 @@ func checkSize(t *testing.T, path string, size uint64) { func TestTruncate(t *testing.T) { MkdirAll("_obj", 0777); const Path = "_obj/_TestTruncate_"; - fd, err := Open(Path, O_WRONLY | O_CREAT, 0666); + fd, err := Open(Path, O_WRONLY|O_CREAT, 0666); if err != nil { t.Fatalf("create %s: %s", Path, err); } @@ -454,7 +454,7 @@ func TestTruncate(t *testing.T) { fd.Truncate(0); checkSize(t, Path, 0); fd.Write(strings.Bytes("surprise!")); - checkSize(t, Path, 13 + 9); // wrote at offset past where hello, world was. + checkSize(t, Path, 13+9); // wrote at offset past where hello, world was. fd.Close(); Remove(Path); } @@ -466,7 +466,7 @@ func TestChdirAndGetwd(t *testing.T) { } // These are chosen carefully not to be symlinks on a Mac // (unlike, say, /var, /etc, and /tmp). - dirs := []string{ "/bin", "/", "/usr/bin" }; + dirs := []string{"/bin", "/", "/usr/bin"}; for mode := 0; mode < 2; mode++ { for _, d := range dirs { if mode == 0 { @@ -529,19 +529,19 @@ func TestSeek(t *testing.T) { io.WriteString(f, data); type test struct { - in int64; - whence int; - out int64; - } - var tests = []test { - test{ 0, 1, int64(len(data)) }, - test{ 0, 0, 0 }, - test{ 5, 0, 5 }, - test{ 0, 2, int64(len(data)) }, - test{ 0, 0, 0 }, - test{ -1, 2, int64(len(data)) - 1 }, - test{ 1<<40, 0, 1<<40 }, - test{ 1<<40, 2, 1<<40 + int64(len(data)) } + in int64; + whence int; + out int64; + } + var tests = []test{ + test{0, 1, int64(len(data))}, + test{0, 0, 0}, + test{5, 0, 5}, + test{0, 2, int64(len(data))}, + test{0, 0, 0}, + test{-1, 2, int64(len(data))-1}, + test{1<<40, 0, 1<<40}, + test{1<<40, 2, 1<<40 + int64(len(data))}, }; for i, tt := range tests { off, err := f.Seek(tt.in, tt.whence); @@ -553,23 +553,23 @@ func TestSeek(t *testing.T) { } type openErrorTest struct { - path string; - mode int; - error string; + path string; + mode int; + error string; } -var openErrorTests = []openErrorTest { - openErrorTest { +var openErrorTests = []openErrorTest{ + openErrorTest{ "/etc/no-such-file", O_RDONLY, "open /etc/no-such-file: no such file or directory", }, - openErrorTest { + openErrorTest{ "/etc", O_WRONLY, "open /etc: is a directory", }, - openErrorTest { + openErrorTest{ "/etc/passwd/group", O_WRONLY, "open /etc/passwd/group: not a directory", @@ -607,7 +607,7 @@ func run(t *testing.T, cmd []string) string { Wait(pid, 0); output := b.String(); if n := len(output); n > 0 && output[n-1] == '\n' { - output = output[0:n-1]; + output = output[0 : n-1]; } if output == "" { t.Fatalf("%v produced no output", cmd); diff --git a/src/pkg/os/path.go b/src/pkg/os/path.go index ca157e50c..de4b020d4 100644 --- a/src/pkg/os/path.go +++ b/src/pkg/os/path.go @@ -35,7 +35,7 @@ func MkdirAll(path string, perm int) Error { if j > 0 { // Create parent - err = MkdirAll(path[0:j-1], perm); + err = MkdirAll(path[0 : j-1], perm); if err != nil { return err; } @@ -91,7 +91,7 @@ func RemoveAll(path string) Error { for { names, err1 := fd.Readdirnames(100); for _, name := range names { - err1 := RemoveAll(path + "/" + name); + err1 := RemoveAll(path+"/"+name); if err == nil { err = err1; } diff --git a/src/pkg/os/path_test.go b/src/pkg/os/path_test.go index d7f595711..cfdd64fc0 100644 --- a/src/pkg/os/path_test.go +++ b/src/pkg/os/path_test.go @@ -5,8 +5,8 @@ package os_test import ( - . "os"; - "testing"; + . "os"; + "testing"; ) func TestMkdirAll(t *testing.T) { @@ -26,7 +26,7 @@ func TestMkdirAll(t *testing.T) { // Make file. fpath := path + "/file"; - _, err = Open(fpath, O_WRONLY | O_CREAT, 0666); + _, err = Open(fpath, O_WRONLY|O_CREAT, 0666); if err != nil { t.Fatalf("create %q: %s", fpath, err); } @@ -65,13 +65,13 @@ func TestRemoveAll(t *testing.T) { // Work directory. path := "_obj/_TestRemoveAll_"; fpath := path + "/file"; - dpath := path + "/dir"; + dpath := path+"/dir"; // Make directory with 1 file and remove. if err := MkdirAll(path, 0777); err != nil { t.Fatalf("MkdirAll %q: %s", path, err); } - fd, err := Open(fpath, O_WRONLY | O_CREAT, 0666); + fd, err := Open(fpath, O_WRONLY|O_CREAT, 0666); if err != nil { t.Fatalf("create %q: %s", fpath, err); } @@ -87,12 +87,12 @@ func TestRemoveAll(t *testing.T) { if err = MkdirAll(dpath, 0777); err != nil { t.Fatalf("MkdirAll %q: %s", dpath, err); } - fd, err = Open(fpath, O_WRONLY | O_CREAT, 0666); + fd, err = Open(fpath, O_WRONLY|O_CREAT, 0666); if err != nil { t.Fatalf("create %q: %s", fpath, err); } fd.Close(); - fd, err = Open(dpath+"/file", O_WRONLY | O_CREAT, 0666); + fd, err = Open(dpath + "/file", O_WRONLY|O_CREAT, 0666); if err != nil { t.Fatalf("create %q: %s", fpath, err); } @@ -109,8 +109,8 @@ func TestRemoveAll(t *testing.T) { t.Fatalf("MkdirAll %q: %s", dpath, err); } - for _, s := range []string{fpath, dpath+"/file1", path+"/zzz"} { - fd, err = Open(s, O_WRONLY | O_CREAT, 0666); + for _, s := range []string{fpath, dpath + "/file1", path+"/zzz"} { + fd, err = Open(s, O_WRONLY|O_CREAT, 0666); if err != nil { t.Fatalf("create %q: %s", s, err); } diff --git a/src/pkg/os/proc.go b/src/pkg/os/proc.go index 3a6f5a16f..0dd295edf 100644 --- a/src/pkg/os/proc.go +++ b/src/pkg/os/proc.go @@ -8,8 +8,8 @@ package os import "syscall" -var Args []string; // provided by runtime -var Envs []string; // provided by runtime +var Args []string // provided by runtime +var Envs []string // provided by runtime // Getuid returns the numeric user id of the caller. @@ -43,4 +43,3 @@ func Getgroups() ([]int, Error) { func Exit(code int) { syscall.Exit(code); } - diff --git a/src/pkg/os/stat_darwin_386.go b/src/pkg/os/stat_darwin_386.go index cc6e54966..b8b2fe3a2 100644 --- a/src/pkg/os/stat_darwin_386.go +++ b/src/pkg/os/stat_darwin_386.go @@ -9,7 +9,7 @@ package os import "syscall" func isSymlink(stat *syscall.Stat_t) bool { - return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK + return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK; } func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { @@ -26,9 +26,9 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atimespec)); dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtimespec)); dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctimespec)); - for i := len(name) - 1; i >= 0; i-- { + for i := len(name)-1; i >= 0; i-- { if name[i] == '/' { - name = name[i+1:len(name)]; + name = name[i+1 : len(name)]; break; } } diff --git a/src/pkg/os/stat_darwin_amd64.go b/src/pkg/os/stat_darwin_amd64.go index c6f031a24..d7400b210 100644 --- a/src/pkg/os/stat_darwin_amd64.go +++ b/src/pkg/os/stat_darwin_amd64.go @@ -9,7 +9,7 @@ package os import "syscall" func isSymlink(stat *syscall.Stat_t) bool { - return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK + return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK; } func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { @@ -26,9 +26,9 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atimespec)); dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtimespec)); dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctimespec)); - for i := len(name) - 1; i >= 0; i-- { + for i := len(name)-1; i >= 0; i-- { if name[i] == '/' { - name = name[i+1:len(name)]; + name = name[i+1 : len(name)]; break; } } diff --git a/src/pkg/os/stat_linux_386.go b/src/pkg/os/stat_linux_386.go index d08fabcc6..a1df33028 100644 --- a/src/pkg/os/stat_linux_386.go +++ b/src/pkg/os/stat_linux_386.go @@ -13,7 +13,7 @@ package os import "syscall" func isSymlink(stat *syscall.Stat_t) bool { - return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK + return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK; } func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { @@ -30,9 +30,9 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atim)); dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtim)); dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctim)); - for i := len(name) - 1; i >= 0; i-- { + for i := len(name)-1; i >= 0; i-- { if name[i] == '/' { - name = name[i+1:len(name)]; + name = name[i+1 : len(name)]; break; } } diff --git a/src/pkg/os/stat_linux_amd64.go b/src/pkg/os/stat_linux_amd64.go index f4c300b2c..dcc29c04e 100644 --- a/src/pkg/os/stat_linux_amd64.go +++ b/src/pkg/os/stat_linux_amd64.go @@ -9,7 +9,7 @@ package os import "syscall" func isSymlink(stat *syscall.Stat_t) bool { - return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK + return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK; } func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { @@ -26,9 +26,9 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atim)); dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtim)); dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctim)); - for i := len(name) - 1; i >= 0; i-- { + for i := len(name)-1; i >= 0; i-- { if name[i] == '/' { - name = name[i+1:len(name)]; + name = name[i+1 : len(name)]; break; } } diff --git a/src/pkg/os/stat_linux_arm.go b/src/pkg/os/stat_linux_arm.go index d08fabcc6..a1df33028 100644 --- a/src/pkg/os/stat_linux_arm.go +++ b/src/pkg/os/stat_linux_arm.go @@ -13,7 +13,7 @@ package os import "syscall" func isSymlink(stat *syscall.Stat_t) bool { - return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK + return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK; } func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { @@ -30,9 +30,9 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atim)); dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtim)); dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctim)); - for i := len(name) - 1; i >= 0; i-- { + for i := len(name)-1; i >= 0; i-- { if name[i] == '/' { - name = name[i+1:len(name)]; + name = name[i+1 : len(name)]; break; } } diff --git a/src/pkg/os/stat_nacl_386.go b/src/pkg/os/stat_nacl_386.go index 83b0d6c38..67b2ba8c8 100644 --- a/src/pkg/os/stat_nacl_386.go +++ b/src/pkg/os/stat_nacl_386.go @@ -13,7 +13,7 @@ package os import "syscall" func isSymlink(stat *syscall.Stat_t) bool { - return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK + return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK; } func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { @@ -27,12 +27,12 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir { dir.Size = uint64(stat.Size); dir.Blksize = uint64(stat.Blksize); dir.Blocks = uint64(stat.Blocks); - dir.Atime_ns = uint64(stat.Atime)*1e9; - dir.Mtime_ns = uint64(stat.Mtime)*1e9; - dir.Ctime_ns = uint64(stat.Ctime)*1e9; - for i := len(name) - 1; i >= 0; i-- { + dir.Atime_ns = uint64(stat.Atime) * 1e9; + dir.Mtime_ns = uint64(stat.Mtime) * 1e9; + dir.Ctime_ns = uint64(stat.Ctime) * 1e9; + for i := len(name)-1; i >= 0; i-- { if name[i] == '/' { - name = name[i+1:len(name)]; + name = name[i+1 : len(name)]; break; } } diff --git a/src/pkg/os/time.go b/src/pkg/os/time.go index d0ba6e1fa..f5c2880a1 100644 --- a/src/pkg/os/time.go +++ b/src/pkg/os/time.go @@ -16,6 +16,5 @@ func Time() (sec int64, nsec int64, err Error) { if errno := syscall.Gettimeofday(&tv); errno != 0 { return 0, 0, NewSyscallError("gettimeofday", errno); } - return int64(tv.Sec), int64(tv.Usec)*1000, err; + return int64(tv.Sec), int64(tv.Usec) * 1000, err; } - diff --git a/src/pkg/os/types.go b/src/pkg/os/types.go index b5db86660..7ed547c9b 100644 --- a/src/pkg/os/types.go +++ b/src/pkg/os/types.go @@ -10,66 +10,65 @@ import "syscall" // OS-specific routines in this directory convert the OS-local versions to these. // Getpagesize returns the underlying system's memory page size. -func Getpagesize() int{ - return syscall.Getpagesize() +func Getpagesize() int { + return syscall.Getpagesize(); } // A Dir describes a file and is returned by Stat, Fstat, and Lstat type Dir struct { - Dev uint64; // device number of file system holding file. - Ino uint64; // inode number. - Nlink uint64; // number of hard links. - Mode uint32; // permission and mode bits. - Uid uint32; // user id of owner. - Gid uint32; // group id of owner. - Rdev uint64; // device type for special file. - Size uint64; // length in bytes. - Blksize uint64; // size of blocks, in bytes. - Blocks uint64; // number of blocks allocated for file. + Dev uint64; // device number of file system holding file. + Ino uint64; // inode number. + Nlink uint64; // number of hard links. + Mode uint32; // permission and mode bits. + Uid uint32; // user id of owner. + Gid uint32; // group id of owner. + Rdev uint64; // device type for special file. + Size uint64; // length in bytes. + Blksize uint64; // size of blocks, in bytes. + Blocks uint64; // number of blocks allocated for file. Atime_ns uint64; // access time; nanoseconds since epoch. Mtime_ns uint64; // modified time; nanoseconds since epoch. Ctime_ns uint64; // status change time; nanoseconds since epoch. - Name string; // name of file as presented to Open. - FollowedSymlink bool; // followed a symlink to get this information + Name string; // name of file as presented to Open. + FollowedSymlink bool; // followed a symlink to get this information } // IsFifo reports whether the Dir describes a FIFO file. func (dir *Dir) IsFifo() bool { - return (dir.Mode & syscall.S_IFMT) == syscall.S_IFIFO + return (dir.Mode & syscall.S_IFMT) == syscall.S_IFIFO; } // IsChar reports whether the Dir describes a character special file. func (dir *Dir) IsChar() bool { - return (dir.Mode & syscall.S_IFMT) == syscall.S_IFCHR + return (dir.Mode & syscall.S_IFMT) == syscall.S_IFCHR; } // IsDirectory reports whether the Dir describes a directory. func (dir *Dir) IsDirectory() bool { - return (dir.Mode & syscall.S_IFMT) == syscall.S_IFDIR + return (dir.Mode & syscall.S_IFMT) == syscall.S_IFDIR; } // IsBlock reports whether the Dir describes a block special file. func (dir *Dir) IsBlock() bool { - return (dir.Mode & syscall.S_IFMT) == syscall.S_IFBLK + return (dir.Mode & syscall.S_IFMT) == syscall.S_IFBLK; } // IsRegular reports whether the Dir describes a regular file. func (dir *Dir) IsRegular() bool { - return (dir.Mode & syscall.S_IFMT) == syscall.S_IFREG + return (dir.Mode & syscall.S_IFMT) == syscall.S_IFREG; } // IsSymlink reports whether the Dir describes a symbolic link. func (dir *Dir) IsSymlink() bool { - return (dir.Mode & syscall.S_IFMT) == syscall.S_IFLNK + return (dir.Mode & syscall.S_IFMT) == syscall.S_IFLNK; } // IsSocket reports whether the Dir describes a socket. func (dir *Dir) IsSocket() bool { - return (dir.Mode & syscall.S_IFMT) == syscall.S_IFSOCK + return (dir.Mode & syscall.S_IFMT) == syscall.S_IFSOCK; } // Permission returns the file permission bits. func (dir *Dir) Permission() int { - return int(dir.Mode & 0777) + return int(dir.Mode & 0777); } - -- cgit v1.2.3