xmlstring.c

   1 /*
   2  * string.c : an XML string utilities module
   3  *
   4  * This module provides various utility functions for manipulating
   5  * the xmlChar* type. All functions named xmlStr* have been moved here
   6  * from the parser.c file (their original home).
   7  *
   8  * See Copyright for the status of this software.
   9  *
  10  * UTF8 string routines from:
  11  * William Brack <wbrack@mmm.com.hk>
  12  *
  13  * daniel@veillard.com
  14  */
  15
  16 #define IN_LIBXML
  17 #include "libxml.h"
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <libxml/xmlmemory.h>
  22 #include <libxml/parserInternals.h>
  23 #include <libxml/xmlstring.h>
  24
  25 /************************************************************************
  26  *                                                                      *
  27  *                Commodity functions to handle xmlChars                *
  28  *                                                                      *
  29  ************************************************************************/
  30
  31 /**
  32  * xmlStrndup:
  33  * @cur:  the input xmlChar *
  34  * @len:  the len of @cur
  35  *
  36  * a strndup for array of xmlChar's
  37  *
  38  * Returns a new xmlChar * or NULL
  39  */
  40 xmlChar *
  41 xmlStrndup(const xmlChar *cur, int len) {
  42     xmlChar *ret;
  43
  44     if ((cur == NULL) || (len < 0)) return(NULL);
  45     ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
  46     if (ret == NULL) {
  47         xmlErrMemory(NULL, NULL);
  48         return(NULL);
  49     }
  50     memcpy(ret, cur, len * sizeof(xmlChar));
  51     ret[len] = 0;
  52     return(ret);
  53 }
  54
  55 /**
  56  * xmlStrdup:
  57  * @cur:  the input xmlChar *
  58  *
  59  * a strdup for array of xmlChar's. Since they are supposed to be
  60  * encoded in UTF-8 or an encoding with 8bit based chars, we assume
  61  * a termination mark of '0'.
  62  *
  63  * Returns a new xmlChar * or NULL
  64  */
  65 xmlChar *
  66 xmlStrdup(const xmlChar *cur) {
  67     const xmlChar *p = cur;
  68
  69     if (cur == NULL) return(NULL);
  70     while (*p != 0) p++; /* non input consuming */
  71     return(xmlStrndup(cur, p - cur));
  72 }
  73
  74 /**
  75  * xmlCharStrndup:
  76  * @cur:  the input char *
  77  * @len:  the len of @cur
  78  *
  79  * a strndup for char's to xmlChar's
  80  *
  81  * Returns a new xmlChar * or NULL
  82  */
  83
  84 xmlChar *
  85 xmlCharStrndup(const char *cur, int len) {
  86     int i;
  87     xmlChar *ret;
  88
  89     if ((cur == NULL) || (len < 0)) return(NULL);
  90     ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
  91     if (ret == NULL) {
  92         xmlErrMemory(NULL, NULL);
  93         return(NULL);
  94     }
  95     for (i = 0;i < len;i++) {
  96         ret[i] = (xmlChar) cur[i];
  97         if (ret[i] == 0) return(ret);
  98     }
  99     ret[len] = 0;
 100     return(ret);
 101 }
 102
 103 /**
 104  * xmlCharStrdup:
 105  * @cur:  the input char *
 106  *
 107  * a strdup for char's to xmlChar's
 108  *
 109  * Returns a new xmlChar * or NULL
 110  */
 111
 112 xmlChar *
 113 xmlCharStrdup(const char *cur) {
 114     const char *p = cur;
 115
 116     if (cur == NULL) return(NULL);
 117     while (*p != '\0') p++; /* non input consuming */
 118     return(xmlCharStrndup(cur, p - cur));
 119 }
 120
 121 /**
 122  * xmlStrcmp:
 123  * @str1:  the first xmlChar *
 124  * @str2:  the second xmlChar *
 125  *
 126  * a strcmp for xmlChar's
 127  *
 128  * Returns the integer result of the comparison
 129  */
 130
 131 int
 132 xmlStrcmp(const xmlChar *str1, const xmlChar *str2) {
 133     register int tmp;
 134
 135     if (str1 == str2) return(0);
 136     if (str1 == NULL) return(-1);
 137     if (str2 == NULL) return(1);
 138     do {
 139         tmp = *str1++ - *str2;
 140         if (tmp != 0) return(tmp);
 141     } while (*str2++ != 0);
 142     return 0;
 143 }
 144
 145 /**
 146  * xmlStrEqual:
 147  * @str1:  the first xmlChar *
 148  * @str2:  the second xmlChar *
 149  *
 150  * Check if both strings are equal of have same content.
 151  * Should be a bit more readable and faster than xmlStrcmp()
 152  *
 153  * Returns 1 if they are equal, 0 if they are different
 154  */
 155
 156 int
 157 xmlStrEqual(const xmlChar *str1, const xmlChar *str2) {
 158     if (str1 == str2) return(1);
 159     if (str1 == NULL) return(0);
 160     if (str2 == NULL) return(0);
 161     do {
 162         if (*str1++ != *str2) return(0);
 163     } while (*str2++);
 164     return(1);
 165 }
 166
 167 /**
 168  * xmlStrQEqual:
 169  * @pref:  the prefix of the QName
 170  * @name:  the localname of the QName
 171  * @str:  the second xmlChar *
 172  *
 173  * Check if a QName is Equal to a given string
 174  *
 175  * Returns 1 if they are equal, 0 if they are different
 176  */
 177
 178 int
 179 xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str) {
 180     if (pref == NULL) return(xmlStrEqual(name, str));
 181     if (name == NULL) return(0);
 182     if (str == NULL) return(0);
 183
 184     do {
 185         if (*pref++ != *str) return(0);
 186     } while ((*str++) && (*pref));
 187     if (*str++ != ':') return(0);
 188     do {
 189         if (*name++ != *str) return(0);
 190     } while (*str++);
 191     return(1);
 192 }
 193
 194 /**
 195  * xmlStrncmp:
 196  * @str1:  the first xmlChar *
 197  * @str2:  the second xmlChar *
 198  * @len:  the max comparison length
 199  *
 200  * a strncmp for xmlChar's
 201  *
 202  * Returns the integer result of the comparison
 203  */
 204
 205 int
 206 xmlStrncmp(const xmlChar *str1, const xmlChar *str2, int len) {
 207     register int tmp;
 208
 209     if (len <= 0) return(0);
 210     if (str1 == str2) return(0);
 211     if (str1 == NULL) return(-1);
 212     if (str2 == NULL) return(1);
 213 #ifdef __GNUC__
 214     tmp = strncmp((const char *)str1, (const char *)str2, len);
 215     return tmp;
 216 #else
 217     do {
 218         tmp = *str1++ - *str2;
 219         if (tmp != 0 || --len == 0) return(tmp);
 220     } while (*str2++ != 0);
 221     return 0;
 222 #endif
 223 }
 224
 225 static const xmlChar casemap[256] = {
 226     0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
 227     0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
 228     0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
 229     0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
 230     0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
 231     0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
 232     0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
 233     0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
 234     0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
 235     0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
 236     0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
 237     0x78,0x79,0x7A,0x7B,0x5C,0x5D,0x5E,0x5F,
 238     0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
 239     0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
 240     0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
 241     0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
 242     0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
 243     0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
 244     0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
 245     0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
 246     0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
 247     0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
 248     0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
 249     0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
 250     0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
 251     0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
 252     0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
 253     0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
 254     0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
 255     0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
 256     0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
 257     0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
 258 };
 259
 260 /**
 261  * xmlStrcasecmp:
 262  * @str1:  the first xmlChar *
 263  * @str2:  the second xmlChar *
 264  *
 265  * a strcasecmp for xmlChar's
 266  *
 267  * Returns the integer result of the comparison
 268  */
 269
 270 int
 271 xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2) {
 272     register int tmp;
 273
 274     if (str1 == str2) return(0);
 275     if (str1 == NULL) return(-1);
 276     if (str2 == NULL) return(1);
 277     do {
 278         tmp = casemap[*str1++] - casemap[*str2];
 279         if (tmp != 0) return(tmp);
 280     } while (*str2++ != 0);
 281     return 0;
 282 }
 283
 284 /**
 285  * xmlStrncasecmp:
 286  * @str1:  the first xmlChar *
 287  * @str2:  the second xmlChar *
 288  * @len:  the max comparison length
 289  *
 290  * a strncasecmp for xmlChar's
 291  *
 292  * Returns the integer result of the comparison
 293  */
 294
 295 int
 296 xmlStrncasecmp(const xmlChar *str1, const xmlChar *str2, int len) {
 297     register int tmp;
 298
 299     if (len <= 0) return(0);
 300     if (str1 == str2) return(0);
 301     if (str1 == NULL) return(-1);
 302     if (str2 == NULL) return(1);
 303     do {
 304         tmp = casemap[*str1++] - casemap[*str2];
 305         if (tmp != 0 || --len == 0) return(tmp);
 306     } while (*str2++ != 0);
 307     return 0;
 308 }
 309
 310 /**
 311  * xmlStrchr:
 312  * @str:  the xmlChar * array
 313  * @val:  the xmlChar to search
 314  *
 315  * a strchr for xmlChar's
 316  *
 317  * Returns the xmlChar * for the first occurrence or NULL.
 318  */
 319
 320 const xmlChar *
 321 xmlStrchr(const xmlChar *str, xmlChar val) {
 322     if (str == NULL) return(NULL);
 323     while (*str != 0) { /* non input consuming */
 324         if (*str == val) return((xmlChar *) str);
 325         str++;
 326     }
 327     return(NULL);
 328 }
 329
 330 /**
 331  * xmlStrstr:
 332  * @str:  the xmlChar * array (haystack)
 333  * @val:  the xmlChar to search (needle)
 334  *
 335  * a strstr for xmlChar's
 336  *
 337  * Returns the xmlChar * for the first occurrence or NULL.
 338  */
 339
 340 const xmlChar *
 341 xmlStrstr(const xmlChar *str, const xmlChar *val) {
 342     int n;
 343
 344     if (str == NULL) return(NULL);
 345     if (val == NULL) return(NULL);
 346     n = xmlStrlen(val);
 347
 348     if (n == 0) return(str);
 349     while (*str != 0) { /* non input consuming */
 350         if (*str == *val) {
 351             if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str);
 352         }
 353         str++;
 354     }
 355     return(NULL);
 356 }
 357
 358 /**
 359  * xmlStrcasestr:
 360  * @str:  the xmlChar * array (haystack)
 361  * @val:  the xmlChar to search (needle)
 362  *
 363  * a case-ignoring strstr for xmlChar's
 364  *
 365  * Returns the xmlChar * for the first occurrence or NULL.
 366  */
 367
 368 const xmlChar *
 369 xmlStrcasestr(const xmlChar *str, const xmlChar *val) {
 370     int n;
 371
 372     if (str == NULL) return(NULL);
 373     if (val == NULL) return(NULL);
 374     n = xmlStrlen(val);
 375
 376     if (n == 0) return(str);
 377     while (*str != 0) { /* non input consuming */
 378         if (casemap[*str] == casemap[*val])
 379             if (!xmlStrncasecmp(str, val, n)) return(str);
 380         str++;
 381     }
 382     return(NULL);
 383 }
 384
 385 /**
 386  * xmlStrsub:
 387  * @str:  the xmlChar * array (haystack)
 388  * @start:  the index of the first char (zero based)
 389  * @len:  the length of the substring
 390  *
 391  * Extract a substring of a given string
 392  *
 393  * Returns the xmlChar * for the first occurrence or NULL.
 394  */
 395
 396 xmlChar *
 397 xmlStrsub(const xmlChar *str, int start, int len) {
 398     int i;
 399
 400     if (str == NULL) return(NULL);
 401     if (start < 0) return(NULL);
 402     if (len < 0) return(NULL);
 403
 404     for (i = 0;i < start;i++) {
 405         if (*str == 0) return(NULL);
 406         str++;
 407     }
 408     if (*str == 0) return(NULL);
 409     return(xmlStrndup(str, len));
 410 }
 411
 412 /**
 413  * xmlStrlen:
 414  * @str:  the xmlChar * array
 415  *
 416  * length of a xmlChar's string
 417  *
 418  * Returns the number of xmlChar contained in the ARRAY.
 419  */
 420
 421 int
 422 xmlStrlen(const xmlChar *str) {
 423     int len = 0;
 424
 425     if (str == NULL) return(0);
 426     while (*str != 0) { /* non input consuming */
 427         str++;
 428         len++;
 429     }
 430     return(len);
 431 }
 432
 433 /**
 434  * xmlStrncat:
 435  * @cur:  the original xmlChar * array
 436  * @add:  the xmlChar * array added
 437  * @len:  the length of @add
 438  *
 439  * a strncat for array of xmlChar's, it will extend @cur with the len
 440  * first bytes of @add. Note that if @len < 0 then this is an API error
 441  * and NULL will be returned.
 442  *
 443  * Returns a new xmlChar *, the original @cur is reallocated if needed
 444  * and should not be freed
 445  */
 446
 447 xmlChar *
 448 xmlStrncat(xmlChar *cur, const xmlChar *add, int len) {
 449     int size;
 450     xmlChar *ret;
 451
 452     if ((add == NULL) || (len == 0))
 453         return(cur);
 454     if (len < 0)
 455         return(NULL);
 456     if (cur == NULL)
 457         return(xmlStrndup(add, len));
 458
 459     size = xmlStrlen(cur);
 460     ret = (xmlChar *) xmlRealloc(cur, (size + len + 1) * sizeof(xmlChar));
 461     if (ret == NULL) {
 462         xmlErrMemory(NULL, NULL);
 463         return(cur);
 464     }
 465     memcpy(&ret[size], add, len * sizeof(xmlChar));
 466     ret[size + len] = 0;
 467     return(ret);
 468 }
 469
 470 /**
 471  * xmlStrncatNew:
 472  * @str1:  first xmlChar string
 473  * @str2:  second xmlChar string
 474  * @len:  the len of @str2 or < 0
 475  *
 476  * same as xmlStrncat, but creates a new string.  The original
 477  * two strings are not freed. If @len is < 0 then the length
 478  * will be calculated automatically.
 479  *
 480  * Returns a new xmlChar * or NULL
 481  */
 482 xmlChar *
 483 xmlStrncatNew(const xmlChar *str1, const xmlChar *str2, int len) {
 484     int size;
 485     xmlChar *ret;
 486
 487     if (len < 0)
 488         len = xmlStrlen(str2);
 489     if ((str2 == NULL) || (len == 0))
 490         return(xmlStrdup(str1));
 491     if (str1 == NULL)
 492         return(xmlStrndup(str2, len));
 493
 494     size = xmlStrlen(str1);
 495     ret = (xmlChar *) xmlMalloc((size + len + 1) * sizeof(xmlChar));
 496     if (ret == NULL) {
 497         xmlErrMemory(NULL, NULL);
 498         return(xmlStrndup(str1, size));
 499     }
 500     memcpy(ret, str1, size * sizeof(xmlChar));
 501     memcpy(&ret[size], str2, len * sizeof(xmlChar));
 502     ret[size + len] = 0;
 503     return(ret);
 504 }
 505
 506 /**
 507  * xmlStrcat:
 508  * @cur:  the original xmlChar * array
 509  * @add:  the xmlChar * array added
 510  *
 511  * a strcat for array of xmlChar's. Since they are supposed to be
 512  * encoded in UTF-8 or an encoding with 8bit based chars, we assume
 513  * a termination mark of '0'.
 514  *
 515  * Returns a new xmlChar * containing the concatenated string.
 516  */
 517 xmlChar *
 518 xmlStrcat(xmlChar *cur, const xmlChar *add) {
 519     const xmlChar *p = add;
 520
 521     if (add == NULL) return(cur);
 522     if (cur == NULL)
 523         return(xmlStrdup(add));
 524
 525     while (*p != 0) p++; /* non input consuming */
 526     return(xmlStrncat(cur, add, p - add));
 527 }
 528
 529 /**
 530  * xmlStrPrintf:
 531  * @buf:   the result buffer.
 532  * @len:   the result buffer length.
 533  * @msg:   the message with printf formatting.
 534  * @...:   extra parameters for the message.
 535  *
 536  * Formats @msg and places result into @buf.
 537  *
 538  * Returns the number of characters written to @buf or -1 if an error occurs.
 539  */
 540 int XMLCDECL
 541 xmlStrPrintf(xmlChar *buf, int len, const xmlChar *msg, ...) {
 542     va_list args;
 543     int ret;
 544
 545     if((buf == NULL) || (msg == NULL)) {
 546         return(-1);
 547     }
 548
 549     va_start(args, msg);
 550     ret = vsnprintf((char *) buf, len, (const char *) msg, args);
 551     va_end(args);
 552     buf[len - 1] = 0; /* be safe ! */
 553
 554     return(ret);
 555 }
 556
 557 /**
 558  * xmlStrVPrintf:
 559  * @buf:   the result buffer.
 560  * @len:   the result buffer length.
 561  * @msg:   the message with printf formatting.
 562  * @ap:    extra parameters for the message.
 563  *
 564  * Formats @msg and places result into @buf.
 565  *
 566  * Returns the number of characters written to @buf or -1 if an error occurs.
 567  */
 568 int
 569 xmlStrVPrintf(xmlChar *buf, int len, const xmlChar *msg, va_list ap) {
 570     int ret;
 571
 572     if((buf == NULL) || (msg == NULL)) {
 573         return(-1);
 574     }
 575
 576     ret = vsnprintf((char *) buf, len, (const char *) msg, ap);
 577     buf[len - 1] = 0; /* be safe ! */
 578
 579     return(ret);
 580 }
 581
 582 /************************************************************************
 583  *                                                                      *
 584  *              Generic UTF8 handling routines                          *
 585  *                                                                      *
 586  * From rfc2044: encoding of the Unicode values on UTF-8:               *
 587  *                                                                      *
 588  * UCS-4 range (hex.)           UTF-8 octet sequence (binary)           *
 589  * 0000 0000-0000 007F   0xxxxxxx                                       *
 590  * 0000 0080-0000 07FF   110xxxxx 10xxxxxx                              *
 591  * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx                     *
 592  *                                                                      *
 593  * I hope we won't use values > 0xFFFF anytime soon !                   *
 594  *                                                                      *
 595  ************************************************************************/
 596
 597
 598 /**
 599  * xmlUTF8Size:
 600  * @utf: pointer to the UTF8 character
 601  *
 602  * calculates the internal size of a UTF8 character
 603  *
 604  * returns the numbers of bytes in the character, -1 on format error
 605  */
 606 int
 607 xmlUTF8Size(const xmlChar *utf) {
 608     xmlChar mask;
 609     int len;
 610
 611     if (utf == NULL)
 612         return -1;
 613     if (*utf < 0x80)
 614         return 1;
 615     /* check valid UTF8 character */
 616     if (!(*utf & 0x40))
 617         return -1;
 618     /* determine number of bytes in char */
 619     len = 2;
 620     for (mask=0x20; mask != 0; mask>>=1) {
 621         if (!(*utf & mask))
 622             return len;
 623         len++;
 624     }
 625     return -1;
 626 }
 627
 628 /**
 629  * xmlUTF8Charcmp:
 630  * @utf1: pointer to first UTF8 char
 631  * @utf2: pointer to second UTF8 char
 632  *
 633  * compares the two UCS4 values
 634  *
 635  * returns result of the compare as with xmlStrncmp
 636  */
 637 int
 638 xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2) {
 639
 640     if (utf1 == NULL ) {
 641         if (utf2 == NULL)
 642             return 0;
 643         return -1;
 644     }
 645     return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1));
 646 }
 647
 648 /**
 649  * xmlUTF8Strlen:
 650  * @utf:  a sequence of UTF-8 encoded bytes
 651  *
 652  * compute the length of an UTF8 string, it doesn't do a full UTF8
 653  * checking of the content of the string.
 654  *
 655  * Returns the number of characters in the string or -1 in case of error
 656  */
 657 int
 658 xmlUTF8Strlen(const xmlChar *utf) {
 659     int ret = 0;
 660
 661     if (utf == NULL)
 662         return(-1);
 663
 664     while (*utf != 0) {
 665         if (utf[0] & 0x80) {
 666             if ((utf[1] & 0xc0) != 0x80)
 667                 return(-1);
 668             if ((utf[0] & 0xe0) == 0xe0) {
 669                 if ((utf[2] & 0xc0) != 0x80)
 670                     return(-1);
 671                 if ((utf[0] & 0xf0) == 0xf0) {
 672                     if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
 673                         return(-1);
 674                     utf += 4;
 675                 } else {
 676                     utf += 3;
 677                 }
 678             } else {
 679                 utf += 2;
 680             }
 681         } else {
 682             utf++;
 683         }
 684         ret++;
 685     }
 686     return(ret);
 687 }
 688
 689 /**
 690  * xmlGetUTF8Char:
 691  * @utf:  a sequence of UTF-8 encoded bytes
 692  * @len:  a pointer to the minimum number of bytes present in
 693  *        the sequence.  This is used to assure the next character
 694  *        is completely contained within the sequence.
 695  *
 696  * Read the first UTF8 character from @utf
 697  *
 698  * Returns the char value or -1 in case of error, and sets *len to
 699  *        the actual number of bytes consumed (0 in case of error)
 700  */
 701 int
 702 xmlGetUTF8Char(const unsigned char *utf, int *len) {
 703     unsigned int c;
 704
 705     if (utf == NULL)
 706         goto error;
 707     if (len == NULL)
 708         goto error;
 709     if (*len < 1)
 710         goto error;
 711
 712     c = utf[0];
 713     if (c & 0x80) {
 714         if (*len < 2)
 715             goto error;
 716         if ((utf[1] & 0xc0) != 0x80)
 717             goto error;
 718         if ((c & 0xe0) == 0xe0) {
 719             if (*len < 3)
 720                 goto error;
 721             if ((utf[2] & 0xc0) != 0x80)
 722                 goto error;
 723             if ((c & 0xf0) == 0xf0) {
 724                 if (*len < 4)
 725                     goto error;
 726                 if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
 727                     goto error;
 728                 *len = 4;
 729                 /* 4-byte code */
 730                 c = (utf[0] & 0x7) << 18;
 731                 c |= (utf[1] & 0x3f) << 12;
 732                 c |= (utf[2] & 0x3f) << 6;
 733                 c |= utf[3] & 0x3f;
 734             } else {
 735               /* 3-byte code */
 736                 *len = 3;
 737                 c = (utf[0] & 0xf) << 12;
 738                 c |= (utf[1] & 0x3f) << 6;
 739                 c |= utf[2] & 0x3f;
 740             }
 741         } else {
 742           /* 2-byte code */
 743             *len = 2;
 744             c = (utf[0] & 0x1f) << 6;
 745             c |= utf[1] & 0x3f;
 746         }
 747     } else {
 748         /* 1-byte code */
 749         *len = 1;
 750     }
 751     return(c);
 752
 753 error:
 754     if (len != NULL)
 755         *len = 0;
 756     return(-1);
 757 }
 758
 759 /**
 760  * xmlCheckUTF8:
 761  * @utf: Pointer to putative UTF-8 encoded string.
 762  *
 763  * Checks @utf for being valid UTF-8. @utf is assumed to be
 764  * null-terminated. This function is not super-strict, as it will
 765  * allow longer UTF-8 sequences than necessary. Note that Java is
 766  * capable of producing these sequences if provoked. Also note, this
 767  * routine checks for the 4-byte maximum size, but does not check for
 768  * 0x10ffff maximum value.
 769  *
 770  * Return value: true if @utf is valid.
 771  **/
 772 int
 773 xmlCheckUTF8(const unsigned char *utf)
 774 {
 775     int ix;
 776     unsigned char c;
 777
 778     if (utf == NULL)
 779         return(0);
 780     /*
 781      * utf is a string of 1, 2, 3 or 4 bytes.  The valid strings
 782      * are as follows (in "bit format"):
 783      *    0xxxxxxx                                      valid 1-byte
 784      *    110xxxxx 10xxxxxx                             valid 2-byte
 785      *    1110xxxx 10xxxxxx 10xxxxxx                    valid 3-byte
 786      *    11110xxx 10xxxxxx 10xxxxxx 10xxxxxx           valid 4-byte
 787      */
 788     for (ix = 0; (c = utf[ix]);) {      /* string is 0-terminated */
 789         if ((c & 0x80) == 0x00) {       /* 1-byte code, starts with 10 */
 790             ix++;
 791         } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
 792             if ((utf[ix+1] & 0xc0 ) != 0x80)
 793                 return 0;
 794             ix += 2;
 795         } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
 796             if (((utf[ix+1] & 0xc0) != 0x80) ||
 797                 ((utf[ix+2] & 0xc0) != 0x80))
 798                     return 0;
 799             ix += 3;
 800         } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
 801             if (((utf[ix+1] & 0xc0) != 0x80) ||
 802                 ((utf[ix+2] & 0xc0) != 0x80) ||
 803                 ((utf[ix+3] & 0xc0) != 0x80))
 804                     return 0;
 805             ix += 4;
 806         } else                          /* unknown encoding */
 807             return 0;
 808       }
 809       return(1);
 810 }
 811
 812 /**
 813  * xmlUTF8Strsize:
 814  * @utf:  a sequence of UTF-8 encoded bytes
 815  * @len:  the number of characters in the array
 816  *
 817  * storage size of an UTF8 string
 818  * the behaviour is not garanteed if the input string is not UTF-8
 819  *
 820  * Returns the storage size of
 821  * the first 'len' characters of ARRAY
 822  */
 823
 824 int
 825 xmlUTF8Strsize(const xmlChar *utf, int len) {
 826     const xmlChar   *ptr=utf;
 827     xmlChar         ch;
 828
 829     if (utf == NULL)
 830         return(0);
 831
 832     if (len <= 0)
 833         return(0);
 834
 835     while ( len-- > 0) {
 836         if ( !*ptr )
 837             break;
 838         if ( (ch = *ptr++) & 0x80)
 839             while ((ch<<=1) & 0x80 ) {
 840                 ptr++;
 841                 if (*ptr == 0) break;
 842             }
 843     }
 844     return (ptr - utf);
 845 }
 846
 847
 848 /**
 849  * xmlUTF8Strndup:
 850  * @utf:  the input UTF8 *
 851  * @len:  the len of @utf (in chars)
 852  *
 853  * a strndup for array of UTF8's
 854  *
 855  * Returns a new UTF8 * or NULL
 856  */
 857 xmlChar *
 858 xmlUTF8Strndup(const xmlChar *utf, int len) {
 859     xmlChar *ret;
 860     int i;
 861
 862     if ((utf == NULL) || (len < 0)) return(NULL);
 863     i = xmlUTF8Strsize(utf, len);
 864     ret = (xmlChar *) xmlMallocAtomic((i + 1) * sizeof(xmlChar));
 865     if (ret == NULL) {
 866         xmlGenericError(xmlGenericErrorContext,
 867                 "malloc of %ld byte failed\n",
 868                 (len + 1) * (long)sizeof(xmlChar));
 869         return(NULL);
 870     }
 871     memcpy(ret, utf, i * sizeof(xmlChar));
 872     ret[i] = 0;
 873     return(ret);
 874 }
 875
 876 /**
 877  * xmlUTF8Strpos:
 878  * @utf:  the input UTF8 *
 879  * @pos:  the position of the desired UTF8 char (in chars)
 880  *
 881  * a function to provide the equivalent of fetching a
 882  * character from a string array
 883  *
 884  * Returns a pointer to the UTF8 character or NULL
 885  */
 886 const xmlChar *
 887 xmlUTF8Strpos(const xmlChar *utf, int pos) {
 888     xmlChar ch;
 889
 890     if (utf == NULL) return(NULL);
 891     if (pos < 0)
 892         return(NULL);
 893     while (pos--) {
 894         if ((ch=*utf++) == 0) return(NULL);
 895         if ( ch & 0x80 ) {
 896             /* if not simple ascii, verify proper format */
 897             if ( (ch & 0xc0) != 0xc0 )
 898                 return(NULL);
 899             /* then skip over remaining bytes for this char */
 900             while ( (ch <<= 1) & 0x80 )
 901                 if ( (*utf++ & 0xc0) != 0x80 )
 902                     return(NULL);
 903         }
 904     }
 905     return((xmlChar *)utf);
 906 }
 907
 908 /**
 909  * xmlUTF8Strloc:
 910  * @utf:  the input UTF8 *
 911  * @utfchar:  the UTF8 character to be found
 912  *
 913  * a function to provide the relative location of a UTF8 char
 914  *
 915  * Returns the relative character position of the desired char
 916  * or -1 if not found
 917  */
 918 int
 919 xmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar) {
 920     int i, size;
 921     xmlChar ch;
 922
 923     if (utf==NULL || utfchar==NULL) return -1;
 924     size = xmlUTF8Strsize(utfchar, 1);
 925         for(i=0; (ch=*utf) != 0; i++) {
 926             if (xmlStrncmp(utf, utfchar, size)==0)
 927                 return(i);
 928             utf++;
 929             if ( ch & 0x80 ) {
 930                 /* if not simple ascii, verify proper format */
 931                 if ( (ch & 0xc0) != 0xc0 )
 932                     return(-1);
 933                 /* then skip over remaining bytes for this char */
 934                 while ( (ch <<= 1) & 0x80 )
 935                     if ( (*utf++ & 0xc0) != 0x80 )
 936                         return(-1);
 937             }
 938         }
 939
 940     return(-1);
 941 }
 942 /**
 943  * xmlUTF8Strsub:
 944  * @utf:  a sequence of UTF-8 encoded bytes
 945  * @start: relative pos of first char
 946  * @len:   total number to copy
 947  *
 948  * Create a substring from a given UTF-8 string
 949  * Note:  positions are given in units of UTF-8 chars
 950  *
 951  * Returns a pointer to a newly created string
 952  * or NULL if any problem
 953  */
 954
 955 xmlChar *
 956 xmlUTF8Strsub(const xmlChar *utf, int start, int len) {
 957     int            i;
 958     xmlChar ch;
 959
 960     if (utf == NULL) return(NULL);
 961     if (start < 0) return(NULL);
 962     if (len < 0) return(NULL);
 963
 964     /*
 965      * Skip over any leading chars
 966      */
 967     for (i = 0;i < start;i++) {
 968         if ((ch=*utf++) == 0) return(NULL);
 969         if ( ch & 0x80 ) {
 970             /* if not simple ascii, verify proper format */
 971             if ( (ch & 0xc0) != 0xc0 )
 972                 return(NULL);
 973             /* then skip over remaining bytes for this char */
 974             while ( (ch <<= 1) & 0x80 )
 975                 if ( (*utf++ & 0xc0) != 0x80 )
 976                     return(NULL);
 977         }
 978     }
 979
 980     return(xmlUTF8Strndup(utf, len));
 981 }
 982
 983 #define bottom_xmlstring
 984 #include "elfgcchack.h"