sys/contrib/dev/acpica/compiler/aslpredef.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslpredef - support for ACPI predefined names
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2011, 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 #define ACPI_CREATE_PREDEFINED_TABLE
  45
  46 #include <contrib/dev/acpica/compiler/aslcompiler.h>
  47 #include "aslcompiler.y.h"
  48 #include <contrib/dev/acpica/include/acpredef.h>
  49
  50
  51 #define _COMPONENT          ACPI_COMPILER
  52         ACPI_MODULE_NAME    ("aslpredef")
  53
  54
  55 /* Local prototypes */
  56
  57 static UINT32
  58 ApCheckForSpecialName (
  59     ACPI_PARSE_OBJECT       *Op,
  60     char                    *Name);
  61
  62 static void
  63 ApCheckObjectType (
  64     ACPI_PARSE_OBJECT       *Op,
  65     UINT32                  ExpectedBtypes);
  66
  67 static void
  68 ApGetExpectedTypes (
  69     char                    *Buffer,
  70     UINT32                  ExpectedBtypes);
  71
  72
  73 /*
  74  * Names for the types that can be returned by the predefined objects.
  75  * Used for warning messages. Must be in the same order as the ACPI_RTYPEs
  76  */
  77 static const char   *AcpiRtypeNames[] =
  78 {
  79     "/Integer",
  80     "/String",
  81     "/Buffer",
  82     "/Package",
  83     "/Reference",
  84 };
  85
  86 /*
  87  * Predefined names for use in Resource Descriptors. These names do not
  88  * appear in the global Predefined Name table (since these names never
  89  * appear in actual AML byte code, only in the original ASL)
  90  */
  91 static const ACPI_PREDEFINED_INFO      ResourceNames[] = {
  92     {{"_ALN",     0,      0}},
  93     {{"_ASI",     0,      0}},
  94     {{"_ASZ",     0,      0}},
  95     {{"_ATT",     0,      0}},
  96     {{"_BAS",     0,      0}},
  97     {{"_BM_",     0,      0}},
  98     {{"_DEC",     0,      0}},
  99     {{"_GRA",     0,      0}},
 100     {{"_HE_",     0,      0}},
 101     {{"_INT",     0,      0}},
 102     {{"_LEN",     0,      0}},
 103     {{"_LL_",     0,      0}},
 104     {{"_MAF",     0,      0}},
 105     {{"_MAX",     0,      0}},
 106     {{"_MEM",     0,      0}},
 107     {{"_MIF",     0,      0}},
 108     {{"_MIN",     0,      0}},
 109     {{"_MTP",     0,      0}},
 110     {{"_RBO",     0,      0}},
 111     {{"_RBW",     0,      0}},
 112     {{"_RNG",     0,      0}},
 113     {{"_RT_",     0,      0}},  /* Acpi 3.0 */
 114     {{"_RW_",     0,      0}},
 115     {{"_SHR",     0,      0}},
 116     {{"_SIZ",     0,      0}},
 117     {{"_TRA",     0,      0}},
 118     {{"_TRS",     0,      0}},
 119     {{"_TSF",     0,      0}},  /* Acpi 3.0 */
 120     {{"_TTP",     0,      0}},
 121     {{"_TYP",     0,      0}},
 122     {{{0,0,0,0},  0,      0}}   /* Table terminator */
 123 };
 124
 125 static const ACPI_PREDEFINED_INFO      ScopeNames[] = {
 126     {{"_SB_",     0,      0}},
 127     {{"_SI_",     0,      0}},
 128     {{"_TZ_",     0,      0}},
 129     {{{0,0,0,0},  0,      0}}   /* Table terminator */
 130 };
 131
 132
 133 /*******************************************************************************
 134  *
 135  * FUNCTION:    ApCheckForPredefinedMethod
 136  *
 137  * PARAMETERS:  Op              - A parse node of type "METHOD".
 138  *              MethodInfo      - Saved info about this method
 139  *
 140  * RETURN:      None
 141  *
 142  * DESCRIPTION: If method is a predefined name, check that the number of
 143  *              arguments and the return type (returns a value or not)
 144  *              is correct.
 145  *
 146  ******************************************************************************/
 147
 148 void
 149 ApCheckForPredefinedMethod (
 150     ACPI_PARSE_OBJECT       *Op,
 151     ASL_METHOD_INFO         *MethodInfo)
 152 {
 153     UINT32                  Index;
 154     UINT32                  RequiredArgsCurrent;
 155     UINT32                  RequiredArgsOld;
 156
 157
 158     /* Check for a match against the predefined name list */
 159
 160     Index = ApCheckForPredefinedName (Op, Op->Asl.NameSeg);
 161
 162     switch (Index)
 163     {
 164     case ACPI_NOT_RESERVED_NAME:        /* No underscore or _Txx or _xxx name not matched */
 165     case ACPI_PREDEFINED_NAME:          /* Resource Name or reserved scope name */
 166     case ACPI_COMPILER_RESERVED_NAME:   /* A _Txx that was not emitted by compiler */
 167
 168         /* Just return, nothing to do */
 169         break;
 170
 171
 172     case ACPI_EVENT_RESERVED_NAME:      /* _Lxx/_Exx/_Wxx/_Qxx methods */
 173
 174         Gbl_ReservedMethods++;
 175
 176         /* NumArguments must be zero for all _Lxx/_Exx/_Wxx/_Qxx methods */
 177
 178         if (MethodInfo->NumArguments != 0)
 179         {
 180             sprintf (MsgBuffer, "%s requires %u", Op->Asl.ExternalName, 0);
 181
 182             AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op,
 183                 MsgBuffer);
 184         }
 185         break;
 186
 187
 188     default:
 189         /*
 190          * Matched a predefined method name
 191          *
 192          * Validate the ASL-defined argument count. Allow two different legal
 193          * arg counts.
 194          */
 195         Gbl_ReservedMethods++;
 196
 197         RequiredArgsCurrent = PredefinedNames[Index].Info.ParamCount & 0x0F;
 198         RequiredArgsOld = PredefinedNames[Index].Info.ParamCount >> 4;
 199
 200         if ((MethodInfo->NumArguments != RequiredArgsCurrent) &&
 201             (MethodInfo->NumArguments != RequiredArgsOld))
 202         {
 203             sprintf (MsgBuffer, "%4.4s requires %u",
 204                 PredefinedNames[Index].Info.Name, RequiredArgsCurrent);
 205
 206             if (MethodInfo->NumArguments > RequiredArgsCurrent)
 207             {
 208                 AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op,
 209                     MsgBuffer);
 210             }
 211             else
 212             {
 213                 AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_LO, Op,
 214                     MsgBuffer);
 215             }
 216         }
 217
 218         /*
 219          * Check if method returns no value, but the predefined name is
 220          * required to return a value
 221          */
 222         if (MethodInfo->NumReturnNoValue &&
 223             PredefinedNames[Index].Info.ExpectedBtypes)
 224         {
 225             ApGetExpectedTypes (StringBuffer,
 226                 PredefinedNames[Index].Info.ExpectedBtypes);
 227
 228             sprintf (MsgBuffer, "%s required for %4.4s",
 229                 StringBuffer, PredefinedNames[Index].Info.Name);
 230
 231             AslError (ASL_WARNING, ASL_MSG_RESERVED_RETURN_VALUE, Op,
 232                 MsgBuffer);
 233         }
 234         break;
 235     }
 236 }
 237
 238
 239 /*******************************************************************************
 240  *
 241  * FUNCTION:    ApCheckPredefinedReturnValue
 242  *
 243  * PARAMETERS:  Op              - A parse node of type "RETURN".
 244  *              MethodInfo      - Saved info about this method
 245  *
 246  * RETURN:      None
 247  *
 248  * DESCRIPTION: If method is a predefined name, attempt to validate the return
 249  *              value. Only "static" types can be validated - a simple return
 250  *              of an integer/string/buffer/package or a named reference to
 251  *              a static object. Values such as a Localx or Argx or a control
 252  *              method invocation are not checked.
 253  *
 254  ******************************************************************************/
 255
 256 void
 257 ApCheckPredefinedReturnValue (
 258     ACPI_PARSE_OBJECT       *Op,
 259     ASL_METHOD_INFO         *MethodInfo)
 260 {
 261     UINT32                  Index;
 262     ACPI_PARSE_OBJECT       *ReturnValueOp;
 263
 264
 265     /* Check parent method for a match against the predefined name list */
 266
 267     Index = ApCheckForPredefinedName (MethodInfo->Op,
 268                 MethodInfo->Op->Asl.NameSeg);
 269
 270     switch (Index)
 271     {
 272     case ACPI_NOT_RESERVED_NAME:        /* No underscore or _Txx or _xxx name not matched */
 273     case ACPI_PREDEFINED_NAME:          /* Resource Name or reserved scope name */
 274     case ACPI_COMPILER_RESERVED_NAME:   /* A _Txx that was not emitted by compiler */
 275     case ACPI_EVENT_RESERVED_NAME:      /* _Lxx/_Exx/_Wxx/_Qxx methods */
 276
 277         /* Just return, nothing to do */
 278         return;
 279
 280     default: /* A standard predefined ACPI name */
 281
 282         /* Exit if no return value expected */
 283
 284         if (!PredefinedNames[Index].Info.ExpectedBtypes)
 285         {
 286             return;
 287         }
 288
 289         /* Get the object returned, it is the next argument */
 290
 291         ReturnValueOp = Op->Asl.Child;
 292         switch (ReturnValueOp->Asl.ParseOpcode)
 293         {
 294         case PARSEOP_ZERO:
 295         case PARSEOP_ONE:
 296         case PARSEOP_ONES:
 297         case PARSEOP_INTEGER:
 298         case PARSEOP_STRING_LITERAL:
 299         case PARSEOP_BUFFER:
 300         case PARSEOP_PACKAGE:
 301
 302             /* Static data return object - check against expected type */
 303
 304             ApCheckObjectType (ReturnValueOp,
 305                 PredefinedNames[Index].Info.ExpectedBtypes);
 306             break;
 307
 308         default:
 309
 310             /*
 311              * All other ops are very difficult or impossible to typecheck at
 312              * compile time. These include all Localx, Argx, and method
 313              * invocations. Also, NAMESEG and NAMESTRING because the type of
 314              * any named object can be changed at runtime (for example,
 315              * CopyObject will change the type of the target object.)
 316              */
 317             break;
 318         }
 319     }
 320 }
 321
 322
 323 /*******************************************************************************
 324  *
 325  * FUNCTION:    ApCheckForPredefinedObject
 326  *
 327  * PARAMETERS:  Op              - A parse node
 328  *              Name            - The ACPI name to be checked
 329  *
 330  * RETURN:      None
 331  *
 332  * DESCRIPTION: Check for a predefined name for a static object (created via
 333  *              the ASL Name operator). If it is a predefined ACPI name, ensure
 334  *              that the name does not require any arguments (which would
 335  *              require a control method implemenation of the name), and that
 336  *              the type of the object is one of the expected types for the
 337  *              predefined name.
 338  *
 339  ******************************************************************************/
 340
 341 void
 342 ApCheckForPredefinedObject (
 343     ACPI_PARSE_OBJECT       *Op,
 344     char                    *Name)
 345 {
 346     UINT32                  Index;
 347
 348
 349     /*
 350      * Check for a real predefined name -- not a resource descriptor name
 351      * or a predefined scope name
 352      */
 353     Index = ApCheckForPredefinedName (Op, Name);
 354
 355     switch (Index)
 356     {
 357     case ACPI_NOT_RESERVED_NAME:        /* No underscore or _Txx or _xxx name not matched */
 358     case ACPI_PREDEFINED_NAME:          /* Resource Name or reserved scope name */
 359     case ACPI_COMPILER_RESERVED_NAME:   /* A _Txx that was not emitted by compiler */
 360
 361         /* Nothing to do */
 362         return;
 363
 364     case ACPI_EVENT_RESERVED_NAME:      /* _Lxx/_Exx/_Wxx/_Qxx methods */
 365
 366         /*
 367          * These names must be control methods, by definition in ACPI spec.
 368          * Also because they are defined to return no value. None of them
 369          * require any arguments.
 370          */
 371         AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op,
 372             "with zero arguments");
 373         return;
 374
 375     default: /* A standard predefined ACPI name */
 376
 377         /*
 378          * If this predefined name requires input arguments, then
 379          * it must be implemented as a control method
 380          */
 381         if (PredefinedNames[Index].Info.ParamCount > 0)
 382         {
 383             AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op,
 384                 "with arguments");
 385             return;
 386         }
 387
 388         /*
 389          * If no return value is expected from this predefined name, then
 390          * it follows that it must be implemented as a control method
 391          * (with zero args, because the args > 0 case was handled above)
 392          * Examples are: _DIS, _INI, _IRC, _OFF, _ON, _PSx
 393          */
 394         if (!PredefinedNames[Index].Info.ExpectedBtypes)
 395         {
 396             AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op,
 397                 "with zero arguments");
 398             return;
 399         }
 400
 401         /* Typecheck the actual object, it is the next argument */
 402
 403         ApCheckObjectType (Op->Asl.Child->Asl.Next,
 404             PredefinedNames[Index].Info.ExpectedBtypes);
 405         return;
 406     }
 407 }
 408
 409
 410 /*******************************************************************************
 411  *
 412  * FUNCTION:    ApCheckForPredefinedName
 413  *
 414  * PARAMETERS:  Op              - A parse node
 415  *              Name            - NameSeg to check
 416  *
 417  * RETURN:      None
 418  *
 419  * DESCRIPTION: Check a NameSeg against the reserved list.
 420  *
 421  ******************************************************************************/
 422
 423 UINT32
 424 ApCheckForPredefinedName (
 425     ACPI_PARSE_OBJECT       *Op,
 426     char                    *Name)
 427 {
 428     UINT32                  i;
 429
 430
 431     if (Name[0] == 0)
 432     {
 433         AcpiOsPrintf ("Found a null name, external = %s\n",
 434             Op->Asl.ExternalName);
 435     }
 436
 437     /* All reserved names are prefixed with a single underscore */
 438
 439     if (Name[0] != '_')
 440     {
 441         return (ACPI_NOT_RESERVED_NAME);
 442     }
 443
 444     /* Check for a standard predefined method name */
 445
 446     for (i = 0; PredefinedNames[i].Info.Name[0]; i++)
 447     {
 448         if (ACPI_COMPARE_NAME (Name, PredefinedNames[i].Info.Name))
 449         {
 450             /* Return index into predefined array */
 451             return (i);
 452         }
 453     }
 454
 455     /* Check for resource names and predefined scope names */
 456
 457     for (i = 0; ResourceNames[i].Info.Name[0]; i++)
 458     {
 459         if (ACPI_COMPARE_NAME (Name, ResourceNames[i].Info.Name))
 460         {
 461             return (ACPI_PREDEFINED_NAME);
 462         }
 463     }
 464
 465     for (i = 0; ScopeNames[i].Info.Name[0]; i++)
 466     {
 467         if (ACPI_COMPARE_NAME (Name, ScopeNames[i].Info.Name))
 468         {
 469             return (ACPI_PREDEFINED_NAME);
 470         }
 471     }
 472
 473     /* Check for _Lxx/_Exx/_Wxx/_Qxx/_T_x. Warning if unknown predefined name */
 474
 475     return (ApCheckForSpecialName (Op, Name));
 476 }
 477
 478
 479 /*******************************************************************************
 480  *
 481  * FUNCTION:    ApCheckForSpecialName
 482  *
 483  * PARAMETERS:  Op              - A parse node
 484  *              Name            - NameSeg to check
 485  *
 486  * RETURN:      None
 487  *
 488  * DESCRIPTION: Check for the "special" predefined names -
 489  *              _Lxx, _Exx, _Qxx, _Wxx, and _T_x
 490  *
 491  ******************************************************************************/
 492
 493 static UINT32
 494 ApCheckForSpecialName (
 495     ACPI_PARSE_OBJECT       *Op,
 496     char                    *Name)
 497 {
 498
 499     /*
 500      * Check for the "special" predefined names. We already know that the
 501      * first character is an underscore.
 502      *   GPE:  _Lxx
 503      *   GPE:  _Exx
 504      *   GPE:  _Wxx
 505      *   EC:   _Qxx
 506      */
 507     if ((Name[1] == 'L') ||
 508         (Name[1] == 'E') ||
 509         (Name[1] == 'W') ||
 510         (Name[1] == 'Q'))
 511     {
 512         /* The next two characters must be hex digits */
 513
 514         if ((isxdigit ((int) Name[2])) &&
 515             (isxdigit ((int) Name[3])))
 516         {
 517             return (ACPI_EVENT_RESERVED_NAME);
 518         }
 519     }
 520
 521     /* Check for the names reserved for the compiler itself: _T_x */
 522
 523     else if ((Op->Asl.ExternalName[1] == 'T') &&
 524              (Op->Asl.ExternalName[2] == '_'))
 525     {
 526         /* Ignore if actually emitted by the compiler */
 527
 528         if (Op->Asl.CompileFlags & NODE_COMPILER_EMITTED)
 529         {
 530             return (ACPI_NOT_RESERVED_NAME);
 531         }
 532
 533         /*
 534          * Was not actually emitted by the compiler. This is a special case,
 535          * however. If the ASL code being compiled was the result of a
 536          * dissasembly, it may possibly contain valid compiler-emitted names
 537          * of the form "_T_x". We don't want to issue an error or even a
 538          * warning and force the user to manually change the names. So, we
 539          * will issue a remark instead.
 540          */
 541         AslError (ASL_REMARK, ASL_MSG_COMPILER_RESERVED, Op, Op->Asl.ExternalName);
 542         return (ACPI_COMPILER_RESERVED_NAME);
 543     }
 544
 545     /*
 546      * The name didn't match any of the known predefined names. Flag it as a
 547      * warning, since the entire namespace starting with an underscore is
 548      * reserved by the ACPI spec.
 549      */
 550     AslError (ASL_WARNING, ASL_MSG_UNKNOWN_RESERVED_NAME, Op,
 551         Op->Asl.ExternalName);
 552
 553     return (ACPI_NOT_RESERVED_NAME);
 554 }
 555
 556
 557 /*******************************************************************************
 558  *
 559  * FUNCTION:    ApCheckObjectType
 560  *
 561  * PARAMETERS:  Op              - Current parse node
 562  *              ExpectedBtypes  - Bitmap of expected return type(s)
 563  *
 564  * RETURN:      None
 565  *
 566  * DESCRIPTION: Check if the object type is one of the types that is expected
 567  *              by the predefined name. Only a limited number of object types
 568  *              can be returned by the predefined names.
 569  *
 570  ******************************************************************************/
 571
 572 static void
 573 ApCheckObjectType (
 574     ACPI_PARSE_OBJECT       *Op,
 575     UINT32                  ExpectedBtypes)
 576 {
 577     UINT32                  ReturnBtype;
 578
 579
 580     switch (Op->Asl.ParseOpcode)
 581     {
 582     case PARSEOP_ZERO:
 583     case PARSEOP_ONE:
 584     case PARSEOP_ONES:
 585     case PARSEOP_INTEGER:
 586         ReturnBtype = ACPI_RTYPE_INTEGER;
 587         break;
 588
 589     case PARSEOP_BUFFER:
 590         ReturnBtype = ACPI_RTYPE_BUFFER;
 591         break;
 592
 593     case PARSEOP_STRING_LITERAL:
 594         ReturnBtype = ACPI_RTYPE_STRING;
 595         break;
 596
 597     case PARSEOP_PACKAGE:
 598         ReturnBtype = ACPI_RTYPE_PACKAGE;
 599         break;
 600
 601     default:
 602         /* Not one of the supported object types */
 603
 604         goto TypeErrorExit;
 605     }
 606
 607     /* Exit if the object is one of the expected types */
 608
 609     if (ReturnBtype & ExpectedBtypes)
 610     {
 611         return;
 612     }
 613
 614
 615 TypeErrorExit:
 616
 617     /* Format the expected types and emit an error message */
 618
 619     ApGetExpectedTypes (StringBuffer, ExpectedBtypes);
 620
 621     sprintf (MsgBuffer, "found %s, requires %s",
 622         UtGetOpName (Op->Asl.ParseOpcode), StringBuffer);
 623
 624     AslError (ASL_ERROR, ASL_MSG_RESERVED_OPERAND_TYPE, Op,
 625         MsgBuffer);
 626 }
 627
 628
 629 /*******************************************************************************
 630  *
 631  * FUNCTION:    ApDisplayReservedNames
 632  *
 633  * PARAMETERS:  None
 634  *
 635  * RETURN:      None
 636  *
 637  * DESCRIPTION: Dump information about the ACPI predefined names and predefined
 638  *              resource descriptor names.
 639  *
 640  ******************************************************************************/
 641
 642 void
 643 ApDisplayReservedNames (
 644     void)
 645 {
 646     const ACPI_PREDEFINED_INFO  *ThisName;
 647     char                        TypeBuffer[48]; /* Room for 5 types */
 648     UINT32                      Count;
 649
 650
 651     /*
 652      * Predefined names/methods
 653      */
 654     printf ("\nPredefined Name Information\n\n");
 655
 656     Count = 0;
 657     ThisName = PredefinedNames;
 658     while (ThisName->Info.Name[0])
 659     {
 660         printf ("%4.4s    Requires %u arguments, ",
 661             ThisName->Info.Name, ThisName->Info.ParamCount & 0x0F);
 662
 663         if (ThisName->Info.ExpectedBtypes)
 664         {
 665             ApGetExpectedTypes (TypeBuffer, ThisName->Info.ExpectedBtypes);
 666             printf ("Must return: %s\n", TypeBuffer);
 667         }
 668         else
 669         {
 670             printf ("No return value\n");
 671         }
 672
 673         /*
 674          * Skip next entry in the table if this name returns a Package
 675          * (next entry contains the package info)
 676          */
 677         if (ThisName->Info.ExpectedBtypes & ACPI_RTYPE_PACKAGE)
 678         {
 679             ThisName++;
 680         }
 681
 682         Count++;
 683         ThisName++;
 684     }
 685
 686     printf ("%u Predefined Names are recognized\n", Count);
 687
 688     /*
 689      * Resource Descriptor names
 690      */
 691     printf ("\nResource Descriptor Predefined Names\n\n");
 692
 693     Count = 0;
 694     ThisName = ResourceNames;
 695     while (ThisName->Info.Name[0])
 696     {
 697         printf ("%4.4s    Resource Descriptor\n", ThisName->Info.Name);
 698         Count++;
 699         ThisName++;
 700     }
 701
 702     printf ("%u Resource Descriptor Names are recognized\n", Count);
 703
 704     /*
 705      * Predefined scope names
 706      */
 707     printf ("\nPredefined Scope Names\n\n");
 708
 709     ThisName = ScopeNames;
 710     while (ThisName->Info.Name[0])
 711     {
 712         printf ("%4.4s    Scope\n", ThisName->Info.Name);
 713         ThisName++;
 714     }
 715 }
 716
 717
 718 /*******************************************************************************
 719  *
 720  * FUNCTION:    ApGetExpectedTypes
 721  *
 722  * PARAMETERS:  Buffer              - Where the formatted string is returned
 723  *              ExpectedBTypes      - Bitfield of expected data types
 724  *
 725  * RETURN:      None, formatted string
 726  *
 727  * DESCRIPTION: Format the expected object types into a printable string.
 728  *
 729  ******************************************************************************/
 730
 731 static void
 732 ApGetExpectedTypes (
 733     char                        *Buffer,
 734     UINT32                      ExpectedBtypes)
 735 {
 736     UINT32                      ThisRtype;
 737     UINT32                      i;
 738     UINT32                      j;
 739
 740
 741     j = 1;
 742     Buffer[0] = 0;
 743     ThisRtype = ACPI_RTYPE_INTEGER;
 744
 745     for (i = 0; i < ACPI_NUM_RTYPES; i++)
 746     {
 747         /* If one of the expected types, concatenate the name of this type */
 748
 749         if (ExpectedBtypes & ThisRtype)
 750         {
 751             ACPI_STRCAT (Buffer, &AcpiRtypeNames[i][j]);
 752             j = 0;              /* Use name separator from now on */
 753         }
 754         ThisRtype <<= 1;    /* Next Rtype */
 755     }
 756 }
 757