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

3rd set of files.

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

1 files changed, 72 insertions, 72 deletions

diff --git a/src/pkg/net/dnsclient.go b/src/pkg/net/dnsclient.go
index 064e1017b..439cae806 100644
--- a/src/pkg/net/dnsclient.go
+++ b/src/pkg/net/dnsclient.go
@@ -15,24 +15,24 @@
 package net
 
 import (
-	"once";
-	"os";
+	"once"
+	"os"
 )
 
 // DNSError represents a DNS lookup error.
 type DNSError struct {
-	Error	string;	// description of the error
-	Name	string;	// name looked for
-	Server	string;	// server used
+	Error  string // description of the error
+	Name   string // name looked for
+	Server string // server used
 }
 
 func (e *DNSError) String() string {
-	s := "lookup " + e.Name;
+	s := "lookup " + e.Name
 	if e.Server != "" {
 		s += " on " + e.Server
 	}
-	s += ": " + e.Error;
-	return s;
+	s += ": " + e.Error
+	return s
 }
 
 const noSuchHost = "no such host"
@@ -43,53 +43,53 @@ func _Exchange(cfg *_DNS_Config, c Conn, name string) (m *_DNS_Msg, err os.Error
 	if len(name) >= 256 {
 		return nil, &DNSError{"name too long", name, ""}
 	}
-	out := new(_DNS_Msg);
-	out.id = 0x1234;
+	out := new(_DNS_Msg)
+	out.id = 0x1234
 	out.question = []_DNS_Question{
 		_DNS_Question{name, _DNS_TypeA, _DNS_ClassINET},
-	};
-	out.recursion_desired = true;
-	msg, ok := out.Pack();
+	}
+	out.recursion_desired = true
+	msg, ok := out.Pack()
 	if !ok {
 		return nil, &DNSError{"internal error - cannot pack message", name, ""}
 	}
 
 	for attempt := 0; attempt < cfg.attempts; attempt++ {
-		n, err := c.Write(msg);
+		n, err := c.Write(msg)
 		if err != nil {
 			return nil, err
 		}
 
-		c.SetReadTimeout(1e9);	// nanoseconds
+		c.SetReadTimeout(1e9) // nanoseconds
 
-		buf := make([]byte, 2000);	// More than enough.
-		n, err = c.Read(buf);
+		buf := make([]byte, 2000) // More than enough.
+		n, err = c.Read(buf)
 		if isEAGAIN(err) {
-			err = nil;
-			continue;
+			err = nil
+			continue
 		}
 		if err != nil {
 			return nil, err
 		}
-		buf = buf[0:n];
-		in := new(_DNS_Msg);
+		buf = buf[0:n]
+		in := new(_DNS_Msg)
 		if !in.Unpack(buf) || in.id != out.id {
 			continue
 		}
-		return in, nil;
+		return in, nil
 	}
-	var server string;
+	var server string
 	if a := c.RemoteAddr(); a != nil {
 		server = a.String()
 	}
-	return nil, &DNSError{"no answer from server", name, server};
+	return nil, &DNSError{"no answer from server", name, server}
 }
 
 
 // Find answer for name in dns message.
 // On return, if err == nil, addrs != nil.
 func answer(name, server string, dns *_DNS_Msg) (addrs []string, err *DNSError) {
-	addrs = make([]string, 0, len(dns.answer));
+	addrs = make([]string, 0, len(dns.answer))
 
 	if dns.rcode == _DNS_RcodeNameError && dns.recursion_available {
 		return nil, &DNSError{noSuchHost, name, ""}
@@ -109,31 +109,31 @@ func answer(name, server string, dns *_DNS_Msg) (addrs []string, err *DNSError)
 	// all the answers we need in this one packet.
 Cname:
 	for cnameloop := 0; cnameloop < 10; cnameloop++ {
-		addrs = addrs[0:0];
+		addrs = addrs[0:0]
 		for i := 0; i < len(dns.answer); i++ {
-			rr := dns.answer[i];
-			h := rr.Header();
+			rr := dns.answer[i]
+			h := rr.Header()
 			if h.Class == _DNS_ClassINET && h.Name == name {
 				switch h.Rrtype {
 				case _DNS_TypeA:
-					n := len(addrs);
-					a := rr.(*_DNS_RR_A).A;
-					addrs = addrs[0 : n+1];
-					addrs[n] = IPv4(byte(a>>24), byte(a>>16), byte(a>>8), byte(a)).String();
+					n := len(addrs)
+					a := rr.(*_DNS_RR_A).A
+					addrs = addrs[0 : n+1]
+					addrs[n] = IPv4(byte(a>>24), byte(a>>16), byte(a>>8), byte(a)).String()
 				case _DNS_TypeCNAME:
 					// redirect to cname
-					name = rr.(*_DNS_RR_CNAME).Cname;
-					continue Cname;
+					name = rr.(*_DNS_RR_CNAME).Cname
+					continue Cname
 				}
 			}
 		}
 		if len(addrs) == 0 {
 			return nil, &DNSError{noSuchHost, name, server}
 		}
-		return addrs, nil;
+		return addrs, nil
 	}
 
-	return nil, &DNSError{"too many redirects", name, server};
+	return nil, &DNSError{"too many redirects", name, server}
 }
 
 // Do a lookup for a single name, which must be rooted
@@ -149,36 +149,36 @@ func tryOneName(cfg *_DNS_Config, name string) (addrs []string, err os.Error) {
 		// The DNS config parser has already checked that
 		// all the cfg.servers[i] are IP addresses, which
 		// Dial will use without a DNS lookup.
-		server := cfg.servers[i] + ":53";
-		c, cerr := Dial("udp", "", server);
+		server := cfg.servers[i] + ":53"
+		c, cerr := Dial("udp", "", server)
 		if cerr != nil {
-			err = cerr;
-			continue;
+			err = cerr
+			continue
 		}
-		msg, merr := _Exchange(cfg, c, name);
-		c.Close();
+		msg, merr := _Exchange(cfg, c, name)
+		c.Close()
 		if merr != nil {
-			err = merr;
-			continue;
+			err = merr
+			continue
 		}
-		var dnserr *DNSError;
-		addrs, dnserr = answer(name, server, msg);
+		var dnserr *DNSError
+		addrs, dnserr = answer(name, server, msg)
 		if dnserr != nil {
 			err = dnserr
 		} else {
-			err = nil	// nil os.Error, not nil *DNSError
+			err = nil // nil os.Error, not nil *DNSError
 		}
 		if dnserr == nil || dnserr.Error == noSuchHost {
 			break
 		}
 	}
-	return;
+	return
 }
 
 var cfg *_DNS_Config
 var dnserr os.Error
 
