ReactOS  0.4.14-dev-41-g31d7680
atom.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS system libraries
4  * FILE: lib/rtl/atom.c
5  * PURPOSE: Atom managment
6  * PROGRAMMER: Thomas Weidenmueller
7  */
8 
9 /* INCLUDES *****************************************************************/
10 
11 #include <rtl.h>
12 
13 #define NDEBUG
14 #include <debug.h>
15 
16 /* PROTOTYPES ****************************************************************/
17 
20 extern BOOLEAN RtlpLockAtomTable(PRTL_ATOM_TABLE AtomTable);
21 extern VOID RtlpUnlockAtomTable(PRTL_ATOM_TABLE AtomTable);
22 
25 
27 extern VOID RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable);
30 
34 
35 /* FUNCTIONS *****************************************************************/
36 
37 static
40  IN PRTL_ATOM_TABLE AtomTable,
41  IN PWSTR AtomName,
42  OUT PRTL_ATOM_TABLE_ENTRY **HashLink)
43 {
45  ULONG Hash;
46 
47  RtlInitUnicodeString(&Name, AtomName);
48 
49  if (Name.Length != 0 &&
51  TRUE,
53  &Hash)))
54  {
55  PRTL_ATOM_TABLE_ENTRY Current;
57 
58  Link = &AtomTable->Buckets[Hash % AtomTable->NumberOfBuckets];
59 
60  /* search for an existing entry */
61  Current = *Link;
62  while (Current != NULL)
63  {
64  if (Current->NameLength == Name.Length / sizeof(WCHAR) &&
65  !_wcsicmp(Current->Name, Name.Buffer))
66  {
67  *HashLink = Link;
68  return Current;
69  }
70 
71  Link = &Current->HashLink;
72  Current = Current->HashLink;
73  }
74 
75  /* no matching atom found, return the hash link */
76  *HashLink = Link;
77  }
78  else
79  *HashLink = NULL;
80 
81  return NULL;
82 }
83 
84 static
85 BOOLEAN
87  PWSTR AtomName,
88  PUSHORT AtomValue)
89 {
90  UNICODE_STRING AtomString;
91  ULONG LongValue;
92  USHORT LoValue;
93  PWCHAR p;
94 
95  DPRINT("RtlpCheckIntegerAtom(AtomName '%S' AtomValue %p)\n",
96  AtomName, AtomValue);
97 
98  if (!((ULONG_PTR)AtomName & 0xFFFF0000))
99  {
100  LoValue = (USHORT)((ULONG_PTR)AtomName & 0xFFFF);
101 
102  if (LoValue == 0)
103  LoValue = 0xC000;
104 
105  if (AtomValue != NULL)
106  *AtomValue = LoValue;
107 
108  return TRUE;
109  }
110 
111  /*
112  * AtomName cannot be NULL because this
113  * case was caught by the previous test.
114  */
115  ASSERT(AtomName != NULL);
116 
117  if (*AtomName != L'#')
118  return FALSE;
119 
120  p = AtomName;
121  p++;
122  while (*p)
123  {
124  if ((*p < L'0') || (*p > L'9'))
125  return FALSE;
126  p++;
127  }
128 
129  p = AtomName;
130  p++;
131  RtlInitUnicodeString(&AtomString, p);
132 
133  DPRINT("AtomString: %wZ\n", &AtomString);
134 
135  RtlUnicodeStringToInteger(&AtomString, 10, &LongValue);
136 
137  DPRINT("LongValue: %lu\n", LongValue);
138 
139  *AtomValue = (USHORT)(LongValue & 0x0000FFFF);
140 
141  return TRUE;
142 }
143 
144 
145 /*
146  * @implemented
147  */
148 NTSTATUS
149 NTAPI
152  IN OUT PRTL_ATOM_TABLE *AtomTable)
153 {
156 
157  DPRINT("RtlCreateAtomTable(TableSize %lu AtomTable %p)\n",
158  TableSize, AtomTable);
159 
160  if (*AtomTable != NULL)
161  {
162  return STATUS_SUCCESS;
163  }
164 
165  /* Use default if size was incorrect */
166  if (TableSize <= 1) TableSize = 37;
167 
168  /* allocate atom table */
170  sizeof(RTL_ATOM_TABLE));
171  if (Table == NULL)
172  {
173  return STATUS_NO_MEMORY;
174  }
175 
176  /* initialize atom table */
177  Table->NumberOfBuckets = TableSize;
178 
180  if (!NT_SUCCESS(Status))
181  {
183  return Status;
184  }
185 
187  {
190  return STATUS_NO_MEMORY;
191  }
192 
193  *AtomTable = Table;
194  return STATUS_SUCCESS;
195 }
196 
197 
198 /*
199  * @implemented
200  */
201 NTSTATUS
202 NTAPI
204  IN PRTL_ATOM_TABLE AtomTable)
205 {
206  PRTL_ATOM_TABLE_ENTRY *CurrentBucket, *LastBucket;
207  PRTL_ATOM_TABLE_ENTRY CurrentEntry, NextEntry;
208 
209  DPRINT("RtlDestroyAtomTable (AtomTable %p)\n", AtomTable);
210 
211  if (!RtlpLockAtomTable(AtomTable))
212  {
213  return (STATUS_INVALID_PARAMETER);
214  }
215 
216  /* delete all atoms */
217  LastBucket = AtomTable->Buckets + AtomTable->NumberOfBuckets;
218  for (CurrentBucket = AtomTable->Buckets;
219  CurrentBucket != LastBucket;
220  CurrentBucket++)
221  {
222  NextEntry = *CurrentBucket;
223  *CurrentBucket = NULL;
224 
225  while (NextEntry != NULL)
226  {
227  CurrentEntry = NextEntry;
228  NextEntry = NextEntry->HashLink;
229 
230  /* no need to delete the atom handle, the handles will all be freed
231  up when destroying the atom handle table! */
232 
233  RtlpFreeAtomTableEntry(CurrentEntry);
234  }
235  }
236 
237  RtlpDestroyAtomHandleTable(AtomTable);
238 
239  RtlpUnlockAtomTable(AtomTable);
240 
241  RtlpDestroyAtomTableLock(AtomTable);
242 
243  RtlpFreeAtomTable(AtomTable);
244 
245  return STATUS_SUCCESS;
246 }
247 
248 
249 /*
250  * @implemented
251  */
252 NTSTATUS
253 NTAPI
255  PRTL_ATOM_TABLE AtomTable,
256  BOOLEAN DeletePinned)
257 {
258  PRTL_ATOM_TABLE_ENTRY *CurrentBucket, *LastBucket;
259  PRTL_ATOM_TABLE_ENTRY CurrentEntry, NextEntry, *PtrEntry;
260 
261  DPRINT("RtlEmptyAtomTable (AtomTable %p DeletePinned %x)\n",
262  AtomTable, DeletePinned);
263 
264  if (RtlpLockAtomTable(AtomTable) == FALSE)
265  {
266  return (STATUS_INVALID_PARAMETER);
267  }
268 
269  /* delete all atoms */
270  LastBucket = AtomTable->Buckets + AtomTable->NumberOfBuckets;
271  for (CurrentBucket = AtomTable->Buckets;
272  CurrentBucket != LastBucket;
273  CurrentBucket++)
274  {
275  NextEntry = *CurrentBucket;
276  PtrEntry = CurrentBucket;
277 
278  while (NextEntry != NULL)
279  {
280  CurrentEntry = NextEntry;
281  NextEntry = NextEntry->HashLink;
282 
283  if (DeletePinned || !(CurrentEntry->Flags & RTL_ATOM_IS_PINNED))
284  {
285  *PtrEntry = NextEntry;
286 
287  RtlpFreeAtomHandle(AtomTable, CurrentEntry);
288 
289  RtlpFreeAtomTableEntry(CurrentEntry);
290  }
291  else
292  {
293  PtrEntry = &CurrentEntry->HashLink;
294  }
295  }
296  }
297 
298  RtlpUnlockAtomTable(AtomTable);
299 
300  return STATUS_SUCCESS;
301 }
302 
303 
304 /*
305  * @implemented
306  */
309  IN PWSTR AtomName,
311 {
312  USHORT AtomValue;
313  PRTL_ATOM_TABLE_ENTRY *HashLink;
316 
317  DPRINT("RtlAddAtomToAtomTable (AtomTable %p AtomName %S Atom %p)\n",
318  AtomTable, AtomName, Atom);
319 
320  if (RtlpCheckIntegerAtom (AtomName, &AtomValue))
321  {
322  /* integer atom */
323  if (AtomValue >= 0xC000)
324  {
326  }
327  else if (Atom != NULL)
328  {
329  *Atom = (RTL_ATOM)AtomValue;
330  }
331 
332  return Status;
333  }
334 
335  RtlpLockAtomTable(AtomTable);
336 
337  /* string atom, hash it and try to find an existing atom with the same name */
338  Entry = RtlpHashAtomName(AtomTable, AtomName, &HashLink);
339 
340  if (Entry != NULL)
341  {
342  /* found another atom, increment the reference counter unless it's pinned */
343 
344  if (!(Entry->Flags & RTL_ATOM_IS_PINNED))
345  {
346  if (++Entry->ReferenceCount == 0)
347  {
348  /* FIXME - references overflowed, pin the atom? */
349  Entry->Flags |= RTL_ATOM_IS_PINNED;
350  }
351  }
352 
353  if (Atom != NULL)
354  {
355  *Atom = (RTL_ATOM)Entry->Atom;
356  }
357  }
358  else
359  {
360  /* couldn't find an existing atom, HashLink now points to either the
361  HashLink pointer of the previous atom or to the bucket so we can
362  simply add it to the list */
363  if (HashLink != NULL)
364  {
365  ULONG AtomNameLen = (ULONG)wcslen(AtomName);
366 
367  if (AtomNameLen > RTL_MAXIMUM_ATOM_LENGTH)
368  {
370  goto end;
371  }
372 
374  sizeof(Entry->Name) +
375  (AtomNameLen + 1) * sizeof(WCHAR));
376  if (Entry != NULL)
377  {
378  Entry->HashLink = NULL;
379  Entry->ReferenceCount = 1;
380  Entry->Flags = 0x0;
381 
382  Entry->NameLength = (UCHAR)AtomNameLen;
383  RtlCopyMemory(Entry->Name,
384  AtomName,
385  (AtomNameLen + 1) * sizeof(WCHAR));
386 
387  if (RtlpCreateAtomHandle(AtomTable, Entry))
388  {
389  /* append the atom to the list */
390  *HashLink = Entry;
391 
392  if (Atom != NULL)
393  {
394  *Atom = (RTL_ATOM)Entry->Atom;
395  }
396  }
397  else
398  {
401  }
402  }
403  else
404  {
406  }
407  }
408  else
409  {
410  /* The caller supplied an empty atom name! */
412  }
413  }
414 end:
415  RtlpUnlockAtomTable(AtomTable);
416 
417  return Status;
418 }
419 
420 
421 /*
422  * @implemented
423  */
424 NTSTATUS
425 NTAPI
427  IN PRTL_ATOM_TABLE AtomTable,
428  IN RTL_ATOM Atom)
429 {
432 
433  DPRINT("RtlDeleteAtomFromAtomTable (AtomTable %p Atom %x)\n",
434  AtomTable, Atom);
435 
436  if (Atom >= 0xC000)
437  {
438  RtlpLockAtomTable(AtomTable);
439 
440  Entry = RtlpGetAtomEntry(AtomTable, (ULONG)((USHORT)Atom - 0xC000));
441 
442  if (Entry != NULL && Entry->Atom == (USHORT)Atom)
443  {
444  if (!(Entry->Flags & RTL_ATOM_IS_PINNED))
445  {
446  if (--Entry->ReferenceCount == 0)
447  {
448  PRTL_ATOM_TABLE_ENTRY *HashLink;
449 
450  /* it's time to delete the atom. we need to unlink it from
451  the list. The easiest way is to take the atom name and
452  hash it again, this way we get the pointer to either
453  the hash bucket or the previous atom that links to the
454  one we want to delete. This way we can easily bypass
455  this item. */
456  if (RtlpHashAtomName(AtomTable, Entry->Name, &HashLink) != NULL)
457  {
458  /* bypass this atom */
459  *HashLink = Entry->HashLink;
460 
461  RtlpFreeAtomHandle(AtomTable, Entry);
462 
464  }
465  else
466  {
467  /* WTF?! This should never happen!!! */
468  ASSERT(FALSE);
469  }
470  }
471  }
472  else
473  {
474  /* tried to delete a pinned atom, do nothing and return
475  STATUS_WAS_LOCKED, which is NOT a failure code! */
477  }
478  }
479  else
480  {
482  }
483 
484  RtlpUnlockAtomTable(AtomTable);
485  }
486 
487  return Status;
488 }
489 
490 
491 /*
492  * @implemented
493  */
496  IN PWSTR AtomName,
498 {
499  PRTL_ATOM_TABLE_ENTRY Entry, *HashLink;
500  USHORT AtomValue;
501  RTL_ATOM FoundAtom = 0;
503 
504  DPRINT("RtlLookupAtomInAtomTable (AtomTable %p AtomName %S Atom %p)\n",
505  AtomTable, AtomName, Atom);
506 
507  if (RtlpCheckIntegerAtom (AtomName, &AtomValue))
508  {
509  /* integer atom */
510  if (AtomValue >= 0xC000)
511  {
513  }
514  else if (Atom != NULL)
515  {
516  *Atom = (RTL_ATOM)AtomValue;
517  }
518 
519  return Status;
520  }
521 
522  RtlpLockAtomTable(AtomTable);
524 
525  /* string atom */
526  Entry = RtlpHashAtomName(AtomTable, AtomName, &HashLink);
527  if (Entry != NULL)
528  {
530  FoundAtom = (RTL_ATOM)Entry->Atom;
531  }
532 
533  RtlpUnlockAtomTable(AtomTable);
534  if (NT_SUCCESS(Status) && Atom != NULL)
535  {
536  *Atom = FoundAtom;
537  }
538  return Status;
539 }
540 
541 
542 /*
543  * @implemented
544  */
547  IN RTL_ATOM Atom)
548 {
550 
551  DPRINT("RtlPinAtomInAtomTable (AtomTable %p Atom %x)\n",
552  AtomTable, Atom);
553 
554  if (Atom >= 0xC000)
555  {
557 
558  RtlpLockAtomTable(AtomTable);
559 
560  Entry = RtlpGetAtomEntry(AtomTable, (ULONG)((USHORT)Atom - 0xC000));
561 
562  if (Entry != NULL && Entry->Atom == (USHORT)Atom)
563  {
564  Entry->Flags |= RTL_ATOM_IS_PINNED;
565  }
566  else
567  {
569  }
570 
571  RtlpUnlockAtomTable(AtomTable);
572  }
573 
574  return Status;
575 }
576 
577 
578 /*
579  * @implemented
580  *
581  * This API is really messed up with regards to NameLength. If you pass in a
582  * valid buffer for AtomName, NameLength should be the size of the buffer
583  * (in bytes, not characters). So if you expect the string to be 6 char long,
584  * you need to allocate a buffer of 7 WCHARs and pass 14 for NameLength.
585  * The AtomName returned is always null terminated. If the NameLength you pass
586  * is smaller than 4 (4 would leave room for 1 character) the function will
587  * return with status STATUS_BUFFER_TOO_SMALL. If you pass more than 4, the
588  * return status will be STATUS_SUCCESS, even if the buffer is not large enough
589  * to hold the complete string. In that case, the string is silently truncated
590  * and made to fit in the provided buffer. On return NameLength is set to the
591  * number of bytes (but EXCLUDING the bytes for the null terminator) copied.
592  * So, if the string is 6 char long, you pass a buffer of 10 bytes, on return
593  * NameLength will be set to 8.
594  * If you pass in a NULL value for AtomName, the length of the string in bytes
595  * (again EXCLUDING the null terminator) is returned in NameLength, at least
596  * on Win2k, XP and ReactOS. NT4 will return 0 in that case.
597  */
598 NTSTATUS
599 NTAPI
601  PRTL_ATOM_TABLE AtomTable,
602  RTL_ATOM Atom,
603  PULONG RefCount,
605  PWSTR AtomName,
606  PULONG NameLength)
607 {
608  ULONG Length;
609  BOOL Unlock = FALSE;
610 
611  union
612  {
613  /* A RTL_ATOM_TABLE_ENTRY has a "WCHAR Name[1]" entry at the end.
614  * Make sure we reserve enough room to facilitate a 12 character name */
615  RTL_ATOM_TABLE_ENTRY AtomTableEntry;
616  WCHAR StringBuffer[sizeof(RTL_ATOM_TABLE_ENTRY) / sizeof(WCHAR) + 12];
617  } NumberEntry;
620 
621  if (Atom < 0xC000)
622  {
623  /* Synthesize an entry */
624  NumberEntry.AtomTableEntry.Atom = Atom;
625  NumberEntry.AtomTableEntry.NameLength = swprintf(NumberEntry.AtomTableEntry.Name,
626  L"#%lu",
627  (ULONG)Atom);
628  NumberEntry.AtomTableEntry.ReferenceCount = 1;
629  NumberEntry.AtomTableEntry.Flags = RTL_ATOM_IS_PINNED;
630  Entry = &NumberEntry.AtomTableEntry;
631  }
632  else
633  {
634  RtlpLockAtomTable(AtomTable);
635  Unlock = TRUE;
636 
637  Entry = RtlpGetAtomEntry(AtomTable, (ULONG)((USHORT)Atom - 0xC000));
638  }
639 
640  if (Entry != NULL && Entry->Atom == (USHORT)Atom)
641  {
642  DPRINT("Atom name: %wZ\n", &Entry->Name);
643 
644  if (RefCount != NULL)
645  {
646  *RefCount = Entry->ReferenceCount;
647  }
648 
649  if (PinCount != NULL)
650  {
651  *PinCount = ((Entry->Flags & RTL_ATOM_IS_PINNED) != 0);
652  }
653 
654  if (NULL != NameLength)
655  {
656  Length = Entry->NameLength * sizeof(WCHAR);
657  if (NULL != AtomName)
658  {
659  if (*NameLength < Length + sizeof(WCHAR))
660  {
661  if (*NameLength < 4)
662  {
663  *NameLength = Length;
665  }
666  else
667  {
668  Length = *NameLength - sizeof(WCHAR);
669  }
670  }
671  if (NT_SUCCESS(Status))
672  {
673  RtlCopyMemory(AtomName, Entry->Name, Length);
674  AtomName[Length / sizeof(WCHAR)] = L'\0';
675  *NameLength = Length;
676  }
677  }
678  else
679  {
680  *NameLength = Length;
681  }
682  }
683  else if (NULL != AtomName)
684  {
686  }
687  }
688  else
689  {
691  }
692 
693  if (Unlock) RtlpUnlockAtomTable(AtomTable);
694 
695  return Status;
696 }
697 
698 
699 /*
700  * @private - only used by NtQueryInformationAtom
701  */
702 NTSTATUS
703 NTAPI
705  IN PRTL_ATOM_TABLE AtomTable,
706  IN ULONG MaxAtomCount,
707  OUT ULONG *AtomCount,
708  OUT RTL_ATOM *AtomList)
709 {
710  PRTL_ATOM_TABLE_ENTRY *CurrentBucket, *LastBucket;
711  PRTL_ATOM_TABLE_ENTRY CurrentEntry;
712  ULONG Atoms = 0;
714 
715  RtlpLockAtomTable(AtomTable);
716 
717  LastBucket = AtomTable->Buckets + AtomTable->NumberOfBuckets;
718  for (CurrentBucket = AtomTable->Buckets;
719  CurrentBucket != LastBucket;
720  CurrentBucket++)
721  {
722  CurrentEntry = *CurrentBucket;
723 
724  while (CurrentEntry != NULL)
725  {
726  if (MaxAtomCount > 0)
727  {
728  *(AtomList++) = (RTL_ATOM)CurrentEntry->Atom;
729  MaxAtomCount--;
730  }
731  else
732  {
733  /* buffer too small, but don't bail. we need to determine the
734  total number of atoms in the table! */
736  }
737 
738  Atoms++;
739  CurrentEntry = CurrentEntry->HashLink;
740  }
741  }
742 
743  *AtomCount = Atoms;
744 
745  RtlpUnlockAtomTable(AtomTable);
746 
747  return Status;
748 }
749 
static int Hash(const char *)
Definition: reader.c:2257
#define IN
Definition: typedefs.h:38
Definition: rtltypes.h:1642
ASMGENDATA Table[]
Definition: genincdata.c:61
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
UCHAR NameLength
Definition: rtltypes.h:1649
unsigned short RTL_ATOM
Definition: atom.c:42
NTSTATUS NTAPI RtlDestroyAtomTable(IN PRTL_ATOM_TABLE AtomTable)
Definition: atom.c:203
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
struct _Entry Entry
Definition: kefuncs.h:640
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
uint16_t * PWSTR
Definition: typedefs.h:54
LONG NTSTATUS
Definition: precomp.h:26
UCHAR Flags
Definition: rtltypes.h:1648
NTSTATUS RtlpInitAtomTableLock(PRTL_ATOM_TABLE AtomTable)
Definition: libsupp.c:362
USHORT Atom
Definition: rtltypes.h:1646
VOID RtlpFreeAtomTableEntry(PRTL_ATOM_TABLE_ENTRY Entry)
Definition: libsupp.c:434
GLuint GLuint end
Definition: gl.h:1545
uint16_t * PWCHAR
Definition: typedefs.h:54
_Out_ RTL_ATOM * Atom
Definition: class.h:54
_In_ const GUID _In_ ULONG PinCount
Definition: strmini.h:504
static int Link(const char **args)
Definition: vfdcmd.c:2414
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:231
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
PRTL_ATOM_TABLE_ENTRY RtlpAllocAtomTableEntry(ULONG Size)
Definition: libsupp.c:426
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define RTL_ATOM_IS_PINNED
Definition: rtltypes.h:377
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
unsigned int BOOL
Definition: ntddk_ex.h:94
VOID RtlpFreeAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
Definition: libsupp.c:442
NTSTATUS NTAPI RtlQueryAtomInAtomTable(PRTL_ATOM_TABLE AtomTable, RTL_ATOM Atom, PULONG RefCount, PULONG PinCount, PWSTR AtomName, PULONG NameLength)
Definition: atom.c:600
struct NameRec_ * Name
Definition: cdprocs.h:464
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
BOOLEAN RtlpCreateAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
Definition: libsupp.c:394
VOID RtlpUnlockAtomTable(PRTL_ATOM_TABLE AtomTable)
Definition: libsupp.c:385
BOOLEAN RtlpCreateAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
Definition: libsupp.c:456
static ULONG
Definition: atom.c:57
__wchar_t WCHAR
Definition: xmlstorage.h:180
NTSTATUS NTAPI RtlDeleteAtomFromAtomTable(IN PRTL_ATOM_TABLE AtomTable, IN RTL_ATOM Atom)
Definition: atom.c:426
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define swprintf(buf, format,...)
Definition: sprintf.c:56
static const UCHAR Index[8]
Definition: usbohci.c:18
#define RTL_MAXIMUM_ATOM_LENGTH
Definition: rtltypes.h:36
WCHAR Name[1]
Definition: rtltypes.h:1650
struct atom_table * RTL_ATOM_TABLE
Definition: atom.c:43
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
unsigned char UCHAR
Definition: xmlstorage.h:181
PRTL_ATOM_TABLE_ENTRY RtlpGetAtomEntry(PRTL_ATOM_TABLE AtomTable, ULONG Index)
Definition: libsupp.c:492
static BOOLEAN RtlpCheckIntegerAtom(PWSTR AtomName, PUSHORT AtomValue)
Definition: atom.c:86
static const WCHAR L[]
Definition: oid.c:1250
VOID RtlpDestroyAtomTableLock(PRTL_ATOM_TABLE AtomTable)
Definition: libsupp.c:370
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
NTSTATUS NTAPI RtlCreateAtomTable(IN ULONG TableSize, IN OUT PRTL_ATOM_TABLE *AtomTable)
Definition: atom.c:150
struct atom_table ** PRTL_ATOM_TABLE
Definition: atom.c:43
unsigned short * PRTL_ATOM
Definition: atom.c:42
Status
Definition: gdiplustypes.h:24
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
#define STATUS_WAS_LOCKED
Definition: ntstatus.h:139
unsigned short USHORT
Definition: pedump.c:61
struct _RTL_ATOM_TABLE_ENTRY * HashLink
Definition: rtltypes.h:1644
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
struct _RTL_ATOM_TABLE_ENTRY RTL_ATOM_TABLE_ENTRY
#define STATUS_OBJECT_NAME_INVALID
Definition: udferr_usr.h:148
unsigned int * PULONG
Definition: retypes.h:1
NTSTATUS NTAPI RtlPinAtomInAtomTable(IN PRTL_ATOM_TABLE AtomTable, IN RTL_ATOM Atom)
Definition: atom.c:546
VOID RtlpDestroyAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
Definition: libsupp.c:404
BOOLEAN RtlpLockAtomTable(PRTL_ATOM_TABLE AtomTable)
Definition: libsupp.c:377
static PRTL_ATOM_TABLE_ENTRY RtlpHashAtomName(IN PRTL_ATOM_TABLE AtomTable, IN PWSTR AtomName, OUT PRTL_ATOM_TABLE_ENTRY **HashLink)
Definition: atom.c:39
#define OUT
Definition: typedefs.h:39
_Must_inspect_result_ typedef _Out_ PULONG TableSize
Definition: iotypes.h:3971
NTSTATUS NTAPI RtlEmptyAtomTable(PRTL_ATOM_TABLE AtomTable, BOOLEAN DeletePinned)
Definition: atom.c:254
NTSYSAPI NTSTATUS NTAPI RtlHashUnicodeString(_In_ CONST UNICODE_STRING *String, _In_ BOOLEAN CaseInSensitive, _In_ ULONG HashAlgorithm, _Out_ PULONG HashValue)
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToInteger(PUNICODE_STRING String, ULONG Base, PULONG Value)
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSTATUS NTAPI RtlQueryAtomListInAtomTable(IN PRTL_ATOM_TABLE AtomTable, IN ULONG MaxAtomCount, OUT ULONG *AtomCount, OUT RTL_ATOM *AtomList)
Definition: atom.c:704
PRTL_ATOM_TABLE RtlpAllocAtomTable(ULONG Size)
Definition: libsupp.c:410
#define HASH_STRING_ALGORITHM_X65599
Definition: rtlstr.c:33
GLfloat GLfloat p
Definition: glext.h:8902
NTSTATUS NTAPI RtlAddAtomToAtomTable(IN PRTL_ATOM_TABLE AtomTable, IN PWSTR AtomName, OUT PRTL_ATOM Atom)
Definition: atom.c:308
return STATUS_SUCCESS
Definition: btrfs.c:2966
VOID RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable)
Definition: libsupp.c:418
WCHAR StringBuffer[156]
Definition: ldrinit.c:41
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
unsigned short * PUSHORT
Definition: retypes.h:2
base of all file and directory entries
Definition: entries.h:82
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
NTSTATUS NTAPI RtlLookupAtomInAtomTable(IN PRTL_ATOM_TABLE AtomTable, IN PWSTR AtomName, OUT PRTL_ATOM Atom)
Definition: atom.c:495