ReactOS 0.4.15-dev-5666-gc548b97
xmlstring.c
Go to the documentation of this file.
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 <limits.h>
22#include <libxml/xmlmemory.h>
24#include <libxml/xmlstring.h>
25
26/************************************************************************
27 * *
28 * Commodity functions to handle xmlChars *
29 * *
30 ************************************************************************/
31
41xmlChar *
42xmlStrndup(const xmlChar *cur, int len) {
43 xmlChar *ret;
44
45 if ((cur == NULL) || (len < 0)) return(NULL);
46 ret = (xmlChar *) xmlMallocAtomic(((size_t) len + 1) * sizeof(xmlChar));
47 if (ret == NULL) {
49 return(NULL);
50 }
51 memcpy(ret, cur, len * sizeof(xmlChar));
52 ret[len] = 0;
53 return(ret);
54}
55
66xmlChar *
68 const xmlChar *p = cur;
69
70 if (cur == NULL) return(NULL);
71 while (*p != 0) p++; /* non input consuming */
72 return(xmlStrndup(cur, p - cur));
73}
74
85xmlChar *
86xmlCharStrndup(const char *cur, int len) {
87 int i;
88 xmlChar *ret;
89
90 if ((cur == NULL) || (len < 0)) return(NULL);
91 ret = (xmlChar *) xmlMallocAtomic(((size_t) len + 1) * sizeof(xmlChar));
92 if (ret == NULL) {
94 return(NULL);
95 }
96 for (i = 0;i < len;i++) {
97 ret[i] = (xmlChar) cur[i];
98 if (ret[i] == 0) return(ret);
99 }
100 ret[len] = 0;
101 return(ret);
102}
103
113xmlChar *
114xmlCharStrdup(const char *cur) {
115 const char *p = cur;
116
117 if (cur == NULL) return(NULL);
118 while (*p != '\0') p++; /* non input consuming */
119 return(xmlCharStrndup(cur, p - cur));
120}
121
132int
133xmlStrcmp(const xmlChar *str1, const xmlChar *str2) {
134 if (str1 == str2) return(0);
135 if (str1 == NULL) return(-1);
136 if (str2 == NULL) return(1);
137#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
138 return(strcmp((const char *)str1, (const char *)str2));
139#else
140 do {
141 int tmp = *str1++ - *str2;
142 if (tmp != 0) return(tmp);
143 } while (*str2++ != 0);
144 return 0;
145#endif
146}
147
159int
160xmlStrEqual(const xmlChar *str1, const xmlChar *str2) {
161 if (str1 == str2) return(1);
162 if (str1 == NULL) return(0);
163 if (str2 == NULL) return(0);
164#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
165 return(strcmp((const char *)str1, (const char *)str2) == 0);
166#else
167 do {
168 if (*str1++ != *str2) return(0);
169 } while (*str2++);
170 return(1);
171#endif
172}
173
185int
186xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str) {
187 if (pref == NULL) return(xmlStrEqual(name, str));
188 if (name == NULL) return(0);
189 if (str == NULL) return(0);
190
191 do {
192 if (*pref++ != *str) return(0);
193 } while ((*str++) && (*pref));
194 if (*str++ != ':') return(0);
195 do {
196 if (*name++ != *str) return(0);
197 } while (*str++);
198 return(1);
199}
200
212int
213xmlStrncmp(const xmlChar *str1, const xmlChar *str2, int len) {
214 if (len <= 0) return(0);
215 if (str1 == str2) return(0);
216 if (str1 == NULL) return(-1);
217 if (str2 == NULL) return(1);
218#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
219 return(strncmp((const char *)str1, (const char *)str2, len));
220#else
221 do {
222 int tmp = *str1++ - *str2;
223 if (tmp != 0 || --len == 0) return(tmp);
224 } while (*str2++ != 0);
225 return 0;
226#endif
227}
228
229static const xmlChar casemap[256] = {
230 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
231 0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
232 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
233 0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
234 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
235 0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
236 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
237 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
238 0x40,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,0x5C,0x5D,0x5E,0x5F,
242 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
243 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
244 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
245 0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
246 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
247 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
248 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
249 0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
250 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
251 0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
252 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
253 0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
254 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
255 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
256 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
257 0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
258 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
259 0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
260 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
261 0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
262};
263
274int
275xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2) {
276 register int tmp;
277
278 if (str1 == str2) return(0);
279 if (str1 == NULL) return(-1);
280 if (str2 == NULL) return(1);
281 do {
282 tmp = casemap[*str1++] - casemap[*str2];
283 if (tmp != 0) return(tmp);
284 } while (*str2++ != 0);
285 return 0;
286}
287
299int
300xmlStrncasecmp(const xmlChar *str1, const xmlChar *str2, int len) {
301 register int tmp;
302
303 if (len <= 0) return(0);
304 if (str1 == str2) return(0);
305 if (str1 == NULL) return(-1);
306 if (str2 == NULL) return(1);
307 do {
308 tmp = casemap[*str1++] - casemap[*str2];
309 if (tmp != 0 || --len == 0) return(tmp);
310 } while (*str2++ != 0);
311 return 0;
312}
313
324const xmlChar *
326 if (str == NULL) return(NULL);
327 while (*str != 0) { /* non input consuming */
328 if (*str == val) return((xmlChar *) str);
329 str++;
330 }
331 return(NULL);
332}
333
344const xmlChar *
345xmlStrstr(const xmlChar *str, const xmlChar *val) {
346 int n;
347
348 if (str == NULL) return(NULL);
349 if (val == NULL) return(NULL);
350 n = xmlStrlen(val);
351
352 if (n == 0) return(str);
353 while (*str != 0) { /* non input consuming */
354 if (*str == *val) {
355 if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str);
356 }
357 str++;
358 }
359 return(NULL);
360}
361
372const xmlChar *
374 int n;
375
376 if (str == NULL) return(NULL);
377 if (val == NULL) return(NULL);
378 n = xmlStrlen(val);
379
380 if (n == 0) return(str);
381 while (*str != 0) { /* non input consuming */
382 if (casemap[*str] == casemap[*val])
383 if (!xmlStrncasecmp(str, val, n)) return(str);
384 str++;
385 }
386 return(NULL);
387}
388
400xmlChar *
401xmlStrsub(const xmlChar *str, int start, int len) {
402 int i;
403
404 if (str == NULL) return(NULL);
405 if (start < 0) return(NULL);
406 if (len < 0) return(NULL);
407
408 for (i = 0;i < start;i++) {
409 if (*str == 0) return(NULL);
410 str++;
411 }
412 if (*str == 0) return(NULL);
413 return(xmlStrndup(str, len));
414}
415
425int
427 size_t len = str ? strlen((const char *)str) : 0;
428 return(len > INT_MAX ? 0 : len);
429}
430
445xmlChar *
446xmlStrncat(xmlChar *cur, const xmlChar *add, int len) {
447 int size;
448 xmlChar *ret;
449
450 if ((add == NULL) || (len == 0))
451 return(cur);
452 if (len < 0)
453 return(NULL);
454 if (cur == NULL)
455 return(xmlStrndup(add, len));
456
457 size = xmlStrlen(cur);
458 if ((size < 0) || (size > INT_MAX - len))
459 return(NULL);
460 ret = (xmlChar *) xmlRealloc(cur, ((size_t) size + len + 1) * sizeof(xmlChar));
461 if (ret == NULL) {
463 return(cur);
464 }
465 memcpy(&ret[size], add, len * sizeof(xmlChar));
466 ret[size + len] = 0;
467 return(ret);
468}
469
482xmlChar *
483xmlStrncatNew(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 (len < 0)
490 return(NULL);
491 }
492 if ((str2 == NULL) || (len == 0))
493 return(xmlStrdup(str1));
494 if (str1 == NULL)
495 return(xmlStrndup(str2, len));
496
497 size = xmlStrlen(str1);
498 if ((size < 0) || (size > INT_MAX - len))
499 return(NULL);
500 ret = (xmlChar *) xmlMalloc(((size_t) size + len + 1) * sizeof(xmlChar));
501 if (ret == NULL) {
503 return(xmlStrndup(str1, size));
504 }
505 memcpy(ret, str1, size * sizeof(xmlChar));
506 memcpy(&ret[size], str2, len * sizeof(xmlChar));
507 ret[size + len] = 0;
508 return(ret);
509}
510
523xmlChar *
525 const xmlChar *p = add;
526
527 if (add == NULL) return(cur);
528 if (cur == NULL)
529 return(xmlStrdup(add));
530
531 while (*p != 0) p++; /* non input consuming */
532 return(xmlStrncat(cur, add, p - add));
533}
534
546int XMLCDECL
547xmlStrPrintf(xmlChar *buf, int len, const char *msg, ...) {
549 int ret;
550
551 if((buf == NULL) || (msg == NULL)) {
552 return(-1);
553 }
554
555 va_start(args, msg);
556 ret = vsnprintf((char *) buf, len, (const char *) msg, args);
557 va_end(args);
558 buf[len - 1] = 0; /* be safe ! */
559
560 return(ret);
561}
562
574int
575xmlStrVPrintf(xmlChar *buf, int len, const char *msg, va_list ap) {
576 int ret;
577
578 if((buf == NULL) || (msg == NULL)) {
579 return(-1);
580 }
581
582 ret = vsnprintf((char *) buf, len, (const char *) msg, ap);
583 buf[len - 1] = 0; /* be safe ! */
584
585 return(ret);
586}
587
588/************************************************************************
589 * *
590 * Generic UTF8 handling routines *
591 * *
592 * From rfc2044: encoding of the Unicode values on UTF-8: *
593 * *
594 * UCS-4 range (hex.) UTF-8 octet sequence (binary) *
595 * 0000 0000-0000 007F 0xxxxxxx *
596 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx *
597 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx *
598 * *
599 * I hope we won't use values > 0xFFFF anytime soon ! *
600 * *
601 ************************************************************************/
602
603
612int
613xmlUTF8Size(const xmlChar *utf) {
615 int len;
616
617 if (utf == NULL)
618 return -1;
619 if (*utf < 0x80)
620 return 1;
621 /* check valid UTF8 character */
622 if (!(*utf & 0x40))
623 return -1;
624 /* determine number of bytes in char */
625 len = 2;
626 for (mask=0x20; mask != 0; mask>>=1) {
627 if (!(*utf & mask))
628 return len;
629 len++;
630 }
631 return -1;
632}
633
643int
644xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2) {
645
646 if (utf1 == NULL ) {
647 if (utf2 == NULL)
648 return 0;
649 return -1;
650 }
651 return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1));
652}
653
663int
665 size_t ret = 0;
666
667 if (utf == NULL)
668 return(-1);
669
670 while (*utf != 0) {
671 if (utf[0] & 0x80) {
672 if ((utf[1] & 0xc0) != 0x80)
673 return(-1);
674 if ((utf[0] & 0xe0) == 0xe0) {
675 if ((utf[2] & 0xc0) != 0x80)
676 return(-1);
677 if ((utf[0] & 0xf0) == 0xf0) {
678 if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
679 return(-1);
680 utf += 4;
681 } else {
682 utf += 3;
683 }
684 } else {
685 utf += 2;
686 }
687 } else {
688 utf++;
689 }
690 ret++;
691 }
692 return(ret > INT_MAX ? 0 : ret);
693}
694
707int
708xmlGetUTF8Char(const unsigned char *utf, int *len) {
709 unsigned int c;
710
711 if (utf == NULL)
712 goto error;
713 if (len == NULL)
714 goto error;
715 if (*len < 1)
716 goto error;
717
718 c = utf[0];
719 if (c & 0x80) {
720 if (*len < 2)
721 goto error;
722 if ((utf[1] & 0xc0) != 0x80)
723 goto error;
724 if ((c & 0xe0) == 0xe0) {
725 if (*len < 3)
726 goto error;
727 if ((utf[2] & 0xc0) != 0x80)
728 goto error;
729 if ((c & 0xf0) == 0xf0) {
730 if (*len < 4)
731 goto error;
732 if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
733 goto error;
734 *len = 4;
735 /* 4-byte code */
736 c = (utf[0] & 0x7) << 18;
737 c |= (utf[1] & 0x3f) << 12;
738 c |= (utf[2] & 0x3f) << 6;
739 c |= utf[3] & 0x3f;
740 } else {
741 /* 3-byte code */
742 *len = 3;
743 c = (utf[0] & 0xf) << 12;
744 c |= (utf[1] & 0x3f) << 6;
745 c |= utf[2] & 0x3f;
746 }
747 } else {
748 /* 2-byte code */
749 *len = 2;
750 c = (utf[0] & 0x1f) << 6;
751 c |= utf[1] & 0x3f;
752 }
753 } else {
754 /* 1-byte code */
755 *len = 1;
756 }
757 return(c);
758
759error:
760 if (len != NULL)
761 *len = 0;
762 return(-1);
763}
764
778int
779xmlCheckUTF8(const unsigned char *utf)
780{
781 int ix;
782 unsigned char c;
783
784 if (utf == NULL)
785 return(0);
786 /*
787 * utf is a string of 1, 2, 3 or 4 bytes. The valid strings
788 * are as follows (in "bit format"):
789 * 0xxxxxxx valid 1-byte
790 * 110xxxxx 10xxxxxx valid 2-byte
791 * 1110xxxx 10xxxxxx 10xxxxxx valid 3-byte
792 * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx valid 4-byte
793 */
794 while ((c = utf[0])) { /* string is 0-terminated */
795 ix = 0;
796 if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */
797 ix = 1;
798 } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
799 if ((utf[1] & 0xc0 ) != 0x80)
800 return 0;
801 ix = 2;
802 } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
803 if (((utf[1] & 0xc0) != 0x80) ||
804 ((utf[2] & 0xc0) != 0x80))
805 return 0;
806 ix = 3;
807 } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
808 if (((utf[1] & 0xc0) != 0x80) ||
809 ((utf[2] & 0xc0) != 0x80) ||
810 ((utf[3] & 0xc0) != 0x80))
811 return 0;
812 ix = 4;
813 } else /* unknown encoding */
814 return 0;
815 utf += ix;
816 }
817 return(1);
818}
819
832int
833xmlUTF8Strsize(const xmlChar *utf, int len) {
834 const xmlChar *ptr=utf;
835 int ch;
836 size_t ret;
837
838 if (utf == NULL)
839 return(0);
840
841 if (len <= 0)
842 return(0);
843
844 while ( len-- > 0) {
845 if ( !*ptr )
846 break;
847 if ( (ch = *ptr++) & 0x80)
848 while ((ch<<=1) & 0x80 ) {
849 if (*ptr == 0) break;
850 ptr++;
851 }
852 }
853 ret = ptr - utf;
854 return (ret > INT_MAX ? 0 : ret);
855}
856
857
867xmlChar *
868xmlUTF8Strndup(const xmlChar *utf, int len) {
869 xmlChar *ret;
870 int i;
871
872 if ((utf == NULL) || (len < 0)) return(NULL);
873 i = xmlUTF8Strsize(utf, len);
874 ret = (xmlChar *) xmlMallocAtomic(((size_t) i + 1) * sizeof(xmlChar));
875 if (ret == NULL) {
876 return(NULL);
877 }
878 memcpy(ret, utf, i * sizeof(xmlChar));
879 ret[i] = 0;
880 return(ret);
881}
882
893const xmlChar *
894xmlUTF8Strpos(const xmlChar *utf, int pos) {
895 int ch;
896
897 if (utf == NULL) return(NULL);
898 if (pos < 0)
899 return(NULL);
900 while (pos--) {
901 if ((ch=*utf++) == 0) return(NULL);
902 if ( ch & 0x80 ) {
903 /* if not simple ascii, verify proper format */
904 if ( (ch & 0xc0) != 0xc0 )
905 return(NULL);
906 /* then skip over remaining bytes for this char */
907 while ( (ch <<= 1) & 0x80 )
908 if ( (*utf++ & 0xc0) != 0x80 )
909 return(NULL);
910 }
911 }
912 return((xmlChar *)utf);
913}
914
925int
926xmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar) {
927 size_t i;
928 int size;
929 int ch;
930
931 if (utf==NULL || utfchar==NULL) return -1;
932 size = xmlUTF8Strsize(utfchar, 1);
933 for(i=0; (ch=*utf) != 0; i++) {
934 if (xmlStrncmp(utf, utfchar, size)==0)
935 return(i > INT_MAX ? 0 : i);
936 utf++;
937 if ( ch & 0x80 ) {
938 /* if not simple ascii, verify proper format */
939 if ( (ch & 0xc0) != 0xc0 )
940 return(-1);
941 /* then skip over remaining bytes for this char */
942 while ( (ch <<= 1) & 0x80 )
943 if ( (*utf++ & 0xc0) != 0x80 )
944 return(-1);
945 }
946 }
947
948 return(-1);
949}
963xmlChar *
964xmlUTF8Strsub(const xmlChar *utf, int start, int len) {
965 int i;
966 int ch;
967
968 if (utf == NULL) return(NULL);
969 if (start < 0) return(NULL);
970 if (len < 0) return(NULL);
971
972 /*
973 * Skip over any leading chars
974 */
975 for (i = 0;i < start;i++) {
976 if ((ch=*utf++) == 0) return(NULL);
977 if ( ch & 0x80 ) {
978 /* if not simple ascii, verify proper format */
979 if ( (ch & 0xc0) != 0xc0 )
980 return(NULL);
981 /* then skip over remaining bytes for this char */
982 while ( (ch <<= 1) & 0x80 )
983 if ( (*utf++ & 0xc0) != 0x80 )
984 return(NULL);
985 }
986 }
987
988 return(xmlUTF8Strndup(utf, len));
989}
990
1000xmlChar *
1002{
1003 xmlChar *msgPtr = NULL;
1004 xmlChar *result = NULL;
1005 xmlChar *resultPtr = NULL;
1006 size_t count = 0;
1007 size_t msgLen = 0;
1008 size_t resultLen = 0;
1009
1010 if (!msg || !*msg)
1011 return(NULL);
1012
1013 for (msgPtr = *msg; *msgPtr != '\0'; ++msgPtr) {
1014 ++msgLen;
1015 if (*msgPtr == '%')
1016 ++count;
1017 }
1018
1019 if (count == 0)
1020 return(*msg);
1021
1022 if ((count > INT_MAX) || (msgLen > INT_MAX - count))
1023 return(NULL);
1024 resultLen = msgLen + count + 1;
1025 result = (xmlChar *) xmlMallocAtomic(resultLen * sizeof(xmlChar));
1026 if (result == NULL) {
1027 /* Clear *msg to prevent format string vulnerabilities in
1028 out-of-memory situations. */
1029 xmlFree(*msg);
1030 *msg = NULL;
1032 return(NULL);
1033 }
1034
1035 for (msgPtr = *msg, resultPtr = result; *msgPtr != '\0'; ++msgPtr, ++resultPtr) {
1036 *resultPtr = *msgPtr;
1037 if (*msgPtr == '%')
1038 *(++resultPtr) = '%';
1039 }
1040 result[resultLen - 1] = '\0';
1041
1042 xmlFree(*msg);
1043 *msg = result;
1044
1045 return *msg;
1046}
1047
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
char * va_list
Definition: acmsvcex.h:78
#define va_end(ap)
Definition: acmsvcex.h:90
#define va_start(ap, A)
Definition: acmsvcex.h:91
#define msg(x)
Definition: auth_time.c:54
#define NULL
Definition: types.h:112
FxCollectionEntry * cur
GLuint start
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizeiptr size
Definition: glext.h:5919
GLdouble n
Definition: glext.h:7729
const GLubyte * c
Definition: glext.h:8905
GLenum GLint GLuint mask
Definition: glext.h:6028
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
GLuint64EXT * result
Definition: glext.h:11304
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define INT_MAX
Definition: limits.h:40
#define c
Definition: ke_i.h:80
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static PVOID ptr
Definition: dispmode.c:27
void xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra)
const WCHAR * str
XMLPUBVAR xmlMallocFunc xmlMallocAtomic
Definition: globals.h:249
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
XMLPUBVAR xmlReallocFunc xmlRealloc
Definition: globals.h:250
#define args
Definition: format.c:66
Definition: match.c:390
Definition: name.c:39
#define vsnprintf
Definition: tif_win32.c:406
int ret
void int int ULONGLONG int va_list * ap
Definition: winesup.h:36
#define XMLCDECL
Definition: xmlexports.h:52
xmlChar * xmlStrcat(xmlChar *cur, const xmlChar *add)
Definition: xmlstring.c:524
int xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
const xmlChar * xmlStrchr(const xmlChar *str, xmlChar val)
Definition: xmlstring.c:325
int xmlCheckUTF8(const unsigned char *utf)
Definition: xmlstring.c:779
int XMLCDECL xmlStrPrintf(xmlChar *buf, int len, const char *msg,...)
Definition: xmlstring.c:547
xmlChar * xmlCharStrdup(const char *cur)
Definition: xmlstring.c:114
int xmlUTF8Strsize(const xmlChar *utf, int len)
Definition: xmlstring.c:833
xmlChar * xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:42
xmlChar * xmlUTF8Strndup(const xmlChar *utf, int len)
Definition: xmlstring.c:868
int xmlStrlen(const xmlChar *str)
Definition: xmlstring.c:426
int xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:275
int xmlStrncmp(const xmlChar *str1, const xmlChar *str2, int len)
Definition: xmlstring.c:213
xmlChar * xmlStrsub(const xmlChar *str, int start, int len)
Definition: xmlstring.c:401
xmlChar * xmlEscapeFormatString(xmlChar **msg)
Definition: xmlstring.c:1001
const xmlChar * xmlStrcasestr(const xmlChar *str, const xmlChar *val)
Definition: xmlstring.c:373
int xmlStrVPrintf(xmlChar *buf, int len, const char *msg, va_list ap)
Definition: xmlstring.c:575
const xmlChar * xmlStrstr(const xmlChar *str, const xmlChar *val)
Definition: xmlstring.c:345
int xmlStrncasecmp(const xmlChar *str1, const xmlChar *str2, int len)
Definition: xmlstring.c:300
int xmlStrcmp(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:133
xmlChar * xmlCharStrndup(const char *cur, int len)
Definition: xmlstring.c:86
int xmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar)
Definition: xmlstring.c:926
xmlChar * xmlStrncatNew(const xmlChar *str1, const xmlChar *str2, int len)
Definition: xmlstring.c:483
xmlChar * xmlUTF8Strsub(const xmlChar *utf, int start, int len)
Definition: xmlstring.c:964
const xmlChar * xmlUTF8Strpos(const xmlChar *utf, int pos)
Definition: xmlstring.c:894
int xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str)
Definition: xmlstring.c:186
int xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2)
Definition: xmlstring.c:644
int xmlUTF8Strlen(const xmlChar *utf)
Definition: xmlstring.c:664
int xmlUTF8Size(const xmlChar *utf)
Definition: xmlstring.c:613
static const xmlChar casemap[256]
Definition: xmlstring.c:229
xmlChar * xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
xmlChar * xmlStrncat(xmlChar *cur, const xmlChar *add, int len)
Definition: xmlstring.c:446
int xmlGetUTF8Char(const unsigned char *utf, int *len)
Definition: xmlstring.c:708
unsigned char xmlChar
Definition: xmlstring.h:28