-func loadConfig()	{ cfg, dnserr = _DNS_ReadConfig() }
+func loadConfig() { cfg, dnserr = _DNS_ReadConfig() }
 
 func isDomainName(s string) bool {
 	// Requirements on DNS name:
@@ -192,14 +192,14 @@ func isDomainName(s string) bool {
 	if len(s) == 0 {
 		return false
 	}
-	if s[len(s)-1] != '.' {	// simplify checking loop: make name end in dot
+	if s[len(s)-1] != '.' { // simplify checking loop: make name end in dot
 		s += "."
 	}
 
-	last := byte('.');
-	ok := false;	// ok once we've seen a letter
+	last := byte('.')
+	ok := false // ok once we've seen a letter
 	for i := 0; i < len(s); i++ {
-		c := s[i];
+		c := s[i]
 		switch {
 		default:
 			return false
@@ -218,10 +218,10 @@ func isDomainName(s string) bool {
 				return false
 			}
 		}
-		last = c;
+		last = c
 	}
 
-	return ok;
+	return ok
 }
 
 // LookupHost looks up the host name using the local DNS resolver.
@@ -231,25 +231,25 @@ func LookupHost(name string) (cname string, addrs []string, err os.Error) {
 	if !isDomainName(name) {
 		return name, nil, &DNSError{"invalid domain name", name, ""}
 	}
-	once.Do(loadConfig);
+	once.Do(loadConfig)
 	if dnserr != nil || cfg == nil {
-		err = dnserr;
-		return;
+		err = dnserr
+		return
 	}
 
 	// If name is rooted (trailing dot) or has enough dots,
 	// try it by itself first.
-	rooted := len(name) > 0 && name[len(name)-1] == '.';
+	rooted := len(name) > 0 && name[len(name)-1] == '.'
 	if rooted || count(name, '.') >= cfg.ndots {
-		rname := name;
+		rname := name
 		if !rooted {
 			rname += "."
 		}
 		// Can try as ordinary name.
-		addrs, err = tryOneName(cfg, rname);
+		addrs, err = tryOneName(cfg, rname)
 		if err == nil {
-			cname = rname;
-			return;
+			cname = rname
+			return
 		}
 	}
 	if rooted {
@@ -258,26 +258,26 @@ func LookupHost(name string) (cname string, addrs []string, err os.Error) {
 
 	// Otherwise, try suffixes.
 	for i := 0; i < len(cfg.search); i++ {
-		rname := name + "." + cfg.search[i];
+		rname := name + "." + cfg.search[i]
 		if rname[len(rname)-1] != '.' {
 			rname += "."
 		}
-		addrs, err = tryOneName(cfg, rname);
+		addrs, err = tryOneName(cfg, rname)
 		if err == nil {
-			cname = rname;
-			return;
+			cname = rname
+			return
 		}
 	}
 
 	// Last ditch effort: try unsuffixed.
-	rname := name;
+	rname := name
 	if !rooted {
 		rname += "."
 	}
-	addrs, err = tryOneName(cfg, rname);
+	addrs, err = tryOneName(cfg, rname)
 	if err == nil {
-		cname = rname;
-		return;
+		cname = rname
+		return
 	}
-	return;
+	return
 }