gofmt-ify ebnf

R=r
http://go/go-review/1018050

diff --git a/src/pkg/ebnf/ebnf.go b/src/pkg/ebnf/ebnf.go
index ad630fca523e6b6a67e482e3e6e85b32dc8fddb0..3d0be92c7ab905afff7105728e4063660c85b825 100644 (file)
--- a/src/pkg/ebnf/ebnf.go
+++ b/src/pkg/ebnf/ebnf.go
@@ -37,72 +37,72 @@ import (
 
 type (
        // An Expression node represents a production expression.
-       Expression interface {
-               // Pos is the position of the first character of the syntactic construct
-               Pos() token.Position;
+       Expression      interface {
+                       // Pos is the position of the first character of the syntactic construct
+                       Pos() token.Position;
        };
 
        // An Alternative node represents a non-empty list of alternative expressions.
-       Alternative []Expression;  // x | y | z
+       Alternative     []Expression;   // x | y | z
 
        // A Sequence node represents a non-empty list of sequential expressions.
-       Sequence []Expression;  // x y z
+       Sequence        []Expression;   // x y z
 
        // A Name node represents a production name.
-       Name struct {
+       Name    struct {
                token.Position;
-               String string;
+               String  string;
        };
 
        // A Token node represents a literal.
-       Token struct {
+       Token   struct {
                token.Position;
-               String string;
+               String  string;
        };
 
        // A List node represents a range of characters.
-       Range struct {
-               Begin, End *Token;  // begin ... end
+       Range   struct {
+               Begin, End *Token;      // begin ... end
        };
 
        // A Group node represents a grouped expression.
-       Group struct {
+       Group   struct {
                token.Position;
-               Body Expression;  // (body)
+               Body    Expression;     // (body)
        };
 
        // An Option node represents an optional expression.
-       Option struct {
+       Option  struct {
                token.Position;
-               Body Expression;  // [body]
+               Body    Expression;     // [body]
        };
 
        // A Repetition node represents a repeated expression.
-       Repetition struct {
+       Repetition      struct {
                token.Position;
-               Body Expression;  // {body}
+               Body    Expression;     // {body}
        };
 
        // A Production node represents an EBNF production.
-       Production struct {
-               Name *Name;
-               Expr Expression;
+       Production      struct {
+               Name    *Name;
+               Expr    Expression;
        };
 
        // A Grammar is a set of EBNF productions. The map
        // is indexed by production name.
        //
-       Grammar map [string] *Production;
+       Grammar map[string]*Production;
 )
 
 
 func (x Alternative) Pos() token.Position {
-       return x[0].Pos();  // the parser always generates non-empty Alternative
+       return x[0].Pos();      // the parser always generates non-empty Alternative
 }
 
 
 func (x Sequence) Pos() token.Position {
-       return x[0].Pos();  // the parser always generates non-empty Sequences
+       return x[0].Pos();      // the parser always generates non-empty Sequences
 }
 
 
@@ -127,9 +127,9 @@ func isLexical(name string) bool {
 
 type verifier struct {
        scanner.ErrorVector;
-       worklist vector.Vector;
-       reached Grammar;  // set of productions reached from (and including) the root production
-       grammar Grammar;
+       worklist        vector.Vector;
+       reached         Grammar;        // set of productions reached from (and including) the root production
+       grammar         Grammar;
 }
 
 

diff --git a/src/pkg/ebnf/ebnf_test.go b/src/pkg/ebnf/ebnf_test.go
index 3dd3c7a6c5e7dcc4003f843f8f6c69317c66126b..498be622c0b27a295676c9a09bd233e6066e5a26 100644 (file)
--- a/src/pkg/ebnf/ebnf_test.go
+++ b/src/pkg/ebnf/ebnf_test.go
@@ -11,7 +11,7 @@ import (
 )
 
 
-var grammars = []string {
+var grammars = []string{
        `Program = .
        `,
 
@@ -58,8 +58,8 @@ func TestGrammars(t *testing.T) {
 }
 
 
-var files = []string {
-       // TODO(gri) add some test files
+var files = []string{
+// TODO(gri) add some test files
 }