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

	       2nd set of files.

R=rsc
CC=golang-dev
http://codereview.appspot.com/179067

1 files changed, 205 insertions, 205 deletions

diff --git a/src/pkg/fmt/print.go b/src/pkg/fmt/print.go
index 6fa747c29..d4ef3c62f 100644
--- a/src/pkg/fmt/print.go
+++ b/src/pkg/fmt/print.go
@@ -77,25 +77,25 @@ package fmt
 
 
 import (
-	"bytes";
-	"io";
-	"os";
-	"reflect";
-	"utf8";
+	"bytes"
+	"io"
+	"os"
+	"reflect"
+	"utf8"
 )
 
 // Some constants in the form of bytes, to avoid string overhead.
 // Needlessly fastidious, I suppose.
 var (
-	trueBytes	= []byte{'t', 'r', 'u', 'e'};
-	falseBytes	= []byte{'f', 'a', 'l', 's', 'e'};
-	commaSpaceBytes	= []byte{',', ' '};
-	nilAngleBytes	= []byte{'<', 'n', 'i', 'l', '>'};
-	nilParenBytes	= []byte{'(', 'n', 'i', 'l', ')'};
-	nilBytes	= []byte{'n', 'i', 'l'};
-	mapBytes	= []byte{'m', 'a', 'p', '['};
-	missingBytes	= []byte{'m', 'i', 's', 's', 'i', 'n', 'g'};
-	extraBytes	= []byte{'?', '(', 'e', 'x', 't', 'r', 'a', ' '};
+	trueBytes       = []byte{'t', 'r', 'u', 'e'}
+	falseBytes      = []byte{'f', 'a', 'l', 's', 'e'}
+	commaSpaceBytes = []byte{',', ' '}
+	nilAngleBytes   = []byte{'<', 'n', 'i', 'l', '>'}
+	nilParenBytes   = []byte{'(', 'n', 'i', 'l', ')'}
+	nilBytes        = []byte{'n', 'i', 'l'}
+	mapBytes        = []byte{'m', 'a', 'p', '['}
+	missingBytes    = []byte{'m', 'i', 's', 's', 'i', 'n', 'g'}
+	extraBytes      = []byte{'?', '(', 'e', 'x', 't', 'r', 'a', ' '}
 )
 
 // State represents the printer state passed to custom formatters.
