diff options
Diffstat (limited to 'vendor/golang.org/x/net/idna/punycode.go')
-rw-r--r-- | vendor/golang.org/x/net/idna/punycode.go | 203 |
1 files changed, 203 insertions, 0 deletions
diff --git a/vendor/golang.org/x/net/idna/punycode.go b/vendor/golang.org/x/net/idna/punycode.go new file mode 100644 index 0000000..02c7d59 --- /dev/null +++ b/vendor/golang.org/x/net/idna/punycode.go | |||
@@ -0,0 +1,203 @@ | |||
1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. | ||
2 | |||
3 | // Copyright 2016 The Go Authors. All rights reserved. | ||
4 | // Use of this source code is governed by a BSD-style | ||
5 | // license that can be found in the LICENSE file. | ||
6 | |||
7 | package idna | ||
8 | |||
9 | // This file implements the Punycode algorithm from RFC 3492. | ||
10 | |||
11 | import ( | ||
12 | "math" | ||
13 | "strings" | ||
14 | "unicode/utf8" | ||
15 | ) | ||
16 | |||
17 | // These parameter values are specified in section 5. | ||
18 | // | ||
19 | // All computation is done with int32s, so that overflow behavior is identical | ||
20 | // regardless of whether int is 32-bit or 64-bit. | ||
21 | const ( | ||
22 | base int32 = 36 | ||
23 | damp int32 = 700 | ||
24 | initialBias int32 = 72 | ||
25 | initialN int32 = 128 | ||
26 | skew int32 = 38 | ||
27 | tmax int32 = 26 | ||
28 | tmin int32 = 1 | ||
29 | ) | ||
30 | |||
31 | func punyError(s string) error { return &labelError{s, "A3"} } | ||
32 | |||
33 | // decode decodes a string as specified in section 6.2. | ||
34 | func decode(encoded string) (string, error) { | ||
35 | if encoded == "" { | ||
36 | return "", nil | ||
37 | } | ||
38 | pos := 1 + strings.LastIndex(encoded, "-") | ||
39 | if pos == 1 { | ||
40 | return "", punyError(encoded) | ||
41 | } | ||
42 | if pos == len(encoded) { | ||
43 | return encoded[:len(encoded)-1], nil | ||
44 | } | ||
45 | output := make([]rune, 0, len(encoded)) | ||
46 | if pos != 0 { | ||
47 | for _, r := range encoded[:pos-1] { | ||
48 | output = append(output, r) | ||
49 | } | ||
50 | } | ||
51 | i, n, bias := int32(0), initialN, initialBias | ||
52 | for pos < len(encoded) { | ||
53 | oldI, w := i, int32(1) | ||
54 | for k := base; ; k += base { | ||
55 | if pos == len(encoded) { | ||
56 | return "", punyError(encoded) | ||
57 | } | ||
58 | digit, ok := decodeDigit(encoded[pos]) | ||
59 | if !ok { | ||
60 | return "", punyError(encoded) | ||
61 | } | ||
62 | pos++ | ||
63 | i += digit * w | ||
64 | if i < 0 { | ||
65 | return "", punyError(encoded) | ||
66 | } | ||
67 | t := k - bias | ||
68 | if t < tmin { | ||
69 | t = tmin | ||
70 | } else if t > tmax { | ||
71 | t = tmax | ||
72 | } | ||
73 | if digit < t { | ||
74 | break | ||
75 | } | ||
76 | w *= base - t | ||
77 | if w >= math.MaxInt32/base { | ||
78 | return "", punyError(encoded) | ||
79 | } | ||
80 | } | ||
81 | x := int32(len(output) + 1) | ||
82 | bias = adapt(i-oldI, x, oldI == 0) | ||
83 | n += i / x | ||
84 | i %= x | ||
85 | if n > utf8.MaxRune || len(output) >= 1024 { | ||
86 | return "", punyError(encoded) | ||
87 | } | ||
88 | output = append(output, 0) | ||
89 | copy(output[i+1:], output[i:]) | ||
90 | output[i] = n | ||
91 | i++ | ||
92 | } | ||
93 | return string(output), nil | ||
94 | } | ||
95 | |||
96 | // encode encodes a string as specified in section 6.3 and prepends prefix to | ||
97 | // the result. | ||
98 | // | ||
99 | // The "while h < length(input)" line in the specification becomes "for | ||
100 | // remaining != 0" in the Go code, because len(s) in Go is in bytes, not runes. | ||
101 | func encode(prefix, s string) (string, error) { | ||
102 | output := make([]byte, len(prefix), len(prefix)+1+2*len(s)) | ||
103 | copy(output, prefix) | ||
104 | delta, n, bias := int32(0), initialN, initialBias | ||
105 | b, remaining := int32(0), int32(0) | ||
106 | for _, r := range s { | ||
107 | if r < 0x80 { | ||
108 | b++ | ||
109 | output = append(output, byte(r)) | ||
110 | } else { | ||
111 | remaining++ | ||
112 | } | ||
113 | } | ||
114 | h := b | ||
115 | if b > 0 { | ||
116 | output = append(output, '-') | ||
117 | } | ||
118 | for remaining != 0 { | ||
119 | m := int32(0x7fffffff) | ||
120 | for _, r := range s { | ||
121 | if m > r && r >= n { | ||
122 | m = r | ||
123 | } | ||
124 | } | ||
125 | delta += (m - n) * (h + 1) | ||
126 | if delta < 0 { | ||
127 | return "", punyError(s) | ||
128 | } | ||
129 | n = m | ||
130 | for _, r := range s { | ||
131 | if r < n { | ||
132 | delta++ | ||
133 | if delta < 0 { | ||
134 | return "", punyError(s) | ||
135 | } | ||
136 | continue | ||
137 | } | ||
138 | if r > n { | ||
139 | continue | ||
140 | } | ||
141 | q := delta | ||
142 | for k := base; ; k += base { | ||
143 | t := k - bias | ||
144 | if t < tmin { | ||
145 | t = tmin | ||
146 | } else if t > tmax { | ||
147 | t = tmax | ||
148 | } | ||
149 | if q < t { | ||
150 | break | ||
151 | } | ||
152 | output = append(output, encodeDigit(t+(q-t)%(base-t))) | ||
153 | q = (q - t) / (base - t) | ||
154 | } | ||
155 | output = append(output, encodeDigit(q)) | ||
156 | bias = adapt(delta, h+1, h == b) | ||
157 | delta = 0 | ||
158 | h++ | ||
159 | remaining-- | ||
160 | } | ||
161 | delta++ | ||
162 | n++ | ||
163 | } | ||
164 | return string(output), nil | ||
165 | } | ||
166 | |||
167 | func decodeDigit(x byte) (digit int32, ok bool) { | ||
168 | switch { | ||
169 | case '0' <= x && x <= '9': | ||
170 | return int32(x - ('0' - 26)), true | ||
171 | case 'A' <= x && x <= 'Z': | ||
172 | return int32(x - 'A'), true | ||
173 | case 'a' <= x && x <= 'z': | ||
174 | return int32(x - 'a'), true | ||
175 | } | ||
176 | return 0, false | ||
177 | } | ||
178 | |||
179 | func encodeDigit(digit int32) byte { | ||
180 | switch { | ||
181 | case 0 <= digit && digit < 26: | ||
182 | return byte(digit + 'a') | ||
183 | case 26 <= digit && digit < 36: | ||
184 | return byte(digit + ('0' - 26)) | ||
185 | } | ||
186 | panic("idna: internal error in punycode encoding") | ||
187 | } | ||
188 | |||
189 | // adapt is the bias adaptation function specified in section 6.1. | ||
190 | func adapt(delta, numPoints int32, firstTime bool) int32 { | ||
191 | if firstTime { | ||
192 | delta /= damp | ||
193 | } else { | ||
194 | delta /= 2 | ||
195 | } | ||
196 | delta += delta / numPoints | ||
197 | k := int32(0) | ||
198 | for delta > ((base-tmin)*tmax)/2 { | ||
199 | delta /= base - tmin | ||
200 | k += base | ||
201 | } | ||
202 | return k + (base-tmin+1)*delta/(delta+skew) | ||
203 | } | ||