git.oblomov.eu Git - wine/blob - 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
  11 #include "windef.h"
  12 #include "winbase.h"
  13 #include "wine/winbase16.h"
  14 #include "wine/exception.h"
  15 #include "wine/unicode.h"
  16 #include "winerror.h"
  17 #include "winnls.h"
  18 #include "ldt.h"
  19 #include "debugtools.h"
  20
  21 DEFAULT_DEBUG_CHANNEL(string);
  22
  23 /* filter for page-fault exceptions */
  24 static WINE_EXCEPTION_FILTER(page_fault)
  25 {
  26     if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
  27         return EXCEPTION_EXECUTE_HANDLER;
  28     return EXCEPTION_CONTINUE_SEARCH;
  29 }
  30
  31
  32 /***********************************************************************
  33  *           hmemcpy16   (KERNEL.348)
  34  */
  35 void WINAPI hmemcpy16( LPVOID dst, LPCVOID src, LONG count )
  36 {
  37     memcpy( dst, src, count );
  38 }
  39
  40
  41 /***********************************************************************
  42  *           lstrcat16   (KERNEL.89)
  43  */
  44 SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
  45 {
  46     /* Windows does not check for NULL pointers here, so we don't either */
  47     strcat( (LPSTR)PTR_SEG_TO_LIN(dst), src );
  48     return dst;
  49 }
  50
  51
  52 /***********************************************************************
  53  *           lstrcatA   (KERNEL32.599)
  54  */
  55 LPSTR WINAPI lstrcatA( LPSTR dst, LPCSTR src )
  56 {
  57     __TRY
  58     {
  59         strcat( dst, src );
  60     }
  61     __EXCEPT(page_fault)
  62     {
  63         SetLastError( ERROR_INVALID_PARAMETER );
  64         return NULL;
  65     }
  66     __ENDTRY
  67     return dst;
  68 }
  69
  70
  71 /***********************************************************************
  72  *           lstrcatW   (KERNEL32.600)
  73  */
  74 LPWSTR WINAPI lstrcatW( LPWSTR dst, LPCWSTR src )
  75 {
  76     __TRY
  77     {
  78         strcatW( dst, src );
  79     }
  80     __EXCEPT(page_fault)
  81     {
  82         SetLastError( ERROR_INVALID_PARAMETER );
  83         return NULL;
  84     }
  85     __ENDTRY
  86     return dst;
  87 }
  88
  89
  90 /***********************************************************************
  91  *           lstrcatn16   (KERNEL.352)
  92  */
  93 SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
  94 {
  95     LPSTR p = (LPSTR)PTR_SEG_TO_LIN(dst);
  96
  97     while (*p) p++;
  98     if ((n -= (p - (LPSTR)PTR_SEG_TO_LIN(dst))) <= 0) return dst;
  99     lstrcpynA( p, src, n );
 100     return dst;
 101 }
 102
 103
 104 /***********************************************************************
 105  *           lstrcmpA   (KERNEL.602)
 106  */
 107 INT WINAPI lstrcmpA( LPCSTR str1, LPCSTR str2 )
 108 {
 109     return CompareStringA(LOCALE_SYSTEM_DEFAULT,0,str1,-1,str2,-1) - 2 ;
 110 }
 111
 112
 113 /***********************************************************************
 114  *           lstrcmpW   (KERNEL.603)
 115  * FIXME : should call CompareStringW, when it is implemented.
 116  *    This implementation is not "word sort", as it should.
 117  */
 118 INT WINAPI lstrcmpW( LPCWSTR str1, LPCWSTR str2 )
 119 {
 120     TRACE("%s and %s\n",
 121                    debugstr_w (str1), debugstr_w (str2));
 122     if (!str1 || !str2) {
 123         SetLastError(ERROR_INVALID_PARAMETER);
 124         return 0;
 125     }
 126     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 127     return (INT)(*str1 - *str2);
 128 }
 129
 130
 131 /***********************************************************************
 132  *           lstrcmpiA   (KERNEL32.605)
 133  */
 134 INT WINAPI lstrcmpiA( LPCSTR str1, LPCSTR str2 )
 135 {    TRACE("strcmpi %s and %s\n",
 136                    debugstr_a (str1), debugstr_a (str2));
 137     return CompareStringA(LOCALE_SYSTEM_DEFAULT,NORM_IGNORECASE,str1,-1,str2,-1)-2;
 138 }
 139
 140
 141 /***********************************************************************
 142  *           lstrcmpiW   (KERNEL32.606)
 143  */
 144 INT WINAPI lstrcmpiW( LPCWSTR str1, LPCWSTR str2 )
 145 {
 146     if (!str1 || !str2) {
 147         SetLastError(ERROR_INVALID_PARAMETER);
 148         return 0;
 149     }
 150     return strcmpiW( str1, str2 );
 151 }
 152
 153
 154 /***********************************************************************
 155  *           lstrcpy16   (KERNEL.88)
 156  */
 157 SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
 158 {
 159     if (!lstrcpyA( PTR_SEG_TO_LIN(dst), src )) dst = 0;
 160     return dst;
 161 }
 162
 163
 164 /***********************************************************************
 165  *           lstrcpyA   (KERNEL32.608)
 166  */
 167 LPSTR WINAPI lstrcpyA( LPSTR dst, LPCSTR src )
 168 {
 169     __TRY
 170     {
 171         /* this is how Windows does it */
 172         memmove( dst, src, strlen(src)+1 );
 173     }
 174     __EXCEPT(page_fault)
 175     {
 176         ERR("(%p, %p): page fault occurred ! Caused by bug ?\n", dst, src);
 177         SetLastError( ERROR_INVALID_PARAMETER );
 178         return NULL;
 179     }
 180     __ENDTRY
 181     return dst;
 182 }
 183
 184
 185 /***********************************************************************
 186  *           lstrcpyW   (KERNEL32.609)
 187  */
 188 LPWSTR WINAPI lstrcpyW( LPWSTR dst, LPCWSTR src )
 189 {
 190     __TRY
 191     {
 192         strcpyW( dst, src );
 193     }
 194     __EXCEPT(page_fault)
 195     {
 196         SetLastError( ERROR_INVALID_PARAMETER );
 197         return NULL;
 198     }
 199     __ENDTRY
 200     return dst;
 201 }
 202
 203
 204 /***********************************************************************
 205  *           lstrcpyn16   (KERNEL.353)
 206  */
 207 SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
 208 {
 209     lstrcpynA( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
 210     return dst;
 211 }
 212
 213
 214 /***********************************************************************
 215  *           lstrcpynA   (KERNEL32.611)
 216  * Note: this function differs from the UNIX strncpy, it _always_ writes
 217  * a terminating \0
 218  */
 219 LPSTR WINAPI lstrcpynA( LPSTR dst, LPCSTR src, INT n )
 220 {
 221     LPSTR p = dst;
 222     TRACE("(%p, %s, %i)\n", dst, debugstr_an(src,n), n);
 223     /* In real windows the whole function is protected by an exception handler
 224      * that returns ERROR_INVALID_PARAMETER on faulty parameters
 225      * We currently just check for NULL.
 226      */
 227     if (!dst || !src) {
 228         SetLastError(ERROR_INVALID_PARAMETER);
 229         return 0;
 230     }
 231     while ((n-- > 1) && *src) *p++ = *src++;
 232     if (n >= 0) *p = 0;
 233     return dst;
 234 }
 235
 236
 237 /***********************************************************************
 238  *           lstrcpynW   (KERNEL32.612)
 239  * Note: this function differs from the UNIX strncpy, it _always_ writes
 240  * a terminating \0
 241  */
 242 LPWSTR WINAPI lstrcpynW( LPWSTR dst, LPCWSTR src, INT n )
 243 {
 244     LPWSTR p = dst;
 245     TRACE("(%p, %s, %i)\n", dst,  debugstr_wn(src,n), n);
 246     /* In real windows the whole function is protected by an exception handler
 247      * that returns ERROR_INVALID_PARAMETER on faulty parameters
 248      * We currently just check for NULL.
 249      */
 250     if (!dst || !src) {
 251         SetLastError(ERROR_INVALID_PARAMETER);
 252         return 0;
 253     }
 254     while ((n-- > 1) && *src) *p++ = *src++;
 255     if (n >= 0) *p = 0;
 256     return dst;
 257 }
 258
 259
 260 /***********************************************************************
 261  *           lstrlen16   (KERNEL.90)
 262  */
 263 INT16 WINAPI lstrlen16( LPCSTR str )
 264 {
 265     return (INT16)lstrlenA( str );
 266 }
 267
 268
 269 /***********************************************************************
 270  *           lstrlenA   (KERNEL32.614)
 271  */
 272 INT WINAPI lstrlenA( LPCSTR str )
 273 {
 274     INT ret;
 275     __TRY
 276     {
 277         ret = strlen(str);
 278     }
 279     __EXCEPT(page_fault)
 280     {
 281         SetLastError( ERROR_INVALID_PARAMETER );
 282         return 0;
 283     }
 284     __ENDTRY
 285     return ret;
 286 }
 287
 288
 289 /***********************************************************************
 290  *           lstrlenW   (KERNEL32.615)
 291  */
 292 INT WINAPI lstrlenW( LPCWSTR str )
 293 {
 294     INT ret;
 295     __TRY
 296     {
 297         ret = strlenW(str);
 298     }
 299     __EXCEPT(page_fault)
 300     {
 301         SetLastError( ERROR_INVALID_PARAMETER );
 302         return 0;
 303     }
 304     __ENDTRY
 305     return ret;
 306 }
 307
 308
 309 /***********************************************************************
 310  *           lstrcpynAtoW   (Not a Windows API)
 311  * Note: this function differs from the UNIX strncpy, it _always_ writes
 312  * a terminating \0
 313  */
 314 LPWSTR WINAPI lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT n )
 315 {
 316     if (n > 0 && !MultiByteToWideChar( CP_ACP, 0, src, -1, dst, n )) dst[n-1] = 0;
 317     return dst;
 318 }
 319
 320
 321 /***********************************************************************
 322  *           lstrcpynWtoA   (Not a Windows API)
 323  * Note: this function differs from the UNIX strncpy, it _always_ writes
 324  * a terminating \0
 325  *
 326  * The terminating zero should be written at the end of the string, not
 327  * the end of the buffer, as some programs specify the wrong size for
 328  * the buffer (eg. winnt's sol.exe)
 329  */
 330 LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT n )
 331 {
 332     if (n > 0 && !WideCharToMultiByte( CP_ACP, 0, src, -1, dst, n, NULL, NULL )) dst[n-1] = 0;
 333     return dst;
 334 }
 335
 336 /***********************************************************************
 337  *           UnicodeToAnsi   (KERNEL.434)
 338  */
 339 INT16 WINAPI UnicodeToAnsi16( LPCWSTR src, LPSTR dst, INT16 codepage )
 340 {
 341     if ( codepage == -1 )
 342         codepage = CP_ACP;
 343
 344     return WideCharToMultiByte( codepage, 0, src, -1, dst, 0x7fffffff, NULL, NULL );
 345 }