parse.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  // Simple file i/o and string manipulation, to avoid
     6  // depending on strconv and bufio and strings.
     7  
     8  package net
     9  
    10  import (
    11  	"internal/bytealg"
    12  	"io"
    13  	"os"
    14  	"time"
    15  )
    16  
    17  type file struct {
    18  	file  *os.File
    19  	data  []byte
    20  	atEOF bool
    21  }
    22  
    23  func (f *file) close() { f.file.Close() }
    24  
    25  func (f *file) getLineFromData() (s string, ok bool) {
    26  	data := f.data
    27  	i := 0
    28  	for i = 0; i < len(data); i++ {
    29  		if data[i] == '\n' {
    30  			s = string(data[0:i])
    31  			ok = true
    32  			// move data
    33  			i++
    34  			n := len(data) - i
    35  			copy(data[0:], data[i:])
    36  			f.data = data[0:n]
    37  			return
    38  		}
    39  	}
    40  	if f.atEOF && len(f.data) > 0 {
    41  		// EOF, return all we have
    42  		s = string(data)
    43  		f.data = f.data[0:0]
    44  		ok = true
    45  	}
    46  	return
    47  }
    48  
    49  func (f *file) readLine() (s string, ok bool) {
    50  	if s, ok = f.getLineFromData(); ok {
    51  		return
    52  	}
    53  	if len(f.data) < cap(f.data) {
    54  		ln := len(f.data)
    55  		n, err := io.ReadFull(f.file, f.data[ln:cap(f.data)])
    56  		if n >= 0 {
    57  			f.data = f.data[0 : ln+n]
    58  		}
    59  		if err == io.EOF || err == io.ErrUnexpectedEOF {
    60  			f.atEOF = true
    61  		}
    62  	}
    63  	s, ok = f.getLineFromData()
    64  	return
    65  }
    66  
    67  func (f *file) stat() (mtime time.Time, size int64, err error) {
    68  	st, err := f.file.Stat()
    69  	if err != nil {
    70  		return time.Time{}, 0, err
    71  	}
    72  	return st.ModTime(), st.Size(), nil
    73  }
    74  
    75  func open(name string) (*file, error) {
    76  	fd, err := os.Open(name)
    77  	if err != nil {
    78  		return nil, err
    79  	}
    80  	return &file{fd, make([]byte, 0, 64*1024), false}, nil
    81  }
    82  
    83  func stat(name string) (mtime time.Time, size int64, err error) {
    84  	st, err := os.Stat(name)
    85  	if err != nil {
    86  		return time.Time{}, 0, err
    87  	}
    88  	return st.ModTime(), st.Size(), nil
    89  }
    90  
    91  // Count occurrences in s of any bytes in t.
    92  func countAnyByte(s string, t string) int {
    93  	n := 0
    94  	for i := 0; i < len(s); i++ {
    95  		if bytealg.IndexByteString(t, s[i]) >= 0 {
    96  			n++
    97  		}
    98  	}
    99  	return n
   100  }
   101  
   102  // Split s at any bytes in t.
   103  func splitAtBytes(s string, t string) []string {
   104  	a := make([]string, 1+countAnyByte(s, t))
   105  	n := 0
   106  	last := 0
   107  	for i := 0; i < len(s); i++ {
   108  		if bytealg.IndexByteString(t, s[i]) >= 0 {
   109  			if last < i {
   110  				a[n] = s[last:i]
   111  				n++
   112  			}
   113  			last = i + 1
   114  		}
   115  	}
   116  	if last < len(s) {
   117  		a[n] = s[last:]
   118  		n++
   119  	}
   120  	return a[0:n]
   121  }
   122  
   123  func getFields(s string) []string { return splitAtBytes(s, " \r\t\n") }
   124  
   125  // Bigger than we need, not too big to worry about overflow
   126  const big = 0xFFFFFF
   127  
   128  // Decimal to integer.
   129  // Returns number, characters consumed, success.
   130  func dtoi(s string) (n int, i int, ok bool) {
   131  	n = 0
   132  	for i = 0; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
   133  		n = n*10 + int(s[i]-'0')
   134  		if n >= big {
   135  			return big, i, false
   136  		}
   137  	}
   138  	if i == 0 {
   139  		return 0, 0, false
   140  	}
   141  	return n, i, true
   142  }
   143  
   144  // Hexadecimal to integer.
   145  // Returns number, characters consumed, success.
   146  func xtoi(s string) (n int, i int, ok bool) {
   147  	n = 0
   148  	for i = 0; i < len(s); i++ {
   149  		if '0' <= s[i] && s[i] <= '9' {
   150  			n *= 16
   151  			n += int(s[i] - '0')
   152  		} else if 'a' <= s[i] && s[i] <= 'f' {
   153  			n *= 16
   154  			n += int(s[i]-'a') + 10
   155  		} else if 'A' <= s[i] && s[i] <= 'F' {
   156  			n *= 16
   157  			n += int(s[i]-'A') + 10
   158  		} else {
   159  			break
   160  		}
   161  		if n >= big {
   162  			return 0, i, false
   163  		}
   164  	}
   165  	if i == 0 {
   166  		return 0, i, false
   167  	}
   168  	return n, i, true
   169  }
   170  
   171  // xtoi2 converts the next two hex digits of s into a byte.
   172  // If s is longer than 2 bytes then the third byte must be e.
   173  // If the first two bytes of s are not hex digits or the third byte
   174  // does not match e, false is returned.
   175  func xtoi2(s string, e byte) (byte, bool) {
   176  	if len(s) > 2 && s[2] != e {
   177  		return 0, false
   178  	}
   179  	n, ei, ok := xtoi(s[:2])
   180  	return byte(n), ok && ei == 2
   181  }
   182  
   183  // hasUpperCase tells whether the given string contains at least one upper-case.
   184  func hasUpperCase(s string) bool {
   185  	for i := range s {
   186  		if 'A' <= s[i] && s[i] <= 'Z' {
   187  			return true
   188  		}
   189  	}
   190  	return false
   191  }
   192  
   193  // lowerASCIIBytes makes x ASCII lowercase in-place.
   194  func lowerASCIIBytes(x []byte) {
   195  	for i, b := range x {
   196  		if 'A' <= b && b <= 'Z' {
   197  			x[i] += 'a' - 'A'
   198  		}
   199  	}
   200  }
   201  
   202  // lowerASCII returns the ASCII lowercase version of b.
   203  func lowerASCII(b byte) byte {
   204  	if 'A' <= b && b <= 'Z' {
   205  		return b + ('a' - 'A')
   206  	}
   207  	return b
   208  }
   209  
   210  // trimSpace returns x without any leading or trailing ASCII whitespace.
   211  func trimSpace(x string) string {
   212  	for len(x) > 0 && isSpace(x[0]) {
   213  		x = x[1:]
   214  	}
   215  	for len(x) > 0 && isSpace(x[len(x)-1]) {
   216  		x = x[:len(x)-1]
   217  	}
   218  	return x
   219  }
   220  
   221  // isSpace reports whether b is an ASCII space character.
   222  func isSpace(b byte) bool {
   223  	return b == ' ' || b == '\t' || b == '\n' || b == '\r'
   224  }
   225  
   226  // removeComment returns line, removing any '#' byte and any following
   227  // bytes.
   228  func removeComment(line string) string {
   229  	if i := bytealg.IndexByteString(line, '#'); i != -1 {
   230  		return line[:i]
   231  	}
   232  	return line
   233  }
   234  
   235  // foreachField runs fn on each non-empty run of non-space bytes in x.
   236  // It returns the first non-nil error returned by fn.
   237  func foreachField(x string, fn func(field string) error) error {
   238  	x = trimSpace(x)
   239  	for len(x) > 0 {
   240  		sp := bytealg.IndexByteString(x, ' ')
   241  		if sp == -1 {
   242  			return fn(x)
   243  		}
   244  		if field := trimSpace(x[:sp]); len(field) > 0 {
   245  			if err := fn(field); err != nil {
   246  				return err
   247  			}
   248  		}
   249  		x = trimSpace(x[sp+1:])
   250  	}
   251  	return nil
   252  }
   253  
   254  // stringsHasSuffixFold reports whether s ends in suffix,
   255  // ASCII-case-insensitively.
   256  func stringsHasSuffixFold(s, suffix string) bool {
   257  	return len(s) >= len(suffix) && stringsEqualFold(s[len(s)-len(suffix):], suffix)
   258  }
   259  
   260  // stringsEqualFold is strings.EqualFold, ASCII only. It reports whether s and t
   261  // are equal, ASCII-case-insensitively.
   262  func stringsEqualFold(s, t string) bool {
   263  	if len(s) != len(t) {
   264  		return false
   265  	}
   266  	for i := 0; i < len(s); i++ {
   267  		if lowerASCII(s[i]) != lowerASCII(t[i]) {
   268  			return false
   269  		}
   270  	}
   271  	return true
   272  }
   273
View as plain text