text: // Copyright 2013 The Go Authors. All rights reserved.
  //
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file or at
  // https://developers.google.com/open-source/licenses/bsd.
  
  package cayleyhttp
  
  import (
  	"net/http"
  	"strings"
  )
  
  // Octet types from RFC 2616.
  var octetTypes [256]octetType
  
  type octetType byte
  
  const (
  	isToken octetType = 1 << iota
  	isSpace
  )
  
  func init() {
  	// OCTET      = <any 8-bit sequence of data>
  	// CHAR       = <any US-ASCII character (octets 0 - 127)>
  	// CTL        = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
  	// CR         = <US-ASCII CR, carriage return (13)>
  	// LF         = <US-ASCII LF, linefeed (10)>
  	// SP         = <US-ASCII SP, space (32)>
  	// HT         = <US-ASCII HT, horizontal-tab (9)>
  	// <">        = <US-ASCII double-quote mark (34)>
  	// CRLF       = CR LF
  	// LWS        = [CRLF] 1*( SP | HT )
  	// TEXT       = <any OCTET except CTLs, but including LWS>
  	// separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <">
  	//              | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT
  	// token      = 1*<any CHAR except CTLs or separators>
  	// qdtext     = <any TEXT except <">>
  
  	for c := 0; c < 256; c++ {
  		var t octetType
  		isCtl := c <= 31 || c == 127
  		isChar := 0 <= c && c <= 127
  		isSeparator := strings.IndexRune(" \t\"(),/:;<=>?@[]\\{}", rune(c)) >= 0
  		if strings.IndexRune(" \t\r\n", rune(c)) >= 0 {
  			t |= isSpace
  		}
  		if isChar && !isCtl && !isSeparator {
  			t |= isToken
  		}
  		octetTypes[c] = t
  	}
  }
  
  // AcceptSpec describes an Accept* header.
  type AcceptSpec struct {
  	Value string
  	Q     float64
  }
  
  // ParseAccept parses Accept* headers.
  func ParseAccept(header http.Header, key string) (specs []AcceptSpec) {
  loop:
  	for _, s := range header[key] {
  		for {
  			var spec AcceptSpec
  			spec.Value, s = expectTokenSlash(s)
  			if spec.Value == "" {
  				continue loop
  			}
  			spec.Q = 1.0
  			s = skipSpace(s)
  			if strings.HasPrefix(s, ";") {
  				s = skipSpace(s[1:])
  				if !strings.HasPrefix(s, "q=") {
  					continue loop
  				}
  				spec.Q, s = expectQuality(s[2:])
  				if spec.Q < 0.0 {
  					continue loop
  				}
  			}
  			specs = append(specs, spec)
  			s = skipSpace(s)
  			if !strings.HasPrefix(s, ",") {
  				continue loop
  			}
  			s = skipSpace(s[1:])
  		}
  	}
  	return
  }
  
  func skipSpace(s string) (rest string) {
  	i := 0
  	for ; i < len(s); i++ {
  		if octetTypes[s[i]]&isSpace == 0 {
  			break
  		}
  	}
  	return s[i:]
  }
  
  func expectTokenSlash(s string) (token, rest string) {
  	i := 0
  	for ; i < len(s); i++ {
  		b := s[i]
  		if (octetTypes[b]&isToken == 0) && b != '/' {
  			break
  		}
  	}
  	return s[:i], s[i:]
  }
  
  func expectQuality(s string) (q float64, rest string) {
  	switch {
  	case len(s) == 0:
  		return -1, ""
  	case s[0] == '0':
  		q = 0
  	case s[0] == '1':
  		q = 1
  	default:
  		return -1, ""
  	}
  	s = s[1:]
  	if !strings.HasPrefix(s, ".") {
  		return q, s
  	}
  	s = s[1:]
  	i := 0
  	n := 0
  	d := 1
  	for ; i < len(s); i++ {
  		b := s[i]
  		if b < '0' || b > '9' {
  			break
  		}
  		n = n*10 + int(b) - '0'
  		d *= 10
  	}
  	return q + float64(n)/float64(d), s[i:]
  }
  