...
Run Format

Source file src/go/scanner/errors.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package scanner
     6	
     7	import (
     8		"fmt"
     9		"go/token"
    10		"io"
    11		"sort"
    12	)
    13	
    14	// In an ErrorList, an error is represented by an *Error.
    15	// The position Pos, if valid, points to the beginning of
    16	// the offending token, and the error condition is described
    17	// by Msg.
    18	//
    19	type Error struct {
    20		Pos token.Position
    21		Msg string
    22	}
    23	
    24	// Error implements the error interface.
    25	func (e Error) Error() string {
    26		if e.Pos.Filename != "" || e.Pos.IsValid() {
    27			// don't print "<unknown position>"
    28			// TODO(gri) reconsider the semantics of Position.IsValid
    29			return e.Pos.String() + ": " + e.Msg
    30		}
    31		return e.Msg
    32	}
    33	
    34	// ErrorList is a list of *Errors.
    35	// The zero value for an ErrorList is an empty ErrorList ready to use.
    36	//
    37	type ErrorList []*Error
    38	
    39	// Add adds an Error with given position and error message to an ErrorList.
    40	func (p *ErrorList) Add(pos token.Position, msg string) {
    41		*p = append(*p, &Error{pos, msg})
    42	}
    43	
    44	// Reset resets an ErrorList to no errors.
    45	func (p *ErrorList) Reset() { *p = (*p)[0:0] }
    46	
    47	// ErrorList implements the sort Interface.
    48	func (p ErrorList) Len() int      { return len(p) }
    49	func (p ErrorList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
    50	
    51	func (p ErrorList) Less(i, j int) bool {
    52		e := &p[i].Pos
    53		f := &p[j].Pos
    54		// Note that it is not sufficient to simply compare file offsets because
    55		// the offsets do not reflect modified line information (through //line
    56		// comments).
    57		if e.Filename != f.Filename {
    58			return e.Filename < f.Filename
    59		}
    60		if e.Line != f.Line {
    61			return e.Line < f.Line
    62		}
    63		if e.Column != f.Column {
    64			return e.Column < f.Column
    65		}
    66		return p[i].Msg < p[j].Msg
    67	}
    68	
    69	// Sort sorts an ErrorList. *Error entries are sorted by position,
    70	// other errors are sorted by error message, and before any *Error
    71	// entry.
    72	//
    73	func (p ErrorList) Sort() {
    74		sort.Sort(p)
    75	}
    76	
    77	// RemoveMultiples sorts an ErrorList and removes all but the first error per line.
    78	func (p *ErrorList) RemoveMultiples() {
    79		sort.Sort(p)
    80		var last token.Position // initial last.Line is != any legal error line
    81		i := 0
    82		for _, e := range *p {
    83			if e.Pos.Filename != last.Filename || e.Pos.Line != last.Line {
    84				last = e.Pos
    85				(*p)[i] = e
    86				i++
    87			}
    88		}
    89		(*p) = (*p)[0:i]
    90	}
    91	
    92	// An ErrorList implements the error interface.
    93	func (p ErrorList) Error() string {
    94		switch len(p) {
    95		case 0:
    96			return "no errors"
    97		case 1:
    98			return p[0].Error()
    99		}
   100		return fmt.Sprintf("%s (and %d more errors)", p[0], len(p)-1)
   101	}
   102	
   103	// Err returns an error equivalent to this error list.
   104	// If the list is empty, Err returns nil.
   105	func (p ErrorList) Err() error {
   106		if len(p) == 0 {
   107			return nil
   108		}
   109		return p
   110	}
   111	
   112	// PrintError is a utility function that prints a list of errors to w,
   113	// one error per line, if the err parameter is an ErrorList. Otherwise
   114	// it prints the err string.
   115	//
   116	func PrintError(w io.Writer, err error) {
   117		if list, ok := err.(ErrorList); ok {
   118			for _, e := range list {
   119				fmt.Fprintf(w, "%s\n", e)
   120			}
   121		} else if err != nil {
   122			fmt.Fprintf(w, "%s\n", err)
   123		}
   124	}
   125	

View as plain text