83 #define basic(cp) ((punycode_uint)(cp) < 0x80)
86 #define delim(cp) ((cp) == delimiter)
95 return cp - 48 < 10 ? cp - 22 : cp - 65 < 26 ? cp - 65 :
96 cp - 97 < 26 ? cp - 97 :
base;
108 return d + 22 + 75 * (d < 26) - ((flag != 0) << 5);
117 #define flagged(bcp) ((punycode_uint)(bcp) - 65 < 26)
128 bcp -= (bcp - 97 < 26) << 5;
129 return bcp + ((!flag && (bcp - 65 < 26)) << 5);
145 delta = firsttime ? delta /
damp : delta >> 1;
147 delta += delta / numpoints;
199 const unsigned char case_flags[],
200 size_t * output_length,
char output[])
202 punycode_uint input_len, n, delta, h, b, bias, j, m, q, k, t;
209 if (input_length > maxint)
218 max_out = *output_length;
223 for (j = 0; j < input_len; ++j)
225 if (
basic (input[j]))
227 if (max_out - out < 2)
229 output[out++] = case_flags ?
230 encode_basic (input[j], case_flags[j]) : (char) input[j];
248 while (h < input_len)
253 for (m = maxint, j = 0; j < input_len; ++j)
257 if (input[j] >= n && input[j] < m)
264 if (m - n > (maxint - delta) / (h + 1))
266 delta += (m - n) * (h + 1);
269 for (j = 0; j < input_len; ++j)
282 for (q = delta, k =
base;; k +=
base)
286 t = k <= bias ?
tmin :
290 output[out++] = encode_digit (t + (q - t) % (
base - t), 0);
291 q = (q - t) / (
base - t);
294 output[out++] = encode_digit (q, case_flags && case_flags[j]);
295 bias = adapt (delta, h + 1, h == b);
304 *output_length = out;
348 size_t * output_length,
351 punycode_uint n, out, i, max_out, bias, oldi, w, k, digit, t;
358 max_out = *output_length > maxint ? maxint
366 for (b = j = 0; j < input_length; ++j)
367 if (
delim (input[j]))
372 for (j = 0; j < b; ++j)
375 case_flags[out] =
flagged (input[j]);
376 if (!
basic (input[j]))
378 output[out++] = input[j];
384 for (in = b > 0 ? b + 1 : 0; in < input_length; ++out)
395 for (oldi = i, w = 1, k =
base;; k +=
base)
397 if (in >= input_length)
399 digit = decode_digit (input[in++]);
402 if (digit > (maxint - i) / w)
405 t = k <= bias ?
tmin :
409 if (w > maxint / (
base - t))
414 bias = adapt (i - oldi, out + 1, oldi == 0);
419 if (i / (out + 1) > maxint - n)
433 memmove (case_flags + i + 1, case_flags + i, out - i);
435 case_flags[i] =
flagged (input[in - 1]);
438 memmove (output + i + 1, output + i, (out - i) *
sizeof *output);
442 *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[])