OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [net/] [http/] [lex.go] - Blame information for rev 747

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 747 jeremybenn 
// 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 
package http
6 
 
7 
// This file deals with lexical matters of HTTP
8 
 
9 
func isSeparator(c byte) bool {
10 
        switch c {
11 
        case '(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?', '=', '{', '}', ' ', '\t':
12 
                return true
13 
        }
14 
        return false
15 
}
16 
 
17 
func isSpace(c byte) bool {
18 
        switch c {
19 
        case ' ', '\t', '\r', '\n':
20 
                return true
21 
        }
22 
        return false
23 
}
24 
 
25 
func isCtl(c byte) bool { return (0 <= c && c <= 31) || c == 127 }
26 
 
27 
func isChar(c byte) bool { return 0 <= c && c <= 127 }
28 
 
29 
func isAnyText(c byte) bool { return !isCtl(c) }
30 
 
31 
func isQdText(c byte) bool { return isAnyText(c) && c != '"' }
32 
 
33 
func isToken(c byte) bool { return isChar(c) && !isCtl(c) && !isSeparator(c) }
34 
 
35 
// Valid escaped sequences are not specified in RFC 2616, so for now, we assume
36 
// that they coincide with the common sense ones used by GO. Malformed
37 
// characters should probably not be treated as errors by a robust (forgiving)
38 
// parser, so we replace them with the '?' character.
39 
func httpUnquotePair(b byte) byte {
40 
        // skip the first byte, which should always be '\'
41 
        switch b {
42 
        case 'a':
43 
                return '\a'
44 
        case 'b':
45 
                return '\b'
46 
        case 'f':
47 
                return '\f'
48 
        case 'n':
49 
                return '\n'
50 
        case 'r':
51 
                return '\r'
52 
        case 't':
53 
                return '\t'
54 
        case 'v':
55 
                return '\v'
56 
        case '\\':
57 
                return '\\'
58 
        case '\'':
59 
                return '\''
60 
        case '"':
61 
                return '"'
62 
        }
63 
        return '?'
64 
}
65 
 
66 
// raw must begin with a valid quoted string. Only the first quoted string is
67 
// parsed and is unquoted in result. eaten is the number of bytes parsed, or -1
68 
// upon failure.
69 
func httpUnquote(raw []byte) (eaten int, result string) {
70 
        buf := make([]byte, len(raw))
71 
        if raw[0] != '"' {
72 
                return -1, ""
73 
        }
74 
        eaten = 1
75 
        j := 0 // # of bytes written in buf
76 
        for i := 1; i < len(raw); i++ {
77 
                switch b := raw[i]; b {
78 
                case '"':
79 
                        eaten++
80 
                        buf = buf[0:j]
81 
                        return i + 1, string(buf)
82 
                case '\\':
83 
                        if len(raw) < i+2 {
84 
                                return -1, ""
85 
                        }
86 
                        buf[j] = httpUnquotePair(raw[i+1])
87 
                        eaten += 2
88 
                        j++
89 
                        i++
90 
                default:
91 
                        if isQdText(b) {
92 
                                buf[j] = b
93 
                        } else {
94 
                                buf[j] = '?'
95 
                        }
96 
                        eaten++
97 
                        j++
98 
                }
99 
        }
100 
        return -1, ""
101 
}
102 
 
103 
// This is a best effort parse, so errors are not returned, instead not all of
104 
// the input string might be parsed. result is always non-nil.
105 
func httpSplitFieldValue(fv string) (eaten int, result []string) {
106 
        result = make([]string, 0, len(fv))
107 
        raw := []byte(fv)
108 
        i := 0
109 
        chunk := ""
110 
        for i < len(raw) {
111 
                b := raw[i]
112 
                switch {
113 
                case b == '"':
114 
                        eaten, unq := httpUnquote(raw[i:len(raw)])
115 
                        if eaten < 0 {
116 
                                return i, result
117 
                        } else {
118 
                                i += eaten
119 
                                chunk += unq
120 
                        }
121 
                case isSeparator(b):
122 
                        if chunk != "" {
123 
                                result = result[0 : len(result)+1]
124 
                                result[len(result)-1] = chunk
125 
                                chunk = ""
126 
                        }
127 
                        i++
128 
                case isToken(b):
129 
                        chunk += string(b)
130 
                        i++
131 
                case b == '\n' || b == '\r':
132 
                        i++
133 
                default:
134 
                        chunk += "?"
135 
                        i++
136 
                }
137 
        }
138 
        if chunk != "" {
139 
                result = result[0 : len(result)+1]
140 
                result[len(result)-1] = chunk
141 
                chunk = ""
142 
        }
143 
        return i, result
144 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.