git.oblomov.eu Git - wine/blob - dlls/kernel/string.c

   1 /*
   2  * Kernel string functions
   3  *
   4  * Copyright 2001 Dmitry Timoshkov for Codeweavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <ctype.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wine/winbase16.h"
  28
  29
  30 static INT (WINAPI *pLoadStringA)(HINSTANCE, UINT, LPSTR, INT);
  31 static INT (WINAPI *pwvsprintfA)(LPSTR, LPCSTR, va_list);
  32
  33 /***********************************************************************
  34  * Helper for k32 family functions
  35  */
  36 static void *user32_proc_address(const char *proc_name)
  37 {
  38     static HMODULE hUser32;
  39
  40     if(!hUser32) hUser32 = LoadLibraryA("user32.dll");
  41     return GetProcAddress(hUser32, proc_name);
  42 }
  43
  44
  45 /***********************************************************************
  46  *              k32CharToOemBuffA   (KERNEL32.11)
  47  */
  48 BOOL WINAPI k32CharToOemBuffA(LPCSTR s, LPSTR d, DWORD len)
  49 {
  50     WCHAR *bufW;
  51
  52     if ((bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
  53     {
  54         MultiByteToWideChar( CP_ACP, 0, s, len, bufW, len );
  55         WideCharToMultiByte( CP_OEMCP, 0, bufW, len, d, len, NULL, NULL );
  56         HeapFree( GetProcessHeap(), 0, bufW );
  57     }
  58     return TRUE;
  59 }
  60
  61
  62 /***********************************************************************
  63  *              k32CharToOemA   (KERNEL32.10)
  64  */
  65 BOOL WINAPI k32CharToOemA(LPCSTR s, LPSTR d)
  66 {
  67     if (!s || !d) return TRUE;
  68     return k32CharToOemBuffA( s, d, strlen(s) + 1 );
  69 }
  70
  71
  72 /***********************************************************************
  73  *              k32OemToCharBuffA   (KERNEL32.13)
  74  */
  75 BOOL WINAPI k32OemToCharBuffA(LPCSTR s, LPSTR d, DWORD len)
  76 {
  77     WCHAR *bufW;
  78
  79     if ((bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
  80     {
  81         MultiByteToWideChar( CP_OEMCP, 0, s, len, bufW, len );
  82         WideCharToMultiByte( CP_ACP, 0, bufW, len, d, len, NULL, NULL );
  83         HeapFree( GetProcessHeap(), 0, bufW );
  84     }
  85     return TRUE;
  86 }
  87
  88
  89 /***********************************************************************
  90  *              k32OemToCharA   (KERNEL32.12)
  91  */
  92 BOOL WINAPI k32OemToCharA(LPCSTR s, LPSTR d)
  93 {
  94     return k32OemToCharBuffA( s, d, strlen(s) + 1 );
  95 }
  96
  97
  98 /**********************************************************************
  99  *              k32LoadStringA   (KERNEL32.14)
 100  */
 101 INT WINAPI k32LoadStringA(HINSTANCE instance, UINT resource_id,
 102                           LPSTR buffer, INT buflen)
 103 {
 104     if(!pLoadStringA) pLoadStringA = user32_proc_address("LoadStringA");
 105     return pLoadStringA(instance, resource_id, buffer, buflen);
 106 }
 107
 108
 109 /***********************************************************************
 110  *              k32wvsprintfA   (KERNEL32.16)
 111  */
 112 INT WINAPI k32wvsprintfA(LPSTR buffer, LPCSTR spec, va_list args)
 113 {
 114     if(!pwvsprintfA) pwvsprintfA = user32_proc_address("wvsprintfA");
 115     return (*pwvsprintfA)(buffer, spec, args);
 116 }
 117
 118
 119 /***********************************************************************
 120  *              k32wsprintfA   (KERNEL32.15)
 121  */
 122 INT WINAPIV k32wsprintfA(LPSTR buffer, LPCSTR spec, ...)
 123 {
 124     va_list args;
 125     INT res;
 126
 127     va_start(args, spec);
 128     res = k32wvsprintfA(buffer, spec, args);
 129     va_end(args);
 130     return res;
 131 }
 132
 133
 134 /***************************************************************************
 135  *
 136  * Win 2.x string functions now moved to USER
 137  *
 138  * We rather want to implement them here instead of doing Callouts
 139  */
 140
 141 /***********************************************************************
 142  *              Reserved1 (KERNEL.77)
 143  */
 144 SEGPTR WINAPI KERNEL_AnsiNext16(SEGPTR current)
 145 {
 146     return (*(char *)MapSL(current)) ? current + 1 : current;
 147 }
 148
 149 /***********************************************************************
 150  *              Reserved2(KERNEL.78)
 151  */
 152 SEGPTR WINAPI KERNEL_AnsiPrev16( SEGPTR start, SEGPTR current )
 153 {
 154     return (current==start)?start:current-1;
 155 }
 156
 157 /***********************************************************************
 158  *              Reserved3 (KERNEL.79)
 159  */
 160 SEGPTR WINAPI KERNEL_AnsiUpper16( SEGPTR strOrChar )
 161 {
 162     /* uppercase only one char if strOrChar < 0x10000 */
 163     if (HIWORD(strOrChar))
 164     {
 165         char *s = MapSL(strOrChar);
 166         while (*s)
 167         {
 168             *s = toupper(*s);
 169             s++;
 170         }
 171         return strOrChar;
 172     }
 173     else return toupper((char)strOrChar);
 174 }
 175
 176 /***********************************************************************
 177  *              Reserved4 (KERNEL.80)
 178  */
 179 SEGPTR WINAPI KERNEL_AnsiLower16( SEGPTR strOrChar )
 180 {
 181     /* lowercase only one char if strOrChar < 0x10000 */
 182     if (HIWORD(strOrChar))
 183     {
 184         char *s = MapSL(strOrChar);
 185         while (*s)
 186         {
 187             *s = tolower(*s);
 188             s++;
 189         }
 190         return strOrChar;
 191     }
 192     else return tolower((char)strOrChar);
 193 }
 194
 195
 196 /***********************************************************************
 197  *              Reserved5 (KERNEL.87)
 198  */
 199 INT16 WINAPI KERNEL_lstrcmp16( LPCSTR str1, LPCSTR str2 )
 200 {
 201     return (INT16)strcmp( str1, str2 );
 202 }