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, 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"