memory/string.c

   1 /*
   2  * String functions
   3  *
   4  * Copyright 1993 Yngvi Sigurjonsson
   5  * Copyright 1996 Alexandre Julliard
   6  */
   7
   8 #define NO_TRANSITION_TYPES  /* This file is Win32-clean */
   9 #include <ctype.h>
  10 #include <string.h>
  11 #include "windows.h"
  12 #include "ldt.h"
  13
  14
  15 /***********************************************************************
  16  *           hmemcpy   (KERNEL.348)
  17  */
  18 void hmemcpy( LPVOID dst, LPCVOID src, LONG count )
  19 {
  20     memcpy( dst, src, count );
  21 }
  22
  23
  24 /***********************************************************************
  25  *           lstrcat16   (KERNEL.89)
  26  */
  27 SEGPTR lstrcat16( SEGPTR dst, SEGPTR src )
  28 {
  29     lstrcat32A( (LPSTR)PTR_SEG_TO_LIN(dst), (LPCSTR)PTR_SEG_TO_LIN(src) );
  30     return dst;
  31 }
  32
  33
  34 /***********************************************************************
  35  *           lstrcat32A   (KERNEL32.599)
  36  */
  37 LPSTR lstrcat32A( LPSTR dst, LPCSTR src )
  38 {
  39     strcat( dst, src );
  40     return dst;
  41 }
  42
  43
  44 /***********************************************************************
  45  *           lstrcat32W   (KERNEL32.600)
  46  */
  47 LPWSTR lstrcat32W( LPWSTR dst, LPCWSTR src )
  48 {
  49     register LPWSTR p = dst;
  50     while (*p) p++;
  51     while ((*p++ = *src++));
  52     return dst;
  53 }
  54
  55
  56 /***********************************************************************
  57  *           lstrcatn16   (KERNEL.352)
  58  */
  59 SEGPTR lstrcatn16( SEGPTR dst, SEGPTR src, INT16 n )
  60 {
  61     lstrcatn32A( (LPSTR)PTR_SEG_TO_LIN(dst), (LPCSTR)PTR_SEG_TO_LIN(src), n );
  62     return dst;
  63 }
  64
  65
  66 /***********************************************************************
  67  *           lstrcatn32A   (Not a Windows API)
  68  */
  69 LPSTR lstrcatn32A( LPSTR dst, LPCSTR src, INT32 n )
  70 {
  71     register LPSTR p = dst;
  72     while (*p) p++;
  73     if ((n -= (INT32)(p - dst)) <= 0) return dst;
  74     lstrcpyn32A( p, src, n );
  75     return dst;
  76 }
  77
  78
  79 /***********************************************************************
  80  *           lstrcatn32W   (Not a Windows API)
  81  */
  82 LPWSTR lstrcatn32W( LPWSTR dst, LPCWSTR src, INT32 n )
  83 {
  84     register LPWSTR p = dst;
  85     while (*p) p++;
  86     if ((n -= (INT32)(p - dst)) <= 0) return dst;
  87     lstrcpyn32W( p, src, n );
  88     return dst;
  89 }
  90
  91
  92 /***********************************************************************
  93  *           lstrcmp16   (USER.430)
  94  */
  95 INT16 lstrcmp16( LPCSTR str1, LPCSTR str2 )
  96 {
  97     return (INT16)lstrcmp32A( str1, str2 );
  98 }
  99
 100
 101 /***********************************************************************
 102  *           lstrcmp32A   (KERNEL.602)
 103  */
 104 INT32 lstrcmp32A( LPCSTR str1, LPCSTR str2 )
 105 {
 106     return (INT32)strcmp( str1, str2 );
 107 }
 108
 109
 110 /***********************************************************************
 111  *           lstrcmp32W   (KERNEL.603)
 112  */
 113 INT32 lstrcmp32W( LPCWSTR str1, LPCWSTR str2 )
 114 {
 115     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 116     return (INT32)(*str1 - *str2);
 117 }
 118
 119
 120 /***********************************************************************
 121  *           lstrcmpi16   (USER.471)
 122  */
 123 INT16 lstrcmpi16( LPCSTR str1, LPCSTR str2 )
 124 {
 125     return (INT16)lstrcmpi32A( str1, str2 );
 126 }
 127
 128
 129 /***********************************************************************
 130  *           lstrcmpi32A   (KERNEL32.605)
 131  */
 132 INT32 lstrcmpi32A( LPCSTR str1, LPCSTR str2 )
 133 {
 134     INT32 res;
 135
 136     while (*str1)
 137     {
 138         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 139         str1++;
 140         str2++;
 141     }
 142     return toupper(*str1) - toupper(*str2);
 143 }
 144
 145
 146 /***********************************************************************
 147  *           lstrcmpi32W   (KERNEL32.606)
 148  */
 149 INT32 lstrcmpi32W( LPCWSTR str1, LPCWSTR str2 )
 150 {
 151     INT32 res;
 152
 153     while (*str1)
 154     {
 155         /* FIXME: Unicode */
 156         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 157         str1++;
 158         str2++;
 159     }
 160     return toupper(*str1) - toupper(*str2);
 161 }
 162
 163
 164 /***********************************************************************
 165  *           lstrcpy16   (KERNEL.88)
 166  */
 167 SEGPTR lstrcpy16( SEGPTR dst, SEGPTR src )
 168 {
 169     lstrcpy32A( (LPSTR)PTR_SEG_TO_LIN(dst), (LPCSTR)PTR_SEG_TO_LIN(src) );
 170     return dst;
 171 }
 172
 173
 174 /***********************************************************************
 175  *           lstrcpy32A   (KERNEL32.608)
 176  */
 177 LPSTR lstrcpy32A( LPSTR dst, LPCSTR src )
 178 {
 179     if (!src || !dst) return NULL;
 180     strcpy( dst, src );
 181     return dst;
 182 }
 183
 184
 185 /***********************************************************************
 186  *           lstrcpy32W   (KERNEL32.609)
 187  */
 188 LPWSTR lstrcpy32W( LPWSTR dst, LPCWSTR src )
 189 {
 190     register LPWSTR p = dst;
 191     while ((*p++ = *src++));
 192     return dst;
 193 }
 194
 195
 196 /***********************************************************************
 197  *           lstrcpyn16   (KERNEL.353)
 198  */
 199 SEGPTR lstrcpyn16( SEGPTR dst, SEGPTR src, INT16 n )
 200 {
 201     lstrcpyn32A( (LPSTR)PTR_SEG_TO_LIN(dst), (LPCSTR)PTR_SEG_TO_LIN(src), n );
 202     return dst;
 203 }
 204
 205
 206 /***********************************************************************
 207  *           lstrcpyn32A   (KERNEL32.611)
 208  */
 209 LPSTR lstrcpyn32A( LPSTR dst, LPCSTR src, INT32 n )
 210 {
 211     LPSTR p = dst;
 212     while ((n-- > 1) && *src) *p++ = *src++;
 213     *p = 0;
 214     return dst;
 215 }
 216
 217
 218 /***********************************************************************
 219  *           lstrcpyn32W   (KERNEL32.612)
 220  */
 221 LPWSTR lstrcpyn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 222 {
 223     LPWSTR p = dst;
 224     while ((n-- > 1) && *src) *p++ = *src++;
 225     *p = 0;
 226     return dst;
 227 }
 228
 229
 230 /***********************************************************************
 231  *           lstrlen16   (KERNEL.90)
 232  */
 233 INT16 lstrlen16( LPCSTR str )
 234 {
 235     return (INT16)lstrlen32A( str );
 236 }
 237
 238
 239 /***********************************************************************
 240  *           lstrlen32A   (KERNEL32.614)
 241  */
 242 INT32 lstrlen32A( LPCSTR str )
 243 {
 244     /* looks weird, but win3.1 KERNEL got a GeneralProtection handler
 245      * in lstrlen() ... we check only for NULL pointer reference.
 246      * - Marcus Meissner
 247      */
 248     if (!str) return 0;
 249     return (INT32)strlen(str);
 250 }
 251
 252
 253 /***********************************************************************
 254  *           lstrlen32W   (KERNEL32.615)
 255  */
 256 INT32 lstrlen32W( LPCWSTR str )
 257 {
 258     INT32 len = 0;
 259     if (!str) return 0;
 260     while (*str++) len++;
 261     return len;
 262 }
 263
 264
 265 /***********************************************************************
 266  *           lstrncmp32A   (Not a Windows API)
 267  */
 268 INT32 lstrncmp32A( LPCSTR str1, LPCSTR str2, INT32 n )
 269 {
 270     return (INT32)strncmp( str1, str2, n );
 271 }
 272
 273
 274 /***********************************************************************
 275  *           lstrncmp32W   (Not a Windows API)
 276  */
 277 INT32 lstrncmp32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 278 {
 279     if (!n) return 0;
 280     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 281     return (INT32)(*str1 - *str2);
 282 }
 283
 284
 285 /***********************************************************************
 286  *           lstrncmpi32A   (Not a Windows API)
 287  */
 288 INT32 lstrncmpi32A( LPCSTR str1, LPCSTR str2, INT32 n )
 289 {
 290     INT32 res;
 291
 292     if (!n) return 0;
 293     while ((--n > 0) && *str1)
 294     {
 295         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 296         str1++;
 297         str2++;
 298     }
 299     return toupper(*str1) - toupper(*str2);
 300 }
 301
 302
 303 /***********************************************************************
 304  *           lstrncmpi32W   (Not a Windows API)
 305  */
 306 INT32 lstrncmpi32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 307 {
 308     INT32 res;
 309
 310     if (!n) return 0;
 311     while ((--n > 0) && *str1)
 312     {
 313         /* FIXME: Unicode */
 314         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 315         str1++;
 316         str2++;
 317     }
 318     return toupper(*str1) - toupper(*str2);
 319 }
 320
 321
 322 /***********************************************************************
 323  *           lstrcpynAtoW   (Not a Windows API)
 324  */
 325 LPWSTR lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT32 n )
 326 {
 327     LPWSTR p = dst;
 328     while ((n-- > 1) && *src) *p++ = (WCHAR)(unsigned char)*src++;
 329     *p = 0;
 330     return dst;
 331 }
 332
 333
 334 /***********************************************************************
 335  *           lstrcpynWtoA   (Not a Windows API)
 336  */
 337 LPSTR lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT32 n )
 338 {
 339     LPSTR p = dst;
 340     while ((n-- > 1) && *src) *p++ = (CHAR)*src++;
 341     *p = 0;
 342     return dst;
 343 }
 344
 345
 346 /***********************************************************************
 347  *           RtlFillMemory   (KERNEL32.441)
 348  */
 349 VOID RtlFillMemory( LPVOID ptr, UINT32 len, UINT32 fill )
 350 {
 351     memset( ptr, fill, len );
 352 }
 353
 354
 355 /***********************************************************************
 356  *           RtlMoveMemory   (KERNEL32.442)
 357  */
 358 VOID RtlMoveMemory( LPVOID dst, LPCVOID src, UINT32 len )
 359 {
 360     /* memcpy does not support overlapped copies, */
 361     /* and memmove is not portable. */
 362     if (((BYTE *)dst + len <= (BYTE *)src) ||
 363         ((BYTE *)src + len <= (BYTE *)dst))
 364     {
 365         memcpy( dst, src, len );
 366         return;
 367     }
 368     /* do it the hard way (FIXME: could do better than this) */
 369     if (dst < src)
 370     {
 371         while (len--) *((BYTE *)dst)++ = *((BYTE *)src)++;
 372     }
 373     else
 374     {
 375         dst = (BYTE *)dst + len - 1;
 376         src = (BYTE *)src + len - 1;
 377         while (len--) *((BYTE *)dst)-- = *((BYTE *)src)--;
 378     }
 379 }
 380
 381
 382 /***********************************************************************
 383  *           RtlZeroMemory   (KERNEL32.444)
 384  */
 385 VOID RtlZeroMemory( LPVOID ptr, UINT32 len )
 386 {
 387     memset( ptr, 0, len );
 388 }