ReactOS  0.4.13-dev-66-gc714b7f
nsutils.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: nsutils - Utilities for accessing ACPI namespace, accessing
4  * parents and siblings and Scope manipulation
5  *
6  *****************************************************************************/
7 
8 /*
9  * Copyright (C) 2000 - 2019, Intel Corp.
10  * All rights reserved.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  * notice, this list of conditions, and the following disclaimer,
17  * without modification.
18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19  * substantially similar to the "NO WARRANTY" disclaimer below
20  * ("Disclaimer") and any redistribution must be conditioned upon
21  * including a substantially similar Disclaimer requirement for further
22  * binary redistribution.
23  * 3. Neither the names of the above-listed copyright holders nor the names
24  * of any contributors may be used to endorse or promote products derived
25  * from this software without specific prior written permission.
26  *
27  * Alternatively, this software may be distributed under the terms of the
28  * GNU General Public License ("GPL") version 2 as published by the Free
29  * Software Foundation.
30  *
31  * NO WARRANTY
32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42  * POSSIBILITY OF SUCH DAMAGES.
43  */
44 
45 #include "acpi.h"
46 #include "accommon.h"
47 #include "acnamesp.h"
48 #include "amlcode.h"
49 
50 #define _COMPONENT ACPI_NAMESPACE
51  ACPI_MODULE_NAME ("nsutils")
52 
53 /* Local prototypes */
54 
55 #ifdef ACPI_OBSOLETE_FUNCTIONS
57 AcpiNsFindParentName (
58  ACPI_NAMESPACE_NODE *NodeToSearch);
59 #endif
60 
61 
62 /*******************************************************************************
63  *
64  * FUNCTION: AcpiNsPrintNodePathname
65  *
66  * PARAMETERS: Node - Object
67  * Message - Prefix message
68  *
69  * DESCRIPTION: Print an object's full namespace pathname
70  * Manages allocation/freeing of a pathname buffer
71  *
72  ******************************************************************************/
73 
74 void
77  const char *Message)
78 {
81 
82 
83  if (!Node)
84  {
85  AcpiOsPrintf ("[NULL NAME]");
86  return;
87  }
88 
89  /* Convert handle to full pathname and print it (with supplied message) */
90 
92 
94  if (ACPI_SUCCESS (Status))
95  {
96  if (Message)
97  {
98  AcpiOsPrintf ("%s ", Message);
99  }
100 
101  AcpiOsPrintf ("%s", (char *) Buffer.Pointer);
102  ACPI_FREE (Buffer.Pointer);
103  }
104 }
105 
106 
107 /*******************************************************************************
108  *
109  * FUNCTION: AcpiNsGetType
110  *
111  * PARAMETERS: Node - Parent Node to be examined
112  *
113  * RETURN: Type field from Node whose handle is passed
114  *
115  * DESCRIPTION: Return the type of a Namespace node
116  *
117  ******************************************************************************/
118 
122 {
123  ACPI_FUNCTION_TRACE (NsGetType);
124 
125 
126  if (!Node)
127  {
128  ACPI_WARNING ((AE_INFO, "Null Node parameter"));
130  }
131 
132  return_UINT8 (Node->Type);
133 }
134 
135 
136 /*******************************************************************************
137  *
138  * FUNCTION: AcpiNsLocal
139  *
140  * PARAMETERS: Type - A namespace object type
141  *
142  * RETURN: LOCAL if names must be found locally in objects of the
143  * passed type, 0 if enclosing scopes should be searched
144  *
145  * DESCRIPTION: Returns scope rule for the given object type.
146  *
147  ******************************************************************************/
148 
149 UINT32
152 {
153  ACPI_FUNCTION_TRACE (NsLocal);
154 
155 
157  {
158  /* Type code out of range */
159 
160  ACPI_WARNING ((AE_INFO, "Invalid Object Type 0x%X", Type));
162  }
163 
165 }
166 
167 
168 /*******************************************************************************
169  *
170  * FUNCTION: AcpiNsGetInternalNameLength
171  *
172  * PARAMETERS: Info - Info struct initialized with the
173  * external name pointer.
174  *
175  * RETURN: None
176  *
177  * DESCRIPTION: Calculate the length of the internal (AML) namestring
178  * corresponding to the external (ASL) namestring.
179  *
180  ******************************************************************************/
181 
182 void
185 {
186  const char *NextExternalChar;
187  UINT32 i;
188 
189 
191 
192 
193  NextExternalChar = Info->ExternalName;
194  Info->NumCarats = 0;
195  Info->NumSegments = 0;
196  Info->FullyQualified = FALSE;
197 
198  /*
199  * For the internal name, the required length is 4 bytes per segment,
200  * plus 1 each for RootPrefix, MultiNamePrefixOp, segment count,
201  * trailing null (which is not really needed, but no there's harm in
202  * putting it there)
203  *
204  * strlen() + 1 covers the first NameSeg, which has no path separator
205  */
206  if (ACPI_IS_ROOT_PREFIX (*NextExternalChar))
207  {
208  Info->FullyQualified = TRUE;
209  NextExternalChar++;
210 
211  /* Skip redundant RootPrefix, like \\_SB.PCI0.SBRG.EC0 */
212 
213  while (ACPI_IS_ROOT_PREFIX (*NextExternalChar))
214  {
215  NextExternalChar++;
216  }
217  }
218  else
219  {
220  /* Handle Carat prefixes */
221 
222  while (ACPI_IS_PARENT_PREFIX (*NextExternalChar))
223  {
224  Info->NumCarats++;
225  NextExternalChar++;
226  }
227  }
228 
229  /*
230  * Determine the number of ACPI name "segments" by counting the number of
231  * path separators within the string. Start with one segment since the
232  * segment count is [(# separators) + 1], and zero separators is ok.
233  */
234  if (*NextExternalChar)
235  {
236  Info->NumSegments = 1;
237  for (i = 0; NextExternalChar[i]; i++)
238  {
239  if (ACPI_IS_PATH_SEPARATOR (NextExternalChar[i]))
240  {
241  Info->NumSegments++;
242  }
243  }
244  }
245 
246  Info->Length = (ACPI_NAMESEG_SIZE * Info->NumSegments) +
247  4 + Info->NumCarats;
248 
249  Info->NextExternalChar = NextExternalChar;
250 }
251 
252 
253 /*******************************************************************************
254  *
255  * FUNCTION: AcpiNsBuildInternalName
256  *
257  * PARAMETERS: Info - Info struct fully initialized
258  *
259  * RETURN: Status
260  *
261  * DESCRIPTION: Construct the internal (AML) namestring
262  * corresponding to the external (ASL) namestring.
263  *
264  ******************************************************************************/
265 
269 {
270  UINT32 NumSegments = Info->NumSegments;
271  char *InternalName = Info->InternalName;
272  const char *ExternalName = Info->NextExternalChar;
273  char *Result = NULL;
274  UINT32 i;
275 
276 
277  ACPI_FUNCTION_TRACE (NsBuildInternalName);
278 
279 
280  /* Setup the correct prefixes, counts, and pointers */
281 
282  if (Info->FullyQualified)
283  {
284  InternalName[0] = AML_ROOT_PREFIX;
285 
286  if (NumSegments <= 1)
287  {
288  Result = &InternalName[1];
289  }
290  else if (NumSegments == 2)
291  {
292  InternalName[1] = AML_DUAL_NAME_PREFIX;
293  Result = &InternalName[2];
294  }
295  else
296  {
297  InternalName[1] = AML_MULTI_NAME_PREFIX;
298  InternalName[2] = (char) NumSegments;
299  Result = &InternalName[3];
300  }
301  }
302  else
303  {
304  /*
305  * Not fully qualified.
306  * Handle Carats first, then append the name segments
307  */
308  i = 0;
309  if (Info->NumCarats)
310  {
311  for (i = 0; i < Info->NumCarats; i++)
312  {
313  InternalName[i] = AML_PARENT_PREFIX;
314  }
315  }
316 
317  if (NumSegments <= 1)
318  {
319  Result = &InternalName[i];
320  }
321  else if (NumSegments == 2)
322  {
323  InternalName[i] = AML_DUAL_NAME_PREFIX;
324  Result = &InternalName[(ACPI_SIZE) i+1];
325  }
326  else
327  {
328  InternalName[i] = AML_MULTI_NAME_PREFIX;
329  InternalName[(ACPI_SIZE) i+1] = (char) NumSegments;
330  Result = &InternalName[(ACPI_SIZE) i+2];
331  }
332  }
333 
334  /* Build the name (minus path separators) */
335 
336  for (; NumSegments; NumSegments--)
337  {
338  for (i = 0; i < ACPI_NAMESEG_SIZE; i++)
339  {
340  if (ACPI_IS_PATH_SEPARATOR (*ExternalName) ||
341  (*ExternalName == 0))
342  {
343  /* Pad the segment with underscore(s) if segment is short */
344 
345  Result[i] = '_';
346  }
347  else
348  {
349  /* Convert the character to uppercase and save it */
350 
351  Result[i] = (char) toupper ((int) *ExternalName);
352  ExternalName++;
353  }
354  }
355 
356  /* Now we must have a path separator, or the pathname is bad */
357 
358  if (!ACPI_IS_PATH_SEPARATOR (*ExternalName) &&
359  (*ExternalName != 0))
360  {
362  }
363 
364  /* Move on the next segment */
365 
366  ExternalName++;
368  }
369 
370  /* Terminate the string */
371 
372  *Result = 0;
373 
374  if (Info->FullyQualified)
375  {
376  ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (abs) \"\\%s\"\n",
377  InternalName, InternalName));
378  }
379  else
380  {
381  ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (rel) \"%s\"\n",
382  InternalName, InternalName));
383  }
384 
386 }
387 
388 
389 /*******************************************************************************
390  *
391  * FUNCTION: AcpiNsInternalizeName
392  *
393  * PARAMETERS: *ExternalName - External representation of name
394  * **Converted Name - Where to return the resulting
395  * internal represention of the name
396  *
397  * RETURN: Status
398  *
399  * DESCRIPTION: Convert an external representation (e.g. "\_PR_.CPU0")
400  * to internal form (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30)
401  *
402  *******************************************************************************/
403 
406  const char *ExternalName,
407  char **ConvertedName)
408 {
409  char *InternalName;
412 
413 
414  ACPI_FUNCTION_TRACE (NsInternalizeName);
415 
416 
417  if ((!ExternalName) ||
418  (*ExternalName == 0) ||
419  (!ConvertedName))
420  {
422  }
423 
424  /* Get the length of the new internal name */
425 
426  Info.ExternalName = ExternalName;
428 
429  /* We need a segment to store the internal name */
430 
431  InternalName = ACPI_ALLOCATE_ZEROED (Info.Length);
432  if (!InternalName)
433  {
435  }
436 
437  /* Build the name */
438 
439  Info.InternalName = InternalName;
441  if (ACPI_FAILURE (Status))
442  {
443  ACPI_FREE (InternalName);
445  }
446 
447  *ConvertedName = InternalName;
449 }
450 
451 
452 /*******************************************************************************
453  *
454  * FUNCTION: AcpiNsExternalizeName
455  *
456  * PARAMETERS: InternalNameLength - Length of the internal name below
457  * InternalName - Internal representation of name
458  * ConvertedNameLength - Where the length is returned
459  * ConvertedName - Where the resulting external name
460  * is returned
461  *
462  * RETURN: Status
463  *
464  * DESCRIPTION: Convert internal name (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30)
465  * to its external (printable) form (e.g. "\_PR_.CPU0")
466  *
467  ******************************************************************************/
468 
471  UINT32 InternalNameLength,
472  const char *InternalName,
473  UINT32 *ConvertedNameLength,
474  char **ConvertedName)
475 {
476  UINT32 NamesIndex = 0;
477  UINT32 NumSegments = 0;
479  UINT32 PrefixLength = 0;
480  UINT32 i = 0;
481  UINT32 j = 0;
482 
483 
484  ACPI_FUNCTION_TRACE (NsExternalizeName);
485 
486 
487  if (!InternalNameLength ||
488  !InternalName ||
489  !ConvertedName)
490  {
492  }
493 
494  /* Check for a prefix (one '\' | one or more '^') */
495 
496  switch (InternalName[0])
497  {
498  case AML_ROOT_PREFIX:
499 
500  PrefixLength = 1;
501  break;
502 
503  case AML_PARENT_PREFIX:
504 
505  for (i = 0; i < InternalNameLength; i++)
506  {
507  if (ACPI_IS_PARENT_PREFIX (InternalName[i]))
508  {
509  PrefixLength = i + 1;
510  }
511  else
512  {
513  break;
514  }
515  }
516 
517  if (i == InternalNameLength)
518  {
519  PrefixLength = i;
520  }
521 
522  break;
523 
524  default:
525 
526  break;
527  }
528 
529  /*
530  * Check for object names. Note that there could be 0-255 of these
531  * 4-byte elements.
532  */
533  if (PrefixLength < InternalNameLength)
534  {
535  switch (InternalName[PrefixLength])
536  {
538 
539  /* <count> 4-byte names */
540 
541  NamesIndex = PrefixLength + 2;
542  NumSegments = (UINT8)
543  InternalName[(ACPI_SIZE) PrefixLength + 1];
544  break;
545 
547 
548  /* Two 4-byte names */
549 
550  NamesIndex = PrefixLength + 1;
551  NumSegments = 2;
552  break;
553 
554  case 0:
555 
556  /* NullName */
557 
558  NamesIndex = 0;
559  NumSegments = 0;
560  break;
561 
562  default:
563 
564  /* one 4-byte name */
565 
566  NamesIndex = PrefixLength;
567  NumSegments = 1;
568  break;
569  }
570  }
571 
572  /*
573  * Calculate the length of ConvertedName, which equals the length
574  * of the prefix, length of all object names, length of any required
575  * punctuation ('.') between object names, plus the NULL terminator.
576  */
577  RequiredLength = PrefixLength + (4 * NumSegments) +
578  ((NumSegments > 0) ? (NumSegments - 1) : 0) + 1;
579 
580  /*
581  * Check to see if we're still in bounds. If not, there's a problem
582  * with InternalName (invalid format).
583  */
584  if (RequiredLength > InternalNameLength)
585  {
586  ACPI_ERROR ((AE_INFO, "Invalid internal name"));
588  }
589 
590  /* Build the ConvertedName */
591 
592  *ConvertedName = ACPI_ALLOCATE_ZEROED (RequiredLength);
593  if (!(*ConvertedName))
594  {
596  }
597 
598  j = 0;
599 
600  for (i = 0; i < PrefixLength; i++)
601  {
602  (*ConvertedName)[j++] = InternalName[i];
603  }
604 
605  if (NumSegments > 0)
606  {
607  for (i = 0; i < NumSegments; i++)
608  {
609  if (i > 0)
610  {
611  (*ConvertedName)[j++] = '.';
612  }
613 
614  /* Copy and validate the 4-char name segment */
615 
616  ACPI_COPY_NAMESEG (&(*ConvertedName)[j],
617  &InternalName[NamesIndex]);
618  AcpiUtRepairName (&(*ConvertedName)[j]);
619 
620  j += ACPI_NAMESEG_SIZE;
621  NamesIndex += ACPI_NAMESEG_SIZE;
622  }
623  }
624 
625  if (ConvertedNameLength)
626  {
627  *ConvertedNameLength = (UINT32) RequiredLength;
628  }
629 
631 }
632 
633 
634 /*******************************************************************************
635  *
636  * FUNCTION: AcpiNsValidateHandle
637  *
638  * PARAMETERS: Handle - Handle to be validated and typecast to a
639  * namespace node.
640  *
641  * RETURN: A pointer to a namespace node
642  *
643  * DESCRIPTION: Convert a namespace handle to a namespace node. Handles special
644  * cases for the root node.
645  *
646  * NOTE: Real integer handles would allow for more verification
647  * and keep all pointers within this subsystem - however this introduces
648  * more overhead and has not been necessary to this point. Drivers
649  * holding handles are typically notified before a node becomes invalid
650  * due to a table unload.
651  *
652  ******************************************************************************/
653 
657 {
658 
660 
661 
662  /* Parameter validation */
663 
664  if ((!Handle) || (Handle == ACPI_ROOT_OBJECT))
665  {
666  return (AcpiGbl_RootNode);
667  }
668 
669  /* We can at least attempt to verify the handle */
670 
672  {
673  return (NULL);
674  }
675 
677 }
678 
679 
680 /*******************************************************************************
681  *
682  * FUNCTION: AcpiNsTerminate
683  *
684  * PARAMETERS: none
685  *
686  * RETURN: none
687  *
688  * DESCRIPTION: free memory allocated for namespace and ACPI table storage.
689  *
690  ******************************************************************************/
691 
692 void
694  void)
695 {
697  ACPI_OPERAND_OBJECT *Prev;
698  ACPI_OPERAND_OBJECT *Next;
699 
700 
701  ACPI_FUNCTION_TRACE (NsTerminate);
702 
703 
704  /* Delete any module-level code blocks */
705 
706  Next = AcpiGbl_ModuleCodeList;
707  while (Next)
708  {
709  Prev = Next;
710  Next = Next->Method.Mutex;
711  Prev->Method.Mutex = NULL; /* Clear the Mutex (cheated) field */
712  AcpiUtRemoveReference (Prev);
713  }
714 
715  /*
716  * Free the entire namespace -- all nodes and all objects
717  * attached to the nodes
718  */
719  AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
720 
721  /* Delete any objects attached to the root node */
722 
724  if (ACPI_FAILURE (Status))
725  {
726  return_VOID;
727  }
728 
729  AcpiNsDeleteNode (AcpiGbl_RootNode);
731 
732  ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Namespace freed\n"));
733  return_VOID;
734 }
735 
736 
737 /*******************************************************************************
738  *
739  * FUNCTION: AcpiNsOpensScope
740  *
741  * PARAMETERS: Type - A valid namespace type
742  *
743  * RETURN: NEWSCOPE if the passed type "opens a name scope" according
744  * to the ACPI specification, else 0
745  *
746  ******************************************************************************/
747 
748 UINT32
751 {
753 
754 
756  {
757  /* type code out of range */
758 
759  ACPI_WARNING ((AE_INFO, "Invalid Object Type 0x%X", Type));
760  return (ACPI_NS_NORMAL);
761  }
762 
764 }
765 
766 
767 /*******************************************************************************
768  *
769  * FUNCTION: AcpiNsGetNodeUnlocked
770  *
771  * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The
772  * \ (backslash) and ^ (carat) prefixes, and the
773  * . (period) to separate segments are supported.
774  * PrefixNode - Root of subtree to be searched, or NS_ALL for the
775  * root of the name space. If Name is fully
776  * qualified (first INT8 is '\'), the passed value
777  * of Scope will not be accessed.
778  * Flags - Used to indicate whether to perform upsearch or
779  * not.
780  * ReturnNode - Where the Node is returned
781  *
782  * DESCRIPTION: Look up a name relative to a given scope and return the
783  * corresponding Node. NOTE: Scope can be null.
784  *
785  * MUTEX: Doesn't locks namespace
786  *
787  ******************************************************************************/
788 
791  ACPI_NAMESPACE_NODE *PrefixNode,
792  const char *Pathname,
793  UINT32 Flags,
794  ACPI_NAMESPACE_NODE **ReturnNode)
795 {
796  ACPI_GENERIC_STATE ScopeInfo;
798  char *InternalPath;
799 
800 
801  ACPI_FUNCTION_TRACE_PTR (NsGetNodeUnlocked, ACPI_CAST_PTR (char, Pathname));
802 
803 
804  /* Simplest case is a null pathname */
805 
806  if (!Pathname)
807  {
808  *ReturnNode = PrefixNode;
809  if (!PrefixNode)
810  {
811  *ReturnNode = AcpiGbl_RootNode;
812  }
813 
815  }
816 
817  /* Quick check for a reference to the root */
818 
819  if (ACPI_IS_ROOT_PREFIX (Pathname[0]) && (!Pathname[1]))
820  {
821  *ReturnNode = AcpiGbl_RootNode;
823  }
824 
825  /* Convert path to internal representation */
826 
828  if (ACPI_FAILURE (Status))
829  {
831  }
832 
833  /* Setup lookup scope (search starting point) */
834 
835  ScopeInfo.Scope.Node = PrefixNode;
836 
837  /* Lookup the name in the namespace */
838 
841  NULL, ReturnNode);
842  if (ACPI_FAILURE (Status))
843  {
844  ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s, %s\n",
846  }
847 
850 }
851 
852 
853 /*******************************************************************************
854  *
855  * FUNCTION: AcpiNsGetNode
856  *
857  * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The
858  * \ (backslash) and ^ (carat) prefixes, and the
859  * . (period) to separate segments are supported.
860  * PrefixNode - Root of subtree to be searched, or NS_ALL for the
861  * root of the name space. If Name is fully
862  * qualified (first INT8 is '\'), the passed value
863  * of Scope will not be accessed.
864  * Flags - Used to indicate whether to perform upsearch or
865  * not.
866  * ReturnNode - Where the Node is returned
867  *
868  * DESCRIPTION: Look up a name relative to a given scope and return the
869  * corresponding Node. NOTE: Scope can be null.
870  *
871  * MUTEX: Locks namespace
872  *
873  ******************************************************************************/
874 
877  ACPI_NAMESPACE_NODE *PrefixNode,
878  const char *Pathname,
879  UINT32 Flags,
880  ACPI_NAMESPACE_NODE **ReturnNode)
881 {
883 
884 
885  ACPI_FUNCTION_TRACE_PTR (NsGetNode, ACPI_CAST_PTR (char, Pathname));
886 
887 
889  if (ACPI_FAILURE (Status))
890  {
892  }
893 
894  Status = AcpiNsGetNodeUnlocked (PrefixNode, Pathname,
895  Flags, ReturnNode);
896 
899 }
ACPI_STATUS AcpiNsInternalizeName(const char *ExternalName, char **ConvertedName)
Definition: nsutils.c:405
BOOLEAN AcpiUtValidObjectType(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:680
#define ACPI_FREE(a)
Definition: actypes.h:386
#define ACPI_ALLOCATE_ZEROED(a)
Definition: actypes.h:385
#define TRUE
Definition: types.h:120
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
ACPI_STATUS AcpiNsLookup(ACPI_GENERIC_STATE *ScopeInfo, char *Name, ACPI_OBJECT_TYPE Type, ACPI_INTERPRETER_MODE InterpreterMode, UINT32 Flags, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE **RetNode)
Definition: nsaccess.c:294
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
Type
Definition: Type.h:6
UINT32 AcpiNsLocal(ACPI_OBJECT_TYPE Type)
Definition: nsutils.c:150
#define AE_NO_MEMORY
Definition: acexcep.h:112
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
#define ACPI_WARNING(plist)
Definition: acoutput.h:238
#define return_UINT32(s)
Definition: acoutput.h:501
#define ACPI_NS_LOCAL
Definition: acnamesp.h:58
#define ACPI_TYPE_LOCAL_MAX
Definition: actypes.h:729
void AcpiUtRepairName(char *Name)
Definition: utstring.c:183
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_NS_NEWSCOPE
Definition: acnamesp.h:57
struct TraceInfo Info
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ACPI_STATUS AcpiUtReleaseMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:348
const char * AcpiFormatException(ACPI_STATUS Status)
Definition: utexcep.c:70
ACPI_STATUS AcpiUtAcquireMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:256
#define ACPI_IS_PATH_SEPARATOR(c)
Definition: acmacros.h:403
unsigned int UINT32
#define AE_BAD_PATHNAME
Definition: acexcep.h:153
#define ACPI_NS_DONT_OPEN_SCOPE
Definition: acnamesp.h:64
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
ACPI_STATUS AcpiNsExternalizeName(UINT32 InternalNameLength, const char *InternalName, UINT32 *ConvertedNameLength, char **ConvertedName)
Definition: nsutils.c:470
#define AML_DUAL_NAME_PREFIX
Definition: amlcode.h:66
const UINT8 AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES]
Definition: utdecode.c:57
smooth NULL
Definition: ftsmooth.c:416
#define AE_INFO
Definition: acoutput.h:230
ACPI_NAMESPACE_NODE * AcpiNsValidateHandle(ACPI_HANDLE Handle)
Definition: nsutils.c:655
unsigned char
Definition: typeof.h:29
ACPI_STATUS AcpiNsGetNodeUnlocked(ACPI_NAMESPACE_NODE *PrefixNode, const char *Pathname, UINT32 Flags, ACPI_NAMESPACE_NODE **ReturnNode)
Definition: nsutils.c:790
ACPI_OBJECT_TYPE AcpiNsGetType(ACPI_NAMESPACE_NODE *Node)
Definition: nsutils.c:120
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
#define ACPI_ALLOCATE_LOCAL_BUFFER
Definition: actypes.h:1036
UINT32 ACPI_OBJECT_TYPE
Definition: actypes.h:676
Definition: bufpool.h:45
#define ACPI_FUNCTION_ENTRY()
Definition: acoutput.h:484
#define ACPI_FUNCTION_TRACE_PTR(a, b)
Definition: acoutput.h:481
#define ACPI_ROOT_OBJECT
Definition: actypes.h:500
ACPI_STATUS AcpiNsHandleToPathname(ACPI_HANDLE TargetHandle, ACPI_BUFFER *Buffer, BOOLEAN NoTrailing)
Definition: nsnames.c:193
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
_In_ HANDLE Handle
Definition: extypes.h:390
int toupper(int c)
Definition: utclib.c:881
UINT32 AcpiNsOpensScope(ACPI_OBJECT_TYPE Type)
Definition: nsutils.c:749
#define AML_PARENT_PREFIX
Definition: amlcode.h:70
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
void AcpiNsTerminate(void)
Definition: nsutils.c:693
ACPI_STATUS AcpiNsBuildInternalName(ACPI_NAMESTRING_INFO *Info)
Definition: nsutils.c:267
void AcpiNsGetInternalNameLength(ACPI_NAMESTRING_INFO *Info)
Definition: nsutils.c:183
#define return_VOID
Definition: acoutput.h:495
void AcpiNsDeleteNamespaceSubtree(ACPI_NAMESPACE_NODE *ParentHandle)
Definition: nsalloc.c:399
void ACPI_INTERNAL_VAR_XFACE AcpiOsPrintf(const char *Format,...)
Definition: osl.c:851
CHAR Message[80]
Definition: alive.c:5
#define AML_ROOT_PREFIX
Definition: amlcode.h:69
#define ACPI_TYPE_ANY
Definition: actypes.h:678
UINT32 ACPI_NAME
Definition: actypes.h:461
#define ACPI_NS_NORMAL
Definition: acnamesp.h:56
#define ACPI_COPY_NAMESEG(dest, src)
Definition: actypes.h:562
#define ACPI_IS_PARENT_PREFIX(c)
Definition: acmacros.h:402
union acpi_operand_object * Mutex
Definition: acobject.h:218
Status
Definition: gdiplustypes.h:24
ACPI_OBJECT_METHOD Method
Definition: acobject.h:522
#define ACPI_DB_EXEC
Definition: acoutput.h:165
#define ACPI_DB_INFO
Definition: acoutput.h:153
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
_In_ ULONG _Out_opt_ PULONG RequiredLength
Definition: wmifuncs.h:29
ACPI_STATE_COMMON ACPI_NAMESPACE_NODE * Node
Definition: aclocal.h:740
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:784
void AcpiNsDeleteNode(ACPI_NAMESPACE_NODE *Node)
Definition: nsalloc.c:117
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
#define AML_MULTI_NAME_PREFIX
Definition: amlcode.h:67
void AcpiNsPrintNodePathname(ACPI_NAMESPACE_NODE *Node, const char *Message)
Definition: nsutils.c:75
#define ACPI_IS_ROOT_PREFIX(c)
Definition: acmacros.h:401
#define ACPI_DESC_TYPE_NAMED
Definition: acobject.h:574
#define ACPI_MTX_NAMESPACE
Definition: aclocal.h:85
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
#define ACPI_NAMESEG_SIZE
Definition: actypes.h:415
#define ACPI_CAST_PTR(t, p)
Definition: actypes.h:544
unsigned char UINT8
ACPI_STATUS AcpiNsGetNode(ACPI_NAMESPACE_NODE *PrefixNode, const char *Pathname, UINT32 Flags, ACPI_NAMESPACE_NODE **ReturnNode)
Definition: nsutils.c:876
#define AE_OK
Definition: acexcep.h:97
ACPI_SCOPE_STATE Scope
Definition: aclocal.h:825
#define return_UINT8(s)
Definition: acoutput.h:500
Definition: dlist.c:348
#define ACPI_GET_DESCRIPTOR_TYPE(d)
Definition: acmacros.h:414
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING Pathname
Definition: acpixf.h:688