git.oblomov.eu Git - wine/blob - dlls/kernel32/atom.c

   1 /*
   2  * Atom table functions
   3  *
   4  * Copyright 1993, 1994, 1995 Alexandre Julliard
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdlib.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <ctype.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "winternl.h"
  34
  35 #include "wine/exception.h"
  36 #include "wine/unicode.h"
  37 #include "kernel_private.h"
  38
  39 #define MAX_ATOM_LEN 255
  40 #define IS_INTATOM(x)   (((ULONG_PTR)(x) >> 16) == 0)
  41
  42 /******************************************************************
  43  *              get_local_table
  44  *
  45  * Returns the local atom table for this process (and create it if doesn't
  46  * exist yet)
  47  */
  48 static RTL_ATOM_TABLE get_local_table(DWORD entries)
  49 {
  50     static RTL_ATOM_TABLE local_table;
  51
  52     if (!local_table)
  53     {
  54         NTSTATUS        status;
  55         RTL_ATOM_TABLE  table = NULL;
  56
  57         if ((status = RtlCreateAtomTable( entries, &table )))
  58             SetLastError( RtlNtStatusToDosError( status ) );
  59         else if (InterlockedCompareExchangePointer((void*)&local_table, table, NULL) != NULL)
  60             RtlDestroyAtomTable( table );
  61     }
  62
  63     return local_table;
  64 }
  65
  66
  67 /***********************************************************************
  68  *           InitAtomTable   (KERNEL32.@)
  69  *
  70  * Initialise the global atom table.
  71  *
  72  * PARAMS
  73  *  entries [I] The number of entries to reserve in the table.
  74  *
  75  * RETURNS
  76  *  Success: TRUE.
  77  *  Failure: FALSE.
  78  */
  79 BOOL WINAPI InitAtomTable( DWORD entries )
  80 {
  81     return get_local_table( entries ) != 0;
  82 }
  83
  84 /******************************************************************
  85  *              check_integral_atom
  86  *
  87  * Check if a string (ANSI or UNICODE) is in fact an integral atom
  88  * (but doesn't check the "#1234" form)
  89  */
  90 static inline BOOL check_integral_atom( const void* ptr, ATOM* patom)
  91 {
  92     if (!IS_INTATOM( ptr )) return FALSE;
  93     if ((*patom = LOWORD( ptr )) >= MAXINTATOM)
  94     {
  95         SetLastError( ERROR_INVALID_PARAMETER );
  96         *patom = 0;
  97     }
  98     return TRUE;
  99 }
 100
 101 /***********************************************************************
 102  *           GlobalAddAtomA   (KERNEL32.@)
 103  *
 104  * Add a character string to the global atom table and return a unique
 105  * value identifying it.
 106  *
 107  * RETURNS
 108  *      Success: The atom allocated to str.
 109  *      Failure: 0.
 110  */
 111 ATOM WINAPI GlobalAddAtomA( LPCSTR str /* [in] String to add */ )
 112 {
 113     ATOM atom = 0;
 114     __TRY
 115     {
 116         if (!check_integral_atom( str, &atom ))
 117         {
 118             WCHAR buffer[MAX_ATOM_LEN];
 119             DWORD len = MultiByteToWideChar( CP_ACP, 0, str, strlen(str), buffer, MAX_ATOM_LEN );
 120             if (!len) SetLastError( ERROR_INVALID_PARAMETER );
 121             else
 122             {
 123                 NTSTATUS status = NtAddAtom( buffer, len * sizeof(WCHAR), &atom );
 124                 if (status)
 125                 {
 126                     SetLastError( RtlNtStatusToDosError( status ) );
 127                     atom = 0;
 128                 }
 129             }
 130         }
 131     }
 132     __EXCEPT_PAGE_FAULT
 133     {
 134         SetLastError( ERROR_INVALID_PARAMETER );
 135         atom = 0;
 136     }
 137     __ENDTRY
 138     return atom;
 139 }
 140
 141
 142 /***********************************************************************
 143  *           AddAtomA   (KERNEL32.@)
 144  *
 145  * Add a character string to the global atom table and return a unique
 146  * value identifying it.
 147  *
 148  * RETURNS
 149  *      Success: The atom allocated to str.
 150  *      Failure: 0.
 151  */
 152 ATOM WINAPI AddAtomA( LPCSTR str /* [in] String to add */ )
 153 {
 154     ATOM atom = 0;
 155
 156     if (!check_integral_atom( str, &atom ))
 157     {
 158         WCHAR           buffer[MAX_ATOM_LEN + 1];
 159         DWORD           len;
 160         RTL_ATOM_TABLE  table;
 161
 162         len = MultiByteToWideChar( CP_ACP, 0, str, -1, buffer, MAX_ATOM_LEN + 1 );
 163         if (!len) SetLastError( ERROR_INVALID_PARAMETER );
 164         else if ((table = get_local_table( 0 )))
 165         {
 166             NTSTATUS status = RtlAddAtomToAtomTable( table, buffer, &atom );
 167             if (status)
 168             {
 169                 SetLastError( RtlNtStatusToDosError( status ) );
 170                 atom = 0;
 171             }
 172         }
 173     }
 174     return atom;
 175 }
 176
 177 /***********************************************************************
 178  *           GlobalAddAtomW   (KERNEL32.@)
 179  *
 180  * Unicode version of GlobalAddAtomA.
 181  */
 182 ATOM WINAPI GlobalAddAtomW( LPCWSTR str )
 183 {
 184     ATOM        atom = 0;
 185     NTSTATUS    status;
 186
 187     if (!check_integral_atom( str, &atom ) &&
 188         (status = NtAddAtom( str, strlenW( str ) * sizeof(WCHAR), &atom )))
 189     {
 190         SetLastError( RtlNtStatusToDosError( status ) );
 191         atom = 0;
 192     }
 193     return atom;
 194 }
 195
 196
 197 /***********************************************************************
 198  *           AddAtomW   (KERNEL32.@)
 199  *
 200  * Unicode version of AddAtomA.
 201  */
 202 ATOM WINAPI AddAtomW( LPCWSTR str )
 203 {
 204     ATOM                atom = 0;
 205     RTL_ATOM_TABLE      table;
 206
 207     if (!check_integral_atom( str, &atom ) && (table = get_local_table( 0 )))
 208     {
 209         NTSTATUS status = RtlAddAtomToAtomTable( table, str, &atom );
 210         if (status)
 211         {
 212             SetLastError( RtlNtStatusToDosError( status ) );
 213             atom = 0;
 214         }
 215     }
 216     return atom;
 217 }
 218
 219
 220 /***********************************************************************
 221  *           GlobalDeleteAtom   (KERNEL32.@)
 222  *
 223  * Decrement the reference count of a string atom.  If the count is
 224  * zero, the string associated with the atom is removed from the table.
 225  *
 226  * RETURNS
 227  *      Success: 0.
 228  *      Failure: atom.
 229  */
 230 ATOM WINAPI GlobalDeleteAtom( ATOM atom /* [in] Atom to delete */ )
 231 {
 232     if (atom >= MAXINTATOM)
 233     {
 234         NTSTATUS status = NtDeleteAtom( atom );
 235         if (status)
 236         {
 237             SetLastError( RtlNtStatusToDosError( status ) );
 238             return atom;
 239         }
 240     }
 241     return 0;
 242 }
 243
 244
 245 /***********************************************************************
 246  *           DeleteAtom   (KERNEL32.@)
 247  *
 248  * Decrement the reference count of a string atom.  If the count becomes
 249  * zero, the string associated with the atom is removed from the table.
 250  *
 251  * RETURNS
 252  *      Success: 0.
 253  *      Failure: atom
 254  */
 255 ATOM WINAPI DeleteAtom( ATOM atom /* [in] Atom to delete */ )
 256 {
 257     NTSTATUS            status;
 258     RTL_ATOM_TABLE      table;
 259
 260     if (atom >= MAXINTATOM)
 261     {
 262         if (!(table = get_local_table( 0 ))) return atom;
 263         status = RtlDeleteAtomFromAtomTable( table, atom );
 264         if (status)
 265         {
 266             SetLastError( RtlNtStatusToDosError( status ) );
 267             return atom;
 268         }
 269     }
 270     return 0;
 271 }
 272
 273
 274 /***********************************************************************
 275  *           GlobalFindAtomA   (KERNEL32.@)
 276  *
 277  * Get the atom associated with a string.
 278  *
 279  * RETURNS
 280  *      Success: The associated atom.
 281  *      Failure: 0.
 282  */
 283 ATOM WINAPI GlobalFindAtomA( LPCSTR str /* [in] Pointer to string to search for */ )
 284 {
 285     ATOM atom = 0;
 286
 287     if (!check_integral_atom( str, &atom ))
 288     {
 289         WCHAR buffer[MAX_ATOM_LEN];
 290         DWORD len = MultiByteToWideChar( CP_ACP, 0, str, strlen(str), buffer, MAX_ATOM_LEN );
 291
 292         if (!len) SetLastError( ERROR_INVALID_PARAMETER );
 293         else
 294         {
 295             NTSTATUS status = NtFindAtom( buffer, len * sizeof(WCHAR), &atom );
 296             if (status)
 297             {
 298                 SetLastError( RtlNtStatusToDosError( status ) );
 299                 atom = 0;
 300             }
 301         }
 302     }
 303     return atom;
 304 }
 305
 306 /***********************************************************************
 307  *           FindAtomA   (KERNEL32.@)
 308  *
 309  * Get the atom associated with a string.
 310  *
 311  * RETURNS
 312  *      Success: The associated atom.
 313  *      Failure: 0.
 314  */
 315 ATOM WINAPI FindAtomA( LPCSTR str /* [in] Pointer to string to find */ )
 316 {
 317     ATOM atom = 0;
 318
 319     if (!check_integral_atom( str, &atom ))
 320     {
 321         WCHAR           buffer[MAX_ATOM_LEN + 1];
 322         DWORD           len;
 323         RTL_ATOM_TABLE  table;
 324
 325         len = MultiByteToWideChar( CP_ACP, 0, str, -1, buffer, MAX_ATOM_LEN + 1 );
 326         if (!len) SetLastError( ERROR_INVALID_PARAMETER );
 327         else if ((table = get_local_table( 0 )))
 328         {
 329             NTSTATUS status = RtlLookupAtomInAtomTable( table, buffer, &atom );
 330             if (status)
 331             {
 332                 SetLastError( RtlNtStatusToDosError( status ) );
 333                 atom = 0;
 334             }
 335         }
 336     }
 337     return atom;
 338 }
 339
 340
 341 /***********************************************************************
 342  *           GlobalFindAtomW   (KERNEL32.@)
 343  *
 344  * Unicode version of GlobalFindAtomA.
 345  */
 346 ATOM WINAPI GlobalFindAtomW( LPCWSTR str )
 347 {
 348     ATOM atom = 0;
 349
 350     if (!check_integral_atom( str, &atom ))
 351     {
 352         NTSTATUS status = NtFindAtom( str, strlenW( str ) * sizeof(WCHAR), &atom );
 353         if (status)
 354         {
 355             SetLastError( RtlNtStatusToDosError( status ) );
 356             atom = 0;
 357         }
 358     }
 359     return atom;
 360 }
 361
 362
 363 /***********************************************************************
 364  *           FindAtomW   (KERNEL32.@)
 365  *
 366  * Unicode version of FindAtomA.
 367  */
 368 ATOM WINAPI FindAtomW( LPCWSTR str )
 369 {
 370     ATOM                atom = 0;
 371     NTSTATUS            status;
 372     RTL_ATOM_TABLE      table;
 373
 374     if ((table = get_local_table( 0 )))
 375     {
 376         status = RtlLookupAtomInAtomTable( table, str, &atom );
 377         if (status)
 378         {
 379             SetLastError( RtlNtStatusToDosError( status ) );
 380             atom = 0;
 381         }
 382     }
 383     return atom;
 384 }
 385
 386
 387 /***********************************************************************
 388  *           GlobalGetAtomNameA   (KERNEL32.@)
 389  *
 390  * Get a copy of the string associated with an atom.
 391  *
 392  * RETURNS
 393  *      Success: The length of the returned string in characters.
 394  *      Failure: 0.
 395  */
 396 UINT WINAPI GlobalGetAtomNameA(
 397               ATOM atom,    /* [in]  Atom identifier */
 398               LPSTR buffer, /* [out] Pointer to buffer for atom string */
 399               INT count )   /* [in]  Size of buffer */
 400 {
 401     WCHAR       tmpW[MAX_ATOM_LEN + 1];
 402     UINT        wlen, len = 0, c;
 403
 404     if (count <= 0) SetLastError( ERROR_MORE_DATA );
 405     else if ((wlen = GlobalGetAtomNameW( atom, tmpW, MAX_ATOM_LEN + 1 )))
 406     {
 407         char    tmp[MAX_ATOM_LEN + 1];
 408
 409         len = WideCharToMultiByte( CP_ACP, 0, tmpW, wlen, tmp, MAX_ATOM_LEN + 1, NULL, NULL );
 410         c = min(len, count - 1);
 411         memcpy(buffer, tmp, c);
 412         buffer[c] = '\0';
 413         if (len >= count)
 414         {
 415             len = 0;
 416             SetLastError( ERROR_MORE_DATA );
 417         }
 418     }
 419     return len;
 420 }
 421
 422
 423 /***********************************************************************
 424  *           GetAtomNameA   (KERNEL32.@)
 425  *
 426  * Get a copy of the string associated with an atom.
 427  *
 428  * RETURNS
 429  *      Success: The length of the returned string in characters.
 430  *      Failure: 0.
 431  */
 432 UINT WINAPI GetAtomNameA(
 433               ATOM atom,    /* [in]  Atom */
 434               LPSTR buffer, /* [out] Pointer to string for atom string */
 435               INT count)    /* [in]  Size of buffer */
 436 {
 437     WCHAR       tmpW[MAX_ATOM_LEN + 1];
 438     UINT        wlen, len = 0, c;
 439
 440     if (count <= 0) SetLastError( ERROR_MORE_DATA );
 441     else if ((wlen = GetAtomNameW( atom, tmpW, MAX_ATOM_LEN + 1 )))
 442     {
 443         char    tmp[MAX_ATOM_LEN + 1];
 444
 445         len = WideCharToMultiByte( CP_ACP, 0, tmpW, wlen, tmp, MAX_ATOM_LEN + 1, NULL, NULL );
 446         c = min(len, count - 1);
 447         memcpy(buffer, tmp, c);
 448         buffer[c] = '\0';
 449         if (len >= count)
 450         {
 451             len = c;
 452             SetLastError( ERROR_MORE_DATA );
 453         }
 454     }
 455     return len;
 456 }
 457
 458
 459 /***********************************************************************
 460  *           GlobalGetAtomNameW   (KERNEL32.@)
 461  *
 462  * Unicode version of GlobalGetAtomNameA.
 463  */
 464 UINT WINAPI GlobalGetAtomNameW( ATOM atom, LPWSTR buffer, INT count )
 465 {
 466     char        ptr[sizeof(ATOM_BASIC_INFORMATION) + MAX_ATOM_LEN * sizeof(WCHAR)];
 467     ATOM_BASIC_INFORMATION*     abi = (ATOM_BASIC_INFORMATION*)ptr;
 468     ULONG       ptr_size = sizeof(ATOM_BASIC_INFORMATION) + MAX_ATOM_LEN * sizeof(WCHAR);
 469     NTSTATUS    status;
 470     UINT        length = 0;
 471
 472     if (count <= 0)
 473     {
 474         SetLastError( ERROR_MORE_DATA );
 475         return 0;
 476     }
 477     status = NtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
 478     if (status) SetLastError( RtlNtStatusToDosError( status ) );
 479     else
 480     {
 481         length = min( abi->NameLength / sizeof(WCHAR), count);
 482         memcpy( buffer, abi->Name, length * sizeof(WCHAR) );
 483         /* yes, the string will not be null terminated if the passed buffer
 484          * is one WCHAR too small (and it's not an error)
 485          */
 486         if (length < abi->NameLength / sizeof(WCHAR))
 487         {
 488             SetLastError( ERROR_MORE_DATA );
 489             length = count;
 490         }
 491         else if (length < count) buffer[length] = '\0';
 492     }
 493     return length;
 494 }
 495
 496
 497 /***********************************************************************
 498  *           GetAtomNameW   (KERNEL32.@)
 499  *
 500  * Unicode version of GetAtomNameA.
 501  */
 502 UINT WINAPI GetAtomNameW( ATOM atom, LPWSTR buffer, INT count )
 503 {
 504     NTSTATUS            status;
 505     RTL_ATOM_TABLE      table;
 506     DWORD               length;
 507     WCHAR               tmp[MAX_ATOM_LEN + 1];
 508
 509     if (count <= 0)
 510     {
 511         SetLastError( ERROR_MORE_DATA );
 512         return 0;
 513     }
 514     if (!(table = get_local_table( 0 ))) return 0;
 515     length = sizeof(tmp);
 516     status = RtlQueryAtomInAtomTable( table, atom, NULL, NULL, tmp, &length );
 517     if (status)
 518     {
 519         SetLastError( RtlNtStatusToDosError( status ) );
 520         return 0;
 521     }
 522     length = min(length, (count - 1) * sizeof(WCHAR));
 523     if (length) memcpy(buffer, tmp, length);
 524     else SetLastError( ERROR_INSUFFICIENT_BUFFER );
 525     length /= sizeof(WCHAR);
 526     buffer[length] = '\0';
 527     return length;
 528 }