libgo/go/go/build/read.go

   1 // Copyright 2012 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 build
   6
   7 import (
   8         "bufio"
   9         "errors"
  10         "io"
  11         "unicode/utf8"
  12 )
  13
  14 type importReader struct {
  15         b    *bufio.Reader
  16         buf  []byte
  17         peek byte
  18         err  error
  19         eof  bool
  20         nerr int
  21 }
  22
  23 func isIdent(c byte) bool {
  24         return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '_' || c >= utf8.RuneSelf
  25 }
  26
  27 var (
  28         errSyntax = errors.New("syntax error")
  29         errNUL    = errors.New("unexpected NUL in input")
  30 )
  31
  32 // syntaxError records a syntax error, but only if an I/O error has not already been recorded.
  33 func (r *importReader) syntaxError() {
  34         if r.err == nil {
  35                 r.err = errSyntax
  36         }
  37 }
  38
  39 // readByte reads the next byte from the input, saves it in buf, and returns it.
  40 // If an error occurs, readByte records the error in r.err and returns 0.
  41 func (r *importReader) readByte() byte {
  42         c, err := r.b.ReadByte()
  43         if err == nil {
  44                 r.buf = append(r.buf, c)
  45                 if c == 0 {
  46                         err = errNUL
  47                 }
  48         }
  49         if err != nil {
  50                 if err == io.EOF {
  51                         r.eof = true
  52                 } else if r.err == nil {
  53                         r.err = err
  54                 }
  55                 c = 0
  56         }
  57         return c
  58 }
  59
  60 // peekByte returns the next byte from the input reader but does not advance beyond it.
  61 // If skipSpace is set, peekByte skips leading spaces and comments.
  62 func (r *importReader) peekByte(skipSpace bool) byte {
  63         if r.err != nil {
  64                 if r.nerr++; r.nerr > 10000 {
  65                         panic("go/build: import reader looping")
  66                 }
  67                 return 0
  68         }
  69
  70         // Use r.peek as first input byte.
  71         // Don't just return r.peek here: it might have been left by peekByte(false)
  72         // and this might be peekByte(true).
  73         c := r.peek
  74         if c == 0 {
  75                 c = r.readByte()
  76         }
  77         for r.err == nil && !r.eof {
  78                 if skipSpace {
  79                         // For the purposes of this reader, semicolons are never necessary to
  80                         // understand the input and are treated as spaces.
  81                         switch c {
  82                         case ' ', '\f', '\t', '\r', '\n', ';':
  83                                 c = r.readByte()
  84                                 continue
  85
  86                         case '/':
  87                                 c = r.readByte()
  88                                 if c == '/' {
  89                                         for c != '\n' && r.err == nil && !r.eof {
  90                                                 c = r.readByte()
  91                                         }
  92                                 } else if c == '*' {
  93                                         var c1 byte
  94                                         for (c != '*' || c1 != '/') && r.err == nil {
  95                                                 if r.eof {
  96                                                         r.syntaxError()
  97                                                 }
  98                                                 c, c1 = c1, r.readByte()
  99                                         }
 100                                 } else {
 101                                         r.syntaxError()
 102                                 }
 103                                 c = r.readByte()
 104                                 continue
 105                         }
 106                 }
 107                 break
 108         }
 109         r.peek = c
 110         return r.peek
 111 }
 112
 113 // nextByte is like peekByte but advances beyond the returned byte.
 114 func (r *importReader) nextByte(skipSpace bool) byte {
 115         c := r.peekByte(skipSpace)
 116         r.peek = 0
 117         return c
 118 }
 119
 120 // readKeyword reads the given keyword from the input.
 121 // If the keyword is not present, readKeyword records a syntax error.
 122 func (r *importReader) readKeyword(kw string) {
 123         r.peekByte(true)
 124         for i := 0; i < len(kw); i++ {
 125                 if r.nextByte(false) != kw[i] {
 126                         r.syntaxError()
 127                         return
 128                 }
 129         }
 130         if isIdent(r.peekByte(false)) {
 131                 r.syntaxError()
 132         }
 133 }
 134
 135 // readIdent reads an identifier from the input.
 136 // If an identifier is not present, readIdent records a syntax error.
 137 func (r *importReader) readIdent() {
 138         c := r.peekByte(true)
 139         if !isIdent(c) {
 140                 r.syntaxError()
 141                 return
 142         }
 143         for isIdent(r.peekByte(false)) {
 144                 r.peek = 0
 145         }
 146 }
 147
 148 // readString reads a quoted string literal from the input.
 149 // If an identifier is not present, readString records a syntax error.
 150 func (r *importReader) readString(save *[]string) {
 151         switch r.nextByte(true) {
 152         case '`':
 153                 start := len(r.buf) - 1
 154                 for r.err == nil {
 155                         if r.nextByte(false) == '`' {
 156                                 if save != nil {
 157                                         *save = append(*save, string(r.buf[start:]))
 158                                 }
 159                                 break
 160                         }
 161                         if r.eof {
 162                                 r.syntaxError()
 163                         }
 164                 }
 165         case '"':
 166                 start := len(r.buf) - 1
 167                 for r.err == nil {
 168                         c := r.nextByte(false)
 169                         if c == '"' {
 170                                 if save != nil {
 171                                         *save = append(*save, string(r.buf[start:]))
 172                                 }
 173                                 break
 174                         }
 175                         if r.eof || c == '\n' {
 176                                 r.syntaxError()
 177                         }
 178                         if c == '\\' {
 179                                 r.nextByte(false)
 180                         }
 181                 }
 182         default:
 183                 r.syntaxError()
 184         }
 185 }
 186
 187 // readImport reads an import clause - optional identifier followed by quoted string -
 188 // from the input.
 189 func (r *importReader) readImport(imports *[]string) {
 190         c := r.peekByte(true)
 191         if c == '.' {
 192                 r.peek = 0
 193         } else if isIdent(c) {
 194                 r.readIdent()
 195         }
 196         r.readString(imports)
 197 }
 198
 199 // readComments is like ioutil.ReadAll, except that it only reads the leading
 200 // block of comments in the file.
 201 func readComments(f io.Reader) ([]byte, error) {
 202         r := &importReader{b: bufio.NewReader(f)}
 203         r.peekByte(true)
 204         if r.err == nil && !r.eof {
 205                 // Didn't reach EOF, so must have found a non-space byte. Remove it.
 206                 r.buf = r.buf[:len(r.buf)-1]
 207         }
 208         return r.buf, r.err
 209 }
 210
 211 // readImports is like ioutil.ReadAll, except that it expects a Go file as input
 212 // and stops reading the input once the imports have completed.
 213 func readImports(f io.Reader, reportSyntaxError bool, imports *[]string) ([]byte, error) {
 214         r := &importReader{b: bufio.NewReader(f)}
 215
 216         r.readKeyword("package")
 217         r.readIdent()
 218         for r.peekByte(true) == 'i' {
 219                 r.readKeyword("import")
 220                 if r.peekByte(true) == '(' {
 221                         r.nextByte(false)
 222                         for r.peekByte(true) != ')' && r.err == nil {
 223                                 r.readImport(imports)
 224                         }
 225                         r.nextByte(false)
 226                 } else {
 227                         r.readImport(imports)
 228                 }
 229         }
 230
 231         // If we stopped successfully before EOF, we read a byte that told us we were done.
 232         // Return all but that last byte, which would cause a syntax error if we let it through.
 233         if r.err == nil && !r.eof {
 234                 return r.buf[:len(r.buf)-1], nil
 235         }
 236
 237         // If we stopped for a syntax error, consume the whole file so that
 238         // we are sure we don't change the errors that go/parser returns.
 239         if r.err == errSyntax && !reportSyntaxError {
 240                 r.err = nil
 241                 for r.err == nil && !r.eof {
 242                         r.readByte()
 243                 }
 244         }
 245
 246         return r.buf, r.err
 247 }