Lines Matching refs:character
138 /* Repeated character flags. */
276 /* Tables of names of POSIX character classes and their lengths. The names are
301 character is removed. The triples in the table consist of the base map offset,
444 Each substring ends with \0 to insert a null character. This includes the final
452 "unrecognized character follows \\\0"
456 "missing terminating ] for character class\0"
457 "invalid escape sequence in character class\0"
458 "range out of order in character class\0"
463 "unrecognized character after (? or (?-\0"
477 "unrecognized character after (?<\0"
489 "character value in \\x{} or \\o{} is too large\0"
498 "unrecognized character after (?P\0"
525 "] is an invalid data character in JavaScript compatibility mode\0"
530 "\\c must be followed by an ASCII character\0"
540 "character value in \\u.... sequence is too large\0"
543 "non-hex character in \\x{} (closing brace missing?)\0"
545 "non-octal character in \\o{} (closing brace missing?)\0"
548 "invalid range in character class\0"
560 character value tests (at least in some simple cases I timed), and in some
693 between adjacent character-type opcodes. The left-hand (repeated) opcode is
737 2 Check character categories in the same group (general or particular)
797 that apply to the character set in question. Duplication means that a little
978 positive value for a simple escape such as \n, or 0 for a data character which
982 character of the escape sequence.
986 chptr points to a returned data character
990 isclass TRUE if inside a character class
992 Returns: zero => a data character
1009 GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */
1095 /* In a character class, \g is just a literal "g". Outside a character
1194 Outside a character class, the digits are read as a decimal number. If the
1202 Inside a character class, \ followed by a digit is always either a literal
1263 specifying character codes in octal. The only supported form is \o{ddd}. */
1325 /* Handle \x in Perl's style. \x{ddd} is a character number which can be
1327 digits. If not, { used to be treated as a data character. However, Perl
1411 An error is given if the byte following \c is not an ASCII character. This
1453 /* Perl supports \N{name} for character names, as well as plain \N for "not
1466 /* Set the pointer to the final character before returning. */
1482 pointing at the P or p. On exit, it is pointing at the final character of the
1530 /* Otherwise there is just one following character */
1641 for a fixed first character, or an anchoring op code etc. It skips over things
1848 need to skip over a multibyte character in UTF8 mode. */
2087 repeated character types, we have to test for \p and \P, which have an extra
2127 /* In UTF-8 mode, opcodes that are followed by a character may be followed by
2128 a multi-byte character. The length in the table is a minimum, so we have to
2204 repeated character types, we have to test for \p and \P, which have an extra
2244 /* In UTF-8 mode, opcodes that are followed by a character may be followed
2245 by a multi-byte character. The length in the table is a minimum, so we have
2536 /* Opcodes that must match a character */
2623 followed by a multibyte character. */
2688 /* None of the remaining opcodes are required to match a character. */
2740 /* Returns the base opcode for repeated single character type opcodes. If the
2741 opcode is not a repeated character type, it returns with the original value.
2762 * Check a character and a property *
2766 is adjacent to a fixed character.
2769 c the character
2845 * Fill the character property list *
2858 can match an empty character string
2995 happen, since all clists are shorter than 5 character now. */
3055 * Scan further character sets for match *
3058 /* Checks whether the base and the current opcode have a common character, in
3091 other character type lists, which stores here that the character iterator
3194 /* If either opcode is a small character list, set pointers for comparing
3335 2 Check character categories in the same group (general or particular)
3364 PCRE character set. The third and fourth entries are a general and a
3432 /* Control reaches here only if one of the items is a small character list.
3578 /* At least one character must be matched from this opcode. */
3594 /* Replaces single character iterations with their possessive alternatives
3752 /* In UTF-8 mode, opcodes that are followed by a character may be followed by
3753 a multi-byte character. The length in the table is a minimum, so we have to
3831 encountered in a character class. It checks whether this is followed by a
3833 reach an unescaped ']' without the special preceding character, return FALSE.
4058 start address. A character with multiple other cases is returned on its own
4062 cptr points to starting character value; updated
4080 /* Find the first character that has an other case. If it has multiple other
4096 /* Found a character that has a single other case. Search for the end of the
4097 range, which is either the end of the input range, or a character that has zero
4118 * Add a character or range to a class *
4121 /* This function packages up the logic of adding a character or range of
4122 characters to a class. The character values in the arguments will be within the
4131 start start of range character
4132 end end of range character
4164 /* Handle a single character that has more than one other case. */
4245 /* Without UTF support, character values are constrained by the bit length,
4290 except character to omit; this is used when adding lists of
4371 firstcharptr place to put the first required character
4372 firstcharflagsptr place to put the first character flags, or a negative number
4373 reqcharptr place to put the last required character
4374 reqcharflagsptr place to put the last required character flags, or a negative number
4476 /* Switch on next character until the end of the branch */
4503 /* Get next character in the pattern */
4691 /* Handle single-character metacharacters. In multiline mode, ^ disables
4692 the setting of any following char as a first character. */
4727 where there is only one such character. For negated classes, we build the
4737 default (Perl) mode, it is treated as a data character. */
4768 /* Handle a real character class. */
4783 /* If the first character is '^', set the negation flag and skip it. Also,
4806 an initial ']' is taken as a data character -- the code below handles
4808 [^] must match any character, so generate OP_ALLANY. */
4837 256 character; class_one_char will be 1 if the class contains just one
4838 character; xclass_has_prop will be TRUE if unicode property checks
4855 means that an initial ] is taken as a data character. At the start of the
4856 loop, c contains the first byte of the character. */
5031 /* Every class contains at least one < 256 character. */
5038 /* Backslash may introduce a single character, or it may introduce one
5041 assume that other escapes have more than one character in them, so
5112 previously set by something earlier in the character class.
5177 c = *ptr; /* Get the final character and fall through */
5182 /* Fall through if the escape just defined a single character (c >= 0).
5189 /* A character may be followed by '-' to form a range. However, Perl does
5190 not permit ']' to be the end of the range. A '-' character at the end is
5227 back the pointer and jump to handle the character that preceded it. */
5235 /* Otherwise, we have a potential range; pick up the next character */
5246 /* The second part of a range can be a single-character escape
5260 /* 0 means a character was put into d; \b is backspace; any other
5286 one-character ranges. */
5295 /* We have found a character range, so single character optimizations
5297 is more than one character. */
5311 /* Handle a single character - we can get here for a normal non-escape
5312 char, or after \ that introduces a single character or for an apparent
5320 /* If class_one_char is 1, we have the first single character in the
5322 escapes. If this is the final character in the class, we can optimize by
5323 turning the item into a 1-character OP_CHAR[I] if it's positive, or
5345 whether this character has more than one other case. If so, generate
5370 /* We are finished with this character class */
5375 /* For a single, positive character, get the value into mcbuffer, and
5376 then we can handle this with the normal one-character code. */
5390 /* There is more than one character in the class, or an XCLASS item
5391 has been generated. Add this character to the class. */
5417 only if the very last character in the class needs XCLASS will it contain
5577 /* If the next character is '+', we have a possessive quantifier. This
5579 If the next character is '?' this is a minimizing repeat, by default,
5625 /* If previous was a character or negated character match, abolish the item
5643 /* Deal with UTF characters that take up more than one character. It's
5645 hold the length of the character in bytes, plus UTF_LENGTH to flag that
5646 it's a length rather than a small character. */
5653 c = (int)(code - lastchar); /* Length of UTF-8 character */
5661 with UTF disabled, or for a single character UTF character. */
5671 goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */
5674 /* If previous was a character type match (\d or similar), abolish it and
5675 create a suitable repeat item. The code is shared with single-character
5749 we have to insert the character for the previous code. For a repeated
5776 preceded by the character, for the previously inserted code. If the
5809 /* The character or character type itself comes last in all cases. */
5833 /* If previous was a character class or a back reference, we put the repeat
6262 /* If the character following a repeat is '+', possessive_quantifier is
7352 character (relevant if it is repeated, because it will then be
7451 } /* End of switch for character following (? */
7600 break; /* No need to waste time with special character handling */
7607 /* For a DEFINE group, required and first character settings are not
7686 that consume a character may be repeated. We can test for values between
7695 if (escape == 0) /* The escape coded a single character */
7709 /* For metasequences that actually match a character, we disable the
7710 setting of a first character if it hasn't already been set. */
7850 Unicode property tests. Note that \b and \B do a one-character
7877 /* We have a data character whose value is in c. In UTF-8 mode it may have
7879 handle it as a data character. */
7895 /* Handle a literal character. It is guaranteed not to be whitespace or #
7897 multi-unit literal character. */
7909 /* At this point we have the character's bytes in mcbuffer, and the length
7916 this character has more than one other case. If so, generate a special
7946 byte, set it from this character, but revert to none on a zero repeat.
7956 /* If the character is more than one byte long, we can set firstchar
7990 break; /* End of literal character handling */
8010 /* On entry, ptr is pointing past the bracket character, but on return it
8026 firstcharptr place to put the first required character
8027 firstcharflagsptr place to put the first character flags, or a negative number
8028 reqcharptr place to put the last required character
8029 reqcharflagsptr place to put the last required character flags, or a negative number
8744 tables pointer to character tables or NULL
8847 /* Set up pointers to the individual character tables */
9149 flags, and character table pointer. NULL is used for the default character
9285 /* Unless disabled, check whether any single character iterators can be