ReactOS  0.4.14-dev-554-g2f8d847
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 <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 
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) {
48  return(NULL);
49  }
50  memcpy(ret, cur, len * sizeof(xmlChar));
51  ret[len] = 0;
52  return(ret);
53 }
54 
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 
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) {
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 
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 
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 
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 
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 
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 
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 
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 
320 const xmlChar *
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 
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 
368 const xmlChar *
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 
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 
421 int
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 
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  if (size < 0)
461  return(NULL);
462  ret = (xmlChar *) xmlRealloc(cur, (size + len + 1) * sizeof(xmlChar));
463  if (ret == NULL) {
465  return(cur);
466  }
467  memcpy(&ret[size], add, len * sizeof(xmlChar));
468  ret[size + len] = 0;
469  return(ret);
470 }
471 
484 xmlChar *
485 xmlStrncatNew(const xmlChar *str1, const xmlChar *str2, int len) {
486  int size;
487  xmlChar *ret;
488 
489  if (len < 0) {
490  len = xmlStrlen(str2);
491  if (len < 0)
492  return(NULL);
493  }
494  if ((str2 == NULL) || (len == 0))
495  return(xmlStrdup(str1));
496  if (str1 == NULL)
497  return(xmlStrndup(str2, len));
498 
499  size = xmlStrlen(str1);
500  if (size < 0)
501  return(NULL);
502  ret = (xmlChar *) xmlMalloc((size + len + 1) * sizeof(xmlChar));
503  if (ret == NULL) {
505  return(xmlStrndup(str1, size));
506  }
507  memcpy(ret, str1, size * sizeof(xmlChar));
508  memcpy(&ret[size], str2, len * sizeof(xmlChar));
509  ret[size + len] = 0;
510  return(ret);
511 }
512 
525 xmlChar *
526 xmlStrcat(xmlChar *cur, const xmlChar *add) {
527  const xmlChar *p = add;
528 
529  if (add == NULL) return(cur);
530  if (cur == NULL)
531  return(xmlStrdup(add));
532 
533  while (*p != 0) p++; /* non input consuming */
534  return(xmlStrncat(cur, add, p - add));
535 }
536 
548 int XMLCDECL
549 xmlStrPrintf(xmlChar *buf, int len, const char *msg, ...) {
550  va_list args;
551  int ret;
552 
553  if((buf == NULL) || (msg == NULL)) {
554  return(-1);
555  }
556 
557  va_start(args, msg);
558  ret = vsnprintf((char *) buf, len, (const char *) msg, args);
559  va_end(args);
560  buf[len - 1] = 0; /* be safe ! */
561 
562  return(ret);
563 }
564 
576 int
577 xmlStrVPrintf(xmlChar *buf, int len, const char *msg, va_list ap) {
578  int ret;
579 
580  if((buf == NULL) || (msg == NULL)) {
581  return(-1);
582  }
583 
584  ret = vsnprintf((char *) buf, len, (const char *) msg, ap);
585  buf[len - 1] = 0; /* be safe ! */
586 
587  return(ret);
588 }
589 
590 /************************************************************************
591  * *
592  * Generic UTF8 handling routines *
593  * *
594  * From rfc2044: encoding of the Unicode values on UTF-8: *
595  * *
596  * UCS-4 range (hex.) UTF-8 octet sequence (binary) *
597  * 0000 0000-0000 007F 0xxxxxxx *
598  * 0000 0080-0000 07FF 110xxxxx 10xxxxxx *
599  * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx *
600  * *
601  * I hope we won't use values > 0xFFFF anytime soon ! *
602  * *
603  ************************************************************************/
604 
605 
614 int
615 xmlUTF8Size(const xmlChar *utf) {
616  xmlChar mask;
617  int len;
618 
619  if (utf == NULL)
620  return -1;
621  if (*utf < 0x80)
622  return 1;
623  /* check valid UTF8 character */
624  if (!(*utf & 0x40))
625  return -1;
626  /* determine number of bytes in char */
627  len = 2;
628  for (mask=0x20; mask != 0; mask>>=1) {
629  if (!(*utf & mask))
630  return len;
631  len++;
632  }
633  return -1;
634 }
635 
645 int
646 xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2) {
647 
648  if (utf1 == NULL ) {
649  if (utf2 == NULL)
650  return 0;
651  return -1;
652  }
653  return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1));
654 }
655 
665 int
666 xmlUTF8Strlen(const xmlChar *utf) {
667  int ret = 0;
668 
669  if (utf == NULL)
670  return(-1);
671 
672  while (*utf != 0) {
673  if (utf[0] & 0x80) {
674  if ((utf[1] & 0xc0) != 0x80)
675  return(-1);
676  if ((utf[0] & 0xe0) == 0xe0) {
677  if ((utf[2] & 0xc0) != 0x80)
678  return(-1);
679  if ((utf[0] & 0xf0) == 0xf0) {
680  if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
681  return(-1);
682  utf += 4;
683  } else {
684  utf += 3;
685  }
686  } else {
687  utf += 2;
688  }
689  } else {
690  utf++;
691  }
692  ret++;
693  }
694  return(ret);
695 }
696 
709 int
710 xmlGetUTF8Char(const unsigned char *utf, int *len) {
711  unsigned int c;
712 
713  if (utf == NULL)
714  goto error;
715  if (len == NULL)
716  goto error;
717  if (*len < 1)
718  goto error;
719 
720  c = utf[0];
721  if (c & 0x80) {
722  if (*len < 2)
723  goto error;
724  if ((utf[1] & 0xc0) != 0x80)
725  goto error;
726  if ((c & 0xe0) == 0xe0) {
727  if (*len < 3)
728  goto error;
729  if ((utf[2] & 0xc0) != 0x80)
730  goto error;
731  if ((c & 0xf0) == 0xf0) {
732  if (*len < 4)
733  goto error;
734  if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
735  goto error;
736  *len = 4;
737  /* 4-byte code */
738  c = (utf[0] & 0x7) << 18;
739  c |= (utf[1] & 0x3f) << 12;
740  c |= (utf[2] & 0x3f) << 6;
741  c |= utf[3] & 0x3f;
742  } else {
743  /* 3-byte code */
744  *len = 3;
745  c = (utf[0] & 0xf) << 12;
746  c |= (utf[1] & 0x3f) << 6;
747  c |= utf[2] & 0x3f;
748  }
749  } else {
750  /* 2-byte code */
751  *len = 2;
752  c = (utf[0] & 0x1f) << 6;
753  c |= utf[1] & 0x3f;
754  }
755  } else {
756  /* 1-byte code */
757  *len = 1;
758  }
759  return(c);
760 
761 error:
762  if (len != NULL)
763  *len = 0;
764  return(-1);
765 }
766 
780 int
781 xmlCheckUTF8(const unsigned char *utf)
782 {
783  int ix;
784  unsigned char c;
785 
786  if (utf == NULL)
787  return(0);
788  /*
789  * utf is a string of 1, 2, 3 or 4 bytes. The valid strings
790  * are as follows (in "bit format"):
791  * 0xxxxxxx valid 1-byte
792  * 110xxxxx 10xxxxxx valid 2-byte
793  * 1110xxxx 10xxxxxx 10xxxxxx valid 3-byte
794  * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx valid 4-byte
795  */
796  for (ix = 0; (c = utf[ix]);) { /* string is 0-terminated */
797  if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */
798  ix++;
799  } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
800  if ((utf[ix+1] & 0xc0 ) != 0x80)
801  return 0;
802  ix += 2;
803  } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
804  if (((utf[ix+1] & 0xc0) != 0x80) ||
805  ((utf[ix+2] & 0xc0) != 0x80))
806  return 0;
807  ix += 3;
808  } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
809  if (((utf[ix+1] & 0xc0) != 0x80) ||
810  ((utf[ix+2] & 0xc0) != 0x80) ||
811  ((utf[ix+3] & 0xc0) != 0x80))
812  return 0;
813  ix += 4;
814  } else /* unknown encoding */
815  return 0;
816  }
817  return(1);
818 }
819 
832 int
833 xmlUTF8Strsize(const xmlChar *utf, int len) {
834  const xmlChar *ptr=utf;
835  xmlChar ch;
836 
837  if (utf == NULL)
838  return(0);
839 
840  if (len <= 0)
841  return(0);
842 
843  while ( len-- > 0) {
844  if ( !*ptr )
845  break;
846  if ( (ch = *ptr++) & 0x80)
847  while ((ch<<=1) & 0x80 ) {
848  if (*ptr == 0) break;
849  ptr++;
850  }
851  }
852  return (ptr - utf);
853 }
854 
855 
865 xmlChar *
866 xmlUTF8Strndup(const xmlChar *utf, int len) {
867  xmlChar *ret;
868  int i;
869 
870  if ((utf == NULL) || (len < 0)) return(NULL);
871  i = xmlUTF8Strsize(utf, len);
872  ret = (xmlChar *) xmlMallocAtomic((i + 1) * sizeof(xmlChar));
873  if (ret == NULL) {
875  "malloc of %ld byte failed\n",
876  (len + 1) * (long)sizeof(xmlChar));
877  return(NULL);
878  }
879  memcpy(ret, utf, i * sizeof(xmlChar));
880  ret[i] = 0;
881  return(ret);
882 }
883 
894 const xmlChar *
895 xmlUTF8Strpos(const xmlChar *utf, int pos) {
896  xmlChar ch;
897 
898  if (utf == NULL) return(NULL);
899  if (pos < 0)
900  return(NULL);
901  while (pos--) {
902  if ((ch=*utf++) == 0) return(NULL);
903  if ( ch & 0x80 ) {
904  /* if not simple ascii, verify proper format */
905  if ( (ch & 0xc0) != 0xc0 )
906  return(NULL);
907  /* then skip over remaining bytes for this char */
908  while ( (ch <<= 1) & 0x80 )
909  if ( (*utf++ & 0xc0) != 0x80 )
910  return(NULL);
911  }
912  }
913  return((xmlChar *)utf);
914 }
915 
926 int
927 xmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar) {
928  int i, size;
929  xmlChar 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);
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 }
963 xmlChar *
964 xmlUTF8Strsub(const xmlChar *utf, int start, int len) {
965  int i;
966  xmlChar 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 
1000 xmlChar *
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  resultLen = msgLen + count + 1;
1023  result = (xmlChar *) xmlMallocAtomic(resultLen * sizeof(xmlChar));
1024  if (result == NULL) {
1025  /* Clear *msg to prevent format string vulnerabilities in
1026  out-of-memory situations. */
1027  xmlFree(*msg);
1028  *msg = NULL;
1030  return(NULL);
1031  }
1032 
1033  for (msgPtr = *msg, resultPtr = result; *msgPtr != '\0'; ++msgPtr, ++resultPtr) {
1034  *resultPtr = *msgPtr;
1035  if (*msgPtr == '%')
1036  *(++resultPtr) = '%';
1037  }
1038  result[resultLen - 1] = '\0';
1039 
1040  xmlFree(*msg);
1041  *msg = result;
1042 
1043  return *msg;
1044 }
1045 
1046 #define bottom_xmlstring
1047 #include "elfgcchack.h"
int add
Definition: i386-dis.c:3122
int xmlStrncasecmp(const xmlChar *str1, const xmlChar *str2, int len)
Definition: xmlstring.c:296
#define vsnprintf
Definition: tif_win32.c:406
XMLPUBVAR xmlMallocFunc xmlMallocAtomic
Definition: globals.h:248
#define error(str)
Definition: mkdosfs.c:1605
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
xmlChar * xmlStrncatNew(const xmlChar *str1, const xmlChar *str2, int len)
Definition: xmlstring.c:485
GLuint GLuint GLsizei count
Definition: gl.h:1545
xmlChar * xmlUTF8Strsub(const xmlChar *utf, int start, int len)
Definition: xmlstring.c:964
GLdouble n
Definition: glext.h:7729
int xmlCheckUTF8(const unsigned char *utf)
Definition: xmlstring.c:781
static const xmlChar casemap[256]
Definition: xmlstring.c:225
Definition: match.c:390
int xmlGetUTF8Char(const unsigned char *utf, int *len)
Definition: xmlstring.c:710
xmlChar * xmlUTF8Strndup(const xmlChar *utf, int len)
Definition: xmlstring.c:866
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
GLenum GLint GLuint mask
Definition: glext.h:6028
#define va_end(ap)
Definition: acmsvcex.h:90
int xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
int xmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar)
Definition: xmlstring.c:927
const xmlChar * xmlStrcasestr(const xmlChar *str, const xmlChar *val)
Definition: xmlstring.c:369
static PVOID ptr
Definition: dispmode.c:27
xmlChar * xmlStrncat(xmlChar *cur, const xmlChar *add, int len)
Definition: xmlstring.c:448
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
int XMLCDECL xmlStrPrintf(xmlChar *buf, int len, const char *msg,...)
Definition: xmlstring.c:549
int xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:271
char * va_list
Definition: acmsvcex.h:78
const xmlChar * xmlStrchr(const xmlChar *str, xmlChar val)
Definition: xmlstring.c:321
int xmlUTF8Strsize(const xmlChar *utf, int len)
Definition: xmlstring.c:833
XMLPUBVAR xmlReallocFunc xmlRealloc
Definition: globals.h:249
GLuint GLfloat * val
Definition: glext.h:7180
xmlChar * xmlStrcat(xmlChar *cur, const xmlChar *add)
Definition: xmlstring.c:526
GLsizeiptr size
Definition: glext.h:5919
int xmlUTF8Strlen(const xmlChar *utf)
Definition: xmlstring.c:666
void xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra)
xmlChar * xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:41
const GLubyte * c
Definition: glext.h:8905
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
int ret
int xmlStrVPrintf(xmlChar *buf, int len, const char *msg, va_list ap)
Definition: xmlstring.c:577
unsigned char xmlChar
Definition: xmlstring.h:28
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
xmlChar * xmlEscapeFormatString(xmlChar **msg)
Definition: xmlstring.c:1001
int xmlUTF8Size(const xmlChar *utf)
Definition: xmlstring.c:615
GLuint start
Definition: gl.h:1545
int xmlStrlen(const xmlChar *str)
Definition: xmlstring.c:422
const xmlChar * xmlUTF8Strpos(const xmlChar *utf, int pos)
Definition: xmlstring.c:895
#define va_start(ap, A)
Definition: acmsvcex.h:91
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
#define XMLCDECL
Definition: xmlexports.h:49
int xmlStrcmp(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:132
int xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str)
Definition: xmlstring.c:179
#define msg(x)
Definition: auth_time.c:54
xmlChar * xmlCharStrdup(const char *cur)
Definition: xmlstring.c:113
Definition: name.c:38
void int int ULONGLONG int va_list * ap
Definition: winesup.h:32
xmlChar * xmlCharStrndup(const char *cur, int len)
Definition: xmlstring.c:85
#define c
Definition: ke_i.h:80
xmlChar * xmlStrsub(const xmlChar *str, int start, int len)
Definition: xmlstring.c:397
const xmlChar * xmlStrstr(const xmlChar *str, const xmlChar *val)
Definition: xmlstring.c:341
int xmlStrncmp(const xmlChar *str1, const xmlChar *str2, int len)
Definition: xmlstring.c:206
GLfloat GLfloat p
Definition: glext.h:8902
GLuint64EXT * result
Definition: glext.h:11304
#define args
Definition: format.c:66
int xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2)
Definition: xmlstring.c:646
xmlChar * xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:66
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362