Dr Andrew Scott
G7VAV
Senior Lecturer
School of Computing
and Communications
D35 InfoLab21
Lancaster University
Lancaster, LA1 4WA
United Kingdom
School of Computing
and Communications
D35 InfoLab21
Lancaster University
Lancaster, LA1 4WA
United Kingdom
| June 2025 | ||||||
| Mo | Tu | We | Th | Fr | Sa | Su |
| 26 | 27 | 28 | 29 | 30 | 31 | 1 |
| 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| 16 | 17 | 18 | 19 | 20 | 21 | 22 |
| 23 | 24 | 25 | 26 | 27 | 28 | 29 |
| 30 | 1 | 2 | 3 | 4 | 5 | 6 |
string2.h
0001: /* Machine-independant string function optimizations. 0002: Copyright (C) 1997-2003, 2004, 2007, 2008 Free Software Foundation, Inc. 0003: This file is part of the GNU C Library. 0004: Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997. 0005: 0006: The GNU C Library is free software; you can redistribute it and/or 0007: modify it under the terms of the GNU Lesser General Public 0008: License as published by the Free Software Foundation; either 0009: version 2.1 of the License, or (at your option) any later version. 0010: 0011: The GNU C Library is distributed in the hope that it will be useful, 0012: but WITHOUT ANY WARRANTY; without even the implied warranty of 0013: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 0014: Lesser General Public License for more details. 0015: 0016: You should have received a copy of the GNU Lesser General Public 0017: License along with the GNU C Library; if not, write to the Free 0018: Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 0019: 02111-1307 USA. */ 0020: 0021: #ifndef _STRING_H 0022: # error "Never use <bits/string2.h> directly; include <string.h> instead." 0023: #endif 0024: 0025: #if !defined __NO_STRING_INLINES && !defined __BOUNDED_POINTERS__ 0026: 0027: /* Unlike the definitions in the header <bits/string.h> the 0028: definitions contained here are not optimized down to assembler 0029: level. Those optimizations are not always a good idea since this 0030: means the code size increases a lot. Instead the definitions here 0031: optimize some functions in a way which do not dramatically 0032: increase the code size and which do not use assembler. The main 0033: trick is to use GCC's `__builtin_constant_p' function. 0034: 0035: Every function XXX which has a defined version in 0036: <bits/string.h> must be accompanied by a symbol _HAVE_STRING_ARCH_XXX 0037: to make sure we don't get redefinitions. 0038: 0039: We must use here macros instead of inline functions since the 0040: trick won't work with the latter. */ 0041: 0042: #ifndef __STRING_INLINE 0043: # ifdef __cplusplus 0044: # define __STRING_INLINE inline 0045: # else 0046: # define __STRING_INLINE __extern_inline 0047: # endif 0048: #endif 0049: 0050: #if _STRING_ARCH_unaligned 0051: /* If we can do unaligned memory accesses we must know the endianess. */ 0052: # include <endian.h> 0053: # include <bits/types.h> 0054: 0055: # if __BYTE_ORDER == __LITTLE_ENDIAN 0056: # define __STRING2_SMALL_GET16(src, idx) \ 0057: (((__const unsigned char *) (__const char *) (src))[idx + 1] << 8 \ 0058: | ((__const unsigned char *) (__const char *) (src))[idx]) 0059: # define __STRING2_SMALL_GET32(src, idx) \ 0060: (((((__const unsigned char *) (__const char *) (src))[idx + 3] << 8 \ 0061: | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8 \ 0062: | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8 \ 0063: | ((__const unsigned char *) (__const char *) (src))[idx]) 0064: # else 0065: # define __STRING2_SMALL_GET16(src, idx) \ 0066: (((__const unsigned char *) (__const char *) (src))[idx] << 8 \ 0067: | ((__const unsigned char *) (__const char *) (src))[idx + 1]) 0068: # define __STRING2_SMALL_GET32(src, idx) \ 0069: (((((__const unsigned char *) (__const char *) (src))[idx] << 8 \ 0070: | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8 \ 0071: | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8 \ 0072: | ((__const unsigned char *) (__const char *) (src))[idx + 3]) 0073: # endif 0074: #else 0075: /* These are a few types we need for the optimizations if we cannot 0076: use unaligned memory accesses. */ 0077: # define __STRING2_COPY_TYPE(N) \ 0078: typedef struct { unsigned char __arr[N]; } \ 0079: __attribute__ ((__packed__)) __STRING2_COPY_ARR##N 0080: __STRING2_COPY_TYPE (2); 0081: __STRING2_COPY_TYPE (3); 0082: __STRING2_COPY_TYPE (4); 0083: __STRING2_COPY_TYPE (5); 0084: __STRING2_COPY_TYPE (6); 0085: __STRING2_COPY_TYPE (7); 0086: __STRING2_COPY_TYPE (8); 0087: # undef __STRING2_COPY_TYPE 0088: #endif 0089: 0090: /* Dereferencing a pointer arg to run sizeof on it fails for the void 0091: pointer case, so we use this instead. 0092: Note that __x is evaluated twice. */ 0093: #define __string2_1bptr_p(__x) \ 0094: ((size_t)(const void *)((__x) + 1) - (size_t)(const void *)(__x) == 1) 0095: 0096: /* Set N bytes of S to C. */ 0097: #if !defined _HAVE_STRING_ARCH_memset 0098: # if !__GNUC_PREREQ (3, 0) 0099: # if _STRING_ARCH_unaligned 0100: # define memset(s, c, n) \ 0101: (__extension__ (__builtin_constant_p (n) && (n) <= 16 \ 0102: ? ((n) == 1 \ 0103: ? __memset_1 (s, c) \ 0104: : __memset_gc (s, c, n)) \ 0105: : (__builtin_constant_p (c) && (c) == '\0' \ 0106: ? ({ void *__s = (s); __bzero (__s, n); __s; }) \ 0107: : memset (s, c, n)))) 0108: 0109: # define __memset_1(s, c) ({ void *__s = (s); \ 0110: *((__uint8_t *) __s) = (__uint8_t) c; __s; }) 0111: 0112: # define __memset_gc(s, c, n) \ 0113: ({ void *__s = (s); \ 0114: union { \ 0115: unsigned int __ui; \ 0116: unsigned short int __usi; \ 0117: unsigned char __uc; \ 0118: } *__u = __s; \ 0119: __uint8_t __c = (__uint8_t) (c); \ 0120: \ 0121: /* This `switch' statement will be removed at compile-time. */ \ 0122: switch ((unsigned int) (n)) \ 0123: { \ 0124: case 15: \ 0125: __u->__ui = __c * 0x01010101; \ 0126: __u = __extension__ ((void *) __u + 4); \ 0127: case 11: \ 0128: __u->__ui = __c * 0x01010101; \ 0129: __u = __extension__ ((void *) __u + 4); \ 0130: case 7: \ 0131: __u->__ui = __c * 0x01010101; \ 0132: __u = __extension__ ((void *) __u + 4); \ 0133: case 3: \ 0134: __u->__usi = (unsigned short int) __c * 0x0101; \ 0135: __u = __extension__ ((void *) __u + 2); \ 0136: __u->__uc = (unsigned char) __c; \ 0137: break; \ 0138: \ 0139: case 14: \ 0140: __u->__ui = __c * 0x01010101; \ 0141: __u = __extension__ ((void *) __u + 4); \ 0142: case 10: \ 0143: __u->__ui = __c * 0x01010101; \ 0144: __u = __extension__ ((void *) __u + 4); \ 0145: case 6: \ 0146: __u->__ui = __c * 0x01010101; \ 0147: __u = __extension__ ((void *) __u + 4); \ 0148: case 2: \ 0149: __u->__usi = (unsigned short int) __c * 0x0101; \ 0150: break; \ 0151: \ 0152: case 13: \ 0153: __u->__ui = __c * 0x01010101; \ 0154: __u = __extension__ ((void *) __u + 4); \ 0155: case 9: \ 0156: __u->__ui = __c * 0x01010101; \ 0157: __u = __extension__ ((void *) __u + 4); \ 0158: case 5: \ 0159: __u->__ui = __c * 0x01010101; \ 0160: __u = __extension__ ((void *) __u + 4); \ 0161: case 1: \ 0162: __u->__uc = (unsigned char) __c; \ 0163: break; \ 0164: \ 0165: case 16: \ 0166: __u->__ui = __c * 0x01010101; \ 0167: __u = __extension__ ((void *) __u + 4); \ 0168: case 12: \ 0169: __u->__ui = __c * 0x01010101; \ 0170: __u = __extension__ ((void *) __u + 4); \ 0171: case 8: \ 0172: __u->__ui = __c * 0x01010101; \ 0173: __u = __extension__ ((void *) __u + 4); \ 0174: case 4: \ 0175: __u->__ui = __c * 0x01010101; \ 0176: case 0: \ 0177: break; \ 0178: } \ 0179: \ 0180: __s; }) 0181: # else 0182: # define memset(s, c, n) \ 0183: (__extension__ (__builtin_constant_p (c) && (c) == '\0' \ 0184: ? ({ void *__s = (s); __bzero (__s, n); __s; }) \ 0185: : memset (s, c, n))) 0186: # endif 0187: # endif 0188: 0189: /* GCC < 3.0 optimizes memset(s, 0, n) but not bzero(s, n). 0190: The optimization is broken before EGCS 1.1. 0191: GCC 3.0+ has __builtin_bzero as well, but at least till GCC 3.4 0192: if it decides to call the library function, it calls memset 0193: and not bzero. */ 0194: # if __GNUC_PREREQ (2, 91) 0195: # define __bzero(s, n) __builtin_memset (s, '\0', n) 0196: # endif 0197: 0198: #endif 0199: 0200: 0201: /* Copy N bytes from SRC to DEST, returning pointer to byte following the 0202: last copied. */ 0203: #ifdef __USE_GNU 0204: # if !defined _HAVE_STRING_ARCH_mempcpy || defined _FORCE_INLINES 0205: # ifndef _HAVE_STRING_ARCH_mempcpy 0206: # if __GNUC_PREREQ (3, 4) 0207: # define __mempcpy(dest, src, n) __builtin_mempcpy (dest, src, n) 0208: # elif __GNUC_PREREQ (3, 0) 0209: # define __mempcpy(dest, src, n) \ 0210: (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ 0211: && __string2_1bptr_p (src) && n <= 8 \ 0212: ? __builtin_memcpy (dest, src, n) + (n) \ 0213: : __mempcpy (dest, src, n))) 0214: # else 0215: # define __mempcpy(dest, src, n) \ 0216: (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ 0217: && __string2_1bptr_p (src) && n <= 8 \ 0218: ? __mempcpy_small (dest, __mempcpy_args (src), n) \ 0219: : __mempcpy (dest, src, n))) 0220: # endif 0221: /* In glibc we use this function frequently but for namespace reasons 0222: we have to use the name `__mempcpy'. */ 0223: # define mempcpy(dest, src, n) __mempcpy (dest, src, n) 0224: # endif 0225: 0226: # if !__GNUC_PREREQ (3, 0) || defined _FORCE_INLINES 0227: # if _STRING_ARCH_unaligned 0228: # ifndef _FORCE_INLINES 0229: # define __mempcpy_args(src) \ 0230: ((__const char *) (src))[0], ((__const char *) (src))[2], \ 0231: ((__const char *) (src))[4], ((__const char *) (src))[6], \ 0232: __extension__ __STRING2_SMALL_GET16 (src, 0), \ 0233: __extension__ __STRING2_SMALL_GET16 (src, 4), \ 0234: __extension__ __STRING2_SMALL_GET32 (src, 0), \ 0235: __extension__ __STRING2_SMALL_GET32 (src, 4) 0236: # endif 0237: __STRING_INLINE void *__mempcpy_small (void *, char, char, char, char, 0238: __uint16_t, __uint16_t, __uint32_t, 0239: __uint32_t, size_t); 0240: __STRING_INLINE void * 0241: __mempcpy_small (void *__dest1, 0242: char __src0_1, char __src2_1, char __src4_1, char __src6_1, 0243: __uint16_t __src0_2, __uint16_t __src4_2, 0244: __uint32_t __src0_4, __uint32_t __src4_4, 0245: size_t __srclen) 0246: { 0247: union { 0248: __uint32_t __ui; 0249: __uint16_t __usi; 0250: unsigned char __uc; 0251: unsigned char __c; 0252: } *__u = __dest1; 0253: switch ((unsigned int) __srclen) 0254: { 0255: case 1: 0256: __u->__c = __src0_1; 0257: __u = __extension__ ((void *) __u + 1); 0258: break; 0259: case 2: 0260: __u->__usi = __src0_2; 0261: __u = __extension__ ((void *) __u + 2); 0262: break; 0263: case 3: 0264: __u->__usi = __src0_2; 0265: __u = __extension__ ((void *) __u + 2); 0266: __u->__c = __src2_1; 0267: __u = __extension__ ((void *) __u + 1); 0268: break; 0269: case 4: 0270: __u->__ui = __src0_4; 0271: __u = __extension__ ((void *) __u + 4); 0272: break; 0273: case 5: 0274: __u->__ui = __src0_4; 0275: __u = __extension__ ((void *) __u + 4); 0276: __u->__c = __src4_1; 0277: __u = __extension__ ((void *) __u + 1); 0278: break; 0279: case 6: 0280: __u->__ui = __src0_4; 0281: __u = __extension__ ((void *) __u + 4); 0282: __u->__usi = __src4_2; 0283: __u = __extension__ ((void *) __u + 2); 0284: break; 0285: case 7: 0286: __u->__ui = __src0_4; 0287: __u = __extension__ ((void *) __u + 4); 0288: __u->__usi = __src4_2; 0289: __u = __extension__ ((void *) __u + 2); 0290: __u->__c = __src6_1; 0291: __u = __extension__ ((void *) __u + 1); 0292: break; 0293: case 8: 0294: __u->__ui = __src0_4; 0295: __u = __extension__ ((void *) __u + 4); 0296: __u->__ui = __src4_4; 0297: __u = __extension__ ((void *) __u + 4); 0298: break; 0299: } 0300: return (void *) __u; 0301: } 0302: # else 0303: # ifndef _FORCE_INLINES 0304: # define __mempcpy_args(src) \ 0305: ((__const char *) (src))[0], \ 0306: __extension__ ((__STRING2_COPY_ARR2) \ 0307: { { ((__const char *) (src))[0], ((__const char *) (src))[1] } }), \ 0308: __extension__ ((__STRING2_COPY_ARR3) \ 0309: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0310: ((__const char *) (src))[2] } }), \ 0311: __extension__ ((__STRING2_COPY_ARR4) \ 0312: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0313: ((__const char *) (src))[2], ((__const char *) (src))[3] } }), \ 0314: __extension__ ((__STRING2_COPY_ARR5) \ 0315: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0316: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0317: ((__const char *) (src))[4] } }), \ 0318: __extension__ ((__STRING2_COPY_ARR6) \ 0319: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0320: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0321: ((__const char *) (src))[4], ((__const char *) (src))[5] } }), \ 0322: __extension__ ((__STRING2_COPY_ARR7) \ 0323: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0324: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0325: ((__const char *) (src))[4], ((__const char *) (src))[5], \ 0326: ((__const char *) (src))[6] } }), \ 0327: __extension__ ((__STRING2_COPY_ARR8) \ 0328: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0329: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0330: ((__const char *) (src))[4], ((__const char *) (src))[5], \ 0331: ((__const char *) (src))[6], ((__const char *) (src))[7] } }) 0332: # endif 0333: __STRING_INLINE void *__mempcpy_small (void *, char, __STRING2_COPY_ARR2, 0334: __STRING2_COPY_ARR3, 0335: __STRING2_COPY_ARR4, 0336: __STRING2_COPY_ARR5, 0337: __STRING2_COPY_ARR6, 0338: __STRING2_COPY_ARR7, 0339: __STRING2_COPY_ARR8, size_t); 0340: __STRING_INLINE void * 0341: __mempcpy_small (void *__dest, char __src1, 0342: __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, 0343: __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, 0344: __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, 0345: __STRING2_COPY_ARR8 __src8, size_t __srclen) 0346: { 0347: union { 0348: char __c; 0349: __STRING2_COPY_ARR2 __sca2; 0350: __STRING2_COPY_ARR3 __sca3; 0351: __STRING2_COPY_ARR4 __sca4; 0352: __STRING2_COPY_ARR5 __sca5; 0353: __STRING2_COPY_ARR6 __sca6; 0354: __STRING2_COPY_ARR7 __sca7; 0355: __STRING2_COPY_ARR8 __sca8; 0356: } *__u = __dest; 0357: switch ((unsigned int) __srclen) 0358: { 0359: case 1: 0360: __u->__c = __src1; 0361: break; 0362: case 2: 0363: __extension__ __u->__sca2 = __src2; 0364: break; 0365: case 3: 0366: __extension__ __u->__sca3 = __src3; 0367: break; 0368: case 4: 0369: __extension__ __u->__sca4 = __src4; 0370: break; 0371: case 5: 0372: __extension__ __u->__sca5 = __src5; 0373: break; 0374: case 6: 0375: __extension__ __u->__sca6 = __src6; 0376: break; 0377: case 7: 0378: __extension__ __u->__sca7 = __src7; 0379: break; 0380: case 8: 0381: __extension__ __u->__sca8 = __src8; 0382: break; 0383: } 0384: return __extension__ ((void *) __u + __srclen); 0385: } 0386: # endif 0387: # endif 0388: # endif 0389: #endif 0390: 0391: 0392: /* Return pointer to C in S. */ 0393: #ifndef _HAVE_STRING_ARCH_strchr 0394: extern void *__rawmemchr (const void *__s, int __c); 0395: # if __GNUC_PREREQ (3, 2) 0396: # define strchr(s, c) \ 0397: (__extension__ (__builtin_constant_p (c) && !__builtin_constant_p (s) \ 0398: && (c) == '\0' \ 0399: ? (char *) __rawmemchr (s, c) \ 0400: : __builtin_strchr (s, c))) 0401: # else 0402: # define strchr(s, c) \ 0403: (__extension__ (__builtin_constant_p (c) && (c) == '\0' \ 0404: ? (char *) __rawmemchr (s, c) \ 0405: : strchr (s, c))) 0406: # endif 0407: #endif 0408: 0409: 0410: /* Copy SRC to DEST. */ 0411: #if (!defined _HAVE_STRING_ARCH_strcpy && !__GNUC_PREREQ (3, 0)) \ 0412: || defined _FORCE_INLINES 0413: # if !defined _HAVE_STRING_ARCH_strcpy && !__GNUC_PREREQ (3, 0) 0414: # define strcpy(dest, src) \ 0415: (__extension__ (__builtin_constant_p (src) \ 0416: ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ 0417: ? __strcpy_small (dest, __strcpy_args (src), \ 0418: strlen (src) + 1) \ 0419: : (char *) memcpy (dest, src, strlen (src) + 1)) \ 0420: : strcpy (dest, src))) 0421: # endif 0422: 0423: # if _STRING_ARCH_unaligned 0424: # ifndef _FORCE_INLINES 0425: # define __strcpy_args(src) \ 0426: __extension__ __STRING2_SMALL_GET16 (src, 0), \ 0427: __extension__ __STRING2_SMALL_GET16 (src, 4), \ 0428: __extension__ __STRING2_SMALL_GET32 (src, 0), \ 0429: __extension__ __STRING2_SMALL_GET32 (src, 4) 0430: # endif 0431: __STRING_INLINE char *__strcpy_small (char *, __uint16_t, __uint16_t, 0432: __uint32_t, __uint32_t, size_t); 0433: __STRING_INLINE char * 0434: __strcpy_small (char *__dest, 0435: __uint16_t __src0_2, __uint16_t __src4_2, 0436: __uint32_t __src0_4, __uint32_t __src4_4, 0437: size_t __srclen) 0438: { 0439: union { 0440: __uint32_t __ui; 0441: __uint16_t __usi; 0442: unsigned char __uc; 0443: } *__u = (void *) __dest; 0444: switch ((unsigned int) __srclen) 0445: { 0446: case 1: 0447: __u->__uc = '\0'; 0448: break; 0449: case 2: 0450: __u->__usi = __src0_2; 0451: break; 0452: case 3: 0453: __u->__usi = __src0_2; 0454: __u = __extension__ ((void *) __u + 2); 0455: __u->__uc = '\0'; 0456: break; 0457: case 4: 0458: __u->__ui = __src0_4; 0459: break; 0460: case 5: 0461: __u->__ui = __src0_4; 0462: __u = __extension__ ((void *) __u + 4); 0463: __u->__uc = '\0'; 0464: break; 0465: case 6: 0466: __u->__ui = __src0_4; 0467: __u = __extension__ ((void *) __u + 4); 0468: __u->__usi = __src4_2; 0469: break; 0470: case 7: 0471: __u->__ui = __src0_4; 0472: __u = __extension__ ((void *) __u + 4); 0473: __u->__usi = __src4_2; 0474: __u = __extension__ ((void *) __u + 2); 0475: __u->__uc = '\0'; 0476: break; 0477: case 8: 0478: __u->__ui = __src0_4; 0479: __u = __extension__ ((void *) __u + 4); 0480: __u->__ui = __src4_4; 0481: break; 0482: } 0483: return __dest; 0484: } 0485: # else 0486: # ifndef _FORCE_INLINES 0487: # define __strcpy_args(src) \ 0488: __extension__ ((__STRING2_COPY_ARR2) \ 0489: { { ((__const char *) (src))[0], '\0' } }), \ 0490: __extension__ ((__STRING2_COPY_ARR3) \ 0491: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0492: '\0' } }), \ 0493: __extension__ ((__STRING2_COPY_ARR4) \ 0494: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0495: ((__const char *) (src))[2], '\0' } }), \ 0496: __extension__ ((__STRING2_COPY_ARR5) \ 0497: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0498: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0499: '\0' } }), \ 0500: __extension__ ((__STRING2_COPY_ARR6) \ 0501: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0502: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0503: ((__const char *) (src))[4], '\0' } }), \ 0504: __extension__ ((__STRING2_COPY_ARR7) \ 0505: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0506: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0507: ((__const char *) (src))[4], ((__const char *) (src))[5], \ 0508: '\0' } }), \ 0509: __extension__ ((__STRING2_COPY_ARR8) \ 0510: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0511: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0512: ((__const char *) (src))[4], ((__const char *) (src))[5], \ 0513: ((__const char *) (src))[6], '\0' } }) 0514: # endif 0515: __STRING_INLINE char *__strcpy_small (char *, __STRING2_COPY_ARR2, 0516: __STRING2_COPY_ARR3, 0517: __STRING2_COPY_ARR4, 0518: __STRING2_COPY_ARR5, 0519: __STRING2_COPY_ARR6, 0520: __STRING2_COPY_ARR7, 0521: __STRING2_COPY_ARR8, size_t); 0522: __STRING_INLINE char * 0523: __strcpy_small (char *__dest, 0524: __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, 0525: __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, 0526: __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, 0527: __STRING2_COPY_ARR8 __src8, size_t __srclen) 0528: { 0529: union { 0530: char __c; 0531: __STRING2_COPY_ARR2 __sca2; 0532: __STRING2_COPY_ARR3 __sca3; 0533: __STRING2_COPY_ARR4 __sca4; 0534: __STRING2_COPY_ARR5 __sca5; 0535: __STRING2_COPY_ARR6 __sca6; 0536: __STRING2_COPY_ARR7 __sca7; 0537: __STRING2_COPY_ARR8 __sca8; 0538: } *__u = (void *) __dest; 0539: switch ((unsigned int) __srclen) 0540: { 0541: case 1: 0542: __u->__c = '\0'; 0543: break; 0544: case 2: 0545: __extension__ __u->__sca2 = __src2; 0546: break; 0547: case 3: 0548: __extension__ __u->__sca3 = __src3; 0549: break; 0550: case 4: 0551: __extension__ __u->__sca4 = __src4; 0552: break; 0553: case 5: 0554: __extension__ __u->__sca5 = __src5; 0555: break; 0556: case 6: 0557: __extension__ __u->__sca6 = __src6; 0558: break; 0559: case 7: 0560: __extension__ __u->__sca7 = __src7; 0561: break; 0562: case 8: 0563: __extension__ __u->__sca8 = __src8; 0564: break; 0565: } 0566: return __dest; 0567: } 0568: # endif 0569: #endif 0570: 0571: 0572: /* Copy SRC to DEST, returning pointer to final NUL byte. */ 0573: #ifdef __USE_GNU 0574: # if !defined _HAVE_STRING_ARCH_stpcpy || defined _FORCE_INLINES 0575: # ifndef _HAVE_STRING_ARCH_stpcpy 0576: # if __GNUC_PREREQ (3, 4) 0577: # define __stpcpy(dest, src) __builtin_stpcpy (dest, src) 0578: # elif __GNUC_PREREQ (3, 0) 0579: # define __stpcpy(dest, src) \ 0580: (__extension__ (__builtin_constant_p (src) \ 0581: ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ 0582: ? __builtin_strcpy (dest, src) + strlen (src) \ 0583: : ((char *) (__mempcpy) (dest, src, strlen (src) + 1) \ 0584: - 1)) \ 0585: : __stpcpy (dest, src))) 0586: # else 0587: # define __stpcpy(dest, src) \ 0588: (__extension__ (__builtin_constant_p (src) \ 0589: ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ 0590: ? __stpcpy_small (dest, __stpcpy_args (src), \ 0591: strlen (src) + 1) \ 0592: : ((char *) (__mempcpy) (dest, src, strlen (src) + 1) \ 0593: - 1)) \ 0594: : __stpcpy (dest, src))) 0595: # endif 0596: /* In glibc we use this function frequently but for namespace reasons 0597: we have to use the name `__stpcpy'. */ 0598: # define stpcpy(dest, src) __stpcpy (dest, src) 0599: # endif 0600: 0601: # if !__GNUC_PREREQ (3, 0) || defined _FORCE_INLINES 0602: # if _STRING_ARCH_unaligned 0603: # ifndef _FORCE_INLINES 0604: # define __stpcpy_args(src) \ 0605: __extension__ __STRING2_SMALL_GET16 (src, 0), \ 0606: __extension__ __STRING2_SMALL_GET16 (src, 4), \ 0607: __extension__ __STRING2_SMALL_GET32 (src, 0), \ 0608: __extension__ __STRING2_SMALL_GET32 (src, 4) 0609: # endif 0610: __STRING_INLINE char *__stpcpy_small (char *, __uint16_t, __uint16_t, 0611: __uint32_t, __uint32_t, size_t); 0612: __STRING_INLINE char * 0613: __stpcpy_small (char *__dest, 0614: __uint16_t __src0_2, __uint16_t __src4_2, 0615: __uint32_t __src0_4, __uint32_t __src4_4, 0616: size_t __srclen) 0617: { 0618: union { 0619: unsigned int __ui; 0620: unsigned short int __usi; 0621: unsigned char __uc; 0622: char __c; 0623: } *__u = (void *) __dest; 0624: switch ((unsigned int) __srclen) 0625: { 0626: case 1: 0627: __u->__uc = '\0'; 0628: break; 0629: case 2: 0630: __u->__usi = __src0_2; 0631: __u = __extension__ ((void *) __u + 1); 0632: break; 0633: case 3: 0634: __u->__usi = __src0_2; 0635: __u = __extension__ ((void *) __u + 2); 0636: __u->__uc = '\0'; 0637: break; 0638: case 4: 0639: __u->__ui = __src0_4; 0640: __u = __extension__ ((void *) __u + 3); 0641: break; 0642: case 5: 0643: __u->__ui = __src0_4; 0644: __u = __extension__ ((void *) __u + 4); 0645: __u->__uc = '\0'; 0646: break; 0647: case 6: 0648: __u->__ui = __src0_4; 0649: __u = __extension__ ((void *) __u + 4); 0650: __u->__usi = __src4_2; 0651: __u = __extension__ ((void *) __u + 1); 0652: break; 0653: case 7: 0654: __u->__ui = __src0_4; 0655: __u = __extension__ ((void *) __u + 4); 0656: __u->__usi = __src4_2; 0657: __u = __extension__ ((void *) __u + 2); 0658: __u->__uc = '\0'; 0659: break; 0660: case 8: 0661: __u->__ui = __src0_4; 0662: __u = __extension__ ((void *) __u + 4); 0663: __u->__ui = __src4_4; 0664: __u = __extension__ ((void *) __u + 3); 0665: break; 0666: } 0667: return &__u->__c; 0668: } 0669: # else 0670: # ifndef _FORCE_INLINES 0671: # define __stpcpy_args(src) \ 0672: __extension__ ((__STRING2_COPY_ARR2) \ 0673: { { ((__const char *) (src))[0], '\0' } }), \ 0674: __extension__ ((__STRING2_COPY_ARR3) \ 0675: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0676: '\0' } }), \ 0677: __extension__ ((__STRING2_COPY_ARR4) \ 0678: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0679: ((__const char *) (src))[2], '\0' } }), \ 0680: __extension__ ((__STRING2_COPY_ARR5) \ 0681: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0682: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0683: '\0' } }), \ 0684: __extension__ ((__STRING2_COPY_ARR6) \ 0685: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0686: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0687: ((__const char *) (src))[4], '\0' } }), \ 0688: __extension__ ((__STRING2_COPY_ARR7) \ 0689: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0690: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0691: ((__const char *) (src))[4], ((__const char *) (src))[5], \ 0692: '\0' } }), \ 0693: __extension__ ((__STRING2_COPY_ARR8) \ 0694: { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 0695: ((__const char *) (src))[2], ((__const char *) (src))[3], \ 0696: ((__const char *) (src))[4], ((__const char *) (src))[5], \ 0697: ((__const char *) (src))[6], '\0' } }) 0698: # endif 0699: __STRING_INLINE char *__stpcpy_small (char *, __STRING2_COPY_ARR2, 0700: __STRING2_COPY_ARR3, 0701: __STRING2_COPY_ARR4, 0702: __STRING2_COPY_ARR5, 0703: __STRING2_COPY_ARR6, 0704: __STRING2_COPY_ARR7, 0705: __STRING2_COPY_ARR8, size_t); 0706: __STRING_INLINE char * 0707: __stpcpy_small (char *__dest, 0708: __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, 0709: __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, 0710: __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, 0711: __STRING2_COPY_ARR8 __src8, size_t __srclen) 0712: { 0713: union { 0714: char __c; 0715: __STRING2_COPY_ARR2 __sca2; 0716: __STRING2_COPY_ARR3 __sca3; 0717: __STRING2_COPY_ARR4 __sca4; 0718: __STRING2_COPY_ARR5 __sca5; 0719: __STRING2_COPY_ARR6 __sca6; 0720: __STRING2_COPY_ARR7 __sca7; 0721: __STRING2_COPY_ARR8 __sca8; 0722: } *__u = (void *) __dest; 0723: switch ((unsigned int) __srclen) 0724: { 0725: case 1: 0726: __u->__c = '\0'; 0727: break; 0728: case 2: 0729: __extension__ __u->__sca2 = __src2; 0730: break; 0731: case 3: 0732: __extension__ __u->__sca3 = __src3; 0733: break; 0734: case 4: 0735: __extension__ __u->__sca4 = __src4; 0736: break; 0737: case 5: 0738: __extension__ __u->__sca5 = __src5; 0739: break; 0740: case 6: 0741: __extension__ __u->__sca6 = __src6; 0742: break; 0743: case 7: 0744: __extension__ __u->__sca7 = __src7; 0745: break; 0746: case 8: 0747: __extension__ __u->__sca8 = __src8; 0748: break; 0749: } 0750: return __dest + __srclen - 1; 0751: } 0752: # endif 0753: # endif 0754: # endif 0755: #endif 0756: 0757: 0758: /* Copy no more than N characters of SRC to DEST. */ 0759: #ifndef _HAVE_STRING_ARCH_strncpy 0760: # if __GNUC_PREREQ (3, 2) 0761: # define strncpy(dest, src, n) __builtin_strncpy (dest, src, n) 0762: # else 0763: # define strncpy(dest, src, n) \ 0764: (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ 0765: ? (strlen (src) + 1 >= ((size_t) (n)) \ 0766: ? (char *) memcpy (dest, src, n) \ 0767: : strncpy (dest, src, n)) \ 0768: : strncpy (dest, src, n))) 0769: # endif 0770: #endif 0771: 0772: 0773: /* Append no more than N characters from SRC onto DEST. */ 0774: #ifndef _HAVE_STRING_ARCH_strncat 0775: # ifdef _USE_STRING_ARCH_strchr 0776: # define strncat(dest, src, n) \ 0777: (__extension__ ({ char *__dest = (dest); \ 0778: __builtin_constant_p (src) && __builtin_constant_p (n) \ 0779: ? (strlen (src) < ((size_t) (n)) \ 0780: ? strcat (__dest, src) \ 0781: : (*((char *) __mempcpy (strchr (__dest, '\0'), \ 0782: src, n)) = '\0', __dest)) \ 0783: : strncat (dest, src, n); })) 0784: # elif __GNUC_PREREQ (3, 2) 0785: # define strncat(dest, src, n) __builtin_strncat (dest, src, n) 0786: # else 0787: # define strncat(dest, src, n) \ 0788: (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ 0789: ? (strlen (src) < ((size_t) (n)) \ 0790: ? strcat (dest, src) \ 0791: : strncat (dest, src, n)) \ 0792: : strncat (dest, src, n))) 0793: # endif 0794: #endif 0795: 0796: 0797: /* Compare characters of S1 and S2. */ 0798: #ifndef _HAVE_STRING_ARCH_strcmp 0799: # if __GNUC_PREREQ (3, 2) 0800: # define strcmp(s1, s2) \ 0801: __extension__ \ 0802: ({ size_t __s1_len, __s2_len; \ 0803: (__builtin_constant_p (s1) && __builtin_constant_p (s2) \ 0804: && (__s1_len = __builtin_strlen (s1), __s2_len = __builtin_strlen (s2), \ 0805: (!__string2_1bptr_p (s1) || __s1_len >= 4) \ 0806: && (!__string2_1bptr_p (s2) || __s2_len >= 4)) \ 0807: ? __builtin_strcmp (s1, s2) \ 0808: : (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ 0809: && (__s1_len = __builtin_strlen (s1), __s1_len < 4) \ 0810: ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ 0811: ? __builtin_strcmp (s1, s2) \ 0812: : __strcmp_cg (s1, s2, __s1_len)) \ 0813: : (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ 0814: && (__s2_len = __builtin_strlen (s2), __s2_len < 4) \ 0815: ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ 0816: ? __builtin_strcmp (s1, s2) \ 0817: : __strcmp_gc (s1, s2, __s2_len)) \ 0818: : __builtin_strcmp (s1, s2)))); }) 0819: # else 0820: # define strcmp(s1, s2) \ 0821: __extension__ \ 0822: ({ size_t __s1_len, __s2_len; \ 0823: (__builtin_constant_p (s1) && __builtin_constant_p (s2) \ 0824: && (__s1_len = strlen (s1), __s2_len = strlen (s2), \ 0825: (!__string2_1bptr_p (s1) || __s1_len >= 4) \ 0826: && (!__string2_1bptr_p (s2) || __s2_len >= 4)) \ 0827: ? memcmp ((__const char *) (s1), (__const char *) (s2), \ 0828: (__s1_len < __s2_len ? __s1_len : __s2_len) + 1) \ 0829: : (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ 0830: && (__s1_len = strlen (s1), __s1_len < 4) \ 0831: ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ 0832: ? __strcmp_cc (s1, s2, __s1_len) \ 0833: : __strcmp_cg (s1, s2, __s1_len)) \ 0834: : (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ 0835: && (__s2_len = strlen (s2), __s2_len < 4) \ 0836: ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ 0837: ? __strcmp_cc (s1, s2, __s2_len) \ 0838: : __strcmp_gc (s1, s2, __s2_len)) \ 0839: : strcmp (s1, s2)))); }) 0840: # endif 0841: 0842: # define __strcmp_cc(s1, s2, l) \ 0843: (__extension__ ({ register int __result = \ 0844: (((__const unsigned char *) (__const char *) (s1))[0] \ 0845: - ((__const unsigned char *) (__const char *)(s2))[0]);\ 0846: if (l > 0 && __result == 0) \ 0847: { \ 0848: __result = (((__const unsigned char *) \ 0849: (__const char *) (s1))[1] \ 0850: - ((__const unsigned char *) \ 0851: (__const char *) (s2))[1]); \ 0852: if (l > 1 && __result == 0) \ 0853: { \ 0854: __result = \ 0855: (((__const unsigned char *) \ 0856: (__const char *) (s1))[2] \ 0857: - ((__const unsigned char *) \ 0858: (__const char *) (s2))[2]); \ 0859: if (l > 2 && __result == 0) \ 0860: __result = \ 0861: (((__const unsigned char *) \ 0862: (__const char *) (s1))[3] \ 0863: - ((__const unsigned char *) \ 0864: (__const char *) (s2))[3]); \ 0865: } \ 0866: } \ 0867: __result; })) 0868: 0869: # define __strcmp_cg(s1, s2, l1) \ 0870: (__extension__ ({ __const unsigned char *__s2 = \ 0871: (__const unsigned char *) (__const char *) (s2); \ 0872: register int __result = \ 0873: (((__const unsigned char *) (__const char *) (s1))[0] \ 0874: - __s2[0]); \ 0875: if (l1 > 0 && __result == 0) \ 0876: { \ 0877: __result = (((__const unsigned char *) \ 0878: (__const char *) (s1))[1] - __s2[1]); \ 0879: if (l1 > 1 && __result == 0) \ 0880: { \ 0881: __result = (((__const unsigned char *) \ 0882: (__const char *) (s1))[2] - __s2[2]);\ 0883: if (l1 > 2 && __result == 0) \ 0884: __result = (((__const unsigned char *) \ 0885: (__const char *) (s1))[3] \ 0886: - __s2[3]); \ 0887: } \ 0888: } \ 0889: __result; })) 0890: 0891: # define __strcmp_gc(s1, s2, l2) \ 0892: (__extension__ ({ __const unsigned char *__s1 = \ 0893: (__const unsigned char *) (__const char *) (s1); \ 0894: register int __result = \ 0895: __s1[0] - ((__const unsigned char *) \ 0896: (__const char *) (s2))[0]; \ 0897: if (l2 > 0 && __result == 0) \ 0898: { \ 0899: __result = (__s1[1] \ 0900: - ((__const unsigned char *) \ 0901: (__const char *) (s2))[1]); \ 0902: if (l2 > 1 && __result == 0) \ 0903: { \ 0904: __result = \ 0905: (__s1[2] - ((__const unsigned char *) \ 0906: (__const char *) (s2))[2]); \ 0907: if (l2 > 2 && __result == 0) \ 0908: __result = \ 0909: (__s1[3] \ 0910: - ((__const unsigned char *) \ 0911: (__const char *) (s2))[3]); \ 0912: } \ 0913: } \ 0914: __result; })) 0915: #endif 0916: 0917: 0918: /* Compare N characters of S1 and S2. */ 0919: #ifndef _HAVE_STRING_ARCH_strncmp 0920: # define strncmp(s1, s2, n) \ 0921: (__extension__ (__builtin_constant_p (n) \ 0922: && ((__builtin_constant_p (s1) \ 0923: && strlen (s1) < ((size_t) (n))) \ 0924: || (__builtin_constant_p (s2) \ 0925: && strlen (s2) < ((size_t) (n)))) \ 0926: ? strcmp (s1, s2) : strncmp (s1, s2, n))) 0927: #endif 0928: 0929: 0930: /* Return the length of the initial segment of S which 0931: consists entirely of characters not in REJECT. */ 0932: #if !defined _HAVE_STRING_ARCH_strcspn || defined _FORCE_INLINES 0933: # ifndef _HAVE_STRING_ARCH_strcspn 0934: # if __GNUC_PREREQ (3, 2) 0935: # define strcspn(s, reject) \ 0936: __extension__ \ 0937: ({ char __r0, __r1, __r2; \ 0938: (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ 0939: ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ 0940: ? __builtin_strcspn (s, reject) \ 0941: : ((__r0 = ((__const char *) (reject))[0], __r0 == '\0') \ 0942: ? strlen (s) \ 0943: : ((__r1 = ((__const char *) (reject))[1], __r1 == '\0') \ 0944: ? __strcspn_c1 (s, __r0) \ 0945: : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0') \ 0946: ? __strcspn_c2 (s, __r0, __r1) \ 0947: : (((__const char *) (reject))[3] == '\0' \ 0948: ? __strcspn_c3 (s, __r0, __r1, __r2) \ 0949: : __builtin_strcspn (s, reject)))))) \ 0950: : __builtin_strcspn (s, reject)); }) 0951: # else 0952: # define strcspn(s, reject) \ 0953: __extension__ \ 0954: ({ char __r0, __r1, __r2; \ 0955: (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ 0956: ? ((__r0 = ((__const char *) (reject))[0], __r0 == '\0') \ 0957: ? strlen (s) \ 0958: : ((__r1 = ((__const char *) (reject))[1], __r1 == '\0') \ 0959: ? __strcspn_c1 (s, __r0) \ 0960: : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0') \ 0961: ? __strcspn_c2 (s, __r0, __r1) \ 0962: : (((__const char *) (reject))[3] == '\0' \ 0963: ? __strcspn_c3 (s, __r0, __r1, __r2) \ 0964: : strcspn (s, reject))))) \ 0965: : strcspn (s, reject)); }) 0966: # endif 0967: # endif 0968: 0969: __STRING_INLINE size_t __strcspn_c1 (__const char *__s, int __reject); 0970: __STRING_INLINE size_t 0971: __strcspn_c1 (__const char *__s, int __reject) 0972: { 0973: register size_t __result = 0; 0974: while (__s[__result] != '\0' && __s[__result] != __reject) 0975: ++__result; 0976: return __result; 0977: } 0978: 0979: __STRING_INLINE size_t __strcspn_c2 (__const char *__s, int __reject1, 0980: int __reject2); 0981: __STRING_INLINE size_t 0982: __strcspn_c2 (__const char *__s, int __reject1, int __reject2) 0983: { 0984: register size_t __result = 0; 0985: while (__s[__result] != '\0' && __s[__result] != __reject1 0986: && __s[__result] != __reject2) 0987: ++__result; 0988: return __result; 0989: } 0990: 0991: __STRING_INLINE size_t __strcspn_c3 (__const char *__s, int __reject1, 0992: int __reject2, int __reject3); 0993: __STRING_INLINE size_t 0994: __strcspn_c3 (__const char *__s, int __reject1, int __reject2, 0995: int __reject3) 0996: { 0997: register size_t __result = 0; 0998: while (__s[__result] != '\0' && __s[__result] != __reject1 0999: && __s[__result] != __reject2 && __s[__result] != __reject3) 1000: ++__result; 1001: return __result; 1002: } 1003: #endif 1004: 1005: 1006: /* Return the length of the initial segment of S which 1007: consists entirely of characters in ACCEPT. */ 1008: #if !defined _HAVE_STRING_ARCH_strspn || defined _FORCE_INLINES 1009: # ifndef _HAVE_STRING_ARCH_strspn 1010: # if __GNUC_PREREQ (3, 2) 1011: # define strspn(s, accept) \ 1012: __extension__ \ 1013: ({ char __a0, __a1, __a2; \ 1014: (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ 1015: ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ 1016: ? __builtin_strspn (s, accept) \ 1017: : ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') \ 1018: ? ((void) (s), 0) \ 1019: : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') \ 1020: ? __strspn_c1 (s, __a0) \ 1021: : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') \ 1022: ? __strspn_c2 (s, __a0, __a1) \ 1023: : (((__const char *) (accept))[3] == '\0' \ 1024: ? __strspn_c3 (s, __a0, __a1, __a2) \ 1025: : __builtin_strspn (s, accept)))))) \ 1026: : __builtin_strspn (s, accept)); }) 1027: # else 1028: # define strspn(s, accept) \ 1029: __extension__ \ 1030: ({ char __a0, __a1, __a2; \ 1031: (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ 1032: ? ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') \ 1033: ? ((void) (s), 0) \ 1034: : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') \ 1035: ? __strspn_c1 (s, __a0) \ 1036: : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') \ 1037: ? __strspn_c2 (s, __a0, __a1) \ 1038: : (((__const char *) (accept))[3] == '\0' \ 1039: ? __strspn_c3 (s, __a0, __a1, __a2) \ 1040: : strspn (s, accept))))) \ 1041: : strspn (s, accept)); }) 1042: # endif 1043: # endif 1044: 1045: __STRING_INLINE size_t __strspn_c1 (__const char *__s, int __accept); 1046: __STRING_INLINE size_t 1047: __strspn_c1 (__const char *__s, int __accept) 1048: { 1049: register size_t __result = 0; 1050: /* Please note that __accept never can be '\0'. */ 1051: while (__s[__result] == __accept) 1052: ++__result; 1053: return __result; 1054: } 1055: 1056: __STRING_INLINE size_t __strspn_c2 (__const char *__s, int __accept1, 1057: int __accept2); 1058: __STRING_INLINE size_t 1059: __strspn_c2 (__const char *__s, int __accept1, int __accept2) 1060: { 1061: register size_t __result = 0; 1062: /* Please note that __accept1 and __accept2 never can be '\0'. */ 1063: while (__s[__result] == __accept1 || __s[__result] == __accept2) 1064: ++__result; 1065: return __result; 1066: } 1067: 1068: __STRING_INLINE size_t __strspn_c3 (__const char *__s, int __accept1, 1069: int __accept2, int __accept3); 1070: __STRING_INLINE size_t 1071: __strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3) 1072: { 1073: register size_t __result = 0; 1074: /* Please note that __accept1 to __accept3 never can be '\0'. */ 1075: while (__s[__result] == __accept1 || __s[__result] == __accept2 1076: || __s[__result] == __accept3) 1077: ++__result; 1078: return __result; 1079: } 1080: #endif 1081: 1082: 1083: /* Find the first occurrence in S of any character in ACCEPT. */ 1084: #if !defined _HAVE_STRING_ARCH_strpbrk || defined _FORCE_INLINES 1085: # ifndef _HAVE_STRING_ARCH_strpbrk 1086: # if __GNUC_PREREQ (3, 2) 1087: # define strpbrk(s, accept) \ 1088: __extension__ \ 1089: ({ char __a0, __a1, __a2; \ 1090: (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ 1091: ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ 1092: ? __builtin_strpbrk (s, accept) \ 1093: : ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') \ 1094: ? ((void) (s), (char *) NULL) \ 1095: : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') \ 1096: ? __builtin_strchr (s, __a0) \ 1097: : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') \ 1098: ? __strpbrk_c2 (s, __a0, __a1) \ 1099: : (((__const char *) (accept))[3] == '\0' \ 1100: ? __strpbrk_c3 (s, __a0, __a1, __a2) \ 1101: : __builtin_strpbrk (s, accept)))))) \ 1102: : __builtin_strpbrk (s, accept)); }) 1103: # else 1104: # define strpbrk(s, accept) \ 1105: __extension__ \ 1106: ({ char __a0, __a1, __a2; \ 1107: (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ 1108: ? ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') \ 1109: ? ((void) (s), (char *) NULL) \ 1110: : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') \ 1111: ? strchr (s, __a0) \ 1112: : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') \ 1113: ? __strpbrk_c2 (s, __a0, __a1) \ 1114: : (((__const char *) (accept))[3] == '\0' \ 1115: ? __strpbrk_c3 (s, __a0, __a1, __a2) \ 1116: : strpbrk (s, accept))))) \ 1117: : strpbrk (s, accept)); }) 1118: # endif 1119: # endif 1120: 1121: __STRING_INLINE char *__strpbrk_c2 (__const char *__s, int __accept1, 1122: int __accept2); 1123: __STRING_INLINE char * 1124: __strpbrk_c2 (__const char *__s, int __accept1, int __accept2) 1125: { 1126: /* Please note that __accept1 and __accept2 never can be '\0'. */ 1127: while (*__s != '\0' && *__s != __accept1 && *__s != __accept2) 1128: ++__s; 1129: return *__s == '\0' ? NULL : (char *) (size_t) __s; 1130: } 1131: 1132: __STRING_INLINE char *__strpbrk_c3 (__const char *__s, int __accept1, 1133: int __accept2, int __accept3); 1134: __STRING_INLINE char * 1135: __strpbrk_c3 (__const char *__s, int __accept1, int __accept2, 1136: int __accept3) 1137: { 1138: /* Please note that __accept1 to __accept3 never can be '\0'. */ 1139: while (*__s != '\0' && *__s != __accept1 && *__s != __accept2 1140: && *__s != __accept3) 1141: ++__s; 1142: return *__s == '\0' ? NULL : (char *) (size_t) __s; 1143: } 1144: #endif 1145: 1146: 1147: /* Find the first occurrence of NEEDLE in HAYSTACK. Newer gcc versions 1148: do this itself. */ 1149: #if !defined _HAVE_STRING_ARCH_strstr && !__GNUC_PREREQ (2, 97) 1150: # define strstr(haystack, needle) \ 1151: (__extension__ (__builtin_constant_p (needle) && __string2_1bptr_p (needle) \ 1152: ? (((__const char *) (needle))[0] == '\0' \ 1153: ? (char *) (size_t) (haystack) \ 1154: : (((__const char *) (needle))[1] == '\0' \ 1155: ? strchr (haystack, \ 1156: ((__const char *) (needle))[0]) \ 1157: : strstr (haystack, needle))) \ 1158: : strstr (haystack, needle))) 1159: #endif 1160: 1161: 1162: #if !defined _HAVE_STRING_ARCH_strtok_r || defined _FORCE_INLINES 1163: # ifndef _HAVE_STRING_ARCH_strtok_r 1164: # define __strtok_r(s, sep, nextp) \ 1165: (__extension__ (__builtin_constant_p (sep) && __string2_1bptr_p (sep) \ 1166: && ((__const char *) (sep))[0] != '\0' \ 1167: && ((__const char *) (sep))[1] == '\0' \ 1168: ? __strtok_r_1c (s, ((__const char *) (sep))[0], nextp) \ 1169: : __strtok_r (s, sep, nextp))) 1170: # endif 1171: 1172: __STRING_INLINE char *__strtok_r_1c (char *__s, char __sep, char **__nextp); 1173: __STRING_INLINE char * 1174: __strtok_r_1c (char *__s, char __sep, char **__nextp) 1175: { 1176: char *__result; 1177: if (__s == NULL) 1178: __s = *__nextp; 1179: while (*__s == __sep) 1180: ++__s; 1181: __result = NULL; 1182: if (*__s != '\0') 1183: { 1184: __result = __s++; 1185: while (*__s != '\0') 1186: if (*__s++ == __sep) 1187: { 1188: __s[-1] = '\0'; 1189: break; 1190: } 1191: } 1192: *__nextp = __s; 1193: return __result; 1194: } 1195: # if defined __USE_POSIX || defined __USE_MISC 1196: # define strtok_r(s, sep, nextp) __strtok_r (s, sep, nextp) 1197: # endif 1198: #endif 1199: 1200: 1201: #if !defined _HAVE_STRING_ARCH_strsep || defined _FORCE_INLINES 1202: # ifndef _HAVE_STRING_ARCH_strsep 1203: 1204: extern char *__strsep_g (char **__stringp, __const char *__delim); 1205: # define __strsep(s, reject) \ 1206: __extension__ \ 1207: ({ char __r0, __r1, __r2; \ 1208: (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ 1209: && (__r0 = ((__const char *) (reject))[0], \ 1210: ((__const char *) (reject))[0] != '\0') \ 1211: ? ((__r1 = ((__const char *) (reject))[1], \ 1212: ((__const char *) (reject))[1] == '\0') \ 1213: ? __strsep_1c (s, __r0) \ 1214: : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0') \ 1215: ? __strsep_2c (s, __r0, __r1) \ 1216: : (((__const char *) (reject))[3] == '\0' \ 1217: ? __strsep_3c (s, __r0, __r1, __r2) \ 1218: : __strsep_g (s, reject)))) \ 1219: : __strsep_g (s, reject)); }) 1220: # endif 1221: 1222: __STRING_INLINE char *__strsep_1c (char **__s, char __reject); 1223: __STRING_INLINE char * 1224: __strsep_1c (char **__s, char __reject) 1225: { 1226: register char *__retval = *__s; 1227: if (__retval != NULL && (*__s = strchr (__retval, __reject)) != NULL) 1228: *(*__s)++ = '\0'; 1229: return __retval; 1230: } 1231: 1232: __STRING_INLINE char *__strsep_2c (char **__s, char __reject1, char __reject2); 1233: __STRING_INLINE char * 1234: __strsep_2c (char **__s, char __reject1, char __reject2) 1235: { 1236: register char *__retval = *__s; 1237: if (__retval != NULL) 1238: { 1239: register char *__cp = __retval; 1240: while (1) 1241: { 1242: if (*__cp == '\0') 1243: { 1244: __cp = NULL; 1245: break; 1246: } 1247: if (*__cp == __reject1 || *__cp == __reject2) 1248: { 1249: *__cp++ = '\0'; 1250: break; 1251: } 1252: ++__cp; 1253: } 1254: *__s = __cp; 1255: } 1256: return __retval; 1257: } 1258: 1259: __STRING_INLINE char *__strsep_3c (char **__s, char __reject1, char __reject2, 1260: char __reject3); 1261: __STRING_INLINE char * 1262: __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3) 1263: { 1264: register char *__retval = *__s; 1265: if (__retval != NULL) 1266: { 1267: register char *__cp = __retval; 1268: while (1) 1269: { 1270: if (*__cp == '\0') 1271: { 1272: __cp = NULL; 1273: break; 1274: } 1275: if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3) 1276: { 1277: *__cp++ = '\0'; 1278: break; 1279: } 1280: ++__cp; 1281: } 1282: *__s = __cp; 1283: } 1284: return __retval; 1285: } 1286: # ifdef __USE_BSD 1287: # define strsep(s, reject) __strsep (s, reject) 1288: # endif 1289: #endif 1290: 1291: /* We need the memory allocation functions for inline strdup(). 1292: Referring to stdlib.h (even minimally) is not allowed 1293: in any of the tight standards compliant modes. */ 1294: #ifdef __USE_MISC 1295: 1296: # if !defined _HAVE_STRING_ARCH_strdup || !defined _HAVE_STRING_ARCH_strndup 1297: # define __need_malloc_and_calloc 1298: # include <stdlib.h> 1299: # endif 1300: 1301: # ifndef _HAVE_STRING_ARCH_strdup 1302: 1303: extern char *__strdup (__const char *__string) __THROW __attribute_malloc__; 1304: # define __strdup(s) \ 1305: (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s) \ 1306: ? (((__const char *) (s))[0] == '\0' \ 1307: ? (char *) calloc ((size_t) 1, (size_t) 1) \ 1308: : ({ size_t __len = strlen (s) + 1; \ 1309: char *__retval = (char *) malloc (__len); \ 1310: if (__retval != NULL) \ 1311: __retval = (char *) memcpy (__retval, s, __len); \ 1312: __retval; })) \ 1313: : __strdup (s))) 1314: 1315: # if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED 1316: # define strdup(s) __strdup (s) 1317: # endif 1318: # endif 1319: 1320: # ifndef _HAVE_STRING_ARCH_strndup 1321: 1322: extern char *__strndup (__const char *__string, size_t __n) 1323: __THROW __attribute_malloc__; 1324: # define __strndup(s, n) \ 1325: (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s) \ 1326: ? (((__const char *) (s))[0] == '\0' \ 1327: ? (char *) calloc ((size_t) 1, (size_t) 1) \ 1328: : ({ size_t __len = strlen (s) + 1; \ 1329: size_t __n = (n); \ 1330: char *__retval; \ 1331: if (__n < __len) \ 1332: __len = __n + 1; \ 1333: __retval = (char *) malloc (__len); \ 1334: if (__retval != NULL) \ 1335: { \ 1336: __retval[__len - 1] = '\0'; \ 1337: __retval = (char *) memcpy (__retval, s, \ 1338: __len - 1); \ 1339: } \ 1340: __retval; })) \ 1341: : __strndup (s, n))) 1342: 1343: # ifdef __USE_GNU 1344: # define strndup(s, n) __strndup (s, n) 1345: # endif 1346: # endif 1347: 1348: #endif /* Use misc. or use GNU. */ 1349: 1350: #ifndef _FORCE_INLINES 1351: # undef __STRING_INLINE 1352: #endif 1353: 1354: #endif /* No string inlines. */ 1355:
for client
(none)
© Andrew Scott 2006 -
2025,
All Rights Reserved
All Rights Reserved
Andrew Scott