Annotation of parser3/src/lib/pcre/pa_pcre_valid_utf8.c, revision 1.1
1.1 ! moko 1: /*************************************************
! 2: * Perl-Compatible Regular Expressions *
! 3: *************************************************/
! 4:
! 5: /* PCRE is a library of functions to support regular expressions whose syntax
! 6: and semantics are as close as possible to those of the Perl 5 language.
! 7:
! 8: Written by Philip Hazel
! 9: Copyright (c) 1997-2012 University of Cambridge
! 10:
! 11: -----------------------------------------------------------------------------
! 12: Redistribution and use in source and binary forms, with or without
! 13: modification, are permitted provided that the following conditions are met:
! 14:
! 15: * Redistributions of source code must retain the above copyright notice,
! 16: this list of conditions and the following disclaimer.
! 17:
! 18: * Redistributions in binary form must reproduce the above copyright
! 19: notice, this list of conditions and the following disclaimer in the
! 20: documentation and/or other materials provided with the distribution.
! 21:
! 22: * Neither the name of the University of Cambridge nor the names of its
! 23: contributors may be used to endorse or promote products derived from
! 24: this software without specific prior written permission.
! 25:
! 26: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
! 27: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 28: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 29: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
! 30: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 31: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 32: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 33: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 34: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 35: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 36: POSSIBILITY OF SUCH DAMAGE.
! 37: -----------------------------------------------------------------------------
! 38: */
! 39:
! 40:
! 41: /* This module contains an internal function for validating UTF-8 character
! 42: strings. */
! 43:
! 44: #include "pcre.h"
! 45: #include "pa_pcre_internal.h"
! 46:
! 47:
! 48: /*************************************************
! 49: * Validate a UTF-8 string *
! 50: *************************************************/
! 51:
! 52: /* This function is called (optionally) at the start of compile or match, to
! 53: check that a supposed UTF-8 string is actually valid. The early check means
! 54: that subsequent code can assume it is dealing with a valid string. The check
! 55: can be turned off for maximum performance, but the consequences of supplying an
! 56: invalid string are then undefined.
! 57:
! 58: Originally, this function checked according to RFC 2279, allowing for values in
! 59: the range 0 to 0x7fffffff, up to 6 bytes long, but ensuring that they were in
! 60: the canonical format. Once somebody had pointed out RFC 3629 to me (it
! 61: obsoletes 2279), additional restrictions were applied. The values are now
! 62: limited to be between 0 and 0x0010ffff, no more than 4 bytes long, and the
! 63: subrange 0xd000 to 0xdfff is excluded. However, the format of 5-byte and 6-byte
! 64: characters is still checked.
! 65:
! 66: From release 8.13 more information about the details of the error are passed
! 67: back in the returned value:
! 68:
! 69: PCRE_UTF8_ERR0 No error
! 70: PCRE_UTF8_ERR1 Missing 1 byte at the end of the string
! 71: PCRE_UTF8_ERR2 Missing 2 bytes at the end of the string
! 72: PCRE_UTF8_ERR3 Missing 3 bytes at the end of the string
! 73: PCRE_UTF8_ERR4 Missing 4 bytes at the end of the string
! 74: PCRE_UTF8_ERR5 Missing 5 bytes at the end of the string
! 75: PCRE_UTF8_ERR6 2nd-byte's two top bits are not 0x80
! 76: PCRE_UTF8_ERR7 3rd-byte's two top bits are not 0x80
! 77: PCRE_UTF8_ERR8 4th-byte's two top bits are not 0x80
! 78: PCRE_UTF8_ERR9 5th-byte's two top bits are not 0x80
! 79: PCRE_UTF8_ERR10 6th-byte's two top bits are not 0x80
! 80: PCRE_UTF8_ERR11 5-byte character is not permitted by RFC 3629
! 81: PCRE_UTF8_ERR12 6-byte character is not permitted by RFC 3629
! 82: PCRE_UTF8_ERR13 4-byte character with value > 0x10ffff is not permitted
! 83: PCRE_UTF8_ERR14 3-byte character with value 0xd000-0xdfff is not permitted
! 84: PCRE_UTF8_ERR15 Overlong 2-byte sequence
! 85: PCRE_UTF8_ERR16 Overlong 3-byte sequence
! 86: PCRE_UTF8_ERR17 Overlong 4-byte sequence
! 87: PCRE_UTF8_ERR18 Overlong 5-byte sequence (won't ever occur)
! 88: PCRE_UTF8_ERR19 Overlong 6-byte sequence (won't ever occur)
! 89: PCRE_UTF8_ERR20 Isolated 0x80 byte (not within UTF-8 character)
! 90: PCRE_UTF8_ERR21 Byte with the illegal value 0xfe or 0xff
! 91:
! 92: Arguments:
! 93: string points to the string
! 94: length length of string, or -1 if the string is zero-terminated
! 95: errp pointer to an error position offset variable
! 96:
! 97: Returns: = 0 if the string is a valid UTF-8 string
! 98: > 0 otherwise, setting the offset of the bad character
! 99: */
! 100:
! 101: typedef unsigned char *PCRE_PUCHAR;
! 102: #define SUPPORT_UTF
! 103:
! 104: static const unsigned char utf8_table4[] = {
! 105: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
! 106: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
! 107: 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
! 108: 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
! 109:
! 110:
! 111: int
! 112: pa_pcre_valid_utf(PCRE_PUCHAR string, int length, int *erroroffset)
! 113: {
! 114: #ifdef SUPPORT_UTF
! 115: register PCRE_PUCHAR p;
! 116:
! 117: if (length < 0)
! 118: {
! 119: for (p = string; *p != 0; p++);
! 120: length = (int)(p - string);
! 121: }
! 122:
! 123: for (p = string; length-- > 0; p++)
! 124: {
! 125: register int ab, c, d;
! 126:
! 127: c = *p;
! 128: if (c < 128) continue; /* ASCII character */
! 129:
! 130: if (c < 0xc0) /* Isolated 10xx xxxx byte */
! 131: {
! 132: *erroroffset = (int)(p - string);
! 133: return PCRE_UTF8_ERR20;
! 134: }
! 135:
! 136: if (c >= 0xfe) /* Invalid 0xfe or 0xff bytes */
! 137: {
! 138: *erroroffset = (int)(p - string);
! 139: return PCRE_UTF8_ERR21;
! 140: }
! 141:
! 142: ab = utf8_table4[c & 0x3f]; /* Number of additional bytes */
! 143: if (length < ab)
! 144: {
! 145: *erroroffset = (int)(p - string); /* Missing bytes */
! 146: return ab - length; /* Codes ERR1 to ERR5 */
! 147: }
! 148: length -= ab; /* Length remaining */
! 149:
! 150: /* Check top bits in the second byte */
! 151:
! 152: if (((d = *(++p)) & 0xc0) != 0x80)
! 153: {
! 154: *erroroffset = (int)(p - string) - 1;
! 155: return PCRE_UTF8_ERR6;
! 156: }
! 157:
! 158: /* For each length, check that the remaining bytes start with the 0x80 bit
! 159: set and not the 0x40 bit. Then check for an overlong sequence, and for the
! 160: excluded range 0xd800 to 0xdfff. */
! 161:
! 162: switch (ab)
! 163: {
! 164: /* 2-byte character. No further bytes to check for 0x80. Check first byte
! 165: for for xx00 000x (overlong sequence). */
! 166:
! 167: case 1: if ((c & 0x3e) == 0)
! 168: {
! 169: *erroroffset = (int)(p - string) - 1;
! 170: return PCRE_UTF8_ERR15;
! 171: }
! 172: break;
! 173:
! 174: /* 3-byte character. Check third byte for 0x80. Then check first 2 bytes
! 175: for 1110 0000, xx0x xxxx (overlong sequence) or
! 176: 1110 1101, 1010 xxxx (0xd800 - 0xdfff) */
! 177:
! 178: case 2:
! 179: if ((*(++p) & 0xc0) != 0x80) /* Third byte */
! 180: {
! 181: *erroroffset = (int)(p - string) - 2;
! 182: return PCRE_UTF8_ERR7;
! 183: }
! 184: if (c == 0xe0 && (d & 0x20) == 0)
! 185: {
! 186: *erroroffset = (int)(p - string) - 2;
! 187: return PCRE_UTF8_ERR16;
! 188: }
! 189: if (c == 0xed && d >= 0xa0)
! 190: {
! 191: *erroroffset = (int)(p - string) - 2;
! 192: return PCRE_UTF8_ERR14;
! 193: }
! 194: break;
! 195:
! 196: /* 4-byte character. Check 3rd and 4th bytes for 0x80. Then check first 2
! 197: bytes for for 1111 0000, xx00 xxxx (overlong sequence), then check for a
! 198: character greater than 0x0010ffff (f4 8f bf bf) */
! 199:
! 200: case 3:
! 201: if ((*(++p) & 0xc0) != 0x80) /* Third byte */
! 202: {
! 203: *erroroffset = (int)(p - string) - 2;
! 204: return PCRE_UTF8_ERR7;
! 205: }
! 206: if ((*(++p) & 0xc0) != 0x80) /* Fourth byte */
! 207: {
! 208: *erroroffset = (int)(p - string) - 3;
! 209: return PCRE_UTF8_ERR8;
! 210: }
! 211: if (c == 0xf0 && (d & 0x30) == 0)
! 212: {
! 213: *erroroffset = (int)(p - string) - 3;
! 214: return PCRE_UTF8_ERR17;
! 215: }
! 216: if (c > 0xf4 || (c == 0xf4 && d > 0x8f))
! 217: {
! 218: *erroroffset = (int)(p - string) - 3;
! 219: return PCRE_UTF8_ERR13;
! 220: }
! 221: break;
! 222:
! 223: /* 5-byte and 6-byte characters are not allowed by RFC 3629, and will be
! 224: rejected by the length test below. However, we do the appropriate tests
! 225: here so that overlong sequences get diagnosed, and also in case there is
! 226: ever an option for handling these larger code points. */
! 227:
! 228: /* 5-byte character. Check 3rd, 4th, and 5th bytes for 0x80. Then check for
! 229: 1111 1000, xx00 0xxx */
! 230:
! 231: case 4:
! 232: if ((*(++p) & 0xc0) != 0x80) /* Third byte */
! 233: {
! 234: *erroroffset = (int)(p - string) - 2;
! 235: return PCRE_UTF8_ERR7;
! 236: }
! 237: if ((*(++p) & 0xc0) != 0x80) /* Fourth byte */
! 238: {
! 239: *erroroffset = (int)(p - string) - 3;
! 240: return PCRE_UTF8_ERR8;
! 241: }
! 242: if ((*(++p) & 0xc0) != 0x80) /* Fifth byte */
! 243: {
! 244: *erroroffset = (int)(p - string) - 4;
! 245: return PCRE_UTF8_ERR9;
! 246: }
! 247: if (c == 0xf8 && (d & 0x38) == 0)
! 248: {
! 249: *erroroffset = (int)(p - string) - 4;
! 250: return PCRE_UTF8_ERR18;
! 251: }
! 252: break;
! 253:
! 254: /* 6-byte character. Check 3rd-6th bytes for 0x80. Then check for
! 255: 1111 1100, xx00 00xx. */
! 256:
! 257: case 5:
! 258: if ((*(++p) & 0xc0) != 0x80) /* Third byte */
! 259: {
! 260: *erroroffset = (int)(p - string) - 2;
! 261: return PCRE_UTF8_ERR7;
! 262: }
! 263: if ((*(++p) & 0xc0) != 0x80) /* Fourth byte */
! 264: {
! 265: *erroroffset = (int)(p - string) - 3;
! 266: return PCRE_UTF8_ERR8;
! 267: }
! 268: if ((*(++p) & 0xc0) != 0x80) /* Fifth byte */
! 269: {
! 270: *erroroffset = (int)(p - string) - 4;
! 271: return PCRE_UTF8_ERR9;
! 272: }
! 273: if ((*(++p) & 0xc0) != 0x80) /* Sixth byte */
! 274: {
! 275: *erroroffset = (int)(p - string) - 5;
! 276: return PCRE_UTF8_ERR10;
! 277: }
! 278: if (c == 0xfc && (d & 0x3c) == 0)
! 279: {
! 280: *erroroffset = (int)(p - string) - 5;
! 281: return PCRE_UTF8_ERR19;
! 282: }
! 283: break;
! 284: }
! 285:
! 286: /* Character is valid under RFC 2279, but 4-byte and 5-byte characters are
! 287: excluded by RFC 3629. The pointer p is currently at the last byte of the
! 288: character. */
! 289:
! 290: if (ab > 3)
! 291: {
! 292: *erroroffset = (int)(p - string) - ab;
! 293: return (ab == 4)? PCRE_UTF8_ERR11 : PCRE_UTF8_ERR12;
! 294: }
! 295: }
! 296:
! 297: #else /* SUPPORT_UTF */
! 298: (void)(string); /* Keep picky compilers happy */
! 299: (void)(length);
! 300: #endif
! 301:
! 302: return PCRE_UTF8_ERR0; /* This indicates success */
! 303: }
! 304:
! 305: /* End of pcre_valid_utf8.c */
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pa_pcre_valid_utf8.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / lib / pcre