Fix kernel-mode executive atom implementation (mostly add SEH and tidy
up the code). Then fix kernel32 implementation which was sending
incorrect sizes, and also re-factored the entire code, since most
functions were quatriplicated. now there are 3 main functions instead of
12. Also fixed a bug in RtlCreateAtomTable.
Modified: trunk/reactos/lib/kernel32/misc/atom.c
Modified: trunk/reactos/lib/rtl/atom.c
Modified: trunk/reactos/ntoskrnl/ex/atom.c
_____
Modified: trunk/reactos/lib/kernel32/misc/atom.c
--- trunk/reactos/lib/kernel32/misc/atom.c 2005-12-29 05:18:21 UTC
(rev 20413)
+++ trunk/reactos/lib/kernel32/misc/atom.c 2005-12-29 08:43:45 UTC
(rev 20414)
@@ -1,635 +1,584 @@
-/* $Id$
- *
+/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: lib/kernel32/misc/atom.c
* PURPOSE: Atom functions
- * PROGRAMMER: Eric Kohl ( ariadne(a)xs4all.nl)
- * UPDATE HISTORY:
- * Created 01/11/98
- * Full rewrite 27/05/2001
+ * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net)
*/
+/* INCLUDES
******************************************************************/
#include <k32.h>
#define NDEBUG
#include "../include/debug.h"
-
/* GLOBALS
*******************************************************************/
-static PRTL_ATOM_TABLE LocalAtomTable = NULL;
+PRTL_ATOM_TABLE BaseLocalAtomTable = NULL;
-static PRTL_ATOM_TABLE GetLocalAtomTable(VOID);
-
-
/* FUNCTIONS
*****************************************************************/
-/*
- * @implemented
- */
-ATOM STDCALL
-GlobalAddAtomA(LPCSTR lpString)
+PVOID
+WINAPI
+InternalInitAtomTable(VOID)
{
- UNICODE_STRING AtomName;
- NTSTATUS Status;
- ATOM Atom;
+ /* Create or return the local table */
+ if (!BaseLocalAtomTable) RtlCreateAtomTable(0,
&BaseLocalAtomTable);
+ return BaseLocalAtomTable;
+}
- if (HIWORD((ULONG)lpString) == 0)
- {
- if ((ULONG)lpString >= 0xC000)
- {
- SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
- return (ATOM)0;
- }
- return (ATOM)LOWORD((ULONG)lpString);
- }
+ATOM
+WINAPI
+InternalAddAtom(BOOLEAN Local,
+ BOOLEAN Unicode,
+ LPCSTR AtomName)
+{
+ NTSTATUS Status;
+ ANSI_STRING AnsiString;
+ UNICODE_STRING UnicodeString;
+ PUNICODE_STRING AtomNameString;
+ ATOM Atom = INVALID_ATOM;
- if (lstrlenA(lpString) > 255)
- {
- /* This limit does not exist with NtAddAtom so the limit is
probably
- * added for compability. -Gunnar
- */
- SetLastError(ERROR_INVALID_PARAMETER);
- return (ATOM)0;
- }
+ /* Check if it's an integer atom */
+ if ((ULONG_PTR)AtomName <= 0xFFFF)
+ {
+ /* Convert the name to an atom */
+ Atom = (ATOM)PtrToShort((PVOID)AtomName);
+ if (Atom >= MAXINTATOM)
+ {
+ /* Fail, atom number too large */
+ SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
+ return INVALID_ATOM;
+ }
- RtlCreateUnicodeStringFromAsciiz(&AtomName,
- (LPSTR)lpString);
+ /* Return it */
+ return Atom;
+ }
+ else
+ {
+ /* Check if this is a unicode atom */
+ if (Unicode)
+ {
+ /* Use a unicode string */
+ AtomNameString = &UnicodeString;
+ RtlInitUnicodeString(AtomNameString, (LPWSTR)AtomName);
+ Status = STATUS_SUCCESS;
+ }
+ else
+ {
+ /* Use an ansi string */
+ RtlInitAnsiString(&AnsiString, AtomName );
- Status = NtAddAtom(AtomName.Buffer,
- AtomName.Length,
- &Atom);
- RtlFreeUnicodeString(&AtomName);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return (ATOM)0;
- }
+ /* Check if we can abuse the TEB */
+ if (AnsiString.MaximumLength > 260)
+ {
+ /* We can't, allocate a new string */
+ AtomNameString = &UnicodeString;
+ Status = RtlAnsiStringToUnicodeString(AtomNameString,
+ &AnsiString,
+ TRUE);
+ }
+ else
+ {
+ /* We can! Use the TEB */
+ AtomNameString = &NtCurrentTeb()->StaticUnicodeString;
+ Status = RtlAnsiStringToUnicodeString(AtomNameString,
+ &AnsiString,
+ FALSE);
+ }
+ }
- return Atom;
-}
+ /* Check for failure */
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return Atom;
+ }
+ }
+ /* Check if we're doing local add */
+ if (Local)
+ {
+ /* Do a local add */
+ Status = RtlAddAtomToAtomTable(InternalInitAtomTable(),
+ AtomNameString->Buffer,
+ &Atom);
+ }
+ else
+ {
+ /* Do a global add */
+ Status = NtAddAtom(AtomNameString->Buffer,
+ AtomNameString->Length,
+ &Atom);
+ }
-/*
- * @implemented
- */
-ATOM STDCALL
-GlobalAddAtomW(LPCWSTR lpString)
+ /* Check for failure */
+ if (!NT_SUCCESS(Status)) SetLastErrorByStatus(Status);
+
+ /* Check if we were non-static ANSI */
+ if (!(Unicode) && (AtomNameString == &UnicodeString))
+ {
+ /* Free the allocated buffer */
+ RtlFreeUnicodeString(AtomNameString);
+ }
+
+ /* Return the atom */
+ return Atom;
+}
+
+ATOM
+WINAPI
+InternalFindAtom(BOOLEAN Local,
+ BOOLEAN Unicode,
+ LPCSTR AtomName)
{
- ATOM Atom;
- NTSTATUS Status;
+ NTSTATUS Status;
+ ANSI_STRING AnsiString;
+ UNICODE_STRING UnicodeString;
+ PUNICODE_STRING AtomNameString;
+ ATOM Atom = INVALID_ATOM;
- if (HIWORD((ULONG)lpString) == 0)
- {
- if ((ULONG)lpString >= 0xC000)
- {
- SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
- return (ATOM)0;
- }
- return (ATOM)LOWORD((ULONG)lpString);
- }
+ /* Check if it's an integer atom */
+ if ((ULONG_PTR)AtomName <= 0xFFFF)
+ {
+ /* Convert the name to an atom */
+ Atom = (ATOM)PtrToShort((PVOID)AtomName);
+ if (Atom >= MAXINTATOM)
+ {
+ /* Fail, atom number too large */
+ SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
+ DPRINT1("Invalid atom\n");
+ }
- if (lstrlenW(lpString) > 255)
- {
- /* This limit does not exist with NtAddAtom so the limit is
probably
- * added for compability. -Gunnar
- */
- SetLastError(ERROR_INVALID_PARAMETER);
- return (ATOM)0;
- }
+ /* Return it */
+ return Atom;
+ }
+ else
+ {
+ /* Check if this is a unicode atom */
+ if (Unicode)
+ {
+ /* Use a unicode string */
+ AtomNameString = &UnicodeString;
+ RtlInitUnicodeString(AtomNameString, (LPWSTR)AtomName);
+ Status = STATUS_SUCCESS;
+ }
+ else
+ {
+ /* Use an ansi string */
+ RtlInitAnsiString(&AnsiString, AtomName);
- Status = NtAddAtom((LPWSTR)lpString,
- wcslen(lpString),
- &Atom);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return (ATOM)0;
- }
+ /* Check if we can abuse the TEB */
+ if (AnsiString.MaximumLength > 260)
+ {
+ /* We can't, allocate a new string */
+ AtomNameString = &UnicodeString;
+ Status = RtlAnsiStringToUnicodeString(AtomNameString,
+ &AnsiString,
+ TRUE);
+ }
+ else
+ {
+ /* We can! Use the TEB */
+ AtomNameString = &NtCurrentTeb()->StaticUnicodeString;
+ Status = RtlAnsiStringToUnicodeString(AtomNameString,
+ &AnsiString,
+ FALSE);
+ }
+ }
- return Atom;
-}
+ /* Check for failure */
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed\n");
+ SetLastErrorByStatus(Status);
+ return Atom;
+ }
+ }
+ /* Check if we're doing local lookup */
+ if (Local)
+ {
+ /* Do a local lookup */
+ Status = RtlLookupAtomInAtomTable(InternalInitAtomTable(),
+ AtomNameString->Buffer,
+ &Atom);
+ }
+ else
+ {
+ /* Do a global search */
+ if (!AtomNameString->Length)
+ {
+ /* This is illegal in win32 */
+ DPRINT1("No name given\n");
+ Status = STATUS_OBJECT_NAME_NOT_FOUND;
+ }
+ else
+ {
+ /* Call the global function */
+ Status = NtFindAtom(AtomNameString->Buffer,
+ AtomNameString->Length,
+ &Atom);
+ }
+ }
-/*
- * @implemented
- */
-ATOM STDCALL
-GlobalDeleteAtom(ATOM nAtom)
+ /* Check for failure */
+ if (!NT_SUCCESS(Status)) SetLastErrorByStatus(Status);
+
+ /* Check if we were non-static ANSI */
+ if (!(Unicode) && (AtomNameString == &UnicodeString))
+ {
+ /* Free the allocated buffer */
+ RtlFreeUnicodeString(AtomNameString);
+ }
+
+ /* Return the atom */
+ return Atom;
+}
+
+ATOM
+WINAPI
+InternalDeleteAtom(BOOLEAN Local,
+ ATOM Atom)
{
- NTSTATUS Status;
+ NTSTATUS Status;
- if (nAtom < 0xC000)
- {
- return 0;
- }
+ /* Validate it */
+ if (Atom >= MAXINTATOM)
+ {
+ /* Check if it's a local delete */
+ if (Local)
+ {
+ /* Delete it locally */
+ Status =
RtlDeleteAtomFromAtomTable(InternalInitAtomTable(), Atom);
+ }
+ else
+ {
+ /* Delete it globall */
+ Status = NtDeleteAtom(Atom);
+ }
- Status = NtDeleteAtom(nAtom);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return nAtom;
- }
+ /* Check for success */
+ if (!NT_SUCCESS(Status))
+ {
+ /* Fail */
+ SetLastErrorByStatus(Status);
+ return INVALID_ATOM;
+ }
+ }
- return 0;
+ /* Return failure */
+ return 0;
}
-
-/*
- * @implemented
- */
-ATOM STDCALL
-GlobalFindAtomA(LPCSTR lpString)
+UINT
+WINAPI
+InternalGetAtomName(BOOLEAN Local,
+ BOOLEAN Unicode,
+ ATOM Atom,
+ LPSTR AtomName,
+ DWORD Size)
{
- UNICODE_STRING AtomName;
- NTSTATUS Status;
- ATOM Atom;
+ NTSTATUS Status;
+ DWORD RetVal = 0;
+ ANSI_STRING AnsiString;
+ UNICODE_STRING UnicodeString;
+ PVOID TempBuffer = NULL;
+ PWSTR AtomNameString;
+ ULONG AtomInfoLength;
+ ULONG AtomNameLength;
+ PATOM_BASIC_INFORMATION AtomInfo;
- if (HIWORD((ULONG)lpString) == 0)
- {
- if ((ULONG)lpString >= 0xC000)
- {
- SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
- return (ATOM)0;
- }
- return (ATOM)LOWORD((ULONG)lpString);
- }
+ /* Normalize the size as not to overflow */
+ if (!Unicode && Size > 0x7000) Size = 0x7000;
- if (lstrlenA(lpString) > 255)
- {
- /* This limit does not exist with NtAddAtom so the limit is
probably
- * added for compability. -Gunnar
- */
- SetLastError(ERROR_INVALID_PARAMETER);
- return (ATOM)0;
- }
+ /* Make sure it's valid too */
+ if (!Size)
+ {
+ SetLastErrorByStatus(STATUS_BUFFER_OVERFLOW);
+ return 0;
+ }
- RtlCreateUnicodeStringFromAsciiz(&AtomName,
- (LPSTR)lpString);
- Status = NtFindAtom(AtomName.Buffer,
- AtomName.Length,
- &Atom);
- RtlFreeUnicodeString(&AtomName);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return (ATOM)0;
- }
+ /* Check if this is a global query */
+ if (Local)
+ {
+ /* Set the query length */
+ AtomNameLength = Size * sizeof(WCHAR);
- return Atom;
-}
+ /* If it's unicode, just keep the name */
+ if (Unicode)
+ {
+ AtomNameString = (PWSTR)AtomName;
+ }
+ else
+ {
+ /* Allocate memory for the ansi buffer */
+ TempBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
+ 0,
+ AtomNameLength);
+ AtomNameString = TempBuffer;
+ }
+ /* Query the name */
+ Status = RtlQueryAtomInAtomTable(InternalInitAtomTable(),
+ Atom,
+ NULL,
+ NULL,
+ AtomNameString,
+ &AtomNameLength);
+ }
+ else
+ {
+ /* We're going to do a global query, so allocate a buffer */
+ AtomInfoLength = sizeof(ATOM_BASIC_INFORMATION) +
+ (Size * sizeof(WCHAR));
+ AtomInfo = TempBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
+ 0,
+ AtomInfoLength);
-/*
- * @implemented
- */
-ATOM STDCALL
-GlobalFindAtomW(LPCWSTR lpString)
-{
- ATOM Atom;
- NTSTATUS Status;
+ /* Query the name */
+ Status = NtQueryInformationAtom(Atom,
+ AtomBasicInformation,
+ AtomInfo,
+ AtomInfoLength,
+ &AtomInfoLength);
+ if (NT_SUCCESS(Status))
+ {
+ /* Success. Update the length and get the name */
+ AtomNameLength = (ULONG)AtomInfo->NameLength;
+ AtomNameString = AtomInfo->Name;
+ }
+ }
- if (HIWORD((ULONG)lpString) == 0)
- {
- if ((ULONG)lpString >= 0xC000)
- {
- SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
- return (ATOM)0;
- }
- return (ATOM)LOWORD((ULONG)lpString);
- }
+ /* Check for global success */
+ if (NT_SUCCESS(Status))
+ {
+ /* Check if it was unicode */
+ if (Unicode)
+ {
+ /* We return the length in chars */
+ RetVal = AtomNameLength / sizeof(WCHAR);
- if (lstrlenW(lpString) > 255)
- {
- /* This limit does not exist with NtAddAtom so the limit is
probably
- * added for compability. -Gunnar
- */
- SetLastError(ERROR_INVALID_PARAMETER);
- return (ATOM)0;
- }
+ /* Copy the memory if this was a global query */
+ if (AtomNameString != (PWSTR)AtomName)
+ {
+ RtlMoveMemory(AtomName, AtomNameString,
AtomNameLength);
+ }
- Status = NtFindAtom((LPWSTR)lpString,
- wcslen(lpString),
- &Atom);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return (ATOM)0;
- }
+ /* And null-terminate it if the buffer was too large */
+ if (RetVal < Size)
+ {
+ ((PWCHAR)AtomName)[RetVal] = UNICODE_NULL;
+ }
+ }
+ else
+ {
+ /* First create a unicode string with our data */
+ UnicodeString.Buffer = AtomNameString;
+ UnicodeString.Length = (USHORT)AtomNameLength;
+ UnicodeString.MaximumLength = (USHORT)(UnicodeString.Length
+
+ sizeof(WCHAR));
- return Atom;
-}
+ /* Now prepare an ansi string for conversion */
+ AnsiString.Buffer = AtomName;
+ AnsiString.Length = 0;
+ AnsiString.MaximumLength = (USHORT)Size;
+ /* Convert it */
+ Status = RtlUnicodeStringToAnsiString(&AnsiString,
+ &UnicodeString,
+ FALSE);
-UINT STDCALL
-GlobalGetAtomNameA(ATOM nAtom,
- LPSTR lpBuffer,
- int nSize)
-{
- PATOM_BASIC_INFORMATION Buffer;
- UNICODE_STRING AtomNameU;
- ANSI_STRING AtomName;
- ULONG BufferSize;
- ULONG ReturnLength;
- NTSTATUS Status;
+ /* Return the length */
+ if (NT_SUCCESS(Status)) RetVal = AnsiString.Length;
+ }
+ }
- BufferSize = sizeof(ATOM_BASIC_INFORMATION) + nSize * sizeof(WCHAR);
- Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
- HEAP_ZERO_MEMORY,
- BufferSize);
- if (Buffer == NULL)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- return 0;
- }
+ /* Free the temporary buffer if we have one */
+ if (TempBuffer) RtlFreeHeap(RtlGetProcessHeap(), 0, TempBuffer);
- Status = NtQueryInformationAtom(nAtom,
- AtomBasicInformation,
- Buffer,
- BufferSize,
- &ReturnLength);
- if (!NT_SUCCESS(Status))
- {
- RtlFreeHeap(RtlGetProcessHeap(),
- 0,
- Buffer);
+ /* Check for failure */
+ if (!NT_SUCCESS(Status))
+ {
+ /* Fail */
+ DPRINT1("Failed: %lx\n", Status);
SetLastErrorByStatus(Status);
- return 0;
- }
+ }
- RtlInitUnicodeString(&AtomNameU,
- Buffer->Name);
- AtomName.Buffer = lpBuffer;
- AtomName.Length = 0;
- AtomName.MaximumLength = nSize;
- RtlUnicodeStringToAnsiString(&AtomName,
- &AtomNameU,
- FALSE);
+ /* Return length */
+ return RetVal;
+}
- ReturnLength = AtomName.Length;
- RtlFreeHeap(RtlGetProcessHeap(),
- 0,
- Buffer);
+/* FUNCTIONS
*****************************************************************/
- return ReturnLength;
+/*
+ * @implemented
+ */
+ATOM
+WINAPI
+GlobalAddAtomA(LPCSTR lpString)
+{
+ return InternalAddAtom(FALSE, FALSE, lpString);
}
+/*
+ * @implemented
+ */
+ATOM
+WINAPI
+GlobalAddAtomW(LPCWSTR lpString)
+{
+ return InternalAddAtom(FALSE, TRUE, (LPSTR)lpString);
+}
/*
* @implemented
*/
-UINT STDCALL
-GlobalGetAtomNameW(ATOM nAtom,
- LPWSTR lpBuffer,
- int nSize)
+ATOM
+WINAPI
+GlobalDeleteAtom(ATOM nAtom)
{
- PATOM_BASIC_INFORMATION Buffer;
- ULONG BufferSize;
- ULONG ReturnLength;
- NTSTATUS Status;
+ return InternalDeleteAtom(FALSE, nAtom);
+}
- BufferSize = sizeof(ATOM_BASIC_INFORMATION) + nSize * sizeof(WCHAR);
- Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
- HEAP_ZERO_MEMORY,
- BufferSize);
- if (Buffer == NULL)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- return 0;
- }
+/*
+ * @implemented
+ */
+ATOM
+WINAPI
+GlobalFindAtomA(LPCSTR lpString)
+{
+ return InternalFindAtom(FALSE, FALSE, lpString);
+}
- Status = NtQueryInformationAtom(nAtom,
- AtomBasicInformation,
- Buffer,
- BufferSize,
- &ReturnLength);
- if (!NT_SUCCESS(Status))
- {
- RtlFreeHeap(RtlGetProcessHeap(),
- 0,
- Buffer);
- SetLastErrorByStatus(Status);
- return 0;
- }
+/*
+ * @implemented
+ */
+ATOM
+WINAPI
+GlobalFindAtomW(LPCWSTR lpString)
+{
+ return InternalFindAtom(FALSE, TRUE, (LPSTR)lpString);
+}
- memcpy(lpBuffer, Buffer->Name, Buffer->NameLength);
- ReturnLength = Buffer->NameLength / sizeof(WCHAR);
- *(lpBuffer + ReturnLength) = 0;
- RtlFreeHeap(RtlGetProcessHeap(),
- 0,
- Buffer);
-
- return ReturnLength;
+/*
+ * @implemented
+ */
+UINT
+WINAPI
+GlobalGetAtomNameA(ATOM nAtom,
+ LPSTR lpBuffer,
+ int nSize)
+{
+ return InternalGetAtomName(FALSE, FALSE, nAtom, lpBuffer,
(DWORD)nSize);
}
-
-static PRTL_ATOM_TABLE
-GetLocalAtomTable(VOID)
+/*
+ * @implemented
+ */
+UINT
+WINAPI
+GlobalGetAtomNameW(ATOM nAtom,
+ LPWSTR lpBuffer,
+ int nSize)
{
- if (LocalAtomTable != NULL)
- {
- return LocalAtomTable;
- }
- RtlCreateAtomTable(37,
- &LocalAtomTable);
- return LocalAtomTable;
+ return InternalGetAtomName(FALSE,
+ TRUE,
+ nAtom,
+ (LPSTR)lpBuffer,
+ (DWORD)nSize);
}
-
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+WINAPI
InitAtomTable(DWORD nSize)
{
- NTSTATUS Status;
+ /* Normalize size */
+ if (nSize < 4 || nSize > 511) nSize = 37;
- /* nSize should be a prime number */
-
- if ( nSize < 4 || nSize >= 512 )
- {
- nSize = 37;
- }
-
- if (LocalAtomTable == NULL)
- {
- Status = RtlCreateAtomTable(nSize,
- &LocalAtomTable);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return FALSE;
- }
- }
-
- return TRUE;
+ DPRINT("Here\n");
+ return NT_SUCCESS(RtlCreateAtomTable(nSize, &BaseLocalAtomTable));
}
-
/*
* @implemented
*/
-ATOM STDCALL
+ATOM
+WINAPI
AddAtomA(LPCSTR lpString)
{
- PRTL_ATOM_TABLE AtomTable;
- UNICODE_STRING AtomName;
- NTSTATUS Status;
- ATOM Atom;
-
- if (HIWORD((ULONG)lpString) == 0)
- {
- if ((ULONG)lpString >= 0xC000)
- {
- SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
- return (ATOM)0;
- }
- return (ATOM)LOWORD((ULONG)lpString);
- }
-
- AtomTable = GetLocalAtomTable();
-
- RtlCreateUnicodeStringFromAsciiz(&AtomName,
- (LPSTR)lpString);
-
- Status = RtlAddAtomToAtomTable(AtomTable,
- AtomName.Buffer,
- &Atom);
- RtlFreeUnicodeString(&AtomName);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return (ATOM)0;
- }
-
- return Atom;
+ return InternalAddAtom(TRUE, FALSE, lpString);
}
-
/*
* @implemented
*/
-ATOM STDCALL
+ATOM
+WINAPI
AddAtomW(LPCWSTR lpString)
{
- PRTL_ATOM_TABLE AtomTable;
- ATOM Atom;
- NTSTATUS Status;
-
- if (HIWORD((ULONG)lpString) == 0)
- {
- if ((ULONG)lpString >= 0xC000)
- {
- SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
- return (ATOM)0;
- }
- return (ATOM)LOWORD((ULONG)lpString);
- }
-
- AtomTable = GetLocalAtomTable();
-
- Status = RtlAddAtomToAtomTable(AtomTable,
- (LPWSTR)lpString,
- &Atom);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return (ATOM)0;
- }
-
- return Atom;
+ return InternalAddAtom(TRUE, TRUE, (LPSTR)lpString);
}
-
/*
* @implemented
*/
-ATOM STDCALL
+ATOM
+WINAPI
DeleteAtom(ATOM nAtom)
{
- PRTL_ATOM_TABLE AtomTable;
- NTSTATUS Status;
-
- if (nAtom < 0xC000)
- {
- return 0;
- }
-
- AtomTable = GetLocalAtomTable();
-
- Status = RtlDeleteAtomFromAtomTable(AtomTable,
- nAtom);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return nAtom;
- }
-
- return 0;
+ return InternalDeleteAtom(TRUE, nAtom);
}
-
/*
* @implemented
*/
-ATOM STDCALL
+ATOM
+WINAPI
FindAtomA(LPCSTR lpString)
{
- PRTL_ATOM_TABLE AtomTable;
- UNICODE_STRING AtomName;
- NTSTATUS Status;
- ATOM Atom;
-
- if (HIWORD((ULONG)lpString) == 0)
- {
- if ((ULONG)lpString >= 0xC000)
- {
- SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
- return (ATOM)0;
- }
- return (ATOM)LOWORD((ULONG)lpString);
- }
-
- AtomTable = GetLocalAtomTable();
- RtlCreateUnicodeStringFromAsciiz(&AtomName,
- (LPSTR)lpString);
- Status = RtlLookupAtomInAtomTable(AtomTable,
- AtomName.Buffer,
- &Atom);
- RtlFreeUnicodeString(&AtomName);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return (ATOM)0;
- }
-
- return Atom;
+ return InternalFindAtom(TRUE, FALSE, lpString);
}
-
/*
* @implemented
*/
-ATOM STDCALL
+ATOM
+WINAPI
FindAtomW(LPCWSTR lpString)
{
- PRTL_ATOM_TABLE AtomTable;
- ATOM Atom;
- NTSTATUS Status;
+ return InternalFindAtom(TRUE, TRUE, (LPSTR)lpString);
- if (HIWORD((ULONG)lpString) == 0)
- {
- if ((ULONG)lpString >= 0xC000)
- {
- SetLastErrorByStatus(STATUS_INVALID_PARAMETER);
- return (ATOM)0;
- }
- return (ATOM)LOWORD((ULONG)lpString);
- }
-
- AtomTable = GetLocalAtomTable();
-
- Status = RtlLookupAtomInAtomTable(AtomTable,
- (LPWSTR)lpString,
- &Atom);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return (ATOM)0;
- }
-
- return Atom;
}
-
/*
* @implemented
*/
-UINT STDCALL
+UINT
+WINAPI
GetAtomNameA(ATOM nAtom,
- LPSTR lpBuffer,
- int nSize)
[truncated at 1000 lines; 539 more skipped]
