1 /****************************************************************************** 2 * 3 * Module Name: aslerror - Error handling and statistics 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2019, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 ***************************************************************************** 115 * 116 * Alternatively, you may choose to be licensed under the terms of the 117 * following license: 118 * 119 * Redistribution and use in source and binary forms, with or without 120 * modification, are permitted provided that the following conditions 121 * are met: 122 * 1. Redistributions of source code must retain the above copyright 123 * notice, this list of conditions, and the following disclaimer, 124 * without modification. 125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 126 * substantially similar to the "NO WARRANTY" disclaimer below 127 * ("Disclaimer") and any redistribution must be conditioned upon 128 * including a substantially similar Disclaimer requirement for further 129 * binary redistribution. 130 * 3. Neither the names of the above-listed copyright holders nor the names 131 * of any contributors may be used to endorse or promote products derived 132 * from this software without specific prior written permission. 133 * 134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 145 * 146 * Alternatively, you may choose to be licensed under the terms of the 147 * GNU General Public License ("GPL") version 2 as published by the Free 148 * Software Foundation. 149 * 150 *****************************************************************************/ 151 152 #include "aslcompiler.h" 153 154 #define _COMPONENT ACPI_COMPILER 155 ACPI_MODULE_NAME ("aslerror") 156 157 /* Local prototypes */ 158 159 static void 160 AeAddToErrorLog ( 161 ASL_ERROR_MSG *Enode); 162 163 static BOOLEAN 164 AslIsExceptionExpected ( 165 UINT8 Level, 166 UINT16 MessageId); 167 168 static BOOLEAN 169 AslIsExceptionDisabled ( 170 UINT8 Level, 171 UINT16 MessageId); 172 173 static void AslInitEnode ( 174 ASL_ERROR_MSG **Enode, 175 UINT8 Level, 176 UINT16 MessageId, 177 UINT32 LineNumber, 178 UINT32 LogicalLineNumber, 179 UINT32 LogicalByteOffset, 180 UINT32 Column, 181 char *Filename, 182 char *Message, 183 char *SourceLine, 184 ASL_ERROR_MSG *SubError); 185 186 static void 187 AslLogNewError ( 188 UINT8 Level, 189 UINT16 MessageId, 190 UINT32 LineNumber, 191 UINT32 LogicalLineNumber, 192 UINT32 LogicalByteOffset, 193 UINT32 Column, 194 char *Filename, 195 char *Message, 196 char *SourceLine, 197 ASL_ERROR_MSG *SubError); 198 199 static void 200 AePrintSubError ( 201 FILE *OutputFile, 202 ASL_ERROR_MSG *Enode); 203 204 static UINT8 205 GetModifiedLevel ( 206 UINT8 Level, 207 UINT16 MessageId); 208 209 210 /******************************************************************************* 211 * 212 * FUNCTION: AslAbort 213 * 214 * PARAMETERS: None 215 * 216 * RETURN: None 217 * 218 * DESCRIPTION: Dump the error log and abort the compiler. Used for serious 219 * I/O errors. 220 * 221 ******************************************************************************/ 222 223 void 224 AslAbort ( 225 void) 226 { 227 228 AePrintErrorLog (ASL_FILE_STDERR); 229 if (AslGbl_DebugFlag) 230 { 231 /* Print error summary to stdout also */ 232 233 AePrintErrorLog (ASL_FILE_STDOUT); 234 } 235 236 exit (1); 237 } 238 239 240 /******************************************************************************* 241 * 242 * FUNCTION: AeClearErrorLog 243 * 244 * PARAMETERS: None 245 * 246 * RETURN: None 247 * 248 * DESCRIPTION: Empty the error list 249 * 250 ******************************************************************************/ 251 252 void 253 AeClearErrorLog ( 254 void) 255 { 256 ASL_ERROR_MSG *Enode = AslGbl_ErrorLog; 257 ASL_ERROR_MSG *Next; 258 259 260 /* Walk the error node list */ 261 262 while (Enode) 263 { 264 Next = Enode->Next; 265 ACPI_FREE (Enode); 266 Enode = Next; 267 } 268 269 AslGbl_ErrorLog = NULL; 270 } 271 272 273 /******************************************************************************* 274 * 275 * FUNCTION: AeAddToErrorLog 276 * 277 * PARAMETERS: Enode - An error node to add to the log 278 * 279 * RETURN: None 280 * 281 * DESCRIPTION: Add a new error node to the error log. The error log is 282 * ordered by the "logical" line number (cumulative line number 283 * including all include files.) 284 * 285 ******************************************************************************/ 286 287 static void 288 AeAddToErrorLog ( 289 ASL_ERROR_MSG *Enode) 290 { 291 ASL_ERROR_MSG *Next; 292 ASL_ERROR_MSG *Prev; 293 294 295 /* If Gbl_ErrorLog is null, this is the first error node */ 296 297 if (!AslGbl_ErrorLog) 298 { 299 AslGbl_ErrorLog = Enode; 300 return; 301 } 302 303 /* 304 * Walk error list until we find a line number greater than ours. 305 * List is sorted according to line number. 306 */ 307 Prev = NULL; 308 Next = AslGbl_ErrorLog; 309 310 while ((Next) && (Next->LogicalLineNumber <= Enode->LogicalLineNumber)) 311 { 312 Prev = Next; 313 Next = Next->Next; 314 } 315 316 /* Found our place in the list */ 317 318 Enode->Next = Next; 319 320 if (Prev) 321 { 322 Prev->Next = Enode; 323 } 324 else 325 { 326 AslGbl_ErrorLog = Enode; 327 } 328 } 329 330 331 /******************************************************************************* 332 * 333 * FUNCTION: AeDecodeErrorMessageId 334 * 335 * PARAMETERS: OutputFile - Output file 336 * Enode - Error node to print 337 * PrematureEOF - True = PrematureEOF has been reached 338 * Total - Total legth of line 339 * 340 * RETURN: None 341 * 342 * DESCRIPTION: Print the source line of an error. 343 * 344 ******************************************************************************/ 345 346 static void 347 AeDecodeErrorMessageId ( 348 FILE *OutputFile, 349 ASL_ERROR_MSG *Enode, 350 BOOLEAN PrematureEOF, 351 UINT32 Total) 352 { 353 UINT32 MsgLength; 354 const char *MainMessage; 355 char *ExtraMessage; 356 UINT32 SourceColumn; 357 UINT32 ErrorColumn; 358 359 360 fprintf (OutputFile, "%s %4.4d -", 361 AeDecodeExceptionLevel (Enode->Level), 362 AeBuildFullExceptionCode (Enode->Level, Enode->MessageId)); 363 364 MainMessage = AeDecodeMessageId (Enode->MessageId); 365 ExtraMessage = Enode->Message; 366 367 /* If a NULL line number, just print the decoded message */ 368 369 if (!Enode->LineNumber) 370 { 371 fprintf (OutputFile, " %s %s\n\n", MainMessage, ExtraMessage); 372 return; 373 } 374 375 MsgLength = strlen (MainMessage); 376 if (MsgLength == 0) 377 { 378 /* Use the secondary/extra message as main message */ 379 380 MainMessage = Enode->Message; 381 if (!MainMessage) 382 { 383 MainMessage = ""; 384 } 385 386 MsgLength = strlen (MainMessage); 387 ExtraMessage = NULL; 388 } 389 390 if (AslGbl_VerboseErrors && !PrematureEOF) 391 { 392 if (Total >= 256) 393 { 394 fprintf (OutputFile, " %s", 395 MainMessage); 396 } 397 else 398 { 399 SourceColumn = Enode->Column + Enode->FilenameLength + 6 + 2; 400 ErrorColumn = ASL_ERROR_LEVEL_LENGTH + 5 + 2 + 1; 401 402 if ((MsgLength + ErrorColumn) < (SourceColumn - 1)) 403 { 404 fprintf (OutputFile, "%*s%s", 405 (int) ((SourceColumn - 1) - ErrorColumn), 406 MainMessage, " ^ "); 407 } 408 else 409 { 410 fprintf (OutputFile, "%*s %s", 411 (int) ((SourceColumn - ErrorColumn) + 1), "^", 412 MainMessage); 413 } 414 } 415 } 416 else 417 { 418 fprintf (OutputFile, " %s", MainMessage); 419 } 420 421 /* Print the extra info message if present */ 422 423 if (ExtraMessage) 424 { 425 fprintf (OutputFile, " (%s)", ExtraMessage); 426 } 427 428 if (PrematureEOF) 429 { 430 fprintf (OutputFile, " and premature End-Of-File"); 431 } 432 433 fprintf (OutputFile, "\n"); 434 if (AslGbl_VerboseErrors && !Enode->SubError) 435 { 436 fprintf (OutputFile, "\n"); 437 } 438 } 439 440 441 /******************************************************************************* 442 * 443 * FUNCTION: AePrintErrorSourceLine 444 * 445 * PARAMETERS: OutputFile - Output file 446 * Enode - Error node to print 447 * PrematureEOF - True = PrematureEOF has been reached 448 * Total - amount of characters printed so far 449 * 450 * 451 * RETURN: Status 452 * 453 * DESCRIPTION: Print the source line of an error. 454 * 455 ******************************************************************************/ 456 457 static ACPI_STATUS 458 AePrintErrorSourceLine ( 459 FILE *OutputFile, 460 ASL_ERROR_MSG *Enode, 461 BOOLEAN *PrematureEOF, 462 UINT32 *Total) 463 { 464 UINT8 SourceByte; 465 int Actual; 466 size_t RActual; 467 FILE *SourceFile = NULL; 468 long FileSize; 469 470 471 if (!Enode->SourceLine) 472 { 473 /* 474 * Use the merged header/source file if present, otherwise 475 * use input file 476 */ 477 SourceFile = FlGetFileHandle (ASL_FILE_SOURCE_OUTPUT, 478 ASL_FILE_SOURCE_OUTPUT, Enode->SourceFilename); 479 if (!SourceFile) 480 { 481 SourceFile = FlGetFileHandle (ASL_FILE_INPUT, 482 ASL_FILE_INPUT, Enode->Filename); 483 } 484 485 if (SourceFile) 486 { 487 /* Determine if the error occurred at source file EOF */ 488 489 fseek (SourceFile, 0, SEEK_END); 490 FileSize = ftell (SourceFile); 491 492 if ((long) Enode->LogicalByteOffset >= FileSize) 493 { 494 *PrematureEOF = TRUE; 495 } 496 } 497 else 498 { 499 fprintf (OutputFile, 500 "[*** iASL: Source File Does not exist ***]\n"); 501 return AE_IO_ERROR; 502 } 503 } 504 505 /* Print filename and line number if present and valid */ 506 507 if (AslGbl_VerboseErrors) 508 { 509 fprintf (OutputFile, "%-8s", Enode->Filename); 510 511 if (Enode->SourceLine && Enode->LineNumber) 512 { 513 fprintf (OutputFile, " %6u: %s", 514 Enode->LineNumber, Enode->SourceLine); 515 } 516 else if (Enode->LineNumber) 517 { 518 fprintf (OutputFile, " %6u: ", Enode->LineNumber); 519 520 /* 521 * If not at EOF, get the corresponding source code line 522 * and display it. Don't attempt this if we have a 523 * premature EOF condition. 524 */ 525 if (*PrematureEOF) 526 { 527 fprintf (OutputFile, "\n"); 528 return AE_OK; 529 } 530 /* 531 * Seek to the offset in the combined source file, 532 * read the source line, and write it to the output. 533 */ 534 Actual = fseek (SourceFile, 535 (long) Enode->LogicalByteOffset, (int) SEEK_SET); 536 if (Actual) 537 { 538 fprintf (OutputFile, 539 "[*** iASL: Seek error on source code temp file %s ***]", 540 AslGbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 541 542 fprintf (OutputFile, "\n"); 543 return AE_OK; 544 } 545 RActual = fread (&SourceByte, 1, 1, SourceFile); 546 if (RActual != 1) 547 { 548 fprintf (OutputFile, 549 "[*** iASL: Read error on source code temp file %s ***]", 550 AslGbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 551 return AE_IO_ERROR; 552 } 553 /* Read/write the source line, up to the maximum line length */ 554 555 while (RActual && SourceByte && (SourceByte != '\n')) 556 { 557 if (*Total < 256) 558 { 559 /* After the max line length, we will just read the line, no write */ 560 561 if (fwrite (&SourceByte, 1, 1, OutputFile) != 1) 562 { 563 printf ("[*** iASL: Write error on output file ***]\n"); 564 return AE_IO_ERROR; 565 } 566 } 567 else if (*Total == 256) 568 { 569 fprintf (OutputFile, 570 "\n[*** iASL: Very long input line, message below refers to column %u ***]", 571 Enode->Column); 572 } 573 574 RActual = fread (&SourceByte, 1, 1, SourceFile); 575 if (RActual != 1) 576 { 577 fprintf (OutputFile, 578 "[*** iASL: Read error on source code temp file %s ***]", 579 AslGbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 580 581 return AE_IO_ERROR; 582 } 583 *Total += 1; 584 } 585 586 fprintf (OutputFile, "\n"); 587 } 588 } 589 else 590 { 591 /* 592 * Less verbose version of the error message, enabled via the 593 * -vi switch. The format is compatible with MS Visual Studio. 594 */ 595 fprintf (OutputFile, "%s", Enode->Filename); 596 597 if (Enode->LineNumber) 598 { 599 fprintf (OutputFile, "(%u) : ", 600 Enode->LineNumber); 601 } 602 } 603 604 return AE_OK; 605 } 606 607 /******************************************************************************* 608 * 609 * FUNCTION: AePrintException 610 * 611 * PARAMETERS: FileId - ID of output file 612 * Enode - Error node to print 613 * Header - Additional text before each message 614 * 615 * RETURN: None 616 * 617 * DESCRIPTION: Print the contents of an error node. 618 * 619 * NOTE: We don't use the FlxxxFile I/O functions here because on error 620 * they abort the compiler and call this function! Since we 621 * are reporting errors here, we ignore most output errors and 622 * just try to get out as much as we can. 623 * 624 ******************************************************************************/ 625 626 void 627 AePrintException ( 628 UINT32 FileId, 629 ASL_ERROR_MSG *Enode, 630 char *Header) 631 { 632 FILE *OutputFile; 633 BOOLEAN PrematureEOF = FALSE; 634 UINT32 Total = 0; 635 ACPI_STATUS Status; 636 ASL_ERROR_MSG *Child = Enode->SubError; 637 638 639 if (AslGbl_NoErrors) 640 { 641 return; 642 } 643 644 /* 645 * Only listing files have a header, and remarks/optimizations 646 * are always output 647 */ 648 if (!Header) 649 { 650 /* Ignore remarks if requested */ 651 652 switch (Enode->Level) 653 { 654 case ASL_WARNING: 655 case ASL_WARNING2: 656 case ASL_WARNING3: 657 658 if (!AslGbl_DisplayWarnings) 659 { 660 return; 661 } 662 break; 663 664 case ASL_REMARK: 665 666 if (!AslGbl_DisplayRemarks) 667 { 668 return; 669 } 670 break; 671 672 case ASL_OPTIMIZATION: 673 674 if (!AslGbl_DisplayOptimizations) 675 { 676 return; 677 } 678 break; 679 680 default: 681 682 break; 683 } 684 } 685 686 /* Get the various required file handles */ 687 688 OutputFile = AslGbl_Files[FileId].Handle; 689 690 if (Header) 691 { 692 fprintf (OutputFile, "%s", Header); 693 } 694 695 if (!Enode->Filename) 696 { 697 AeDecodeErrorMessageId (OutputFile, Enode, PrematureEOF, Total); 698 return; 699 } 700 701 Status = AePrintErrorSourceLine (OutputFile, Enode, &PrematureEOF, &Total); 702 if (ACPI_FAILURE (Status)) 703 { 704 return; 705 } 706 707 /* If a NULL message ID, just print the raw message */ 708 709 if (Enode->MessageId == 0) 710 { 711 fprintf (OutputFile, "%s\n", Enode->Message); 712 return; 713 } 714 715 AeDecodeErrorMessageId (OutputFile, Enode, PrematureEOF, Total); 716 717 while (Child) 718 { 719 fprintf (OutputFile, "\n"); 720 AePrintSubError (OutputFile, Child); 721 Child = Child->SubError; 722 } 723 } 724 725 726 /******************************************************************************* 727 * 728 * FUNCTION: AePrintSubError 729 * 730 * PARAMETERS: OutputFile - Output file 731 * Enode - Error node to print 732 * 733 * RETURN: None 734 * 735 * DESCRIPTION: Print the contents of an error nodes. This function is tailored 736 * to print error nodes that are SubErrors within ASL_ERROR_MSG 737 * 738 ******************************************************************************/ 739 740 static void 741 AePrintSubError ( 742 FILE *OutputFile, 743 ASL_ERROR_MSG *Enode) 744 { 745 UINT32 Total = 0; 746 BOOLEAN PrematureEOF = FALSE; 747 const char *MainMessage; 748 749 750 MainMessage = AeDecodeMessageId (Enode->MessageId); 751 752 fprintf (OutputFile, " %s%s", MainMessage, "\n "); 753 (void) AePrintErrorSourceLine (OutputFile, Enode, &PrematureEOF, &Total); 754 fprintf (OutputFile, "\n"); 755 } 756 757 758 /******************************************************************************* 759 * 760 * FUNCTION: AePrintErrorLog 761 * 762 * PARAMETERS: FileId - Where to output the error log 763 * 764 * RETURN: None 765 * 766 * DESCRIPTION: Print the entire contents of the error log 767 * 768 ******************************************************************************/ 769 770 void 771 AePrintErrorLog ( 772 UINT32 FileId) 773 { 774 ASL_ERROR_MSG *Enode = AslGbl_ErrorLog; 775 776 777 /* Walk the error node list */ 778 779 while (Enode) 780 { 781 AePrintException (FileId, Enode, NULL); 782 Enode = Enode->Next; 783 } 784 } 785 786 787 /******************************************************************************* 788 * 789 * FUNCTION: AslInitEnode 790 * 791 * PARAMETERS: InputEnode - Input Error node to initialize 792 * Level - Seriousness (Warning/error, etc.) 793 * MessageId - Index into global message buffer 794 * CurrentLineNumber - Actual file line number 795 * LogicalLineNumber - Cumulative line number 796 * LogicalByteOffset - Byte offset in source file 797 * Column - Column in current line 798 * Filename - source filename 799 * ExtraMessage - additional error message 800 * SourceLine - Line of error source code 801 * SubError - SubError of this InputEnode 802 * 803 * RETURN: None 804 * 805 * DESCRIPTION: Initialize an Error node 806 * 807 ******************************************************************************/ 808 809 static void AslInitEnode ( 810 ASL_ERROR_MSG **InputEnode, 811 UINT8 Level, 812 UINT16 MessageId, 813 UINT32 LineNumber, 814 UINT32 LogicalLineNumber, 815 UINT32 LogicalByteOffset, 816 UINT32 Column, 817 char *Filename, 818 char *ExtraMessage, 819 char *SourceLine, 820 ASL_ERROR_MSG *SubError) 821 { 822 ASL_ERROR_MSG *Enode; 823 ASL_GLOBAL_FILE_NODE *FileNode; 824 825 826 *InputEnode = UtLocalCalloc (sizeof (ASL_ERROR_MSG)); 827 Enode = *InputEnode; 828 Enode->Level = Level; 829 Enode->MessageId = MessageId; 830 Enode->LineNumber = LineNumber; 831 Enode->LogicalLineNumber = LogicalLineNumber; 832 Enode->LogicalByteOffset = LogicalByteOffset; 833 Enode->Column = Column; 834 Enode->SubError = SubError; 835 Enode->Message = NULL; 836 Enode->SourceLine = NULL; 837 Enode->Filename = NULL; 838 839 if (ExtraMessage) 840 { 841 /* Allocate a buffer for the message and a new error node */ 842 843 Enode->Message = UtLocalCacheCalloc (strlen (ExtraMessage) + 1); 844 845 /* Keep a copy of the extra message */ 846 847 strcpy (Enode->Message, ExtraMessage); 848 } 849 850 if (SourceLine) 851 { 852 Enode->SourceLine = UtLocalCalloc (strlen (SourceLine) + 1); 853 strcpy (Enode->SourceLine, SourceLine); 854 } 855 856 857 if (Filename) 858 { 859 Enode->Filename = Filename; 860 Enode->FilenameLength = strlen (Filename); 861 if (Enode->FilenameLength < 6) 862 { 863 Enode->FilenameLength = 6; 864 } 865 866 FileNode = FlGetCurrentFileNode (); 867 if (!FileNode) 868 { 869 return; 870 } 871 872 if (!FlInputFileExists (Filename)) 873 { 874 /* 875 * This means that this file is an include file. Record the .src 876 * file as the error message source because this file is not in 877 * the global file list. 878 */ 879 Enode->SourceFilename = 880 FileNode->Files[ASL_FILE_SOURCE_OUTPUT].Filename; 881 } 882 } 883 } 884 885 886 /******************************************************************************* 887 * 888 * FUNCTION: AslCommonError2 889 * 890 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 891 * MessageId - Index into global message buffer 892 * LineNumber - Actual file line number 893 * Column - Column in current line 894 * SourceLine - Actual source code line 895 * Filename - source filename 896 * ExtraMessage - additional error message 897 * 898 * RETURN: None 899 * 900 * DESCRIPTION: Create a new error node and add it to the error log 901 * 902 ******************************************************************************/ 903 904 void 905 AslCommonError2 ( 906 UINT8 Level, 907 UINT16 MessageId, 908 UINT32 LineNumber, 909 UINT32 Column, 910 char *SourceLine, 911 char *Filename, 912 char *ExtraMessage) 913 { 914 AslLogNewError (Level, MessageId, LineNumber, LineNumber, 0, Column, 915 Filename, ExtraMessage, SourceLine, NULL); 916 } 917 918 919 /******************************************************************************* 920 * 921 * FUNCTION: AslCommonError 922 * 923 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 924 * MessageId - Index into global message buffer 925 * CurrentLineNumber - Actual file line number 926 * LogicalLineNumber - Cumulative line number 927 * LogicalByteOffset - Byte offset in source file 928 * Column - Column in current line 929 * Filename - source filename 930 * ExtraMessage - additional error message 931 * 932 * RETURN: None 933 * 934 * DESCRIPTION: Create a new error node and add it to the error log 935 * 936 ******************************************************************************/ 937 938 void 939 AslCommonError ( 940 UINT8 Level, 941 UINT16 MessageId, 942 UINT32 CurrentLineNumber, 943 UINT32 LogicalLineNumber, 944 UINT32 LogicalByteOffset, 945 UINT32 Column, 946 char *Filename, 947 char *ExtraMessage) 948 { 949 /* Check if user wants to ignore this exception */ 950 951 if (AslIsExceptionIgnored (Level, MessageId)) 952 { 953 return; 954 } 955 956 AslLogNewError (Level, MessageId, CurrentLineNumber, LogicalLineNumber, 957 LogicalByteOffset, Column, Filename, ExtraMessage, 958 NULL, NULL); 959 } 960 961 962 /******************************************************************************* 963 * 964 * FUNCTION: AslLogNewError 965 * 966 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 967 * MessageId - Index into global message buffer 968 * CurrentLineNumber - Actual file line number 969 * LogicalLineNumber - Cumulative line number 970 * LogicalByteOffset - Byte offset in source file 971 * Column - Column in current line 972 * Filename - source filename 973 * Message - additional error message 974 * SourceLine - Actual line of source code 975 * SubError - Sub-error associated with this error 976 * 977 * RETURN: None 978 * 979 * DESCRIPTION: Create a new error node and add it to the error log 980 * 981 ******************************************************************************/ 982 static void 983 AslLogNewError ( 984 UINT8 Level, 985 UINT16 MessageId, 986 UINT32 LineNumber, 987 UINT32 LogicalLineNumber, 988 UINT32 LogicalByteOffset, 989 UINT32 Column, 990 char *Filename, 991 char *Message, 992 char *SourceLine, 993 ASL_ERROR_MSG *SubError) 994 { 995 ASL_ERROR_MSG *Enode = NULL; 996 UINT8 ModifiedLevel = GetModifiedLevel (Level, MessageId); 997 998 999 AslInitEnode (&Enode, ModifiedLevel, MessageId, LineNumber, 1000 LogicalLineNumber, LogicalByteOffset, Column, Filename, Message, 1001 SourceLine, SubError); 1002 1003 /* Add the new node to the error node list */ 1004 1005 AeAddToErrorLog (Enode); 1006 1007 if (AslGbl_DebugFlag) 1008 { 1009 /* stderr is a file, send error to it immediately */ 1010 1011 AePrintException (ASL_FILE_STDERR, Enode, NULL); 1012 } 1013 1014 AslGbl_ExceptionCount[ModifiedLevel]++; 1015 if (!AslGbl_IgnoreErrors && AslGbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT) 1016 { 1017 printf ("\nMaximum error count (%u) exceeded\n", ASL_MAX_ERROR_COUNT); 1018 1019 AslGbl_SourceLine = 0; 1020 AslGbl_NextError = AslGbl_ErrorLog; 1021 CmCleanupAndExit (); 1022 exit(1); 1023 } 1024 1025 return; 1026 } 1027 1028 1029 /******************************************************************************* 1030 * 1031 * FUNCTION: GetModifiedLevel 1032 * 1033 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1034 * MessageId - Index into global message buffer 1035 * 1036 * RETURN: UINT8 - modified level 1037 * 1038 * DESCRIPTION: Get the modified level of exception codes that are reported as 1039 * errors from the -ww option. 1040 * 1041 ******************************************************************************/ 1042 1043 static UINT8 1044 GetModifiedLevel ( 1045 UINT8 Level, 1046 UINT16 MessageId) 1047 { 1048 UINT16 i; 1049 UINT16 ExceptionCode; 1050 1051 1052 ExceptionCode = AeBuildFullExceptionCode (Level, MessageId); 1053 1054 for (i = 0; i < AslGbl_ElevatedMessagesIndex; i++) 1055 { 1056 if (ExceptionCode == AslGbl_ElevatedMessages[i]) 1057 { 1058 return (ASL_ERROR); 1059 } 1060 } 1061 1062 return (Level); 1063 } 1064 1065 1066 /******************************************************************************* 1067 * 1068 * FUNCTION: AslIsExceptionIgnored 1069 * 1070 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1071 * MessageId - Index into global message buffer 1072 * 1073 * RETURN: BOOLEAN 1074 * 1075 * DESCRIPTION: Check if a particular exception is ignored. In this case it 1076 * means that the exception is (expected or disabled. 1077 * 1078 ******************************************************************************/ 1079 1080 BOOLEAN 1081 AslIsExceptionIgnored ( 1082 UINT8 Level, 1083 UINT16 MessageId) 1084 { 1085 BOOLEAN ExceptionIgnored; 1086 1087 1088 /* Note: this allows exception to be disabled and expected */ 1089 1090 ExceptionIgnored = AslIsExceptionDisabled (Level, MessageId); 1091 ExceptionIgnored |= AslIsExceptionExpected (Level, MessageId); 1092 1093 return (AslGbl_AllExceptionsDisabled || ExceptionIgnored); 1094 } 1095 1096 1097 /******************************************************************************* 1098 * 1099 * FUNCTION: AslCheckExpectException 1100 * 1101 * PARAMETERS: none 1102 * 1103 * RETURN: none 1104 * 1105 * DESCRIPTION: Check the global expected messages table and raise an error 1106 * for each message that has not been received. 1107 * 1108 ******************************************************************************/ 1109 1110 void 1111 AslCheckExpectedExceptions ( 1112 void) 1113 { 1114 UINT8 i; 1115 1116 1117 for (i = 0; i < AslGbl_ExpectedMessagesIndex; ++i) 1118 { 1119 if (!AslGbl_ExpectedMessages[i].MessageReceived) 1120 { 1121 AslError (ASL_ERROR, ASL_MSG_EXCEPTION_NOT_RECEIVED, NULL, 1122 AslGbl_ExpectedMessages[i].MessageIdStr); 1123 } 1124 } 1125 } 1126 1127 1128 /******************************************************************************* 1129 * 1130 * FUNCTION: AslExpectException 1131 * 1132 * PARAMETERS: MessageIdString - ID of excepted exception during compile 1133 * 1134 * RETURN: Status 1135 * 1136 * DESCRIPTION: Enter a message ID into the global expected messages table 1137 * If these messages are not raised during the compilation, throw 1138 * an error. 1139 * 1140 ******************************************************************************/ 1141 1142 ACPI_STATUS 1143 AslExpectException ( 1144 char *MessageIdString) 1145 { 1146 UINT32 MessageId; 1147 1148 1149 /* Convert argument to an integer and validate it */ 1150 1151 MessageId = (UINT32) strtoul (MessageIdString, NULL, 0); 1152 1153 if (MessageId > 6999) 1154 { 1155 printf ("\"%s\" is not a valid warning/remark/erro ID\n", 1156 MessageIdString); 1157 return (AE_BAD_PARAMETER); 1158 } 1159 1160 /* Insert value into the global expected message array */ 1161 1162 if (AslGbl_ExpectedMessagesIndex >= ASL_MAX_EXPECTED_MESSAGES) 1163 { 1164 printf ("Too many messages have been registered as expected (max %d)\n", 1165 ASL_MAX_DISABLED_MESSAGES); 1166 return (AE_LIMIT); 1167 } 1168 1169 AslGbl_ExpectedMessages[AslGbl_ExpectedMessagesIndex].MessageId = MessageId; 1170 AslGbl_ExpectedMessages[AslGbl_ExpectedMessagesIndex].MessageIdStr = MessageIdString; 1171 AslGbl_ExpectedMessages[AslGbl_ExpectedMessagesIndex].MessageReceived = FALSE; 1172 AslGbl_ExpectedMessagesIndex++; 1173 return (AE_OK); 1174 } 1175 1176 1177 /******************************************************************************* 1178 * 1179 * FUNCTION: AslDisableException 1180 * 1181 * PARAMETERS: MessageIdString - ID to be disabled 1182 * 1183 * RETURN: Status 1184 * 1185 * DESCRIPTION: Enter a message ID into the global disabled messages table 1186 * 1187 ******************************************************************************/ 1188 1189 ACPI_STATUS 1190 AslDisableException ( 1191 char *MessageIdString) 1192 { 1193 UINT32 MessageId; 1194 1195 1196 /* Convert argument to an integer and validate it */ 1197 1198 MessageId = (UINT32) strtoul (MessageIdString, NULL, 0); 1199 1200 if ((MessageId < 2000) || (MessageId > 6999)) 1201 { 1202 printf ("\"%s\" is not a valid warning/remark/error ID\n", 1203 MessageIdString); 1204 return (AE_BAD_PARAMETER); 1205 } 1206 1207 /* Insert value into the global disabled message array */ 1208 1209 if (AslGbl_DisabledMessagesIndex >= ASL_MAX_DISABLED_MESSAGES) 1210 { 1211 printf ("Too many messages have been disabled (max %d)\n", 1212 ASL_MAX_DISABLED_MESSAGES); 1213 return (AE_LIMIT); 1214 } 1215 1216 AslGbl_DisabledMessages[AslGbl_DisabledMessagesIndex] = MessageId; 1217 AslGbl_DisabledMessagesIndex++; 1218 return (AE_OK); 1219 } 1220 1221 1222 /******************************************************************************* 1223 * 1224 * FUNCTION: AslElevateException 1225 * 1226 * PARAMETERS: MessageIdString - ID of excepted exception during compile 1227 * 1228 * RETURN: Status 1229 * 1230 * DESCRIPTION: Enter a message ID into the global elevated exceptions table. 1231 * These messages will be considered as compilation errors. 1232 * 1233 ******************************************************************************/ 1234 1235 ACPI_STATUS 1236 AslElevateException ( 1237 char *MessageIdString) 1238 { 1239 UINT32 MessageId; 1240 1241 1242 /* Convert argument to an integer and validate it */ 1243 1244 MessageId = (UINT32) strtoul (MessageIdString, NULL, 0); 1245 1246 if (MessageId > 6999) 1247 { 1248 printf ("\"%s\" is not a valid warning/remark/erro ID\n", 1249 MessageIdString); 1250 return (AE_BAD_PARAMETER); 1251 } 1252 1253 /* Insert value into the global expected message array */ 1254 1255 if (AslGbl_ElevatedMessagesIndex >= ASL_MAX_ELEVATED_MESSAGES) 1256 { 1257 printf ("Too many messages have been registered as elevated (max %d)\n", 1258 ASL_MAX_DISABLED_MESSAGES); 1259 return (AE_LIMIT); 1260 } 1261 1262 AslGbl_ElevatedMessages[AslGbl_ElevatedMessagesIndex] = MessageId; 1263 AslGbl_ElevatedMessagesIndex++; 1264 return (AE_OK); 1265 } 1266 1267 /******************************************************************************* 1268 * 1269 * FUNCTION: AslIsExceptionDisabled 1270 * 1271 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1272 * MessageId - Index into global message buffer 1273 * 1274 * RETURN: TRUE if exception/message should be ignored 1275 * 1276 * DESCRIPTION: Check if the user has specified options such that this 1277 * exception should be ignored 1278 * 1279 ******************************************************************************/ 1280 1281 static BOOLEAN 1282 AslIsExceptionExpected ( 1283 UINT8 Level, 1284 UINT16 MessageId) 1285 { 1286 UINT32 EncodedMessageId; 1287 UINT32 i; 1288 1289 1290 /* Mark this exception as received */ 1291 1292 EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId); 1293 for (i = 0; i < AslGbl_ExpectedMessagesIndex; i++) 1294 { 1295 /* Simple implementation via fixed array */ 1296 1297 if (EncodedMessageId == AslGbl_ExpectedMessages[i].MessageId) 1298 { 1299 return (AslGbl_ExpectedMessages[i].MessageReceived = TRUE); 1300 } 1301 } 1302 1303 return (FALSE); 1304 } 1305 1306 1307 /******************************************************************************* 1308 * 1309 * FUNCTION: AslIsExceptionDisabled 1310 * 1311 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1312 * MessageId - Index into global message buffer 1313 * 1314 * RETURN: TRUE if exception/message should be ignored 1315 * 1316 * DESCRIPTION: Check if the user has specified options such that this 1317 * exception should be ignored 1318 * 1319 ******************************************************************************/ 1320 1321 static BOOLEAN 1322 AslIsExceptionDisabled ( 1323 UINT8 Level, 1324 UINT16 MessageId) 1325 { 1326 UINT32 EncodedMessageId; 1327 UINT32 i; 1328 1329 1330 switch (Level) 1331 { 1332 case ASL_WARNING2: 1333 case ASL_WARNING3: 1334 1335 /* Check for global disable via -w1/-w2/-w3 options */ 1336 1337 if (Level > AslGbl_WarningLevel) 1338 { 1339 return (TRUE); 1340 } 1341 /* Fall through */ 1342 1343 case ASL_WARNING: 1344 case ASL_REMARK: 1345 case ASL_ERROR: 1346 /* 1347 * Ignore this error/warning/remark if it has been disabled by 1348 * the user (-vw option) 1349 */ 1350 EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId); 1351 for (i = 0; i < AslGbl_DisabledMessagesIndex; i++) 1352 { 1353 /* Simple implementation via fixed array */ 1354 1355 if (EncodedMessageId == AslGbl_DisabledMessages[i]) 1356 { 1357 return (TRUE); 1358 } 1359 } 1360 break; 1361 1362 default: 1363 break; 1364 } 1365 1366 return (FALSE); 1367 } 1368 1369 1370 /******************************************************************************* 1371 * 1372 * FUNCTION: AslDualParseOpError 1373 * 1374 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1375 * MainMsgId - Index into global message buffer 1376 * MainOp - Parse node where error happened 1377 * MainMsg - Message pertaining to the MainOp 1378 * SubMsgId - Index into global message buffer 1379 * SubOp - Additional parse node for better message 1380 * SubMsg - Message pertainint to SubOp 1381 * 1382 * 1383 * RETURN: None 1384 * 1385 * DESCRIPTION: Main error reporting routine for the ASL compiler for error 1386 * messages that point to multiple parse objects. 1387 * 1388 ******************************************************************************/ 1389 1390 void 1391 AslDualParseOpError ( 1392 UINT8 Level, 1393 UINT16 MainMsgId, 1394 ACPI_PARSE_OBJECT *MainOp, 1395 char *MainMsg, 1396 UINT16 SubMsgId, 1397 ACPI_PARSE_OBJECT *SubOp, 1398 char *SubMsg) 1399 { 1400 ASL_ERROR_MSG *SubEnode = NULL; 1401 1402 1403 /* Check if user wants to ignore this exception */ 1404 1405 if (AslIsExceptionIgnored (Level, MainMsgId) || !MainOp) 1406 { 1407 return; 1408 } 1409 1410 if (SubOp) 1411 { 1412 AslInitEnode (&SubEnode, Level, SubMsgId, SubOp->Asl.LineNumber, 1413 SubOp->Asl.LogicalLineNumber, SubOp->Asl.LogicalByteOffset, 1414 SubOp->Asl.Column, SubOp->Asl.Filename, SubMsg, 1415 NULL, NULL); 1416 } 1417 1418 AslLogNewError (Level, MainMsgId, MainOp->Asl.LineNumber, 1419 MainOp->Asl.LogicalLineNumber, MainOp->Asl.LogicalByteOffset, 1420 MainOp->Asl.Column, MainOp->Asl.Filename, MainMsg, 1421 NULL, SubEnode); 1422 } 1423 1424 1425 /******************************************************************************* 1426 * 1427 * FUNCTION: AslError 1428 * 1429 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1430 * MessageId - Index into global message buffer 1431 * Op - Parse node where error happened 1432 * ExtraMessage - additional error message 1433 * 1434 * RETURN: None 1435 * 1436 * DESCRIPTION: Main error reporting routine for the ASL compiler (all code 1437 * except the parser.) 1438 * 1439 ******************************************************************************/ 1440 1441 void 1442 AslError ( 1443 UINT8 Level, 1444 UINT16 MessageId, 1445 ACPI_PARSE_OBJECT *Op, 1446 char *ExtraMessage) 1447 { 1448 if (Op) 1449 { 1450 AslCommonError (Level, MessageId, Op->Asl.LineNumber, 1451 Op->Asl.LogicalLineNumber, 1452 Op->Asl.LogicalByteOffset, 1453 Op->Asl.Column, 1454 Op->Asl.Filename, ExtraMessage); 1455 } 1456 else 1457 { 1458 AslCommonError (Level, MessageId, 0, 1459 0, 0, 0, NULL, ExtraMessage); 1460 } 1461 } 1462 1463 1464 /******************************************************************************* 1465 * 1466 * FUNCTION: AslCoreSubsystemError 1467 * 1468 * PARAMETERS: Op - Parse node where error happened 1469 * Status - The ACPICA Exception 1470 * ExtraMessage - additional error message 1471 * Abort - TRUE -> Abort compilation 1472 * 1473 * RETURN: None 1474 * 1475 * DESCRIPTION: Error reporting routine for exceptions returned by the ACPICA 1476 * core subsystem. 1477 * 1478 ******************************************************************************/ 1479 1480 void 1481 AslCoreSubsystemError ( 1482 ACPI_PARSE_OBJECT *Op, 1483 ACPI_STATUS Status, 1484 char *ExtraMessage, 1485 BOOLEAN Abort) 1486 { 1487 1488 sprintf (AslGbl_MsgBuffer, "%s %s", AcpiFormatException (Status), ExtraMessage); 1489 1490 if (Op) 1491 { 1492 AslCommonError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, 1493 Op->Asl.LineNumber, 1494 Op->Asl.LogicalLineNumber, 1495 Op->Asl.LogicalByteOffset, 1496 Op->Asl.Column, 1497 Op->Asl.Filename, AslGbl_MsgBuffer); 1498 } 1499 else 1500 { 1501 AslCommonError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, 1502 0, 0, 0, 0, NULL, AslGbl_MsgBuffer); 1503 } 1504 1505 if (Abort) 1506 { 1507 AslAbort (); 1508 } 1509 } 1510 1511 1512 /******************************************************************************* 1513 * 1514 * FUNCTION: AslCompilererror 1515 * 1516 * PARAMETERS: CompilerMessage - Error message from the parser 1517 * 1518 * RETURN: Status (0 for now) 1519 * 1520 * DESCRIPTION: Report an error situation discovered in a production 1521 * NOTE: don't change the name of this function, it is called 1522 * from the auto-generated parser. 1523 * 1524 ******************************************************************************/ 1525 1526 int 1527 AslCompilererror ( 1528 const char *CompilerMessage) 1529 { 1530 1531 AslGbl_SyntaxError++; 1532 1533 AslCommonError (ASL_ERROR, ASL_MSG_SYNTAX, AslGbl_CurrentLineNumber, 1534 AslGbl_LogicalLineNumber, AslGbl_CurrentLineOffset, 1535 AslGbl_CurrentColumn, AslGbl_Files[ASL_FILE_INPUT].Filename, 1536 ACPI_CAST_PTR (char, CompilerMessage)); 1537 1538 return (0); 1539 } 1540