pymongo: encoding_helpers.c Source File

00001 /*
00002  * Copyright 2009-2010 10gen, Inc.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 #include "encoding_helpers.h"
00018 
00019 /*
00020  * Portions Copyright 2001 Unicode, Inc.
00021  *
00022  * Disclaimer
00023  *
00024  * This source code is provided as is by Unicode, Inc. No claims are
00025  * made as to fitness for any particular purpose. No warranties of any
00026  * kind are expressed or implied. The recipient agrees to determine
00027  * applicability of information provided. If this file has been
00028  * purchased on magnetic or optical media from Unicode, Inc., the
00029  * sole remedy for any claim will be exchange of defective media
00030  * within 90 days of receipt.
00031  *
00032  * Limitations on Rights to Redistribute This Code
00033  *
00034  * Unicode, Inc. hereby grants the right to freely use the information
00035  * supplied in this file in the creation of products supporting the
00036  * Unicode Standard, and to make copies of this file in any form
00037  * for internal or external distribution as long as this notice
00038  * remains attached.
00039  */
00040 
00041 /*
00042  * Index into the table below with the first byte of a UTF-8 sequence to
00043  * get the number of trailing bytes that are supposed to follow it.
00044  */
00045 static const char trailingBytesForUTF8[256] = {
00046     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
00047     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
00048     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
00049     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
00050     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
00051     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
00052     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
00053     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
00054 };
00055 
00056 /* --------------------------------------------------------------------- */
00057 
00058 /*
00059  * Utility routine to tell whether a sequence of bytes is legal UTF-8.
00060  * This must be called with the length pre-determined by the first byte.
00061  * The length can be set by:
00062  *  length = trailingBytesForUTF8[*source]+1;
00063  * and the sequence is illegal right away if there aren't that many bytes
00064  * available.
00065  * If presented with a length > 4, this returns 0.  The Unicode
00066  * definition of UTF-8 goes up to 4-byte sequences.
00067  */
00068 static unsigned char isLegalUTF8(const unsigned char* source, int length) {
00069     unsigned char a;
00070     const unsigned char* srcptr = source + length;
00071     switch (length) {
00072     default: return 0;
00073         /* Everything else falls through when "true"... */
00074     case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
00075     case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
00076     case 2: if ((a = (*--srcptr)) > 0xBF) return 0;
00077         switch (*source) {
00078             /* no fall-through in this inner switch */
00079             case 0xE0: if (a < 0xA0) return 0; break;
00080             case 0xF0: if (a < 0x90) return 0; break;
00081             case 0xF4: if (a > 0x8F) return 0; break;
00082             default:  if (a < 0x80) return 0;
00083         }
00084         case 1: if (*source >= 0x80 && *source < 0xC2) return 0;
00085         if (*source > 0xF4) return 0;
00086     }
00087     return 1;
00088 }
00089 
00090 result_t check_string(const unsigned char* string, const int length,
00091                       const char check_utf8, const char check_null) {
00092     int position = 0;
00093     /* By default we go character by character. Will be different for checking
00094      * UTF-8 */
00095     int sequence_length = 1;
00096 
00097     if (!check_utf8 && !check_null) {
00098         return VALID;
00099     }
00100 
00101     while (position < length) {
00102         if (check_null && *(string + position) == 0) {
00103             return HAS_NULL;
00104         }
00105         if (check_utf8) {
00106             sequence_length = trailingBytesForUTF8[*(string + position)] + 1;
00107             if ((position + sequence_length) > length) {
00108                 return NOT_UTF_8;
00109             }
00110             if (!isLegalUTF8(string + position, sequence_length)) {
00111                 return NOT_UTF_8;
00112             }
00113         }
00114         position += sequence_length;
00115     }
00116 
00117     return VALID;
00118 }