gofmt the last outstanding files in src/pkg

- added a list of issues to printer/nodes.go

R=rsc
http://go/go-review/1024002

src/pkg/debug/elf/elf.go

@@ -623,7 +623,7 @@ const (
 	   string */
 	DF_SYMBOLIC	DynFlag	= 0x0002;	/* Indicates "symbolic" linking. */
 	DF_TEXTREL	DynFlag	= 0x0004;	/* Indicates there may be relocations in
-								   non-writable segments. */
+									   non-writable segments. */
 	DF_BIND_NOW	DynFlag	= 0x0008;	/* Indicates that the dynamic linker should
 	   process all relocations for the object
 	   containing this entry before transferring
@@ -1394,7 +1394,7 @@ type Header32 struct {
  */
 type Section32 struct {
 	Name	uint32;	/* Section name (index into the
-								   section header string table). */
+									   section header string table). */
 	Type		uint32;	/* Section type. */
 	Flags		uint32;	/* Section flags. */
 	Addr		uint32;	/* Address in memory image. */
@@ -1508,7 +1508,7 @@ type Header64 struct {
 
 type Section64 struct {
 	Name	uint32;	/* Section name (index into the
-								   section header string table). */
+									   section header string table). */
 	Type		uint32;	/* Section type. */
 	Flags		uint64;	/* Section flags. */
 	Addr		uint64;	/* Address in memory image. */

src/pkg/exp/datafmt/datafmt.go

@@ -232,40 +232,40 @@ type Formatter func(state *State, value interface{}, ruleName string) bool
 // A FormatterMap is a set of custom formatters.
 // It maps a rule name to a formatter function.
 //
-type FormatterMap map [string] Formatter;
+type FormatterMap map[string]Formatter
 
 
 // A parsed format expression is built from the following nodes.
 //
 type (
-	expr interface {};
+	expr	interface{};
 
-	alternatives []expr;  // x | y | z
+	alternatives	[]expr;	// x | y | z
 
-	sequence []expr;  // x y z
+	sequence	[]expr;	// x y z
 
-	literal [][]byte;  // a list of string segments, possibly starting with '%'
+	literal	[][]byte;	// a list of string segments, possibly starting with '%'
 
-	field struct {
-		fieldName string;  // including "@", "*"
-		ruleName string;  // "" if no rule name specified
+	field	struct {
+		fieldName	string;	// including "@", "*"
+		ruleName	string;	// "" if no rule name specified
 	};
 
-	group struct {
-		indent, body expr;  // (indent >> body)
+	group	struct {
+		indent, body expr;	// (indent >> body)
 	};
 
-	option struct {
-		body expr;  // [body]
+	option	struct {
+		body expr;	// [body]
 	};
 
-	repetition struct {
-		body, separator expr;  // {body / separator}
+	repetition	struct {
+		body, separator expr;	// {body / separator}
 	};
 
-	custom struct {
-		ruleName string;
-		fun Formatter
+	custom	struct {
+		ruleName	string;
+		fun		Formatter;
 	};
 )
 
@@ -273,7 +273,7 @@ type (
 // A Format is the result of parsing a format specification.
 // The format may be applied repeatedly to format values.
 //
-type Format map [string] expr;
+type Format map[string]expr
 
 
 // ----------------------------------------------------------------------------
@@ -290,7 +290,7 @@ type Format map [string] expr;
 // the receiver, and thus can be very light-weight.
 //
 type Environment interface {
-	Copy() Environment
+	Copy() Environment;
 }
 
 
@@ -298,15 +298,15 @@ type Environment interface {
 // It is provided as argument to custom formatters.
 //
 type State struct {
-	fmt Format;  // format in use
-	env Environment;  // user-supplied environment
-	errors chan os.Error;  // not chan *Error (errors <- nil would be wrong!)
-	hasOutput bool;  // true after the first literal has been written
-	indent bytes.Buffer;  // current indentation
-	output bytes.Buffer;  // format output
-	linePos token.Position;  // position of line beginning (Column == 0)
-	default_ expr;  // possibly nil
-	separator expr;  // possibly nil
+	fmt		Format;		// format in use
+	env		Environment;	// user-supplied environment
+	errors		chan os.Error;	// not chan *Error (errors <- nil would be wrong!)
+	hasOutput	bool;		// true after the first literal has been written
+	indent		bytes.Buffer;	// current indentation
+	output		bytes.Buffer;	// format output
+	linePos		token.Position;	// position of line beginning (Column == 0)
+	default_	expr;		// possibly nil
+	separator	expr;		// possibly nil
 }
 
 
@@ -365,22 +365,22 @@ func (s *State) Write(data []byte) (int, os.Error) {
 			// write text segment and indentation
 			n1, _ := s.output.Write(data[i0 : i+1]);
 			n2, _ := s.output.Write(s.indent.Bytes());
-			n += n1 + n2;
-			i0 = i + 1;
+			n += n1+n2;
+			i0 = i+1;
 			s.linePos.Offset = s.output.Len();
 			s.linePos.Line++;
 		}
 	}
-	n3, _ := s.output.Write(data[i0 : len(data)]);
-	return n + n3, nil;
+	n3, _ := s.output.Write(data[i0:len(data)]);
+	return n+n3, nil;
 }
 
 
 type checkpoint struct {
-	env Environment;
-	hasOutput bool;
-	outputLen int;
-	linePos token.Position;
+	env		Environment;
+	hasOutput	bool;
+	outputLen	int;
+	linePos		token.Position;
 }
 
 
@@ -489,13 +489,13 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
 		if s.hasOutput {
 			// not the first literal
 			if s.separator != nil {
-				sep := s.separator;  // save current separator
-				s.separator = nil;  // and disable it (avoid recursion)
+				sep := s.separator;	// save current separator
+				s.separator = nil;	// and disable it (avoid recursion)
 				mark := s.save();
 				if !s.eval(sep, value, index) {
 					s.restore(mark);
 				}
-				s.separator = sep;  // enable it again
+				s.separator = sep;	// enable it again
 			}
 		}
 		s.hasOutput = true;
@@ -505,7 +505,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
 				// segment contains a %-format at the beginning
 				if lit[1] == '%' {
 					// "%%" is printed as a single "%"
-					s.Write(lit[1 : len(lit)]);
+					s.Write(lit[1:len(lit)]);
 				} else {
 					// use s instead of s.output to get indentation right
 					fmt.Fprintf(s, string(lit), value.Interface());
@@ -515,7 +515,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
 				s.Write(lit);
 			}
 		}
-		return true;  // a literal never evaluates to nil
+		return true;	// a literal never evaluates to nil
 
 	case *field:
 		// determine field value
@@ -580,7 +580,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
 		ruleName := t.ruleName;
 		if ruleName == "" {
 			// no alternate rule name, value type determines rule
-			ruleName = typename(value.Type())
+			ruleName = typename(value.Type());
 		}
 		fexpr = s.getFormat(ruleName);
 
@@ -620,10 +620,10 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
 		// evaluate the body and append the result to the state's output
 		// buffer unless the result is nil
 		mark := s.save();
-		if !s.eval(t.body, value, 0) {  // TODO is 0 index correct?
+		if !s.eval(t.body, value, 0) {	// TODO is 0 index correct?
 			s.restore(mark);
 		}
-		return true;  // an option never evaluates to nil
+		return true;	// an option never evaluates to nil
 
 	case *repetition:
 		// evaluate the body and append the result to the state's output
@@ -643,7 +643,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
 				break;
 			}
 		}
-		return true;  // a repetition never evaluates to nil
+		return true;	// a repetition never evaluates to nil
 
 	case *custom:
 		// invoke the custom formatter to obtain the result
@@ -680,14 +680,14 @@ func (f Format) Eval(env Environment, args ...) ([]byte, os.Error) {
 		for i := 0; i < value.NumField(); i++ {
 			fld := value.Field(i);
 			mark := s.save();
-			if !s.eval(s.getFormat(typename(fld.Type())), fld, 0) {  // TODO is 0 index correct?
+			if !s.eval(s.getFormat(typename(fld.Type())), fld, 0) {	// TODO is 0 index correct?
 				s.restore(mark);
 			}
 		}
-		errors <- nil;  // no errors
+		errors <- nil;	// no errors
 	}();
 
-	err := <- errors;
+	err := <-errors;
 	return s.output.Bytes(), err;
 }
 

src/pkg/exp/datafmt/datafmt_test.go

@@ -23,14 +23,13 @@ func parse(t *testing.T, form string, fmap FormatterMap) Format {
 
 func verify(t *testing.T, f Format, expected string, args ...) {
 	if f == nil {
-		return;  // allow other tests to run
+		return;	// allow other tests to run
 	}
 	result := f.Sprint(args);
 	if result != expected {
 		t.Errorf(
 			"result  : `%s`\nexpected: `%s`\n\n",
-			result, expected
-		)
+			result, expected);
 	}
 }
 
@@ -62,9 +61,9 @@ func formatter(s *State, value interface{}, rule_name string) bool {
 
 
 func TestCustomFormatters(t *testing.T) {
-	fmap0 := FormatterMap{ "/": formatter };
-	fmap1 := FormatterMap{ "int": formatter, "blank": formatter, "nil": formatter };
-	fmap2 := FormatterMap{ "testing.T": formatter };
+	fmap0 := FormatterMap{"/": formatter};
+	fmap1 := FormatterMap{"int": formatter, "blank": formatter, "nil": formatter};
+	fmap2 := FormatterMap{"testing.T": formatter};
 
 	f := parse(t, `int=`, fmap0);
 	verify(t, f, ``, 1, 2, 3);
@@ -97,14 +96,13 @@ func TestCustomFormatters(t *testing.T) {
 func check(t *testing.T, form, expected string, args ...) {
 	f := parse(t, form, nil);
 	if f == nil {
-		return;  // allow other tests to run
+		return;	// allow other tests to run
 	}
 	result := f.Sprint(args);
 	if result != expected {
 		t.Errorf(
 			"format  : %s\nresult  : `%s`\nexpected: `%s`\n\n",
-			form, result, expected
-		)
+			form, result, expected);
 	}
 }
 
@@ -164,7 +162,7 @@ func TestChanTypes(t *testing.T) {
 	check(t, `chan="chan"`, `chan`, c0);
 
 	c1 := make(chan int);
-	go func(){ c1 <- 42 }();
+	go func() { c1 <- 42 }();
 	check(t, `chan="chan"`, `chan`, c1);
 	// check(t, `chan=*`, `42`, c1);  // reflection support for chans incomplete
 }
@@ -174,14 +172,14 @@ func TestFuncTypes(t *testing.T) {
 	var f0 func() int;
 	check(t, `func="func"`, `func`, f0);
 
-	f1 := func() int { return 42; };
+	f1 := func() int { return 42 };
 	check(t, `func="func"`, `func`, f1);
 	// check(t, `func=*`, `42`, f1);  // reflection support for funcs incomplete
 }
 
 
 func TestInterfaceTypes(t *testing.T) {
-	var i0 interface{};
+	var i0 interface{}
 	check(t, `interface="interface"`, `interface`, i0);
 
 	i0 = "foo";
@@ -234,8 +232,7 @@ type T1 struct {
 	a int;
 }
 
-const F1 =
-	`datafmt "datafmt";`
+const F1 = `datafmt "datafmt";`
 	`int = "%d";`
 	`datafmt.T1 = "<" a ">";`
 
@@ -248,21 +245,19 @@ func TestStruct1(t *testing.T) {
 // Formatting of a struct with an optional field (ptr)
 
 type T2 struct {
-	s string;
-	p *T1;
+	s	string;
+	p	*T1;
 }
 
-const F2a =
-	F1 +
+const F2a = F1 +
 	`string = "%s";`
-	`ptr = *;`
-	`datafmt.T2 = s ["-" p "-"];`
+		`ptr = *;`
+		`datafmt.T2 = s ["-" p "-"];`
 
-const F2b =
-	F1 +
+const F2b = F1 +
 	`string = "%s";`
-	`ptr = *;`
-	`datafmt.T2 = s ("-" p "-" | "empty");`;
+		`ptr = *;`
+		`datafmt.T2 = s ("-" p "-" | "empty");`
 
 func TestStruct2(t *testing.T) {
 	check(t, F2a, "foo", T2{"foo", nil});
@@ -275,18 +270,16 @@ func TestStruct2(t *testing.T) {
 // Formatting of a struct with a repetitive field (slice)
 
 type T3 struct {
-	s string;
-	a []int;
+	s	string;
+	a	[]int;
 }
 
-const F3a =
-	`datafmt "datafmt";`
+const F3a = `datafmt "datafmt";`
 	`default = "%v";`
 	`array = *;`
 	`datafmt.T3 = s  {" " a a / ","};`
 
-const F3b =
-	`datafmt "datafmt";`
+const F3b = `datafmt "datafmt";`
 	`int = "%d";`
 	`string = "%s";`
 	`array = *;`
@@ -306,12 +299,11 @@ func TestStruct3(t *testing.T) {
 // Formatting of a struct with alternative field
 
 type T4 struct {
-	x *int;
-	a []int;
+	x	*int;
+	a	[]int;
 }
 
-const F4a =
-	`datafmt "datafmt";`
+const F4a = `datafmt "datafmt";`
 	`int = "%d";`
 	`ptr = *;`
 	`array = *;`
@@ -319,8 +311,7 @@ const F4a =
 	`empty = *:nil;`
 	`datafmt.T4 = "<" (x:empty x | "-") ">" `
 
-const F4b =
-	`datafmt "datafmt";`
+const F4b = `datafmt "datafmt";`
 	`int = "%d";`
 	`ptr = *;`
 	`array = *;`
@@ -341,12 +332,11 @@ func TestStruct4(t *testing.T) {
 // Formatting a struct (documentation example)
 
 type Point struct {
-	name string;
-	x, y int;
+	name	string;
+	x, y	int;
 }
 
-const FPoint =
-	`datafmt "datafmt";`
+const FPoint = `datafmt "datafmt";`
 	`int = "%d";`
 	`hexInt = "0x%x";`
 	`string = "---%s---";`
@@ -361,8 +351,7 @@ func TestStructPoint(t *testing.T) {
 // ----------------------------------------------------------------------------
 // Formatting a slice (documentation example)
 
-const FSlice =
-	`int = "%b";`
+const FSlice = `int = "%b";`
 	`array = { * / ", " }`
 
 func TestSlice(t *testing.T) {

src/pkg/go/printer/nodes.go

@@ -24,6 +24,15 @@ const (
 )
 
 
+// Other outstanding formatting issues:
+// - replacement of expression spacing algorithm with rsc's algorithm
+// - support for one-line composite types (e.g. structs) as composite literals types
+// - better comment formatting for /*-style comments at the end of a line (e.g. a declaration)
+//   when the comment spans multiple lines
+// - formatting of expression lists; especially for string lists (stringListMode)
+// - blank after { and before } in one-line composite literals probably looks better
+
+
 // ----------------------------------------------------------------------------
 // Common AST nodes.
 

src/pkg/xml/xml_test.go

@@ -16,7 +16,8 @@ const testInput = `
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<body xmlns:foo="ns1" xmlns="ns2" xmlns:tag="ns3" ` "\r\n\t" `  >
+<body xmlns:foo="ns1" xmlns="ns2" xmlns:tag="ns3" `
+	"\r\n\t" `  >
   <hello lang="en">World &lt;&gt;&apos;&quot; &#x767d;&#40300;翔</hello>
   <goodbye />
   <outer foo:attr="value" xmlns:tag="ns4">
@@ -90,8 +91,8 @@ var cookedTokens = []Token{
 }
 
 type stringReader struct {
-	s string;
-	off int;
+	s	string;
+	off	int;
 }
 
 func (r *stringReader) Read(b []byte) (n int, err os.Error) {
@@ -116,7 +117,7 @@ func (r *stringReader) ReadByte() (b byte, err os.Error) {
 }
 
 func StringReader(s string) io.Reader {
-	return &stringReader{s, 0}
+	return &stringReader{s, 0};
 }
 
 func TestRawToken(t *testing.T) {
@@ -146,4 +147,3 @@ func TestToken(t *testing.T) {
 		}
 	}
 }
-