Lines Matching full:basic

36    Bootstring that allows a string of basic code points to uniquely
48 3.1 Basic code point segregation..........................4
92 Bootstring, which allows strings composed from a small set of "basic"
102 points) can be represented by a basic string (sequence of basic
106 * Uniqueness: There is at most one basic string that represents a
109 * Reversibility: Any extended string mapped to a basic string can
110 be recovered from that basic string.
119 * Efficient encoding: The ratio of basic string length to extended
128 * Readability: Basic code points appearing in the extended string
129 are represented as themselves in the basic string (although the
134 strings are case-folded prior to encoding, the basic string can use
181 "extended string") as a sequence of basic code points (the "basic
188 Bootstring. "Basic code point segregation" is a very simple and
189 efficient encoding for basic code points occurring in the extended
191 coding" encodes the non-basic code points as deltas, and processes
195 basic code points to represent nonnegative integers. The parameters
200 3.1 Basic code point segregation
202 All basic code points appearing in the extended string are
203 represented literally at the beginning of the basic string, in their
205 of basic code points is nonzero. The delimiter is a particular basic
206 code point, which never appears in the remainder of the basic string.
212 The remainder of the basic string (after the last delimiter if there
218 extended string is a copy of the literal portion of the basic string
219 (excluding the last delimiter). The decoder inserts non-basic code
254 basic code point (because basic code points were supposed to be
370 including the basic code points).
404 Given a set of basic code points, one needs to be designated as the
406 distinguishable basic code points remaining. The digit-values in the
408 delimiter basic code points. In some cases multiple code points need
410 versions of the same letter need to be equivalent if basic strings
413 The initial value of n cannot be greater than the minimum non-basic
455 use by the UTF-16 encoding of Unicode). The basic code points are
467 entirely of basic code points, but IDNA forbids such strings from
574 and copy them to output, fail on any non-basic code point
592 {if n is a basic code point then fail}
597 The full statement enclosed in braces (checking whether n is a basic
598 code point) can be omitted if initial_n exceeds all basic code points
611 input, overflow, and basic code points encoded using deltas instead
631 let h = b = the number of basic code points in the input
633 {if the input contains a non-basic code point < n then fail}
635 let m = the minimum {non-basic} code point >= n in the input
639 if c < n {or c is basic} then increment delta, fail on overflow
659 contains a non-basic code point less than n) can be omitted if all
660 code points less than initial_n are basic code points (which is true
663 The brace-enclosed conditions "non-basic" and "or c is basic" can be
664 omitted if initial_n exceeds all basic code points (which is true for
1025 there are no basic code points, so no literal portion
1076 basic code points (0033, 0042) are copied to literal portion: "3B-"
1193 Basic code points can use mixed case directly, because the decoder
1195 leaving uppercase code points uppercase. Each non-basic code point
1197 basic code points, the last of which provides the annotation. If it
1198 is uppercase, it is a suggestion to map the non-basic code point to
1200 map the non-basic code point to lowercase (if possible).
1356 /* basic(cp) tests whether cp is a basic code point: */
1357 #define basic(cp) ((punycode_uint)(cp) < 0x80)
1362 /* decode_digit(cp) returns the numeric value of a basic code */
1372 /* encode_digit(d,flag) returns the basic code point whose value */
1385 /* flagged(bcp) tests whether a basic code point is flagged */
1387 /* basic code point. */
1391 /* encode_basic(bcp,flag) forces a basic code point to lowercase */
1394 /* is caseless. The behavior is undefined if bcp is not a basic */
1453 /* Handle the basic code points: */
1464 if (basic(input[j])) {
1476 /* number of basic code points, and out is the number of characters */
1484 /* All non-basic code points < n have been */
1488 /* if (basic(input[j])) continue; */
1501 /* Punycode does not need to check whether input[j] is basic: */
1502 if (input[j] < n /* || basic(input[j]) */ ) {
1559 /* Handle the basic code points: Let b be the number of input code */
1576 if (!basic(input[j])) return punycode_bad_input;
1581 /* basic code points were copied; start at the beginning otherwise. */