@@ -103,21 +103,21 @@ var (
 // the flags and options for the operand's format specifier.
 type State interface {
 	// Write is the function to call to emit formatted output to be printed.
-	Write(b []byte) (ret int, err os.Error);
+	Write(b []byte) (ret int, err os.Error)
 	// Width returns the value of the width option and whether it has been set.
-	Width() (wid int, ok bool);
+	Width() (wid int, ok bool)
 	// Precision returns the value of the precision option and whether it has been set.
-	Precision() (prec int, ok bool);
+	Precision() (prec int, ok bool)
 
 	// Flag returns whether the flag c, a character, has been set.
-	Flag(int) bool;
+	Flag(int) bool
 }
 
 // Formatter is the interface implemented by values with a custom formatter.
 // The implementation of Format may call Sprintf or Fprintf(f) etc.
 // to generate its output.
 type Formatter interface {
-	Format(f State, c int);
+	Format(f State, c int)
 }
 
 // Stringer is implemented by any value that has a String method(),
@@ -125,7 +125,7 @@ type Formatter interface {
 // The String method is used to print values passed as an operand
 // to a %s or %v format or to an unformatted printer such as Print.
 type Stringer interface {
-	String() string;
+	String() string
 }
 
 // GoStringer is implemented by any value that has a GoString() method,
@@ -133,16 +133,16 @@ type Stringer interface {
 // The GoString method is used to print values passed as an operand
 // to a %#v format.
 type GoStringer interface {
-	GoString() string;
+	GoString() string
 }
 
 const allocSize = 32
 
 type pp struct {
-	n	int;
-	buf	bytes.Buffer;
-	runeBuf	[utf8.UTFMax]byte;
-	fmt	fmt;
+	n       int
+	buf     bytes.Buffer
+	runeBuf [utf8.UTFMax]byte
+	fmt     fmt
 }
 
 // A leaky bucket of reusable pp structures.
@@ -150,12 +150,12 @@ var ppFree = make(chan *pp, 100)
 
 // Allocate a new pp struct.  Probably can grab the previous one from ppFree.
 func newPrinter() *pp {
-	p, ok := <-ppFree;
+	p, ok := <-ppFree
 	if !ok {
 		p = new(pp)
 	}
-	p.fmt.init(&p.buf);
-	return p;
+	p.fmt.init(&p.buf)
+	return p
 }
 
 // Save used pp structs in ppFree; avoids an allocation per invocation.
@@ -164,13 +164,13 @@ func (p *pp) free() {
 	if cap(p.buf.Bytes()) > 1024 {
 		return
 	}
-	p.buf.Reset();
-	_ = ppFree <- p;
+	p.buf.Reset()
+	_ = ppFree <- p
 }
 
-func (p *pp) Width() (wid int, ok bool)	{ return p.fmt.wid, p.fmt.widPresent }
+func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent }
 
-func (p *pp) Precision() (prec int, ok bool)	{ return p.fmt.prec, p.fmt.precPresent }
+func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent }
 
 func (p *pp) Flag(b int) bool {
 	switch b {
@@ -185,15 +185,15 @@ func (p *pp) Flag(b int) bool {
 	case '0':
 		return p.fmt.zero
 	}
-	return false;
+	return false
 }
 
 func (p *pp) add(c int) {
 	if c < utf8.RuneSelf {
 		p.buf.WriteByte(byte(c))
 	} else {
-		w := utf8.EncodeRune(c, &p.runeBuf);
-		p.buf.Write(p.runeBuf[0:w]);
+		w := utf8.EncodeRune(c, &p.runeBuf)
+		p.buf.Write(p.runeBuf[0:w])
 	}
 }
 
@@ -207,28 +207,28 @@ func (p *pp) Write(b []byte) (ret int, err os.Error) {
 
 // Fprintf formats according to a format specifier and writes to w.
 func Fprintf(w io.Writer, format string, a ...) (n int, error os.Error) {
-	v := reflect.NewValue(a).(*reflect.StructValue);
-	p := newPrinter();
-	p.doprintf(format, v);
-	n64, error := p.buf.WriteTo(w);
-	p.free();
-	return int(n64), error;
+	v := reflect.NewValue(a).(*reflect.StructValue)
+	p := newPrinter()
+	p.doprintf(format, v)
+	n64, error := p.buf.WriteTo(w)
+	p.free()
+	return int(n64), error
 }
 
 // Printf formats according to a format specifier and writes to standard output.
 func Printf(format string, v ...) (n int, errno os.Error) {
-	n, errno = Fprintf(os.Stdout, format, v);
-	return n, errno;
+	n, errno = Fprintf(os.Stdout, format, v)
+	return n, errno
 }
 
 // Sprintf formats according to a format specifier and returns the resulting string.
 func Sprintf(format string, a ...) string {
-	v := reflect.NewValue(a).(*reflect.StructValue);
-	p := newPrinter();
-	p.doprintf(format, v);
-	s := p.buf.String();
-	p.free();
-	return s;
+	v := reflect.NewValue(a).(*reflect.StructValue)
+	p := newPrinter()
+	p.doprintf(format, v)
+	s := p.buf.String()
+	p.free()
+	return s
 }
 
 // These routines do not take a format string
@@ -236,30 +236,30 @@ func Sprintf(format string, a ...) string {
 // Fprint formats using the default formats for its operands and writes to w.
 // Spaces are added between operands when neither is a string.
 func Fprint(w io.Writer, a ...) (n int, error os.Error) {
-	v := reflect.NewValue(a).(*reflect.StructValue);
-	p := newPrinter();
-	p.doprint(v, false, false);
-	n64, error := p.buf.WriteTo(w);
-	p.free();
-	return int(n64), error;
+	v := reflect.NewValue(a).(*reflect.StructValue)
+	p := newPrinter()
+	p.doprint(v, false, false)
+	n64, error := p.buf.WriteTo(w)
+	p.free()
+	return int(n64), error
 }
 
 // Print formats using the default formats for its operands and writes to standard output.
 // Spaces are added between operands when neither is a string.
 func Print(v ...) (n int, errno os.Error) {
-	n, errno = Fprint(os.Stdout, v);
-	return n, errno;
+	n, errno = Fprint(os.Stdout, v)
+	return n, errno
 }
 
 // Sprint formats using the default formats for its operands and returns the resulting string.
 // Spaces are added between operands when neither is a string.
 func Sprint(a ...) string {
-	v := reflect.NewValue(a).(*reflect.StructValue);
-	p := newPrinter();
-	p.doprint(v, false, false);
-	s := p.buf.String();
-	p.free();
-	return s;
+	v := reflect.NewValue(a).(*reflect.StructValue)
+	p := newPrinter()
+	p.doprint(v, false, false)
+	s := p.buf.String()
+	p.free()
+	return s
 }
 
 // These routines end in 'ln', do not take a format string,
@@ -269,30 +269,30 @@ func Sprint(a ...) string {
 // Fprintln formats using the default formats for its operands and writes to w.
 // Spaces are always added between operands and a newline is appended.
 func Fprintln(w io.Writer, a ...) (n int, error os.Error) {
-	v := reflect.NewValue(a).(*reflect.StructValue);
-	p := newPrinter();
-	p.doprint(v, true, true);
-	n64, error := p.buf.WriteTo(w);
-	p.free();
-	return int(n64), error;
+	v := reflect.NewValue(a).(*reflect.StructValue)
+	p := newPrinter()
+	p.doprint(v, true, true)
+	n64, error := p.buf.WriteTo(w)
+	p.free()
+	return int(n64), error
 }
 
 // Println formats using the default formats for its operands and writes to standard output.
 // Spaces are always added between operands and a newline is appended.
 func Println(v ...) (n int, errno os.Error) {
-	n, errno = Fprintln(os.Stdout, v);
-	return n, errno;
+	n, errno = Fprintln(os.Stdout, v)
+	return n, errno
 }
 
 // Sprintln formats using the default formats for its operands and returns the resulting string.
 // Spaces are always added between operands and a newline is appended.
 func Sprintln(a ...) string {
-	v := reflect.NewValue(a).(*reflect.StructValue);
-	p := newPrinter();
-	p.doprint(v, true, true);
-	s := p.buf.String();
-	p.free();
-	return s;
+	v := reflect.NewValue(a).(*reflect.StructValue)
+	p := newPrinter()
+	p.doprint(v, true, true)
+	s := p.buf.String()
+	p.free()
+	return s
 }
 
 
@@ -300,13 +300,13 @@ func Sprintln(a ...) string {
 // If the arg itself is an interface, return a value for
 // the thing inside the interface, not the interface itself.
 func getField(v *reflect.StructValue, i int) reflect.Value {
-	val := v.Field(i);
+	val := v.Field(i)
 	if i, ok := val.(*reflect.InterfaceValue); ok {
 		if inter := i.Interface(); inter != nil {
 			return reflect.NewValue(inter)
 		}
 	}
-	return val;
+	return val
 }
 
 // Getters for the fields of the argument structure.
@@ -315,7 +315,7 @@ func getBool(v reflect.Value) (val bool, ok bool) {
 	if b, ok := v.(*reflect.BoolValue); ok {
 		return b.Get(), true
 	}
-	return;
+	return
 }
 
 func getInt(v reflect.Value) (val int64, signed, ok bool) {
@@ -343,7 +343,7 @@ func getInt(v reflect.Value) (val int64, signed, ok bool) {
 	case *reflect.UintptrValue:
 		return int64(v.Get()), false, true
 	}
-	return;
+	return
 }
 
 func getString(v reflect.Value) (val string, ok bool) {
@@ -353,7 +353,7 @@ func getString(v reflect.Value) (val string, ok bool) {
 	if bytes, ok := v.Interface().([]byte); ok {
 		return string(bytes), true
 	}
-	return;
+	return
 }
 
 func getFloat32(v reflect.Value) (val float32, ok bool) {
@@ -365,7 +365,7 @@ func getFloat32(v reflect.Value) (val float32, ok bool) {
 			return float32(v.Get()), true
 		}
 	}
-	return;
+	return
 }
 
 func getFloat64(v reflect.Value) (val float64, ok bool) {
@@ -377,7 +377,7 @@ func getFloat64(v reflect.Value) (val float64, ok bool) {
 	case *reflect.Float64Value:
 		return float64(v.Get()), true
 	}
-	return;
+	return
 }
 
 func getPtr(v reflect.Value) (val uintptr, ok bool) {
@@ -385,7 +385,7 @@ func getPtr(v reflect.Value) (val uintptr, ok bool) {
 	case *reflect.PtrValue:
 		return uintptr(v.Get()), true
 	}
-	return;
+	return
 }
 
 // Convert ASCII to integer.  n is 0 (and got is false) if no number present.
@@ -394,33 +394,33 @@ func parsenum(s string, start, end int) (n int, got bool, newi int) {
 	if start >= end {
 		return 0, false, end
 	}
-	isnum := false;
-	num := 0;
+	isnum := false
+	num := 0
 	for '0' <= s[start] && s[start] <= '9' {
-		num = num*10 + int(s[start]-'0');
-		start++;
-		isnum = true;
+		num = num*10 + int(s[start]-'0')
+		start++
+		isnum = true
 	}
-	return num, isnum, start;
+	return num, isnum, start
 }
 
 type uintptrGetter interface {
-	Get() uintptr;
+	Get() uintptr
 }
 
 func (p *pp) printField(field reflect.Value, plus, sharp bool, depth int) (was_string bool) {
-	inter := field.Interface();
+	inter := field.Interface()
 	if inter != nil {
 		switch {
 		default:
 			if stringer, ok := inter.(Stringer); ok {
-				p.buf.WriteString(stringer.String());
-				return false;	// this value is not a string
+				p.buf.WriteString(stringer.String())
+				return false // this value is not a string
 			}
 		case sharp:
 			if stringer, ok := inter.(GoStringer); ok {
-				p.buf.WriteString(stringer.GoString());
-				return false;	// this value is not a string
+				p.buf.WriteString(stringer.GoString())
+				return false // this value is not a string
 			}
 		}
 	}
@@ -442,17 +442,17 @@ BigSwitch:
 		if sharp {
 			p.fmt.fmt_q(f.Get())
 		} else {
-			p.fmt.fmt_s(f.Get());
-			was_string = true;
+			p.fmt.fmt_s(f.Get())
+			was_string = true
 		}
 	case *reflect.MapValue:
 		if sharp {
-			p.buf.WriteString(field.Type().String());
-			p.buf.WriteByte('{');
+			p.buf.WriteString(field.Type().String())
+			p.buf.WriteByte('{')
 		} else {
 			p.buf.Write(mapBytes)
 		}
-		keys := f.Keys();
+		keys := f.Keys()
 		for i, key := range keys {
 			if i > 0 {
 				if sharp {
@@ -461,9 +461,9 @@ BigSwitch:
 					p.buf.WriteByte(' ')
 				}
 			}
-			p.printField(key, plus, sharp, depth+1);
-			p.buf.WriteByte(':');
-			p.printField(f.Elem(key), plus, sharp, depth+1);
+			p.printField(key, plus, sharp, depth+1)
+			p.buf.WriteByte(':')
+			p.printField(f.Elem(key), plus, sharp, depth+1)
 		}
 		if sharp {
 			p.buf.WriteByte('}')
@@ -474,10 +474,10 @@ BigSwitch:
 		if sharp {
 			p.buf.WriteString(field.Type().String())
 		}
-		p.add('{');
-		v := f;
-		t := v.Type().(*reflect.StructType);
-		p.fmt.clearflags();	// clear flags for p.printField
+		p.add('{')
+		v := f
+		t := v.Type().(*reflect.StructType)
+		p.fmt.clearflags() // clear flags for p.printField
 		for i := 0; i < v.NumField(); i++ {
 			if i > 0 {
 				if sharp {
@@ -488,19 +488,19 @@ BigSwitch:
 			}
 			if plus || sharp {
 				if f := t.Field(i); f.Name != "" {
-					p.buf.WriteString(f.Name);
-					p.buf.WriteByte(':');
+					p.buf.WriteString(f.Name)
+					p.buf.WriteByte(':')
 				}
 			}
-			p.printField(getField(v, i), plus, sharp, depth+1);
+			p.printField(getField(v, i), plus, sharp, depth+1)
 		}
-		p.buf.WriteByte('}');
+		p.buf.WriteByte('}')
 	case *reflect.InterfaceValue:
-		value := f.Elem();
+		value := f.Elem()
 		if value == nil {
 			if sharp {
-				p.buf.WriteString(field.Type().String());
-				p.buf.Write(nilParenBytes);
+				p.buf.WriteString(field.Type().String())
+				p.buf.Write(nilParenBytes)
 			} else {
 				p.buf.Write(nilAngleBytes)
 			}
@@ -509,8 +509,8 @@ BigSwitch:
 		}
 	case reflect.ArrayOrSliceValue:
 		if sharp {
-			p.buf.WriteString(field.Type().String());
-			p.buf.WriteByte('{');
+			p.buf.WriteString(field.Type().String())
+			p.buf.WriteByte('{')
 		} else {
 			p.buf.WriteByte('[')
 		}
@@ -522,7 +522,7 @@ BigSwitch:
 					p.buf.WriteByte(' ')
 				}
 			}
-			p.printField(f.Elem(i), plus, sharp, depth+1);
+			p.printField(f.Elem(i), plus, sharp, depth+1)
 		}
 		if sharp {
 			p.buf.WriteByte('}')
@@ -530,99 +530,99 @@ BigSwitch:
 			p.buf.WriteByte(']')
 		}
 	case *reflect.PtrValue:
-		v := f.Get();
+		v := f.Get()
 		// pointer to array or slice or struct?  ok at top level
 		// but not embedded (avoid loops)
 		if v != 0 && depth == 0 {
 			switch a := f.Elem().(type) {
 			case reflect.ArrayOrSliceValue:
-				p.buf.WriteByte('&');
-				p.printField(a, plus, sharp, depth+1);
-				break BigSwitch;
+				p.buf.WriteByte('&')
+				p.printField(a, plus, sharp, depth+1)
+				break BigSwitch
 			case *reflect.StructValue:
-				p.buf.WriteByte('&');
-				p.printField(a, plus, sharp, depth+1);
-				break BigSwitch;
+				p.buf.WriteByte('&')
+				p.printField(a, plus, sharp, depth+1)
+				break BigSwitch
 			}
 		}
 		if sharp {
-			p.buf.WriteByte('(');
-			p.buf.WriteString(field.Type().String());
-			p.buf.WriteByte(')');
-			p.buf.WriteByte('(');
+			p.buf.WriteByte('(')
+			p.buf.WriteString(field.Type().String())
+			p.buf.WriteByte(')')
+			p.buf.WriteByte('(')
 			if v == 0 {
 				p.buf.Write(nilBytes)
 			} else {
-				p.fmt.sharp = true;
-				p.fmt.fmt_ux64(uint64(v));
+				p.fmt.sharp = true
+				p.fmt.fmt_ux64(uint64(v))
 			}
-			p.buf.WriteByte(')');
-			break;
+			p.buf.WriteByte(')')
+			break
 		}
 		if v == 0 {
-			p.buf.Write(nilAngleBytes);
-			break;
+			p.buf.Write(nilAngleBytes)
+			break
 		}
-		p.fmt.sharp = true;	// turn 0x on
-		p.fmt.fmt_ux64(uint64(v));
+		p.fmt.sharp = true // turn 0x on
+		p.fmt.fmt_ux64(uint64(v))
 	case uintptrGetter:
-		v := f.Get();
+		v := f.Get()
 		if sharp {
-			p.buf.WriteByte('(');
-			p.buf.WriteString(field.Type().String());
-			p.buf.WriteByte(')');
-			p.buf.WriteByte('(');
+			p.buf.WriteByte('(')
+			p.buf.WriteString(field.Type().String())
+			p.buf.WriteByte(')')
+			p.buf.WriteByte('(')
 			if v == 0 {
 				p.buf.Write(nilBytes)
 			} else {
-				p.fmt.sharp = true;
-				p.fmt.fmt_ux64(uint64(v));
+				p.fmt.sharp = true
+				p.fmt.fmt_ux64(uint64(v))
 			}
-			p.buf.WriteByte(')');
+			p.buf.WriteByte(')')
 		} else {
-			p.fmt.sharp = true;	// turn 0x on
-			p.fmt.fmt_ux64(uint64(f.Get()));
+			p.fmt.sharp = true // turn 0x on
+			p.fmt.fmt_ux64(uint64(f.Get()))
 		}
 	default:
-		v, signed, ok := getInt(field);
+		v, signed, ok := getInt(field)
 		if ok {
 			if signed {
 				p.fmt.fmt_d64(v)
 			} else {
 				if sharp {
-					p.fmt.sharp = true;	// turn on 0x
-					p.fmt.fmt_ux64(uint64(v));
+					p.fmt.sharp = true // turn on 0x
+					p.fmt.fmt_ux64(uint64(v))
 				} else {
 					p.fmt.fmt_ud64(uint64(v))
 				}
 			}
-			break;
+			break
 		}
-		p.buf.WriteByte('?');
-		p.buf.WriteString(field.Type().String());
-		p.buf.WriteByte('?');
+		p.buf.WriteByte('?')
+		p.buf.WriteString(field.Type().String())
+		p.buf.WriteByte('?')
 	}
-	return was_string;
+	return was_string
 }
 
 func (p *pp) doprintf(format string, v *reflect.StructValue) {
-	end := len(format) - 1;
-	fieldnum := 0;	// we process one field per non-trivial format
+	end := len(format) - 1
+	fieldnum := 0 // we process one field per non-trivial format
 	for i := 0; i <= end; {
-		c, w := utf8.DecodeRuneInString(format[i:]);
+		c, w := utf8.DecodeRuneInString(format[i:])
 		if c != '%' || i == end {
 			if w == 1 {
 				p.buf.WriteByte(byte(c))
 			} else {
 				p.buf.WriteString(format[i : i+w])
 			}
-			i += w;
-			continue;
+			i += w
+			continue
 		}
-		i++;
+		i++
 		// flags and widths
-		p.fmt.clearflags();
-	F:	for ; i < end; i++ {
+		p.fmt.clearflags()
+	F: for ; i < end; i++ {
 			switch format[i] {
 			case '#':
 				p.fmt.sharp = true
@@ -639,34 +639,34 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 			}
 		}
 		// do we have 20 (width)?
-		p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end);
+		p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
 		// do we have .20 (precision)?
 		if i < end && format[i] == '.' {
 			p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i+1, end)
 		}
-		c, w = utf8.DecodeRuneInString(format[i:]);
-		i += w;
+		c, w = utf8.DecodeRuneInString(format[i:])
+		i += w
 		// percent is special - absorbs no operand
 		if c == '%' {
-			p.buf.WriteByte('%');	// TODO: should we bother with width & prec?
-			continue;
+			p.buf.WriteByte('%') // TODO: should we bother with width & prec?
+			continue
 		}
-		if fieldnum >= v.NumField() {	// out of operands
-			p.buf.WriteByte('%');
-			p.add(c);
-			p.buf.Write(missingBytes);
-			continue;
+		if fieldnum >= v.NumField() { // out of operands
+			p.buf.WriteByte('%')
+			p.add(c)
+			p.buf.Write(missingBytes)
+			continue
 		}
-		field := getField(v, fieldnum);
-		fieldnum++;
+		field := getField(v, fieldnum)
+		fieldnum++
 
 		// Try formatter except for %T,
 		// which is special and handled internally.
-		inter := field.Interface();
+		inter := field.Interface()
 		if inter != nil && c != 'T' {
 			if formatter, ok := inter.(Formatter); ok {
-				formatter.Format(p, c);
-				continue;
+				formatter.Format(p, c)
+				continue
 			}
 		}
 
@@ -686,7 +686,7 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 		// int
 		case 'b':
 			if v, _, ok := getInt(field); ok {
-				p.fmt.fmt_b64(uint64(v))	// always unsigned
+				p.fmt.fmt_b64(uint64(v)) // always unsigned
 			} else if v, ok := getFloat32(field); ok {
 				p.fmt.fmt_fb32(v)
 			} else if v, ok := getFloat64(field); ok {
@@ -792,8 +792,8 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 			if inter != nil {
 				// if object implements String, use the result.
 				if stringer, ok := inter.(Stringer); ok {
-					p.fmt.fmt_s(stringer.String());
-					break;
+					p.fmt.fmt_s(stringer.String())
+					break
 				}
 			}
 			if v, ok := getString(field); ok {
@@ -814,8 +814,8 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 				if v == 0 {
 					p.buf.Write(nilAngleBytes)
 				} else {
-					p.fmt.fmt_s("0x");
-					p.fmt.fmt_uX64(uint64(v));
+					p.fmt.fmt_s("0x")
+					p.fmt.fmt_uX64(uint64(v))
 				}
 			} else {
 				goto badtype
@@ -823,10 +823,10 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 
 		// arbitrary value; do your best
 		case 'v':
-			plus, sharp := p.fmt.plus, p.fmt.sharp;
-			p.fmt.plus = false;
-			p.fmt.sharp = false;
-			p.printField(field, plus, sharp, 0);
+			plus, sharp := p.fmt.plus, p.fmt.sharp
+			p.fmt.plus = false
+			p.fmt.sharp = false
+			p.printField(field, plus, sharp, 0)
 
 		// the value's type
 		case 'T':
@@ -834,42 +834,42 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 
 		default:
 		badtype:
-			p.buf.WriteByte('%');
-			p.add(c);
-			p.buf.WriteByte('(');
-			p.buf.WriteString(field.Type().String());
-			p.buf.WriteByte('=');
-			p.printField(field, false, false, 0);
-			p.buf.WriteByte(')');
+			p.buf.WriteByte('%')
+			p.add(c)
+			p.buf.WriteByte('(')
+			p.buf.WriteString(field.Type().String())
+			p.buf.WriteByte('=')
+			p.printField(field, false, false, 0)
+			p.buf.WriteByte(')')
 		}
 	}
 	if fieldnum < v.NumField() {
-		p.buf.Write(extraBytes);
+		p.buf.Write(extraBytes)
 		for ; fieldnum < v.NumField(); fieldnum++ {
-			field := getField(v, fieldnum);
-			p.buf.WriteString(field.Type().String());
-			p.buf.WriteByte('=');
-			p.printField(field, false, false, 0);
+			field := getField(v, fieldnum)
+			p.buf.WriteString(field.Type().String())
+			p.buf.WriteByte('=')
+			p.printField(field, false, false, 0)
 			if fieldnum+1 < v.NumField() {
 				p.buf.Write(commaSpaceBytes)
 			}
 		}
-		p.buf.WriteByte(')');
+		p.buf.WriteByte(')')
 	}
 }
 
 func (p *pp) doprint(v *reflect.StructValue, addspace, addnewline bool) {
-	prev_string := false;
+	prev_string := false
 	for fieldnum := 0; fieldnum < v.NumField(); fieldnum++ {
 		// always add spaces if we're doing println
-		field := getField(v, fieldnum);
+		field := getField(v, fieldnum)
 		if fieldnum > 0 {
-			_, is_string := field.(*reflect.StringValue);
+			_, is_string := field.(*reflect.StringValue)
 			if addspace || !is_string && !prev_string {
 				p.buf.WriteByte(' ')
 			}
 		}
-		prev_string = p.printField(field, false, false, 0);
+		prev_string = p.printField(field, false, false, 0)
 	}
 	if addnewline {
 		p.buf.WriteByte('\n')