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

src/pkg/os/inotify/inotify_linux.go

 // Copyright 2010 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 inotify implements a wrapper for the Linux inotify system.
 
 Example:
     watcher, err := inotify.NewWatcher()
     if err != nil {
@@ skipping 16 matching lines @@
 package inotify
 
 import (
         "fmt"
         "os"
         "strings"
         "syscall"
         "unsafe"
 )
 
-
 type Event struct {
         Mask   uint32 // Mask of events
         Cookie uint32 // Unique cookie associating related events (for rename(2))
         Name   string // File name (optional)
 }
 
 type watch struct {
         wd    uint32 // Watch descriptor (as returned by the inotify_add_watch() syscall)
         flags uint32 // inotify flags of this watch (see inotify(7) for the list of valid flags)
 }
 
 type Watcher struct {
         fd       int               // File descriptor (as returned by the inotify_init() syscall)
         watches  map[string]*watch // Map of inotify watches (key: path)
         paths    map[int]string    // Map of watched paths (key: watch descriptor)
         Error    chan os.Error     // Errors are sent on this channel
         Event    chan *Event       // Events are returned on this channel
         done     chan bool         // Channel for sending a "quit message" to the reader goroutine
         isClosed bool              // Set to true when Close() is first called
 }
 
-
 // NewWatcher creates and returns a new inotify instance using inotify_init(2)
 func NewWatcher() (*Watcher, os.Error) {
         fd, errno := syscall.InotifyInit()
         if fd == -1 {
                 return nil, os.NewSyscallError("inotify_init", errno)
         }
         w := &Watcher{
                 fd:      fd,
                 watches: make(map[string]*watch),
                 paths:   make(map[int]string),
                 Event:   make(chan *Event),
                 Error:   make(chan os.Error),
                 done:    make(chan bool, 1),
         }
 
         go w.readEvents()
         return w, nil
 }
 
-
 // Close closes an inotify watcher instance
 // It sends a message to the reader goroutine to quit and removes all watches
 // associated with the inotify instance
 func (w *Watcher) Close() os.Error {
         if w.isClosed {
                 return nil
         }
         w.isClosed = true
 
         // Send "quit" message to the reader goroutine
@@ skipping 22 matching lines @@
                 return &os.PathError{"inotify_add_watch", path, os.Errno(errno)}
         }
 
         if !found {
                 w.watches[path] = &watch{wd: uint32(wd), flags: flags}
                 w.paths[wd] = path
         }
         return nil
 }
 
-
 // Watch adds path to the watched file set, watching all events.
 func (w *Watcher) Watch(path string) os.Error {
         return w.AddWatch(path, IN_ALL_EVENTS)
 }
-
 
 // RemoveWatch removes path from the watched file set.
 func (w *Watcher) RemoveWatch(path string) os.Error {
         watch, ok := w.watches[path]
         if !ok {
                 return os.NewError(fmt.Sprintf("can't remove non-existent inotify watch for: %s", path))
         }
         success, errno := syscall.InotifyRmWatch(w.fd, watch.wd)
         if success == -1 {
                 return os.NewSyscallError("inotify_rm_watch", errno)
         }
         w.watches[path] = nil, false
         return nil
 }
-
 
 // readEvents reads from the inotify file descriptor, converts the
 // received events into Event objects and sends them via the Event channel
 func (w *Watcher) readEvents() {
         var (
                 buf   [syscall.SizeofInotifyEvent * 4096]byte // Buffer for a maximum of 4096 raw events
                 n     int                                     // Number of bytes read with read()
                 errno int                                     // Syscall errno
         )
 
@@ skipping 48 matching lines @@
                         }
                         // Send the event on the events channel
                         w.Event <- event
 
                         // Move to the next event in the buffer
                         offset += syscall.SizeofInotifyEvent + nameLen
                 }
         }
 }
 
-
 // String formats the event e in the form
 // "filename: 0xEventMask = IN_ACCESS|IN_ATTRIB_|..."
 func (e *Event) String() string {
         var events string = ""
 
         m := e.Mask
         for _, b := range eventBits {
                 if m&b.Value != 0 {
                         m &^= b.Value
                         events += "|" + b.Name
@@ skipping 64 matching lines @@
         {IN_MOVE, "IN_MOVE"},
         {IN_MOVED_FROM, "IN_MOVED_FROM"},
         {IN_MOVED_TO, "IN_MOVED_TO"},
         {IN_MOVE_SELF, "IN_MOVE_SELF"},
         {IN_OPEN, "IN_OPEN"},
         {IN_ISDIR, "IN_ISDIR"},
         {IN_IGNORED, "IN_IGNORED"},
         {IN_Q_OVERFLOW, "IN_Q_OVERFLOW"},
         {IN_UNMOUNT, "IN_UNMOUNT"},
 }