code review 4715041: go/printer: changed max. number of newlines from 3 to 2

src/pkg/ebnf/ebnf.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package ebnf is a library for EBNF grammars. The input is text ([]byte)
 // satisfying the following grammar (represented itself in EBNF):
 //
 //      Production  = name "=" [ Expression ] "." .
 //      Expression  = Alternative { "|" Alternative } .
 //      Alternative = Term { Term } .
@@ skipping 12 matching lines @@
 package ebnf
 
 import (
         "go/scanner"
         "go/token"
         "os"
         "unicode"
         "utf8"
 )
 
-
 // ----------------------------------------------------------------------------
 // Internal representation
 
 type (
         // An Expression node represents a production expression.
         Expression interface {
                 // Pos is the position of the first character of the syntactic construct
                 Pos() token.Pos
         }
 
@@ skipping 48 matching lines @@
         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
 )
-
 
 func (x Alternative) Pos() token.Pos { return x[0].Pos() } // the parser always generates non-empty Alternative
 func (x Sequence) Pos() token.Pos    { return x[0].Pos() } // the parser always generates non-empty Sequences
 func (x *Name) Pos() token.Pos       { return x.StringPos }
 func (x *Token) Pos() token.Pos      { return x.StringPos }
 func (x *Range) Pos() token.Pos      { return x.Begin.Pos() }
 func (x *Group) Pos() token.Pos      { return x.Lparen }
 func (x *Option) Pos() token.Pos     { return x.Lbrack }
 func (x *Repetition) Pos() token.Pos { return x.Lbrace }
 func (x *Bad) Pos() token.Pos        { return x.TokPos }
 func (x *Production) Pos() token.Pos { return x.Name.Pos() }
 
-
 // ----------------------------------------------------------------------------
 // Grammar verification
 
 func isLexical(name string) bool {
         ch, _ := utf8.DecodeRuneInString(name)
         return !unicode.IsUpper(ch)
 }
-
 
 type verifier struct {
         fset *token.FileSet
         scanner.ErrorVector
         worklist []*Production
         reached  Grammar // set of productions reached from (and including) the root production
         grammar  Grammar
 }
 
-
 func (v *verifier) error(pos token.Pos, msg string) {
         v.Error(v.fset.Position(pos), msg)
 }
-
 
 func (v *verifier) push(prod *Production) {
         name := prod.Name.String
         if _, found := v.reached[name]; !found {
                 v.worklist = append(v.worklist, prod)
                 v.reached[name] = prod
         }
 }
 
-
 func (v *verifier) verifyChar(x *Token) int {
         s := x.String
         if utf8.RuneCountInString(s) != 1 {
                 v.error(x.Pos(), "single char expected, found "+s)
                 return 0
         }
         ch, _ := utf8.DecodeRuneInString(s)
         return ch
 }
-
 
 func (v *verifier) verifyExpr(expr Expression, lexical bool) {
         switch x := expr.(type) {
         case nil:
                 // empty expression
         case Alternative:
                 for _, e := range x {
                         v.verifyExpr(e, lexical)
                 }
         case Sequence:
@@ skipping 25 matching lines @@
                 v.verifyExpr(x.Body, lexical)
         case *Option:
                 v.verifyExpr(x.Body, lexical)
         case *Repetition:
                 v.verifyExpr(x.Body, lexical)
         default:
                 panic("unreachable")
         }
 }
 
-
 func (v *verifier) verify(fset *token.FileSet, grammar Grammar, start string) {
         // find root production
         root, found := grammar[start]
         if !found {
                 // token.NoPos doesn't require a file set;
                 // ok to set v.fset only afterwards
                 v.error(token.NoPos, "no start production "+start)
                 return
         }
 
@@ skipping 19 matching lines @@
         // check if all productions were reached
         if len(v.reached) < len(v.grammar) {
                 for name, prod := range v.grammar {
                         if _, found := v.reached[name]; !found {
                                 v.error(prod.Pos(), name+" is unreachable")
                         }
                 }
         }
 }
 
-
 // Verify checks that:
 //      - all productions used are defined
 //      - all productions defined are used when beginning at start
 //      - lexical productions refer only to other lexical productions
 //
 // Position information is interpreted relative to the file set fset.
 //
 func Verify(fset *token.FileSet, grammar Grammar, start string) os.Error {
         var v verifier
         v.verify(fset, grammar, start)
         return v.GetError(scanner.Sorted)
 }