82 #define basic(cp) ((punycode_uint)(cp) < 0x80) 85 #define delim(cp) ((cp) == delimiter) 94 return cp - 48 < 10 ? cp - 22 : cp - 65 < 26 ? cp - 65 :
95 cp - 97 < 26 ? cp - 97 :
base;
107 return d + 22 + 75 * (d < 26) - ((flag != 0) << 5);
116 #define flagged(bcp) ((punycode_uint)(bcp) - 65 < 26) 127 bcp -= (bcp - 97 < 26) << 5;
128 return bcp + ((!flag && (bcp - 65 < 26)) << 5);
144 delta = firsttime ? delta /
damp : delta >> 1;
146 delta += delta / numpoints;
198 const unsigned char case_flags[],
199 size_t * output_length,
char output[])
201 punycode_uint input_len, n, delta, h, b, bias, j, m, q, k, t;
208 if (input_length > maxint)
217 max_out = *output_length;
222 for (j = 0; j < input_len; ++j)
224 if (
basic (input[j]))
226 if (max_out - out < 2)
228 output[out++] = case_flags ?
229 encode_basic (input[j], case_flags[j]) : (char) input[j];
247 while (h < input_len)
252 for (m = maxint, j = 0; j < input_len; ++j)
256 if (input[j] >= n && input[j] < m)
263 if (m - n > (maxint - delta) / (h + 1))
265 delta += (m - n) * (h + 1);
268 for (j = 0; j < input_len; ++j)
281 for (q = delta, k =
base;; k +=
base)
285 t = k <= bias ?
tmin :
289 output[out++] = encode_digit (t + (q - t) % (
base - t), 0);
290 q = (q - t) / (
base - t);
293 output[out++] = encode_digit (q, case_flags && case_flags[j]);
294 bias = adapt (delta, h + 1, h == b);
303 *output_length = out;
347 size_t * output_length,
350 punycode_uint n, out, i, max_out, bias, oldi, w, k, digit, t;
357 max_out = *output_length > maxint ? maxint
365 for (b = j = 0; j < input_length; ++j)
366 if (
delim (input[j]))
371 for (j = 0; j < b; ++j)
374 case_flags[out] =
flagged (input[j]);
375 if (!
basic (input[j]))
377 output[out++] = input[j];
383 for (in = b > 0 ? b + 1 : 0; in < input_length; ++out)
394 for (oldi = i, w = 1, k =
base;; k +=
base)
396 if (in >= input_length)
398 digit = decode_digit (input[in++]);
401 if (digit > (maxint - i) / w)
404 t = k <= bias ?
tmin :
408 if (w > maxint / (
base - t))
413 bias = adapt (i - oldi, out + 1, oldi == 0);
418 if (i / (out + 1) > maxint - n)
432 memmove (case_flags + i + 1, case_flags + i, out - i);
434 case_flags[i] =
flagged (input[in - 1]);
437 memmove (output + i + 1, output + i, (out - i) *
sizeof *output);
441 *output_length = (size_t) out;
int punycode_encode(size_t input_length, const punycode_uint input[], const unsigned char case_flags[], size_t *output_length, char output[])
int punycode_decode(size_t input_length, const char input[], size_t *output_length, punycode_uint output[], unsigned char case_flags[])