...
Run Format

Source file src/go/build/read.go

Documentation: go/build

     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  }
   248  

View as plain text