git.sur5r.net Git - openldap/blob - libraries/libldap/utf-8.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6
   7 /*
   8  * Basic UTF-8 routines
   9  *
  10  * These routines are not optimized.
  11  */
  12
  13 #include "portable.h"
  14
  15 #include <stdio.h>
  16
  17 #include <ac/stdlib.h>
  18
  19 #include <ac/socket.h>
  20 #include <ac/string.h>
  21 #include <ac/time.h>
  22
  23 #include "ldap-int.h"
  24 #include "ldap_defaults.h"
  25
  26 #define UTF8_ISASCII(u) ( !((u) & ~0x7f) )
  27 #define UCS4_INVALID    0x80000000U
  28
  29 /*
  30  * return the number of bytes required to hold the
  31  * NULL-terminated UTF-8 string INCLUDING the
  32  * termination.
  33  */
  34 ber_len_t ldap_utf8_bytes( const char * p )
  35 {
  36         ber_len_t bytes = 0;
  37
  38         if( p == NULL ) return bytes;
  39
  40         while( p[bytes++] ) {
  41                 /* EMPTY */ ;
  42         }
  43
  44         return bytes;
  45 }
  46
  47 ber_len_t ldap_utf8_chars( const char * p )
  48 {
  49         /* could be optimized and could check for invalid sequences */
  50         ber_len_t chars;
  51
  52         for( chars=0; *p ; chars++ ) {
  53                 int charlen = ldap_utf8_charlen( p );
  54
  55                 if( !charlen ) return chars;
  56
  57                 p = &p[charlen];
  58         };
  59
  60         return chars;
  61 }
  62
  63 int ldap_utf8_charlen( const char * p )
  64 {
  65         unsigned c = * (const unsigned char *) p;
  66
  67         if ((c & 0xfe ) == 0xfc) {
  68                 return 6;
  69         }
  70
  71         if ((c & 0xfc ) == 0xf8) {
  72                 return 5;
  73         }
  74
  75         if ((c & 0xf8 ) == 0xf0) {
  76                 return 4;
  77         }
  78
  79         if ((c & 0xf0 ) == 0xe0) {
  80                 return 3;
  81         }
  82
  83         if ((c & 0xe0 ) == 0xc0) {
  84                 return 2;
  85         }
  86
  87         if ((c & 0x80 ) == 0x80) {
  88                 /* INVALID */
  89                 return 0;
  90         }
  91
  92         return 1;
  93 }
  94
  95 ber_int_t ldap_utf8_to_ucs4( const char * p )
  96 {
  97         int len, i;
  98     ber_int_t c = * (const unsigned char *) p;
  99
 100     if ((c & 0xFE ) == 0xFC) {
 101         len = 6;
 102                 c &= 0x01;
 103
 104     } else if ((c & 0xFC ) == 0xF8) {
 105         len = 5;
 106                 c &= 0x03;
 107
 108     } else if ((c & 0xF8 ) == 0xF0) {
 109         len = 4;
 110                 c &= 0x07;
 111
 112     } else if ((c & 0xF0 ) == 0xE0) {
 113         len = 3;
 114                 c &= 0x0F;
 115
 116     } else if ((c & 0xE0 ) == 0xC0) {
 117         len = 2;
 118                 c &= 0x1F;
 119
 120     } else if ((c & 0x80 ) == 0x80) {
 121         return UCS4_INVALID;
 122
 123     } else {
 124         return c;
 125         }
 126
 127         for(i=1; i < len; i++) {
 128                 ber_int_t ch = ((const unsigned char *) p)[i];
 129
 130                 if ((ch & 0xc0) != 0x80) {
 131                         return UCS4_INVALID;
 132                 }
 133
 134                 c <<= 6;
 135                 c |= ch & 0x3f;
 136         }
 137
 138         return c;
 139 }
 140
 141 int ldap_ucs4_to_utf8( ber_int_t c, char *buf )
 142 {
 143         int len=0;
 144         unsigned char* p = buf;
 145         if(buf == NULL) return 0;
 146
 147         if ( c < 0 ) {
 148                 /* not a valid Unicode character */
 149
 150         } else if( c < 0x80 ) {
 151                 p[len++] = c;
 152
 153         } else if( c < 0x800 ) {
 154                 p[len++] = 0xc0 | ( c >> 6 );
 155                 p[len++] = 0x80 | ( c & 0x3F );
 156
 157         } else if( c < 0x10000 ) {
 158                 p[len++] = 0xe0 | ( c >> 12 );
 159                 p[len++] = 0x80 | ( (c >> 6) & 0x3F );
 160                 p[len++] = 0x80 | ( c & 0x3F );
 161
 162         } else if( c < 0x200000 ) {
 163                 p[len++] = 0xf0 | ( c >> 18 );
 164                 p[len++] = 0x80 | ( (c >> 12) & 0x3F );
 165                 p[len++] = 0x80 | ( (c >> 6) & 0x3F );
 166                 p[len++] = 0x80 | ( c & 0x3F );
 167
 168         } else if( c < 0x400000 ) {
 169                 p[len++] = 0xf8 | ( c >> 24 );
 170                 p[len++] = 0x80 | ( (c >> 18) & 0x3F );
 171                 p[len++] = 0x80 | ( (c >> 12) & 0x3F );
 172                 p[len++] = 0x80 | ( (c >> 6) & 0x3F );
 173                 p[len++] = 0x80 | ( c & 0x3F );
 174
 175         } else /* if( c < 0x80000000 ) */ {
 176                 p[len++] = 0xfc | ( c >> 30 );
 177                 p[len++] = 0x80 | ( (c >> 24) & 0x3F );
 178                 p[len++] = 0x80 | ( (c >> 18) & 0x3F );
 179                 p[len++] = 0x80 | ( (c >> 12) & 0x3F );
 180                 p[len++] = 0x80 | ( (c >> 6) & 0x3F );
 181                 p[len++] = 0x80 | ( c & 0x3F );
 182         }
 183
 184         buf[len] = '\0';
 185         return len;
 186 }
 187
 188 char* ldap_utf8_next( const char * p )
 189 {
 190         int len = ldap_utf8_charlen( p );
 191
 192         return len ? (char *) &p[len] : NULL;
 193 }
 194
 195 char* ldap_utf8_prev( const char * p )
 196 {
 197         int i;
 198         const unsigned char *u = p;
 199
 200         for( i = -1; i >= -6 ; i-- ) {
 201                 if ( u[i] & 0xC0 != 0x80 ) return (char *) &p[i];
 202         }
 203
 204         return NULL;
 205 }
 206
 207 int ldap_utf8_isascii( const char * p )
 208 {
 209         unsigned c = * (const unsigned char *) p;
 210         return UTF8_ISASCII(c);
 211 }
 212
 213 int ldap_utf8_isdigit( const char * p )
 214 {
 215         unsigned c = * (const unsigned char *) p;
 216
 217         if(!UTF8_ISASCII(c)) return 0;
 218
 219         return c >= '0' && c <= '9';
 220 }
 221
 222 int ldap_utf8_isxdigit( const char * p )
 223 {
 224         unsigned c = * (const unsigned char *) p;
 225
 226         if(!UTF8_ISASCII(c)) return 0;
 227
 228         return ( c >= '0' && c <= '9' )
 229                 || ( c >= 'A' && c <= 'F' )
 230                 || ( c >= 'a' && c <= 'f' );
 231 }
 232
 233 int ldap_utf8_isalpha( const char * p )
 234 {
 235         unsigned c = * (const unsigned char *) p;
 236
 237         if(!UTF8_ISASCII(c)) return 0;
 238
 239         return ( c >= 'A' && c <= 'Z' )
 240                 || ( c >= 'a' && c <= 'z' );
 241 }
 242
 243 int ldap_utf8_isalnum( const char * p )
 244 {
 245         unsigned c = * (const unsigned char *) p;
 246
 247         if(!UTF8_ISASCII(c)) return 0;
 248
 249         return ( c >= '0' && c <= '9' )
 250                 || ( c >= 'A' && c <= 'Z' )
 251                 || ( c >= 'a' && c <= 'z' );
 252 }
 253
 254 int ldap_utf8_islower( const char * p )
 255 {
 256         unsigned c = * (const unsigned char *) p;
 257
 258         if(!UTF8_ISASCII(c)) return 0;
 259
 260         return ( c >= 'a' && c <= 'z' );
 261 }
 262
 263 int ldap_utf8_isupper( const char * p )
 264 {
 265         unsigned c = * (const unsigned char *) p;
 266
 267         if(!UTF8_ISASCII(c)) return 0;
 268
 269         return ( c >= 'A' && c <= 'Z' );
 270 }
 271
 272 int ldap_utf8_isspace( const char * p )
 273 {
 274         unsigned c = * (const unsigned char *) p;
 275
 276         if(!UTF8_ISASCII(c)) return 0;
 277
 278         switch(c) {
 279         case ' ':
 280         case '\t':
 281         case '\n':
 282         case '\r':
 283         case '\v':
 284         case '\f':
 285                 return 1;
 286         }
 287
 288         return 0;
 289 }
 290
 291 char* ldap_utf8_fgetc( FILE *s, char *buf )
 292 {
 293         int i;
 294         unsigned char *p;
 295         unsigned int c;
 296         int len;
 297
 298         if( s == NULL ) return NULL;
 299
 300         p = buf;
 301
 302         c = fgetc( s );
 303         if( c == EOF ) {
 304                 p[0] = -1;
 305                 return NULL;
 306         }
 307
 308         p[0] = c;
 309
 310         len = ldap_utf8_charlen( buf );
 311
 312         if( len < 1 ) return NULL;
 313
 314         for( i = 1; i < len; i++ ) {
 315                 unsigned int c = fgetc( s );
 316                 if( c == EOF ) {
 317                         p[i] = -1;
 318                         return NULL;
 319                 }
 320                 if( c & 0xC0 != 0x80 ) {
 321                         ungetc( c, s );
 322                         p[i] = -1;
 323                         return NULL;
 324                 }
 325                 p[i] = c;
 326         }
 327
 328         return buf;
 329 }
 330
 331 ber_len_t (ldap_utf8_strcspn)( const char *str, const char *set )
 332 {
 333         int len;
 334         const char *cstr;
 335
 336         for( cstr = str; *cstr != '\0'; cstr += len ) {
 337                 const char *cset;
 338
 339                 for( cset = set; ; cset += len ) {
 340                         if( ldap_utf8_to_ucs4( cstr ) == ldap_utf8_to_ucs4( cset ) ) {
 341                                 return cstr - str;
 342                         }
 343
 344                         len = ldap_utf8_charlen(cset);
 345                         if( !len ) break;
 346                 }
 347
 348                 len = ldap_utf8_charlen(cstr);
 349                 if( !len ) break;
 350         }
 351
 352         return cstr - str;
 353 }
 354
 355 ber_len_t (ldap_utf8_strspn)( const char *str, const char *set )
 356 {
 357         int len;
 358         const char *cstr;
 359
 360         for( cstr = str; *cstr != '\0'; cstr += len ) {
 361                 const char *cset;
 362
 363                 for( cset = set; ; cset += len ) {
 364                         if( *cset == '\0' ) {
 365                                 return cstr - str;
 366                         }
 367
 368                         if( ldap_utf8_to_ucs4( cstr ) == ldap_utf8_to_ucs4( cset ) ) {
 369                                 break;
 370                         }
 371
 372                         len = ldap_utf8_charlen(cset);
 373                         if( !len ) break;
 374                 }
 375
 376                 len = ldap_utf8_charlen(cstr);
 377                 if( !len ) break;
 378         }
 379
 380         return cstr - str;
 381 }
 382
 383 char *(ldap_utf8_strpbrk)( const char *str, const char *set )
 384 {
 385         int len;
 386         const char *cstr;
 387
 388         for( cstr = str; *cstr != '\0'; cstr += len ) {
 389                 const char *cset;
 390
 391                 for( cset = set; ; cset += len ) {
 392                         if( ldap_utf8_to_ucs4( cstr ) == ldap_utf8_to_ucs4( cset ) ) {
 393                                 return cstr;
 394                         }
 395
 396                         len = ldap_utf8_charlen(cset);
 397                         if( !len ) break;
 398                 }
 399
 400                 len = ldap_utf8_charlen(cstr);
 401                 if( !len ) break;
 402         }
 403
 404         return NULL;
 405 }
 406
 407 char *(ldap_utf8_strtok)(char *str, const char *sep, char **last)
 408 {
 409         char *begin;
 410         char *end;
 411
 412         if( last == NULL ) return NULL;
 413
 414         begin = str ? str : *last;
 415
 416         begin += ldap_utf8_strspn( begin, sep );
 417
 418         if( *begin == '\0' ) {
 419                 *last = NULL;
 420                 return NULL;
 421         }
 422
 423         end = &begin[ ldap_utf8_strcpn( begin, sep ) ];
 424
 425         if( *end != '\0' ) {
 426                 int len = ldap_utf8_charlen( end );
 427                 *end = '\0';
 428
 429                 if( len ) {
 430                         end += len;
 431                 } else {
 432                         end = NULL;
 433                 }
 434         }
 435
 436         *last = end;
 437         return begin;
 438 }