aslpredef.c revision 217365
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 57static UINT32 58ApCheckForSpecialName ( 59 ACPI_PARSE_OBJECT *Op, 60 char *Name); 61 62static void 63ApCheckObjectType ( 64 ACPI_PARSE_OBJECT *Op, 65 UINT32 ExpectedBtypes); 66 67static void 68ApGetExpectedTypes ( 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 */ 77static 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 */ 91static 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 125static 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 148void 149ApCheckForPredefinedMethod ( 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 256void 257ApCheckPredefinedReturnValue ( 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 341void 342ApCheckForPredefinedObject ( 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 423UINT32 424ApCheckForPredefinedName ( 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 493static UINT32 494ApCheckForSpecialName ( 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 572static void 573ApCheckObjectType ( 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 615TypeErrorExit: 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 642void 643ApDisplayReservedNames ( 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 731static void 732ApGetExpectedTypes ( 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 758