memory/string.c

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