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, 112 insertions, 112 deletions

diff --git a/src/pkg/exp/ogle/rruntime.go b/src/pkg/exp/ogle/rruntime.go
index 1a7881476..b13344a5f 100644
--- a/src/pkg/exp/ogle/rruntime.go
+++ b/src/pkg/exp/ogle/rruntime.go
@@ -5,9 +5,9 @@
 package ogle
 
 import (
-	"debug/proc";
-	"exp/eval";
-	"reflect";
+	"debug/proc"
+	"exp/eval"
+	"reflect"
 )
 
 // This file contains remote runtime definitions.  Using reflection,
@@ -31,19 +31,19 @@ import (
  */
 
 type rt1String struct {
-	str	uintptr;
-	len	int;
+	str uintptr
+	len int
 }
 
 type rt1Slice struct {
-	array	uintptr;
-	len	int;
-	cap	int;
+	array uintptr
+	len   int
+	cap   int
 }
 
 type rt1Eface struct {
-	typ	uintptr;
-	ptr	uintptr;
+	typ uintptr
+	ptr uintptr
 }
 
 /*
@@ -53,17 +53,17 @@ type rt1Eface struct {
  */
 
 type rt1UncommonType struct {
-	name	*string;
-	pkgPath	*string;
+	name    *string
+	pkgPath *string
 	//methods []method;
 }
 
 type rt1CommonType struct {
-	size			uintptr;
-	hash			uint32;
-	alg, align, fieldAlign	uint8;
-	string			*string;
-	uncommonType		*rt1UncommonType;
+	size                   uintptr
+	hash                   uint32
+	alg, align, fieldAlign uint8
+	string                 *string
+	uncommonType           *rt1UncommonType
 }
 
 type rt1Type struct {
@@ -71,37 +71,37 @@ type rt1Type struct {
 	// discriminator as an opaque pointer and taking advantage of
 	// the commonType prologue on all Type's makes type parsing
 	// much simpler.
-	typ	uintptr;
-	ptr	*rt1CommonType;
+	typ uintptr
+	ptr *rt1CommonType
 }
 
 type rt1StructField struct {
-	name	*string;
-	pkgPath	*string;
-	typ	*rt1Type;
-	tag	*string;
-	offset	uintptr;
+	name    *string
+	pkgPath *string
+	typ     *rt1Type
+	tag     *string
+	offset  uintptr
 }
 
 type rt1StructType struct {
-	rt1CommonType;
-	fields	[]rt1StructField;
+	rt1CommonType
+	fields []rt1StructField
 }
 
 type rt1PtrType struct {
-	rt1CommonType;
-	elem	*rt1Type;
+	rt1CommonType
+	elem *rt1Type
 }
 
 type rt1SliceType struct {
-	rt1CommonType;
-	elem	*rt1Type;
+	rt1CommonType
+	elem *rt1Type
 }
 
 type rt1ArrayType struct {
-	rt1CommonType;
-	elem	*rt1Type;
-	len	uintptr;
+	rt1CommonType
+	elem *rt1Type
+	len  uintptr
 }
 
 /*
@@ -113,30 +113,30 @@ type rt1ArrayType struct {
 // Fields beginning with _ are only for padding
 
 type rt1Stktop struct {
-	stackguard	uintptr;
-	stackbase	*rt1Stktop;
-	gobuf		rt1Gobuf;
-	_args		uint32;
-	_fp		uintptr;
+	stackguard uintptr
+	stackbase  *rt1Stktop
+	gobuf      rt1Gobuf
+	_args      uint32
+	_fp        uintptr
 }
 
 type rt1Gobuf struct {
-	sp	uintptr;
-	pc	uintptr;
-	g	*rt1G;
-	r0	uintptr;
+	sp uintptr
+	pc uintptr
+	g  *rt1G
+	r0 uintptr
 }
 
 type rt1G struct {
-	_stackguard	uintptr;
-	stackbase	*rt1Stktop;
-	_defer		uintptr;
-	sched		rt1Gobuf;
-	_stack0		uintptr;
-	_entry		uintptr;
-	alllink		*rt1G;
-	_param		uintptr;
-	status		int16;
+	_stackguard uintptr
+	stackbase   *rt1Stktop
+	_defer      uintptr
+	sched       rt1Gobuf
+	_stack0     uintptr
+	_entry      uintptr
+	alllink     *rt1G
+	_param      uintptr
+	status      int16
 	// Incomplete
 }
 
@@ -156,67 +156,67 @@ var rt1GStatus = runtimeGStatus{
 // exactly and the names of the index fields must be the capitalized
 // version of the names of the fields in the runtime structures above.
 type runtimeIndexes struct {
-	String	struct {
-		Str, Len int;
-	};
-	Slice	struct {
-		Array, Len, Cap int;
-	};
-	Eface	struct {
-		Typ, Ptr int;
-	};
+	String struct {
+		Str, Len int
+	}
+	Slice struct {
+		Array, Len, Cap int
+	}
+	Eface struct {
+		Typ, Ptr int
+	}
 
-	UncommonType	struct {
-		Name, PkgPath int;
-	};
-	CommonType	struct {
-		Size, Hash, Alg, Align, FieldAlign, String, UncommonType int;
-	};
-	Type	struct {
-		Typ, Ptr int;
-	};
-	StructField	struct {
-		Name, PkgPath, Typ, Tag, Offset int;
-	};
-	StructType	struct {
-		Fields int;
-	};
-	PtrType	struct {
-		Elem int;
-	};
-	SliceType	struct {
-		Elem int;
-	};
-	ArrayType	struct {
-		Elem, Len int;
-	};
+	UncommonType struct {
+		Name, PkgPath int
+	}
+	CommonType struct {
+		Size, Hash, Alg, Align, FieldAlign, String, UncommonType int
+	}
+	Type struct {
+		Typ, Ptr int
+	}
+	StructField struct {
+		Name, PkgPath, Typ, Tag, Offset int
+	}
+	StructType struct {
+		Fields int
+	}
+	PtrType struct {
+		Elem int
+	}
+	SliceType struct {
+		Elem int
+	}
+	ArrayType struct {
+		Elem, Len int
+	}
 
-	Stktop	struct {
-		Stackguard, Stackbase, Gobuf int;
-	};
-	Gobuf	struct {
-		Sp, Pc, G int;
-	};
-	G	struct {
-		Stackbase, Sched, Status, Alllink int;
-	};
+	Stktop struct {
+		Stackguard, Stackbase, Gobuf int
+	}
+	Gobuf struct {
+		Sp, Pc, G int
+	}
+	G struct {
+		Stackbase, Sched, Status, Alllink int
+	}
 }
 
 // Values of G status codes
 type runtimeGStatus struct {
-	Gidle, Grunnable, Grunning, Gsyscall, Gwaiting, Gmoribund, Gdead int64;
+	Gidle, Grunnable, Grunning, Gsyscall, Gwaiting, Gmoribund, Gdead int64
 }
 
 // runtimeValues stores the types and values that correspond to those
 // in the remote runtime package.
 type runtimeValues struct {
 	// Runtime data headers
-	String, Slice, Eface	*remoteType;
+	String, Slice, Eface *remoteType
 	// Runtime type structures
 	Type, CommonType, UncommonType, StructField, StructType, PtrType,
-		ArrayType, SliceType	*remoteType;
+		ArrayType, SliceType *remoteType
 	// Runtime scheduler structures
-	Stktop, Gobuf, G	*remoteType;
+	Stktop, Gobuf, G *remoteType
 	// Addresses of *runtime.XType types.  These are the
 	// discriminators on the runtime.Type interface.  We use local
 	// reflection to fill these in from the remote symbol table,
@@ -227,45 +227,45 @@ type runtimeValues struct {
 		PFloat32Type, PFloat64Type, PFloatType,
 		PArrayType, PStringType, PStructType, PPtrType, PFuncType,
 		PInterfaceType, PSliceType, PMapType, PChanType,
-		PDotDotDotType, PUnsafePointerType	proc.Word;
+		PDotDotDotType, PUnsafePointerType proc.Word
 	// G status values
-	runtimeGStatus;
+	runtimeGStatus
 }
 
 // fillRuntimeIndexes fills a runtimeIndexes structure will the field
 // indexes gathered from the remoteTypes recorded in a runtimeValues
 // structure.
 func fillRuntimeIndexes(runtime *runtimeValues, out *runtimeIndexes) {
-	outv := reflect.Indirect(reflect.NewValue(out)).(*reflect.StructValue);
-	outt := outv.Type().(*reflect.StructType);
-	runtimev := reflect.Indirect(reflect.NewValue(runtime)).(*reflect.StructValue);
+	outv := reflect.Indirect(reflect.NewValue(out)).(*reflect.StructValue)
+	outt := outv.Type().(*reflect.StructType)
+	runtimev := reflect.Indirect(reflect.NewValue(runtime)).(*reflect.StructValue)
 
 	// out contains fields corresponding to each runtime type
 	for i := 0; i < outt.NumField(); i++ {
 		// Find the interpreter type for this runtime type
-		name := outt.Field(i).Name;
-		et := runtimev.FieldByName(name).Interface().(*remoteType).Type.(*eval.StructType);
+		name := outt.Field(i).Name
+		et := runtimev.FieldByName(name).Interface().(*remoteType).Type.(*eval.StructType)
 
 		// Get the field indexes of the interpreter struct type
-		indexes := make(map[string]int, len(et.Elems));
+		indexes := make(map[string]int, len(et.Elems))
 		for j, f := range et.Elems {
 			if f.Anonymous {
 				continue
 			}
-			name := f.Name;
+			name := f.Name
 			if name[0] >= 'a' && name[0] <= 'z' {
 				name = string(name[0]+'A'-'a') + name[1:]
 			}
-			indexes[name] = j;
+			indexes[name] = j
 		}
 
 		// Fill this field of out
-		outStructv := outv.Field(i).(*reflect.StructValue);
-		outStructt := outStructv.Type().(*reflect.StructType);
+		outStructv := outv.Field(i).(*reflect.StructValue)
+		outStructt := outStructv.Type().(*reflect.StructType)
 		for j := 0; j < outStructt.NumField(); j++ {
-			f := outStructv.Field(j).(*reflect.IntValue);
-			name := outStructt.Field(j).Name;
-			f.Set(indexes[name]);
+			f := outStructv.Field(j).(*reflect.IntValue)
+			name := outStructt.Field(j).Name
+			f.Set(indexes[name])
 		}
 	}
 }