1) Change default gofmt default settings for
parsing and printing to new syntax.
Use -oldparser to parse the old syntax,
use -oldprinter to print the old syntax.
2) Change default gofmt formatting settings
to use tabs for indentation only and to use
spaces for alignment. This will make the code
alignment insensitive to an editor's tabwidth.
Use -spaces=false to use tabs for alignment.
3) Manually changed src/exp/parser/parser_test.go
so that it doesn't try to parse the parser's
source files using the old syntax (they have
new syntax now).
4) gofmt -w src misc test/bench
4th set of files.
R=rsc
CC=golang-dev
https://golang.org/cl/180049
diff --git a/src/pkg/strconv/decimal.go b/src/pkg/strconv/decimal.go
index 04caedb..02c6618 100644
--- a/src/pkg/strconv/decimal.go
+++ b/src/pkg/strconv/decimal.go
@@ -14,13 +14,13 @@
type decimal struct {
// TODO(rsc): Can make d[] a bit smaller and add
// truncated bool;
- d [2000]byte; // digits
- nd int; // number of digits used
- dp int; // decimal point
+ d [2000]byte // digits
+ nd int // number of digits used
+ dp int // decimal point
}
func (a *decimal) String() string {
- n := 10 + a.nd;
+ n := 10 + a.nd
if a.dp > 0 {
n += a.dp
}
@@ -28,48 +28,48 @@
n += -a.dp
}
- buf := make([]byte, n);
- w := 0;
+ buf := make([]byte, n)
+ w := 0
switch {
case a.nd == 0:
return "0"
case a.dp <= 0:
// zeros fill space between decimal point and digits
- buf[w] = '0';
- w++;
- buf[w] = '.';
- w++;
- w += digitZero(buf[w : w+-a.dp]);
- w += copy(buf[w:w+a.nd], a.d[0:a.nd]);
+ buf[w] = '0'
+ w++
+ buf[w] = '.'
+ w++
+ w += digitZero(buf[w : w+-a.dp])
+ w += copy(buf[w:w+a.nd], a.d[0:a.nd])
case a.dp < a.nd:
// decimal point in middle of digits
- w += copy(buf[w:w+a.dp], a.d[0:a.dp]);
- buf[w] = '.';
- w++;
- w += copy(buf[w:w+a.nd-a.dp], a.d[a.dp:a.nd]);
+ w += copy(buf[w:w+a.dp], a.d[0:a.dp])
+ buf[w] = '.'
+ w++
+ w += copy(buf[w:w+a.nd-a.dp], a.d[a.dp:a.nd])
default:
// zeros fill space between digits and decimal point
- w += copy(buf[w:w+a.nd], a.d[0:a.nd]);
- w += digitZero(buf[w : w+a.dp-a.nd]);
+ w += copy(buf[w:w+a.nd], a.d[0:a.nd])
+ w += digitZero(buf[w : w+a.dp-a.nd])
}
- return string(buf[0:w]);
+ return string(buf[0:w])
}
func copy(dst []byte, src []byte) int {
for i := 0; i < len(dst); i++ {
dst[i] = src[i]
}
- return len(dst);
+ return len(dst)
}
func digitZero(dst []byte) int {
for i := 0; i < len(dst); i++ {
dst[i] = '0'
}
- return len(dst);
+ return len(dst)
}
// trim trailing zeros from number.
@@ -86,32 +86,32 @@
// Assign v to a.
func (a *decimal) Assign(v uint64) {
- var buf [50]byte;
+ var buf [50]byte
// Write reversed decimal in buf.
- n := 0;
+ n := 0
for v > 0 {
- v1 := v / 10;
- v -= 10 * v1;
- buf[n] = byte(v + '0');
- n++;
- v = v1;
+ v1 := v / 10
+ v -= 10 * v1
+ buf[n] = byte(v + '0')
+ n++
+ v = v1
}
// Reverse again to produce forward decimal in a.d.
- a.nd = 0;
+ a.nd = 0
for n--; n >= 0; n-- {
- a.d[a.nd] = buf[n];
- a.nd++;
+ a.d[a.nd] = buf[n]
+ a.nd++
}
- a.dp = a.nd;
- trim(a);
+ a.dp = a.nd
+ trim(a)
}
func newDecimal(i uint64) *decimal {
- a := new(decimal);
- a.Assign(i);
- return a;
+ a := new(decimal)
+ a.Assign(i)
+ return a
}
// Maximum shift that we can do in one pass without overflow.
@@ -120,50 +120,50 @@
// Binary shift right (* 2) by k bits. k <= maxShift to avoid overflow.
func rightShift(a *decimal, k uint) {
- r := 0; // read pointer
- w := 0; // write pointer
+ r := 0 // read pointer
+ w := 0 // write pointer
// Pick up enough leading digits to cover first shift.
- n := 0;
+ n := 0
for ; n>>k == 0; r++ {
if r >= a.nd {
if n == 0 {
// a == 0; shouldn't get here, but handle anyway.
- a.nd = 0;
- return;
+ a.nd = 0
+ return
}
for n>>k == 0 {
- n = n * 10;
- r++;
+ n = n * 10
+ r++
}
- break;
+ break
}
- c := int(a.d[r]);
- n = n*10 + c - '0';
+ c := int(a.d[r])
+ n = n*10 + c - '0'
}
- a.dp -= r - 1;
+ a.dp -= r - 1
// Pick up a digit, put down a digit.
for ; r < a.nd; r++ {
- c := int(a.d[r]);
- dig := n >> k;
- n -= dig << k;
- a.d[w] = byte(dig + '0');
- w++;
- n = n*10 + c - '0';
+ c := int(a.d[r])
+ dig := n >> k
+ n -= dig << k
+ a.d[w] = byte(dig + '0')
+ w++
+ n = n*10 + c - '0'
}
// Put down extra digits.
for n > 0 {
- dig := n >> k;
- n -= dig << k;
- a.d[w] = byte(dig + '0');
- w++;
- n = n * 10;
+ dig := n >> k
+ n -= dig << k
+ a.d[w] = byte(dig + '0')
+ w++
+ n = n * 10
}
- a.nd = w;
- trim(a);
+ a.nd = w
+ trim(a)
}
// Cheat sheet for left shift: table indexed by shift count giving
@@ -177,8 +177,8 @@
// Credit for this trick goes to Ken.
type leftCheat struct {
- delta int; // number of new digits
- cutoff string; // minus one digit if original < a.
+ delta int // number of new digits
+ cutoff string // minus one digit if original < a.
}
var leftcheats = []leftCheat{
@@ -195,33 +195,33 @@
}'
*/
leftCheat{0, ""},
- leftCheat{1, "5"}, // * 2
- leftCheat{1, "25"}, // * 4
- leftCheat{1, "125"}, // * 8
- leftCheat{2, "625"}, // * 16
- leftCheat{2, "3125"}, // * 32
- leftCheat{2, "15625"}, // * 64
- leftCheat{3, "78125"}, // * 128
- leftCheat{3, "390625"}, // * 256
- leftCheat{3, "1953125"}, // * 512
- leftCheat{4, "9765625"}, // * 1024
- leftCheat{4, "48828125"}, // * 2048
- leftCheat{4, "244140625"}, // * 4096
- leftCheat{4, "1220703125"}, // * 8192
- leftCheat{5, "6103515625"}, // * 16384
- leftCheat{5, "30517578125"}, // * 32768
- leftCheat{5, "152587890625"}, // * 65536
- leftCheat{6, "762939453125"}, // * 131072
- leftCheat{6, "3814697265625"}, // * 262144
- leftCheat{6, "19073486328125"}, // * 524288
- leftCheat{7, "95367431640625"}, // * 1048576
- leftCheat{7, "476837158203125"}, // * 2097152
- leftCheat{7, "2384185791015625"}, // * 4194304
- leftCheat{7, "11920928955078125"}, // * 8388608
- leftCheat{8, "59604644775390625"}, // * 16777216
- leftCheat{8, "298023223876953125"}, // * 33554432
- leftCheat{8, "1490116119384765625"}, // * 67108864
- leftCheat{9, "7450580596923828125"}, // * 134217728
+ leftCheat{1, "5"}, // * 2
+ leftCheat{1, "25"}, // * 4
+ leftCheat{1, "125"}, // * 8
+ leftCheat{2, "625"}, // * 16
+ leftCheat{2, "3125"}, // * 32
+ leftCheat{2, "15625"}, // * 64
+ leftCheat{3, "78125"}, // * 128
+ leftCheat{3, "390625"}, // * 256
+ leftCheat{3, "1953125"}, // * 512
+ leftCheat{4, "9765625"}, // * 1024
+ leftCheat{4, "48828125"}, // * 2048
+ leftCheat{4, "244140625"}, // * 4096
+ leftCheat{4, "1220703125"}, // * 8192
+ leftCheat{5, "6103515625"}, // * 16384
+ leftCheat{5, "30517578125"}, // * 32768
+ leftCheat{5, "152587890625"}, // * 65536
+ leftCheat{6, "762939453125"}, // * 131072
+ leftCheat{6, "3814697265625"}, // * 262144
+ leftCheat{6, "19073486328125"}, // * 524288
+ leftCheat{7, "95367431640625"}, // * 1048576
+ leftCheat{7, "476837158203125"}, // * 2097152
+ leftCheat{7, "2384185791015625"}, // * 4194304
+ leftCheat{7, "11920928955078125"}, // * 8388608
+ leftCheat{8, "59604644775390625"}, // * 16777216
+ leftCheat{8, "298023223876953125"}, // * 33554432
+ leftCheat{8, "1490116119384765625"}, // * 67108864
+ leftCheat{9, "7450580596923828125"}, // * 134217728
}
// Is the leading prefix of b lexicographically less than s?
@@ -234,42 +234,42 @@
return b[i] < s[i]
}
}
- return false;
+ return false
}
// Binary shift left (/ 2) by k bits. k <= maxShift to avoid overflow.
func leftShift(a *decimal, k uint) {
- delta := leftcheats[k].delta;
+ delta := leftcheats[k].delta
if prefixIsLessThan(a.d[0:a.nd], leftcheats[k].cutoff) {
delta--
}
- r := a.nd; // read index
- w := a.nd + delta; // write index
- n := 0;
+ r := a.nd // read index
+ w := a.nd + delta // write index
+ n := 0
// Pick up a digit, put down a digit.
for r--; r >= 0; r-- {
- n += (int(a.d[r]) - '0') << k;
- quo := n / 10;
- rem := n - 10*quo;
- w--;
- a.d[w] = byte(rem + '0');
- n = quo;
+ n += (int(a.d[r]) - '0') << k
+ quo := n / 10
+ rem := n - 10*quo
+ w--
+ a.d[w] = byte(rem + '0')
+ n = quo
}
// Put down extra digits.
for n > 0 {
- quo := n / 10;
- rem := n - 10*quo;
- w--;
- a.d[w] = byte(rem + '0');
- n = quo;
+ quo := n / 10
+ rem := n - 10*quo
+ w--
+ a.d[w] = byte(rem + '0')
+ n = quo
}
- a.nd += delta;
- a.dp += delta;
- trim(a);
+ a.nd += delta
+ a.dp += delta
+ trim(a)
}
// Binary shift left (k > 0) or right (k < 0).
@@ -280,18 +280,18 @@
// nothing to do: a == 0
case k > 0:
for k > maxShift {
- leftShift(a, maxShift);
- k -= maxShift;
+ leftShift(a, maxShift)
+ k -= maxShift
}
- leftShift(a, uint(k));
+ leftShift(a, uint(k))
case k < 0:
for k < -maxShift {
- rightShift(a, maxShift);
- k += maxShift;
+ rightShift(a, maxShift)
+ k += maxShift
}
- rightShift(a, uint(-k));
+ rightShift(a, uint(-k))
}
- return a;
+ return a
}
// If we chop a at nd digits, should we round up?
@@ -299,11 +299,11 @@
if nd <= 0 || nd >= a.nd {
return false
}
- if a.d[nd] == '5' && nd+1 == a.nd { // exactly halfway - round to even
+ if a.d[nd] == '5' && nd+1 == a.nd { // exactly halfway - round to even
return (a.d[nd-1]-'0')%2 != 0
}
// not halfway - digit tells all
- return a.d[nd] >= '5';
+ return a.d[nd] >= '5'
}
// Round a to nd digits (or fewer).
@@ -315,7 +315,7 @@
if shouldRoundUp(a, nd) {
return a.RoundUp(nd)
}
- return a.RoundDown(nd);
+ return a.RoundDown(nd)
}
// Round a down to nd digits (or fewer).
@@ -324,9 +324,9 @@
if nd <= 0 || nd >= a.nd {
return a
}
- a.nd = nd;
- trim(a);
- return a;
+ a.nd = nd
+ trim(a)
+ return a
}
// Round a up to nd digits (or fewer).
@@ -338,20 +338,20 @@
// round up
for i := nd - 1; i >= 0; i-- {
- c := a.d[i];
- if c < '9' { // can stop after this digit
- a.d[i]++;
- a.nd = i + 1;
- return a;
+ c := a.d[i]
+ if c < '9' { // can stop after this digit
+ a.d[i]++
+ a.nd = i + 1
+ return a
}
}
// Number is all 9s.
// Change to single 1 with adjusted decimal point.
- a.d[0] = '1';
- a.nd = 1;
- a.dp++;
- return a;
+ a.d[0] = '1'
+ a.nd = 1
+ a.dp++
+ return a
}
// Extract integer part, rounded appropriately.
@@ -360,8 +360,8 @@
if a.dp > 20 {
return 0xFFFFFFFFFFFFFFFF
}
- var i int;
- n := uint64(0);
+ var i int
+ n := uint64(0)
for i = 0; i < a.dp && i < a.nd; i++ {
n = n*10 + uint64(a.d[i]-'0')
}
@@ -371,5 +371,5 @@
if shouldRoundUp(a, a.dp) {
n++
}
- return n;
+ return n
}
