ReactOS  r76032
nsprepkg.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: nsprepkg - Validation of package objects for predefined names
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2017, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  * notice, this list of conditions, and the following disclaimer,
16  * without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  * substantially similar to the "NO WARRANTY" disclaimer below
19  * ("Disclaimer") and any redistribution must be conditioned upon
20  * including a substantially similar Disclaimer requirement for further
21  * binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  * of any contributors may be used to endorse or promote products derived
24  * from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include "acpi.h"
45 #include "accommon.h"
46 #include "acnamesp.h"
47 #include "acpredef.h"
48 
49 
50 #define _COMPONENT ACPI_NAMESPACE
51  ACPI_MODULE_NAME ("nsprepkg")
52 
53 
54 /* Local prototypes */
55 
56 static ACPI_STATUS
59  const ACPI_PREDEFINED_INFO *Package,
61  UINT32 Count);
62 
63 static ACPI_STATUS
65  ACPI_EVALUATE_INFO *Info,
66  ACPI_OPERAND_OBJECT **Elements,
67  UINT8 Type1,
68  UINT32 Count1,
69  UINT8 Type2,
70  UINT32 Count2,
71  UINT32 StartIndex);
72 
73 static ACPI_STATUS
75  ACPI_EVALUATE_INFO *Info,
76  ACPI_OPERAND_OBJECT **Elements,
77  UINT32 Count);
78 
79 
80 /*******************************************************************************
81  *
82  * FUNCTION: AcpiNsCheckPackage
83  *
84  * PARAMETERS: Info - Method execution information block
85  * ReturnObjectPtr - Pointer to the object returned from the
86  * evaluation of a method or object
87  *
88  * RETURN: Status
89  *
90  * DESCRIPTION: Check a returned package object for the correct count and
91  * correct type of all sub-objects.
92  *
93  ******************************************************************************/
94 
97  ACPI_EVALUATE_INFO *Info,
98  ACPI_OPERAND_OBJECT **ReturnObjectPtr)
99 {
100  ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr;
101  const ACPI_PREDEFINED_INFO *Package;
104  UINT32 ExpectedCount;
105  UINT32 Count;
106  UINT32 i;
107 
108 
109  ACPI_FUNCTION_NAME (NsCheckPackage);
110 
111 
112  /* The package info for this name is in the next table entry */
113 
114  Package = Info->Predefined + 1;
115 
117  "%s Validating return Package of Type %X, Count %X\n",
118  Info->FullPathname, Package->RetInfo.Type,
119  ReturnObject->Package.Count));
120 
121  /*
122  * For variable-length Packages, we can safely remove all embedded
123  * and trailing NULL package elements
124  */
125  AcpiNsRemoveNullElements (Info, Package->RetInfo.Type, ReturnObject);
126 
127  /* Extract package count and elements array */
128 
129  Elements = ReturnObject->Package.Elements;
130  Count = ReturnObject->Package.Count;
131 
132  /*
133  * Most packages must have at least one element. The only exception
134  * is the variable-length package (ACPI_PTYPE1_VAR).
135  */
136  if (!Count)
137  {
138  if (Package->RetInfo.Type == ACPI_PTYPE1_VAR)
139  {
140  return (AE_OK);
141  }
142 
143  ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
144  "Return Package has no elements (empty)"));
145 
146  return (AE_AML_OPERAND_VALUE);
147  }
148 
149  /*
150  * Decode the type of the expected package contents
151  *
152  * PTYPE1 packages contain no subpackages
153  * PTYPE2 packages contain subpackages
154  */
155  switch (Package->RetInfo.Type)
156  {
157  case ACPI_PTYPE_CUSTOM:
158 
159  Status = AcpiNsCustomPackage (Info, Elements, Count);
160  break;
161 
162  case ACPI_PTYPE1_FIXED:
163  /*
164  * The package count is fixed and there are no subpackages
165  *
166  * If package is too small, exit.
167  * If package is larger than expected, issue warning but continue
168  */
169  ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
170  if (Count < ExpectedCount)
171  {
172  goto PackageTooSmall;
173  }
174  else if (Count > ExpectedCount)
175  {
177  "%s: Return Package is larger than needed - "
178  "found %u, expected %u\n",
179  Info->FullPathname, Count, ExpectedCount));
180  }
181 
182  /* Validate all elements of the returned package */
183 
184  Status = AcpiNsCheckPackageElements (Info, Elements,
185  Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
186  Package->RetInfo.ObjectType2, Package->RetInfo.Count2, 0);
187  break;
188 
189  case ACPI_PTYPE1_VAR:
190  /*
191  * The package count is variable, there are no subpackages, and all
192  * elements must be of the same type
193  */
194  for (i = 0; i < Count; i++)
195  {
196  Status = AcpiNsCheckObjectType (Info, Elements,
197  Package->RetInfo.ObjectType1, i);
198  if (ACPI_FAILURE (Status))
199  {
200  return (Status);
201  }
202 
203  Elements++;
204  }
205  break;
206 
207  case ACPI_PTYPE1_OPTION:
208  /*
209  * The package count is variable, there are no subpackages. There are
210  * a fixed number of required elements, and a variable number of
211  * optional elements.
212  *
213  * Check if package is at least as large as the minimum required
214  */
215  ExpectedCount = Package->RetInfo3.Count;
216  if (Count < ExpectedCount)
217  {
218  goto PackageTooSmall;
219  }
220 
221  /* Variable number of sub-objects */
222 
223  for (i = 0; i < Count; i++)
224  {
225  if (i < Package->RetInfo3.Count)
226  {
227  /* These are the required package elements (0, 1, or 2) */
228 
229  Status = AcpiNsCheckObjectType (Info, Elements,
230  Package->RetInfo3.ObjectType[i], i);
231  if (ACPI_FAILURE (Status))
232  {
233  return (Status);
234  }
235  }
236  else
237  {
238  /* These are the optional package elements */
239 
240  Status = AcpiNsCheckObjectType (Info, Elements,
241  Package->RetInfo3.TailObjectType, i);
242  if (ACPI_FAILURE (Status))
243  {
244  return (Status);
245  }
246  }
247 
248  Elements++;
249  }
250  break;
251 
253 
254  /* First element is the (Integer) revision */
255 
256  Status = AcpiNsCheckObjectType (
257  Info, Elements, ACPI_RTYPE_INTEGER, 0);
258  if (ACPI_FAILURE (Status))
259  {
260  return (Status);
261  }
262 
263  Elements++;
264  Count--;
265 
266  /* Examine the subpackages */
267 
268  Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
269  break;
270 
272 
273  /* First element is the (Integer) count of subpackages to follow */
274 
275  Status = AcpiNsCheckObjectType (
276  Info, Elements, ACPI_RTYPE_INTEGER, 0);
277  if (ACPI_FAILURE (Status))
278  {
279  return (Status);
280  }
281 
282  /*
283  * Count cannot be larger than the parent package length, but allow it
284  * to be smaller. The >= accounts for the Integer above.
285  */
286  ExpectedCount = (UINT32) (*Elements)->Integer.Value;
287  if (ExpectedCount >= Count)
288  {
289  goto PackageTooSmall;
290  }
291 
292  Count = ExpectedCount;
293  Elements++;
294 
295  /* Examine the subpackages */
296 
297  Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
298  break;
299 
300  case ACPI_PTYPE2:
301  case ACPI_PTYPE2_FIXED:
302  case ACPI_PTYPE2_MIN:
303  case ACPI_PTYPE2_COUNT:
304  case ACPI_PTYPE2_FIX_VAR:
305  /*
306  * These types all return a single Package that consists of a
307  * variable number of subpackages.
308  *
309  * First, ensure that the first element is a subpackage. If not,
310  * the BIOS may have incorrectly returned the object as a single
311  * package instead of a Package of Packages (a common error if
312  * there is only one entry). We may be able to repair this by
313  * wrapping the returned Package with a new outer Package.
314  */
315  if (*Elements && ((*Elements)->Common.Type != ACPI_TYPE_PACKAGE))
316  {
317  /* Create the new outer package and populate it */
318 
319  Status = AcpiNsWrapWithPackage (
320  Info, ReturnObject, ReturnObjectPtr);
321  if (ACPI_FAILURE (Status))
322  {
323  return (Status);
324  }
325 
326  /* Update locals to point to the new package (of 1 element) */
327 
328  ReturnObject = *ReturnObjectPtr;
329  Elements = ReturnObject->Package.Elements;
330  Count = 1;
331  }
332 
333  /* Examine the subpackages */
334 
335  Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
336  break;
337 
338  case ACPI_PTYPE2_VAR_VAR:
339  /*
340  * Returns a variable list of packages, each with a variable list
341  * of objects.
342  */
343  break;
344 
346 
347  /* The package must contain pairs of (UUID + type) */
348 
349  if (Count & 1)
350  {
351  ExpectedCount = Count + 1;
352  goto PackageTooSmall;
353  }
354 
355  while (Count > 0)
356  {
357  Status = AcpiNsCheckObjectType(Info, Elements,
358  Package->RetInfo.ObjectType1, 0);
359  if (ACPI_FAILURE(Status))
360  {
361  return (Status);
362  }
363 
364  /* Validate length of the UUID buffer */
365 
366  if ((*Elements)->Buffer.Length != 16)
367  {
368  ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
369  Info->NodeFlags, "Invalid length for UUID Buffer"));
370  return (AE_AML_OPERAND_VALUE);
371  }
372 
373  Status = AcpiNsCheckObjectType(Info, Elements + 1,
374  Package->RetInfo.ObjectType2, 0);
375  if (ACPI_FAILURE(Status))
376  {
377  return (Status);
378  }
379 
380  Elements += 2;
381  Count -= 2;
382  }
383  break;
384 
385  default:
386 
387  /* Should not get here if predefined info table is correct */
388 
389  ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
390  "Invalid internal return type in table entry: %X",
391  Package->RetInfo.Type));
392 
393  return (AE_AML_INTERNAL);
394  }
395 
396  return (Status);
397 
398 
399 PackageTooSmall:
400 
401  /* Error exit for the case with an incorrect package count */
402 
403  ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
404  "Return Package is too small - found %u elements, expected %u",
405  Count, ExpectedCount));
406 
407  return (AE_AML_OPERAND_VALUE);
408 }
409 
410 
411 /*******************************************************************************
412  *
413  * FUNCTION: AcpiNsCheckPackageList
414  *
415  * PARAMETERS: Info - Method execution information block
416  * Package - Pointer to package-specific info for method
417  * Elements - Element list of parent package. All elements
418  * of this list should be of type Package.
419  * Count - Count of subpackages
420  *
421  * RETURN: Status
422  *
423  * DESCRIPTION: Examine a list of subpackages
424  *
425  ******************************************************************************/
426 
427 static ACPI_STATUS
430  const ACPI_PREDEFINED_INFO *Package,
432  UINT32 Count)
433 {
434  ACPI_OPERAND_OBJECT *SubPackage;
435  ACPI_OPERAND_OBJECT **SubElements;
437  UINT32 ExpectedCount;
438  UINT32 i;
439  UINT32 j;
440 
441 
442  /*
443  * Validate each subpackage in the parent Package
444  *
445  * NOTE: assumes list of subpackages contains no NULL elements.
446  * Any NULL elements should have been removed by earlier call
447  * to AcpiNsRemoveNullElements.
448  */
449  for (i = 0; i < Count; i++)
450  {
451  SubPackage = *Elements;
452  SubElements = SubPackage->Package.Elements;
453  Info->ParentPackage = SubPackage;
454 
455  /* Each sub-object must be of type Package */
456 
457  Status = AcpiNsCheckObjectType (Info, &SubPackage,
458  ACPI_RTYPE_PACKAGE, i);
459  if (ACPI_FAILURE (Status))
460  {
461  return (Status);
462  }
463 
464  /* Examine the different types of expected subpackages */
465 
466  Info->ParentPackage = SubPackage;
467  switch (Package->RetInfo.Type)
468  {
469  case ACPI_PTYPE2:
472 
473  /* Each subpackage has a fixed number of elements */
474 
475  ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
476  if (SubPackage->Package.Count < ExpectedCount)
477  {
478  goto PackageTooSmall;
479  }
480 
481  Status = AcpiNsCheckPackageElements (Info, SubElements,
482  Package->RetInfo.ObjectType1,
483  Package->RetInfo.Count1,
484  Package->RetInfo.ObjectType2,
485  Package->RetInfo.Count2, 0);
486  if (ACPI_FAILURE (Status))
487  {
488  return (Status);
489  }
490  break;
491 
492  case ACPI_PTYPE2_FIX_VAR:
493  /*
494  * Each subpackage has a fixed number of elements and an
495  * optional element
496  */
497  ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
498  if (SubPackage->Package.Count < ExpectedCount)
499  {
500  goto PackageTooSmall;
501  }
502 
503  Status = AcpiNsCheckPackageElements (Info, SubElements,
504  Package->RetInfo.ObjectType1,
505  Package->RetInfo.Count1,
506  Package->RetInfo.ObjectType2,
507  SubPackage->Package.Count - Package->RetInfo.Count1, 0);
508  if (ACPI_FAILURE (Status))
509  {
510  return (Status);
511  }
512  break;
513 
514  case ACPI_PTYPE2_VAR_VAR:
515  /*
516  * Each subpackage has a fixed or variable number of elements
517  */
518  break;
519 
520  case ACPI_PTYPE2_FIXED:
521 
522  /* Each subpackage has a fixed length */
523 
524  ExpectedCount = Package->RetInfo2.Count;
525  if (SubPackage->Package.Count < ExpectedCount)
526  {
527  goto PackageTooSmall;
528  }
529 
530  /* Check the type of each subpackage element */
531 
532  for (j = 0; j < ExpectedCount; j++)
533  {
534  Status = AcpiNsCheckObjectType (Info, &SubElements[j],
535  Package->RetInfo2.ObjectType[j], j);
536  if (ACPI_FAILURE (Status))
537  {
538  return (Status);
539  }
540  }
541  break;
542 
543  case ACPI_PTYPE2_MIN:
544 
545  /* Each subpackage has a variable but minimum length */
546 
547  ExpectedCount = Package->RetInfo.Count1;
548  if (SubPackage->Package.Count < ExpectedCount)
549  {
550  goto PackageTooSmall;
551  }
552 
553  /* Check the type of each subpackage element */
554 
555  Status = AcpiNsCheckPackageElements (Info, SubElements,
556  Package->RetInfo.ObjectType1,
557  SubPackage->Package.Count, 0, 0, 0);
558  if (ACPI_FAILURE (Status))
559  {
560  return (Status);
561  }
562  break;
563 
564  case ACPI_PTYPE2_COUNT:
565  /*
566  * First element is the (Integer) count of elements, including
567  * the count field (the ACPI name is NumElements)
568  */
569  Status = AcpiNsCheckObjectType (Info, SubElements,
570  ACPI_RTYPE_INTEGER, 0);
571  if (ACPI_FAILURE (Status))
572  {
573  return (Status);
574  }
575 
576  /*
577  * Make sure package is large enough for the Count and is
578  * is as large as the minimum size
579  */
580  ExpectedCount = (UINT32) (*SubElements)->Integer.Value;
581  if (SubPackage->Package.Count < ExpectedCount)
582  {
583  goto PackageTooSmall;
584  }
585 
586  if (SubPackage->Package.Count < Package->RetInfo.Count1)
587  {
588  ExpectedCount = Package->RetInfo.Count1;
589  goto PackageTooSmall;
590  }
591 
592  if (ExpectedCount == 0)
593  {
594  /*
595  * Either the NumEntries element was originally zero or it was
596  * a NULL element and repaired to an Integer of value zero.
597  * In either case, repair it by setting NumEntries to be the
598  * actual size of the subpackage.
599  */
600  ExpectedCount = SubPackage->Package.Count;
601  (*SubElements)->Integer.Value = ExpectedCount;
602  }
603 
604  /* Check the type of each subpackage element */
605 
606  Status = AcpiNsCheckPackageElements (Info, (SubElements + 1),
607  Package->RetInfo.ObjectType1,
608  (ExpectedCount - 1), 0, 0, 1);
609  if (ACPI_FAILURE (Status))
610  {
611  return (Status);
612  }
613  break;
614 
615  default: /* Should not get here, type was validated by caller */
616 
617  ACPI_ERROR ((AE_INFO, "Invalid Package type: %X",
618  Package->RetInfo.Type));
619  return (AE_AML_INTERNAL);
620  }
621 
622  Elements++;
623  }
624 
625  return (AE_OK);
626 
627 
628 PackageTooSmall:
629 
630  /* The subpackage count was smaller than required */
631 
633  "Return SubPackage[%u] is too small - found %u elements, expected %u",
634  i, SubPackage->Package.Count, ExpectedCount));
635 
636  return (AE_AML_OPERAND_VALUE);
637 }
638 
639 
640 /*******************************************************************************
641  *
642  * FUNCTION: AcpiNsCustomPackage
643  *
644  * PARAMETERS: Info - Method execution information block
645  * Elements - Pointer to the package elements array
646  * Count - Element count for the package
647  *
648  * RETURN: Status
649  *
650  * DESCRIPTION: Check a returned package object for the correct count and
651  * correct type of all sub-objects.
652  *
653  * NOTE: Currently used for the _BIX method only. When needed for two or more
654  * methods, probably a detect/dispatch mechanism will be required.
655  *
656  ******************************************************************************/
657 
658 static ACPI_STATUS
662  UINT32 Count)
663 {
664  UINT32 ExpectedCount;
665  UINT32 Version;
667 
668 
669  ACPI_FUNCTION_NAME (NsCustomPackage);
670 
671 
672  /* Get version number, must be Integer */
673 
674  if ((*Elements)->Common.Type != ACPI_TYPE_INTEGER)
675  {
677  "Return Package has invalid object type for version number"));
679  }
680 
681  Version = (UINT32) (*Elements)->Integer.Value;
682  ExpectedCount = 21; /* Version 1 */
683 
684  if (Version == 0)
685  {
686  ExpectedCount = 20; /* Version 0 */
687  }
688 
689  if (Count < ExpectedCount)
690  {
692  "Return Package is too small - found %u elements, expected %u",
693  Count, ExpectedCount));
695  }
696  else if (Count > ExpectedCount)
697  {
699  "%s: Return Package is larger than needed - "
700  "found %u, expected %u\n",
701  Info->FullPathname, Count, ExpectedCount));
702  }
703 
704  /* Validate all elements of the returned package */
705 
706  Status = AcpiNsCheckPackageElements (Info, Elements,
707  ACPI_RTYPE_INTEGER, 16,
708  ACPI_RTYPE_STRING, 4, 0);
709  if (ACPI_FAILURE (Status))
710  {
711  return_ACPI_STATUS (Status);
712  }
713 
714  /* Version 1 has a single trailing integer */
715 
716  if (Version > 0)
717  {
718  Status = AcpiNsCheckPackageElements (Info, Elements + 20,
719  ACPI_RTYPE_INTEGER, 1, 0, 0, 20);
720  }
721 
722  return_ACPI_STATUS (Status);
723 }
724 
725 
726 /*******************************************************************************
727  *
728  * FUNCTION: AcpiNsCheckPackageElements
729  *
730  * PARAMETERS: Info - Method execution information block
731  * Elements - Pointer to the package elements array
732  * Type1 - Object type for first group
733  * Count1 - Count for first group
734  * Type2 - Object type for second group
735  * Count2 - Count for second group
736  * StartIndex - Start of the first group of elements
737  *
738  * RETURN: Status
739  *
740  * DESCRIPTION: Check that all elements of a package are of the correct object
741  * type. Supports up to two groups of different object types.
742  *
743  ******************************************************************************/
744 
745 static ACPI_STATUS
749  UINT8 Type1,
750  UINT32 Count1,
751  UINT8 Type2,
752  UINT32 Count2,
753  UINT32 StartIndex)
754 {
755  ACPI_OPERAND_OBJECT **ThisElement = Elements;
757  UINT32 i;
758 
759 
760  /*
761  * Up to two groups of package elements are supported by the data
762  * structure. All elements in each group must be of the same type.
763  * The second group can have a count of zero.
764  */
765  for (i = 0; i < Count1; i++)
766  {
767  Status = AcpiNsCheckObjectType (Info, ThisElement,
768  Type1, i + StartIndex);
769  if (ACPI_FAILURE (Status))
770  {
771  return (Status);
772  }
773 
774  ThisElement++;
775  }
776 
777  for (i = 0; i < Count2; i++)
778  {
779  Status = AcpiNsCheckObjectType (Info, ThisElement,
780  Type2, (i + Count1 + StartIndex));
781  if (ACPI_FAILURE (Status))
782  {
783  return (Status);
784  }
785 
786  ThisElement++;
787  }
788 
789  return (AE_OK);
790 }
Definition: video.h:583
GLenum GLclampf GLint GLenum GLuint GLenum GLenum GLsizei GLenum const GLvoid GLfloat GLfloat GLfloat GLfloat GLclampd GLint 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 GLboolean GLboolean GLboolean GLint GLenum GLsizei const GLvoid GLenum GLint GLenum GLint GLint GLsizei GLint GLenum GLint GLint GLint GLint GLsizei GLenum GLsizei const GLuint GLboolean GLenum GLenum GLint GLsizei GLenum GLsizei GLenum const GLvoid GLboolean const GLboolean GLenum const GLdouble const GLfloat const GLdouble const GLfloat GLenum GLint GLint GLint GLint GLint GLint j
Definition: glfuncs.h:98
#define ACPI_RTYPE_INTEGER
Definition: aclocal.h:478
ACPI_STATUS AcpiNsCheckObjectType(ACPI_EVALUATE_INFO *Info, ACPI_OPERAND_OBJECT **ReturnObjectPtr, UINT32 ExpectedBtypes, UINT32 PackageIndex)
Definition: nspredef.c:244
ACPI_OBJECT_PACKAGE Package
Definition: acobject.h:519
#define ACPI_TYPE_INTEGER
Definition: actypes.h:672
#define AE_AML_OPERAND_VALUE
Definition: acexcep.h:171
UINT8 TailObjectType
Definition: aclocal.h:423
ACPI_STATUS AcpiNsCheckPackage(ACPI_EVALUATE_INFO *Info, ACPI_OPERAND_OBJECT **ReturnObjectPtr)
Definition: nsprepkg.c:96
#define AE_AML_INTERNAL
Definition: acexcep.h:182
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
IN PVOID IN PVOID IN USHORT Version
Definition: pci.h:359
void AcpiNsRemoveNullElements(ACPI_EVALUATE_INFO *Info, UINT8 PackageType, ACPI_OPERAND_OBJECT *ObjDesc)
Definition: nsrepair.c:494
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_DB_REPAIR
Definition: acoutput.h:152
ACPI_PACKAGE_INFO3 RetInfo3
Definition: aclocal.h:444
#define AE_AML_OPERAND_TYPE
Definition: acexcep.h:170
#define ACPI_TYPE_PACKAGE
Definition: actypes.h:675
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
GLenum GLclampf GLint i
Definition: glfuncs.h:14
unsigned int UINT32
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:212
static ACPI_STATUS AcpiNsCustomPackage(ACPI_EVALUATE_INFO *Info, ACPI_OPERAND_OBJECT **Elements, UINT32 Count)
Definition: nsprepkg.c:659
#define ACPI_WARN_PREDEFINED(plist)
Definition: acmacros.h:464
#define AE_INFO
Definition: acoutput.h:226
ACPI_STATUS AcpiNsWrapWithPackage(ACPI_EVALUATE_INFO *Info, ACPI_OPERAND_OBJECT *OriginalObject, ACPI_OPERAND_OBJECT **ObjDescPtr)
Definition: nsrepair.c:597
UINT8 ObjectType[4]
Definition: aclocal.h:411
#define ACPI_RTYPE_STRING
Definition: aclocal.h:479
#define const
Definition: zconf.h:230
if(!(yy_init))
Definition: macro.lex.yy.c:704
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:469
UINT8 ObjectType2
Definition: aclocal.h:399
UINT8 ObjectType1
Definition: aclocal.h:397
Status
Definition: gdiplustypes.h:24
static ACPI_STATUS AcpiNsCheckPackageList(ACPI_EVALUATE_INFO *Info, const ACPI_PREDEFINED_INFO *Package, ACPI_OPERAND_OBJECT **Elements, UINT32 Count)
Definition: nsprepkg.c:428
char * FullPathname
Definition: acstruct.h:210
#define return_ACPI_STATUS(s)
Definition: acoutput.h:490
#define ACPI_DB_NAMES
Definition: acoutput.h:164
#define ACPI_ERROR(plist)
Definition: acoutput.h:236
ACPI_PACKAGE_INFO2 RetInfo2
Definition: aclocal.h:443
#define Elements(x)
Definition: compiler.h:496
static ACPI_STATUS AcpiNsCheckPackageElements(ACPI_EVALUATE_INFO *Info, ACPI_OPERAND_OBJECT **Elements, UINT8 Type1, UINT32 Count1, UINT8 Type2, UINT32 Count2, UINT32 StartIndex)
Definition: nsprepkg.c:746
union acpi_operand_object * ParentPackage
Definition: acstruct.h:214
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:473
#define ACPI_RTYPE_PACKAGE
Definition: aclocal.h:481
unsigned char UINT8
ACPI_PACKAGE_INFO RetInfo
Definition: aclocal.h:442
#define AE_OK
Definition: acexcep.h:97
UINT8 ObjectType[2]
Definition: aclocal.h:422
union acpi_operand_object ** Elements
Definition: acobject.h:161