libgo/go/net/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 open(name string) (*file, error) {
  68         fd, err := os.Open(name)
  69         if err != nil {
  70                 return nil, err
  71         }
  72         return &file{fd, make([]byte, 0, 64*1024), false}, nil
  73 }
  74
  75 func stat(name string) (mtime time.Time, size int64, err error) {
  76         st, err := os.Stat(name)
  77         if err != nil {
  78                 return time.Time{}, 0, err
  79         }
  80         return st.ModTime(), st.Size(), nil
  81 }
  82
  83 // Count occurrences in s of any bytes in t.
  84 func countAnyByte(s string, t string) int {
  85         n := 0
  86         for i := 0; i < len(s); i++ {
  87                 if bytealg.IndexByteString(t, s[i]) >= 0 {
  88                         n++
  89                 }
  90         }
  91         return n
  92 }
  93
  94 // Split s at any bytes in t.
  95 func splitAtBytes(s string, t string) []string {
  96         a := make([]string, 1+countAnyByte(s, t))
  97         n := 0
  98         last := 0
  99         for i := 0; i < len(s); i++ {
 100                 if bytealg.IndexByteString(t, s[i]) >= 0 {
 101                         if last < i {
 102                                 a[n] = s[last:i]
 103                                 n++
 104                         }
 105                         last = i + 1
 106                 }
 107         }
 108         if last < len(s) {
 109                 a[n] = s[last:]
 110                 n++
 111         }
 112         return a[0:n]
 113 }
 114
 115 func getFields(s string) []string { return splitAtBytes(s, " \r\t\n") }
 116
 117 // Bigger than we need, not too big to worry about overflow
 118 const big = 0xFFFFFF
 119
 120 // Decimal to integer.
 121 // Returns number, characters consumed, success.
 122 func dtoi(s string) (n int, i int, ok bool) {
 123         n = 0
 124         for i = 0; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
 125                 n = n*10 + int(s[i]-'0')
 126                 if n >= big {
 127                         return big, i, false
 128                 }
 129         }
 130         if i == 0 {
 131                 return 0, 0, false
 132         }
 133         return n, i, true
 134 }
 135
 136 // Hexadecimal to integer.
 137 // Returns number, characters consumed, success.
 138 func xtoi(s string) (n int, i int, ok bool) {
 139         n = 0
 140         for i = 0; i < len(s); i++ {
 141                 if '0' <= s[i] && s[i] <= '9' {
 142                         n *= 16
 143                         n += int(s[i] - '0')
 144                 } else if 'a' <= s[i] && s[i] <= 'f' {
 145                         n *= 16
 146                         n += int(s[i]-'a') + 10
 147                 } else if 'A' <= s[i] && s[i] <= 'F' {
 148                         n *= 16
 149                         n += int(s[i]-'A') + 10
 150                 } else {
 151                         break
 152                 }
 153                 if n >= big {
 154                         return 0, i, false
 155                 }
 156         }
 157         if i == 0 {
 158                 return 0, i, false
 159         }
 160         return n, i, true
 161 }
 162
 163 // xtoi2 converts the next two hex digits of s into a byte.
 164 // If s is longer than 2 bytes then the third byte must be e.
 165 // If the first two bytes of s are not hex digits or the third byte
 166 // does not match e, false is returned.
 167 func xtoi2(s string, e byte) (byte, bool) {
 168         if len(s) > 2 && s[2] != e {
 169                 return 0, false
 170         }
 171         n, ei, ok := xtoi(s[:2])
 172         return byte(n), ok && ei == 2
 173 }
 174
 175 // Convert integer to decimal string.
 176 func itoa(val int) string {
 177         if val < 0 {
 178                 return "-" + uitoa(uint(-val))
 179         }
 180         return uitoa(uint(val))
 181 }
 182
 183 // Convert unsigned integer to decimal string.
 184 func uitoa(val uint) string {
 185         if val == 0 { // avoid string allocation
 186                 return "0"
 187         }
 188         var buf [20]byte // big enough for 64bit value base 10
 189         i := len(buf) - 1
 190         for val >= 10 {
 191                 q := val / 10
 192                 buf[i] = byte('0' + val - q*10)
 193                 i--
 194                 val = q
 195         }
 196         // val < 10
 197         buf[i] = byte('0' + val)
 198         return string(buf[i:])
 199 }
 200
 201 // Convert i to a hexadecimal string. Leading zeros are not printed.
 202 func appendHex(dst []byte, i uint32) []byte {
 203         if i == 0 {
 204                 return append(dst, '0')
 205         }
 206         for j := 7; j >= 0; j-- {
 207                 v := i >> uint(j*4)
 208                 if v > 0 {
 209                         dst = append(dst, hexDigit[v&0xf])
 210                 }
 211         }
 212         return dst
 213 }
 214
 215 // Number of occurrences of b in s.
 216 func count(s string, b byte) int {
 217         n := 0
 218         for i := 0; i < len(s); i++ {
 219                 if s[i] == b {
 220                         n++
 221                 }
 222         }
 223         return n
 224 }
 225
 226 // Index of rightmost occurrence of b in s.
 227 func last(s string, b byte) int {
 228         i := len(s)
 229         for i--; i >= 0; i-- {
 230                 if s[i] == b {
 231                         break
 232                 }
 233         }
 234         return i
 235 }
 236
 237 // lowerASCIIBytes makes x ASCII lowercase in-place.
 238 func lowerASCIIBytes(x []byte) {
 239         for i, b := range x {
 240                 if 'A' <= b && b <= 'Z' {
 241                         x[i] += 'a' - 'A'
 242                 }
 243         }
 244 }
 245
 246 // lowerASCII returns the ASCII lowercase version of b.
 247 func lowerASCII(b byte) byte {
 248         if 'A' <= b && b <= 'Z' {
 249                 return b + ('a' - 'A')
 250         }
 251         return b
 252 }
 253
 254 // trimSpace returns x without any leading or trailing ASCII whitespace.
 255 func trimSpace(x []byte) []byte {
 256         for len(x) > 0 && isSpace(x[0]) {
 257                 x = x[1:]
 258         }
 259         for len(x) > 0 && isSpace(x[len(x)-1]) {
 260                 x = x[:len(x)-1]
 261         }
 262         return x
 263 }
 264
 265 // isSpace reports whether b is an ASCII space character.
 266 func isSpace(b byte) bool {
 267         return b == ' ' || b == '\t' || b == '\n' || b == '\r'
 268 }
 269
 270 // removeComment returns line, removing any '#' byte and any following
 271 // bytes.
 272 func removeComment(line []byte) []byte {
 273         if i := bytealg.IndexByte(line, '#'); i != -1 {
 274                 return line[:i]
 275         }
 276         return line
 277 }
 278
 279 // foreachLine runs fn on each line of x.
 280 // Each line (except for possibly the last) ends in '\n'.
 281 // It returns the first non-nil error returned by fn.
 282 func foreachLine(x []byte, fn func(line []byte) error) error {
 283         for len(x) > 0 {
 284                 nl := bytealg.IndexByte(x, '\n')
 285                 if nl == -1 {
 286                         return fn(x)
 287                 }
 288                 line := x[:nl+1]
 289                 x = x[nl+1:]
 290                 if err := fn(line); err != nil {
 291                         return err
 292                 }
 293         }
 294         return nil
 295 }
 296
 297 // foreachField runs fn on each non-empty run of non-space bytes in x.
 298 // It returns the first non-nil error returned by fn.
 299 func foreachField(x []byte, fn func(field []byte) error) error {
 300         x = trimSpace(x)
 301         for len(x) > 0 {
 302                 sp := bytealg.IndexByte(x, ' ')
 303                 if sp == -1 {
 304                         return fn(x)
 305                 }
 306                 if field := trimSpace(x[:sp]); len(field) > 0 {
 307                         if err := fn(field); err != nil {
 308                                 return err
 309                         }
 310                 }
 311                 x = trimSpace(x[sp+1:])
 312         }
 313         return nil
 314 }
 315
 316 // stringsHasSuffix is strings.HasSuffix. It reports whether s ends in
 317 // suffix.
 318 func stringsHasSuffix(s, suffix string) bool {
 319         return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
 320 }
 321
 322 // stringsHasSuffixFold reports whether s ends in suffix,
 323 // ASCII-case-insensitively.
 324 func stringsHasSuffixFold(s, suffix string) bool {
 325         return len(s) >= len(suffix) && stringsEqualFold(s[len(s)-len(suffix):], suffix)
 326 }
 327
 328 // stringsHasPrefix is strings.HasPrefix. It reports whether s begins with prefix.
 329 func stringsHasPrefix(s, prefix string) bool {
 330         return len(s) >= len(prefix) && s[:len(prefix)] == prefix
 331 }
 332
 333 // stringsEqualFold is strings.EqualFold, ASCII only. It reports whether s and t
 334 // are equal, ASCII-case-insensitively.
 335 func stringsEqualFold(s, t string) bool {
 336         if len(s) != len(t) {
 337                 return false
 338         }
 339         for i := 0; i < len(s); i++ {
 340                 if lowerASCII(s[i]) != lowerASCII(t[i]) {
 341                         return false
 342                 }
 343         }
 344         return true
 345 }
 346
 347 func readFull(r io.Reader) (all []byte, err error) {
 348         buf := make([]byte, 1024)
 349         for {
 350                 n, err := r.Read(buf)
 351                 all = append(all, buf[:n]...)
 352                 if err == io.EOF {
 353                         return all, nil
 354                 }
 355                 if err != nil {
 356                         return nil, err
 357                 }
 358         }
 359 }
 360
 361 // goDebugString returns the value of the named GODEBUG key.
 362 // GODEBUG is of the form "key=val,key2=val2"
 363 func goDebugString(key string) string {
 364         s := os.Getenv("GODEBUG")
 365         for i := 0; i < len(s)-len(key)-1; i++ {
 366                 if i > 0 && s[i-1] != ',' {
 367                         continue
 368                 }
 369                 afterKey := s[i+len(key):]
 370                 if afterKey[0] != '=' || s[i:i+len(key)] != key {
 371                         continue
 372                 }
 373                 val := afterKey[1:]
 374                 for i, b := range val {
 375                         if b == ',' {
 376                                 return val[:i]
 377                         }
 378                 }
 379                 return val
 380         }
 381         return ""
 382 }