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 <contrib/dev/acpica/compiler/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 length 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 - Number 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 /* 532 * Seek to the offset in the combined source file, 533 * read the source line, and write it to the output. 534 */ 535 Actual = fseek (SourceFile, 536 (long) Enode->LogicalByteOffset, (int) SEEK_SET); 537 if (Actual) 538 { 539 fprintf (OutputFile, 540 "[*** iASL: Seek error on source code temp file %s ***]", 541 AslGbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 542 543 fprintf (OutputFile, "\n"); 544 return AE_OK; 545 } 546 RActual = fread (&SourceByte, 1, 1, SourceFile); 547 if (RActual != 1) 548 { 549 fprintf (OutputFile, 550 "[*** iASL: Read error on source code temp file %s ***]", 551 AslGbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 552 return AE_IO_ERROR; 553 } 554 555 /* Read/write the source line, up to the maximum line length */ 556 557 while (RActual && SourceByte && (SourceByte != '\n')) 558 { 559 if (*Total < 256) 560 { 561 /* After the max line length, we will just read the line, no write */ 562 563 if (fwrite (&SourceByte, 1, 1, OutputFile) != 1) 564 { 565 printf ("[*** iASL: Write error on output file ***]\n"); 566 return AE_IO_ERROR; 567 } 568 } 569 else if (*Total == 256) 570 { 571 fprintf (OutputFile, 572 "\n[*** iASL: Very long input line, message below refers to column %u ***]", 573 Enode->Column); 574 } 575 576 RActual = fread (&SourceByte, 1, 1, SourceFile); 577 if (RActual != 1) 578 { 579 fprintf (OutputFile, 580 "[*** iASL: Read error on source code temp file %s ***]", 581 AslGbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 582 583 return AE_IO_ERROR; 584 } 585 *Total += 1; 586 } 587 588 fprintf (OutputFile, "\n"); 589 } 590 } 591 else 592 { 593 /* 594 * Less verbose version of the error message, enabled via the 595 * -vi switch. The format is compatible with MS Visual Studio. 596 */ 597 fprintf (OutputFile, "%s", Enode->Filename); 598 599 if (Enode->LineNumber) 600 { 601 fprintf (OutputFile, "(%u) : ", 602 Enode->LineNumber); 603 } 604 } 605 606 return AE_OK; 607 } 608 609 /******************************************************************************* 610 * 611 * FUNCTION: AePrintException 612 * 613 * PARAMETERS: FileId - ID of output file 614 * Enode - Error node to print 615 * Header - Additional text before each message 616 * 617 * RETURN: None 618 * 619 * DESCRIPTION: Print the contents of an error node. 620 * 621 * NOTE: We don't use the FlxxxFile I/O functions here because on error 622 * they abort the compiler and call this function! Since we 623 * are reporting errors here, we ignore most output errors and 624 * just try to get out as much as we can. 625 * 626 ******************************************************************************/ 627 628 void 629 AePrintException ( 630 UINT32 FileId, 631 ASL_ERROR_MSG *Enode, 632 char *Header) 633 { 634 FILE *OutputFile; 635 BOOLEAN PrematureEOF = FALSE; 636 UINT32 Total = 0; 637 ACPI_STATUS Status; 638 ASL_ERROR_MSG *Child = Enode->SubError; 639 640 641 if (AslGbl_NoErrors) 642 { 643 return; 644 } 645 646 /* 647 * Only listing files have a header, and remarks/optimizations 648 * are always output 649 */ 650 if (!Header) 651 { 652 /* Ignore remarks if requested */ 653 654 switch (Enode->Level) 655 { 656 case ASL_WARNING: 657 case ASL_WARNING2: 658 case ASL_WARNING3: 659 660 if (!AslGbl_DisplayWarnings) 661 { 662 return; 663 } 664 break; 665 666 case ASL_REMARK: 667 668 if (!AslGbl_DisplayRemarks) 669 { 670 return; 671 } 672 break; 673 674 case ASL_OPTIMIZATION: 675 676 if (!AslGbl_DisplayOptimizations) 677 { 678 return; 679 } 680 break; 681 682 default: 683 684 break; 685 } 686 } 687 688 /* Get the various required file handles */ 689 690 OutputFile = AslGbl_Files[FileId].Handle; 691 692 if (Header) 693 { 694 fprintf (OutputFile, "%s", Header); 695 } 696 697 if (!Enode->Filename) 698 { 699 AeDecodeErrorMessageId (OutputFile, Enode, PrematureEOF, Total); 700 return; 701 } 702 703 Status = AePrintErrorSourceLine (OutputFile, Enode, &PrematureEOF, &Total); 704 if (ACPI_FAILURE (Status)) 705 { 706 return; 707 } 708 709 /* If a NULL message ID, just print the raw message */ 710 711 if (Enode->MessageId == 0) 712 { 713 fprintf (OutputFile, "%s\n", Enode->Message); 714 return; 715 } 716 717 AeDecodeErrorMessageId (OutputFile, Enode, PrematureEOF, Total); 718 719 while (Child) 720 { 721 fprintf (OutputFile, "\n"); 722 AePrintSubError (OutputFile, Child); 723 Child = Child->SubError; 724 } 725 } 726 727 728 /******************************************************************************* 729 * 730 * FUNCTION: AePrintSubError 731 * 732 * PARAMETERS: OutputFile - Output file 733 * Enode - Error node to print 734 * 735 * RETURN: None 736 * 737 * DESCRIPTION: Print the contents of an error node. This function is tailored 738 * to print error nodes that are SubErrors within ASL_ERROR_MSG 739 * 740 ******************************************************************************/ 741 742 static void 743 AePrintSubError ( 744 FILE *OutputFile, 745 ASL_ERROR_MSG *Enode) 746 { 747 UINT32 Total = 0; 748 BOOLEAN PrematureEOF = FALSE; 749 const char *MainMessage; 750 751 752 MainMessage = AeDecodeMessageId (Enode->MessageId); 753 754 fprintf (OutputFile, " %s%s", MainMessage, "\n "); 755 (void) AePrintErrorSourceLine (OutputFile, Enode, &PrematureEOF, &Total); 756 fprintf (OutputFile, "\n"); 757 } 758 759 760 /******************************************************************************* 761 * 762 * FUNCTION: AePrintErrorLog 763 * 764 * PARAMETERS: FileId - Where to output the error log 765 * 766 * RETURN: None 767 * 768 * DESCRIPTION: Print the entire contents of the error log 769 * 770 ******************************************************************************/ 771 772 void 773 AePrintErrorLog ( 774 UINT32 FileId) 775 { 776 ASL_ERROR_MSG *Enode = AslGbl_ErrorLog; 777 778 779 /* Walk the error node list */ 780 781 while (Enode) 782 { 783 AePrintException (FileId, Enode, NULL); 784 Enode = Enode->Next; 785 } 786 } 787 788 789 /******************************************************************************* 790 * 791 * FUNCTION: AslInitEnode 792 * 793 * PARAMETERS: InputEnode - Input Error node to initialize 794 * Level - Seriousness (Warning/error, etc.) 795 * MessageId - Index into global message buffer 796 * CurrentLineNumber - Actual file line number 797 * LogicalLineNumber - Cumulative line number 798 * LogicalByteOffset - Byte offset in source file 799 * Column - Column in current line 800 * Filename - Source filename 801 * ExtraMessage - Additional error message 802 * SourceLine - Line of error source code 803 * SubError - SubError of this InputEnode 804 * 805 * RETURN: None 806 * 807 * DESCRIPTION: Initialize an Error node 808 * 809 ******************************************************************************/ 810 811 static void AslInitEnode ( 812 ASL_ERROR_MSG **InputEnode, 813 UINT8 Level, 814 UINT16 MessageId, 815 UINT32 LineNumber, 816 UINT32 LogicalLineNumber, 817 UINT32 LogicalByteOffset, 818 UINT32 Column, 819 char *Filename, 820 char *ExtraMessage, 821 char *SourceLine, 822 ASL_ERROR_MSG *SubError) 823 { 824 ASL_ERROR_MSG *Enode; 825 ASL_GLOBAL_FILE_NODE *FileNode; 826 827 828 *InputEnode = UtLocalCalloc (sizeof (ASL_ERROR_MSG)); 829 Enode = *InputEnode; 830 Enode->Level = Level; 831 Enode->MessageId = MessageId; 832 Enode->LineNumber = LineNumber; 833 Enode->LogicalLineNumber = LogicalLineNumber; 834 Enode->LogicalByteOffset = LogicalByteOffset; 835 Enode->Column = Column; 836 Enode->SubError = SubError; 837 Enode->Message = NULL; 838 Enode->SourceLine = NULL; 839 Enode->Filename = NULL; 840 841 if (ExtraMessage) 842 { 843 /* Allocate a buffer for the message and a new error node */ 844 845 Enode->Message = UtLocalCacheCalloc (strlen (ExtraMessage) + 1); 846 847 /* Keep a copy of the extra message */ 848 849 strcpy (Enode->Message, ExtraMessage); 850 } 851 852 if (SourceLine) 853 { 854 Enode->SourceLine = UtLocalCalloc (strlen (SourceLine) + 1); 855 strcpy (Enode->SourceLine, SourceLine); 856 } 857 858 859 if (Filename) 860 { 861 Enode->Filename = Filename; 862 Enode->FilenameLength = strlen (Filename); 863 if (Enode->FilenameLength < 6) 864 { 865 Enode->FilenameLength = 6; 866 } 867 868 /* 869 * Attempt to get the file node of the filename listed in the parse 870 * node. If the name doesn't exist in the global file node, it is 871 * because the file is included by #include or ASL include. In this 872 * case, get the current file node. The source output of the current 873 * file will contain the contents of the file listed in the parse node. 874 */ 875 FileNode = FlGetFileNode (ASL_FILE_INPUT, Filename); 876 if (!FileNode) 877 { 878 FileNode = FlGetCurrentFileNode (); 879 } 880 881 Enode->SourceFilename = 882 FileNode->Files[ASL_FILE_SOURCE_OUTPUT].Filename; 883 } 884 } 885 886 887 /******************************************************************************* 888 * 889 * FUNCTION: AslCommonError2 890 * 891 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 892 * MessageId - Index into global message buffer 893 * LineNumber - Actual file line number 894 * Column - Column in current line 895 * SourceLine - Actual source code line 896 * Filename - Source filename 897 * ExtraMessage - Additional error message 898 * 899 * RETURN: None 900 * 901 * DESCRIPTION: Create a new error node and add it to the error log 902 * 903 ******************************************************************************/ 904 905 void 906 AslCommonError2 ( 907 UINT8 Level, 908 UINT16 MessageId, 909 UINT32 LineNumber, 910 UINT32 Column, 911 char *SourceLine, 912 char *Filename, 913 char *ExtraMessage) 914 { 915 AslLogNewError (Level, MessageId, LineNumber, LineNumber, 0, Column, 916 Filename, ExtraMessage, SourceLine, NULL); 917 } 918 919 920 /******************************************************************************* 921 * 922 * FUNCTION: AslCommonError 923 * 924 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 925 * MessageId - Index into global message buffer 926 * CurrentLineNumber - Actual file line number 927 * LogicalLineNumber - Cumulative line number 928 * LogicalByteOffset - Byte offset in source file 929 * Column - Column in current line 930 * Filename - Source filename 931 * ExtraMessage - Additional error message 932 * 933 * RETURN: None 934 * 935 * DESCRIPTION: Create a new error node and add it to the error log 936 * 937 ******************************************************************************/ 938 939 void 940 AslCommonError ( 941 UINT8 Level, 942 UINT16 MessageId, 943 UINT32 CurrentLineNumber, 944 UINT32 LogicalLineNumber, 945 UINT32 LogicalByteOffset, 946 UINT32 Column, 947 char *Filename, 948 char *ExtraMessage) 949 { 950 /* Check if user wants to ignore this exception */ 951 952 if (AslIsExceptionIgnored (Level, MessageId)) 953 { 954 return; 955 } 956 957 AslLogNewError (Level, MessageId, CurrentLineNumber, LogicalLineNumber, 958 LogicalByteOffset, Column, Filename, ExtraMessage, 959 NULL, NULL); 960 } 961 962 963 /******************************************************************************* 964 * 965 * FUNCTION: AslLogNewError 966 * 967 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 968 * MessageId - Index into global message buffer 969 * CurrentLineNumber - Actual file line number 970 * LogicalLineNumber - Cumulative line number 971 * LogicalByteOffset - Byte offset in source file 972 * Column - Column in current line 973 * Filename - Source filename 974 * Message - Additional error message 975 * SourceLine - Actual line of source code 976 * SubError - Sub-error associated with this error 977 * 978 * RETURN: None 979 * 980 * DESCRIPTION: Create a new error node and add it to the error log 981 * 982 ******************************************************************************/ 983 static void 984 AslLogNewError ( 985 UINT8 Level, 986 UINT16 MessageId, 987 UINT32 LineNumber, 988 UINT32 LogicalLineNumber, 989 UINT32 LogicalByteOffset, 990 UINT32 Column, 991 char *Filename, 992 char *Message, 993 char *SourceLine, 994 ASL_ERROR_MSG *SubError) 995 { 996 ASL_ERROR_MSG *Enode = NULL; 997 UINT8 ModifiedLevel = GetModifiedLevel (Level, MessageId); 998 999 1000 AslInitEnode (&Enode, ModifiedLevel, MessageId, LineNumber, 1001 LogicalLineNumber, LogicalByteOffset, Column, Filename, Message, 1002 SourceLine, SubError); 1003 1004 /* Add the new node to the error node list */ 1005 1006 AeAddToErrorLog (Enode); 1007 1008 if (AslGbl_DebugFlag) 1009 { 1010 /* stderr is a file, send error to it immediately */ 1011 1012 AePrintException (ASL_FILE_STDERR, Enode, NULL); 1013 } 1014 1015 AslGbl_ExceptionCount[ModifiedLevel]++; 1016 if (!AslGbl_IgnoreErrors && AslGbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT) 1017 { 1018 printf ("\nMaximum error count (%u) exceeded\n", ASL_MAX_ERROR_COUNT); 1019 1020 AslGbl_SourceLine = 0; 1021 AslGbl_NextError = AslGbl_ErrorLog; 1022 CmCleanupAndExit (); 1023 exit(1); 1024 } 1025 1026 return; 1027 } 1028 1029 1030 /******************************************************************************* 1031 * 1032 * FUNCTION: GetModifiedLevel 1033 * 1034 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1035 * MessageId - Index into global message buffer 1036 * 1037 * RETURN: UINT8 - Modified level 1038 * 1039 * DESCRIPTION: Get the modified level of exception codes that are reported as 1040 * errors from the -ww option. 1041 * 1042 ******************************************************************************/ 1043 1044 static UINT8 1045 GetModifiedLevel ( 1046 UINT8 Level, 1047 UINT16 MessageId) 1048 { 1049 UINT16 i; 1050 UINT16 ExceptionCode; 1051 1052 1053 ExceptionCode = AeBuildFullExceptionCode (Level, MessageId); 1054 1055 for (i = 0; i < AslGbl_ElevatedMessagesIndex; i++) 1056 { 1057 if (ExceptionCode == AslGbl_ElevatedMessages[i]) 1058 { 1059 return (ASL_ERROR); 1060 } 1061 } 1062 1063 return (Level); 1064 } 1065 1066 1067 /******************************************************************************* 1068 * 1069 * FUNCTION: AslIsExceptionIgnored 1070 * 1071 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1072 * MessageId - Index into global message buffer 1073 * 1074 * RETURN: BOOLEAN 1075 * 1076 * DESCRIPTION: Check if a particular exception is ignored. In this case it 1077 * means that the exception is (expected or disabled. 1078 * 1079 ******************************************************************************/ 1080 1081 BOOLEAN 1082 AslIsExceptionIgnored ( 1083 UINT8 Level, 1084 UINT16 MessageId) 1085 { 1086 BOOLEAN ExceptionIgnored; 1087 1088 1089 /* Note: this allows exception to be disabled and expected */ 1090 1091 ExceptionIgnored = AslIsExceptionDisabled (Level, MessageId); 1092 ExceptionIgnored |= AslIsExceptionExpected (Level, MessageId); 1093 1094 return (AslGbl_AllExceptionsDisabled || ExceptionIgnored); 1095 } 1096 1097 1098 /******************************************************************************* 1099 * 1100 * FUNCTION: AslCheckExpectException 1101 * 1102 * PARAMETERS: none 1103 * 1104 * RETURN: none 1105 * 1106 * DESCRIPTION: Check the global expected messages table and raise an error 1107 * for each message that has not been received. 1108 * 1109 ******************************************************************************/ 1110 1111 void 1112 AslCheckExpectedExceptions ( 1113 void) 1114 { 1115 UINT8 i; 1116 1117 1118 for (i = 0; i < AslGbl_ExpectedMessagesIndex; ++i) 1119 { 1120 if (!AslGbl_ExpectedMessages[i].MessageReceived) 1121 { 1122 AslError (ASL_ERROR, ASL_MSG_EXCEPTION_NOT_RECEIVED, NULL, 1123 AslGbl_ExpectedMessages[i].MessageIdStr); 1124 } 1125 } 1126 } 1127 1128 1129 /******************************************************************************* 1130 * 1131 * FUNCTION: AslExpectException 1132 * 1133 * PARAMETERS: MessageIdString - ID of excepted exception during compile 1134 * 1135 * RETURN: Status 1136 * 1137 * DESCRIPTION: Enter a message ID into the global expected messages table 1138 * If these messages are not raised during the compilation, throw 1139 * an error. 1140 * 1141 ******************************************************************************/ 1142 1143 ACPI_STATUS 1144 AslExpectException ( 1145 char *MessageIdString) 1146 { 1147 UINT32 MessageId; 1148 1149 1150 /* Convert argument to an integer and validate it */ 1151 1152 MessageId = (UINT32) strtoul (MessageIdString, NULL, 0); 1153 1154 if (MessageId > 6999) 1155 { 1156 printf ("\"%s\" is not a valid warning/remark/erro ID\n", 1157 MessageIdString); 1158 return (AE_BAD_PARAMETER); 1159 } 1160 1161 /* Insert value into the global expected message array */ 1162 1163 if (AslGbl_ExpectedMessagesIndex >= ASL_MAX_EXPECTED_MESSAGES) 1164 { 1165 printf ("Too many messages have been registered as expected (max %d)\n", 1166 ASL_MAX_DISABLED_MESSAGES); 1167 return (AE_LIMIT); 1168 } 1169 1170 AslGbl_ExpectedMessages[AslGbl_ExpectedMessagesIndex].MessageId = MessageId; 1171 AslGbl_ExpectedMessages[AslGbl_ExpectedMessagesIndex].MessageIdStr = MessageIdString; 1172 AslGbl_ExpectedMessages[AslGbl_ExpectedMessagesIndex].MessageReceived = FALSE; 1173 AslGbl_ExpectedMessagesIndex++; 1174 return (AE_OK); 1175 } 1176 1177 1178 /******************************************************************************* 1179 * 1180 * FUNCTION: AslDisableException 1181 * 1182 * PARAMETERS: MessageIdString - ID to be disabled 1183 * 1184 * RETURN: Status 1185 * 1186 * DESCRIPTION: Enter a message ID into the global disabled messages table 1187 * 1188 ******************************************************************************/ 1189 1190 ACPI_STATUS 1191 AslDisableException ( 1192 char *MessageIdString) 1193 { 1194 UINT32 MessageId; 1195 1196 1197 /* Convert argument to an integer and validate it */ 1198 1199 MessageId = (UINT32) strtoul (MessageIdString, NULL, 0); 1200 1201 if ((MessageId < 2000) || (MessageId > 6999)) 1202 { 1203 printf ("\"%s\" is not a valid warning/remark/error ID\n", 1204 MessageIdString); 1205 return (AE_BAD_PARAMETER); 1206 } 1207 1208 /* Insert value into the global disabled message array */ 1209 1210 if (AslGbl_DisabledMessagesIndex >= ASL_MAX_DISABLED_MESSAGES) 1211 { 1212 printf ("Too many messages have been disabled (max %d)\n", 1213 ASL_MAX_DISABLED_MESSAGES); 1214 return (AE_LIMIT); 1215 } 1216 1217 AslGbl_DisabledMessages[AslGbl_DisabledMessagesIndex] = MessageId; 1218 AslGbl_DisabledMessagesIndex++; 1219 return (AE_OK); 1220 } 1221 1222 1223 /******************************************************************************* 1224 * 1225 * FUNCTION: AslElevateException 1226 * 1227 * PARAMETERS: MessageIdString - ID of excepted exception during compile 1228 * 1229 * RETURN: Status 1230 * 1231 * DESCRIPTION: Enter a message ID into the global elevated exceptions table. 1232 * These messages will be considered as compilation errors. 1233 * 1234 ******************************************************************************/ 1235 1236 ACPI_STATUS 1237 AslElevateException ( 1238 char *MessageIdString) 1239 { 1240 UINT32 MessageId; 1241 1242 1243 /* Convert argument to an integer and validate it */ 1244 1245 MessageId = (UINT32) strtoul (MessageIdString, NULL, 0); 1246 1247 if (MessageId > 6999) 1248 { 1249 printf ("\"%s\" is not a valid warning/remark/erro ID\n", 1250 MessageIdString); 1251 return (AE_BAD_PARAMETER); 1252 } 1253 1254 /* Insert value into the global expected message array */ 1255 1256 if (AslGbl_ElevatedMessagesIndex >= ASL_MAX_ELEVATED_MESSAGES) 1257 { 1258 printf ("Too many messages have been registered as elevated (max %d)\n", 1259 ASL_MAX_DISABLED_MESSAGES); 1260 return (AE_LIMIT); 1261 } 1262 1263 AslGbl_ElevatedMessages[AslGbl_ElevatedMessagesIndex] = MessageId; 1264 AslGbl_ElevatedMessagesIndex++; 1265 return (AE_OK); 1266 } 1267 1268 /******************************************************************************* 1269 * 1270 * FUNCTION: AslIsExceptionDisabled 1271 * 1272 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1273 * MessageId - Index into global message buffer 1274 * 1275 * RETURN: TRUE if exception/message should be ignored 1276 * 1277 * DESCRIPTION: Check if the user has specified options such that this 1278 * exception should be ignored 1279 * 1280 ******************************************************************************/ 1281 1282 static BOOLEAN 1283 AslIsExceptionExpected ( 1284 UINT8 Level, 1285 UINT16 MessageId) 1286 { 1287 UINT32 EncodedMessageId; 1288 UINT32 i; 1289 1290 1291 /* Mark this exception as received */ 1292 1293 EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId); 1294 for (i = 0; i < AslGbl_ExpectedMessagesIndex; i++) 1295 { 1296 /* Simple implementation via fixed array */ 1297 1298 if (EncodedMessageId == AslGbl_ExpectedMessages[i].MessageId) 1299 { 1300 return (AslGbl_ExpectedMessages[i].MessageReceived = TRUE); 1301 } 1302 } 1303 1304 return (FALSE); 1305 } 1306 1307 1308 /******************************************************************************* 1309 * 1310 * FUNCTION: AslIsExceptionDisabled 1311 * 1312 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1313 * MessageId - Index into global message buffer 1314 * 1315 * RETURN: TRUE if exception/message should be ignored 1316 * 1317 * DESCRIPTION: Check if the user has specified options such that this 1318 * exception should be ignored 1319 * 1320 ******************************************************************************/ 1321 1322 static BOOLEAN 1323 AslIsExceptionDisabled ( 1324 UINT8 Level, 1325 UINT16 MessageId) 1326 { 1327 UINT32 EncodedMessageId; 1328 UINT32 i; 1329 1330 1331 switch (Level) 1332 { 1333 case ASL_WARNING2: 1334 case ASL_WARNING3: 1335 1336 /* Check for global disable via -w1/-w2/-w3 options */ 1337 1338 if (Level > AslGbl_WarningLevel) 1339 { 1340 return (TRUE); 1341 } 1342 /* Fall through */ 1343 1344 case ASL_WARNING: 1345 case ASL_REMARK: 1346 case ASL_ERROR: 1347 /* 1348 * Ignore this error/warning/remark if it has been disabled by 1349 * the user (-vw option) 1350 */ 1351 EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId); 1352 for (i = 0; i < AslGbl_DisabledMessagesIndex; i++) 1353 { 1354 /* Simple implementation via fixed array */ 1355 1356 if (EncodedMessageId == AslGbl_DisabledMessages[i]) 1357 { 1358 return (TRUE); 1359 } 1360 } 1361 break; 1362 1363 default: 1364 break; 1365 } 1366 1367 return (FALSE); 1368 } 1369 1370 1371 /******************************************************************************* 1372 * 1373 * FUNCTION: AslDualParseOpError 1374 * 1375 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1376 * MainMsgId - Index into global message buffer 1377 * MainOp - Parse node where error happened 1378 * MainMsg - Message pertaining to the MainOp 1379 * SubMsgId - Index into global message buffer 1380 * SubOp - Additional parse node for better message 1381 * SubMsg - Message pertaining to SubOp 1382 * 1383 * 1384 * RETURN: None 1385 * 1386 * DESCRIPTION: Main error reporting routine for the ASL compiler for error 1387 * messages that point to multiple parse objects. 1388 * 1389 ******************************************************************************/ 1390 1391 void 1392 AslDualParseOpError ( 1393 UINT8 Level, 1394 UINT16 MainMsgId, 1395 ACPI_PARSE_OBJECT *MainOp, 1396 char *MainMsg, 1397 UINT16 SubMsgId, 1398 ACPI_PARSE_OBJECT *SubOp, 1399 char *SubMsg) 1400 { 1401 ASL_ERROR_MSG *SubEnode = NULL; 1402 1403 1404 /* Check if user wants to ignore this exception */ 1405 1406 if (AslIsExceptionIgnored (Level, MainMsgId) || !MainOp) 1407 { 1408 return; 1409 } 1410 1411 if (SubOp) 1412 { 1413 AslInitEnode (&SubEnode, Level, SubMsgId, SubOp->Asl.LineNumber, 1414 SubOp->Asl.LogicalLineNumber, SubOp->Asl.LogicalByteOffset, 1415 SubOp->Asl.Column, SubOp->Asl.Filename, SubMsg, 1416 NULL, NULL); 1417 } 1418 1419 AslLogNewError (Level, MainMsgId, MainOp->Asl.LineNumber, 1420 MainOp->Asl.LogicalLineNumber, MainOp->Asl.LogicalByteOffset, 1421 MainOp->Asl.Column, MainOp->Asl.Filename, MainMsg, 1422 NULL, SubEnode); 1423 } 1424 1425 1426 /******************************************************************************* 1427 * 1428 * FUNCTION: AslError 1429 * 1430 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 1431 * MessageId - Index into global message buffer 1432 * Op - Parse node where error happened 1433 * ExtraMessage - Additional error message 1434 * 1435 * RETURN: None 1436 * 1437 * DESCRIPTION: Main error reporting routine for the ASL compiler (all code 1438 * except the parser.) 1439 * 1440 ******************************************************************************/ 1441 1442 void 1443 AslError ( 1444 UINT8 Level, 1445 UINT16 MessageId, 1446 ACPI_PARSE_OBJECT *Op, 1447 char *ExtraMessage) 1448 { 1449 if (Op) 1450 { 1451 AslCommonError (Level, MessageId, Op->Asl.LineNumber, 1452 Op->Asl.LogicalLineNumber, 1453 Op->Asl.LogicalByteOffset, 1454 Op->Asl.Column, 1455 Op->Asl.Filename, ExtraMessage); 1456 } 1457 else 1458 { 1459 AslCommonError (Level, MessageId, 0, 1460 0, 0, 0, NULL, ExtraMessage); 1461 } 1462 } 1463 1464 1465 /******************************************************************************* 1466 * 1467 * FUNCTION: AslCoreSubsystemError 1468 * 1469 * PARAMETERS: Op - Parse node where error happened 1470 * Status - The ACPICA Exception 1471 * ExtraMessage - Additional error message 1472 * Abort - TRUE -> Abort compilation 1473 * 1474 * RETURN: None 1475 * 1476 * DESCRIPTION: Error reporting routine for exceptions returned by the ACPICA 1477 * core subsystem. 1478 * 1479 ******************************************************************************/ 1480 1481 void 1482 AslCoreSubsystemError ( 1483 ACPI_PARSE_OBJECT *Op, 1484 ACPI_STATUS Status, 1485 char *ExtraMessage, 1486 BOOLEAN Abort) 1487 { 1488 1489 sprintf (AslGbl_MsgBuffer, "%s %s", AcpiFormatException (Status), ExtraMessage); 1490 1491 if (Op) 1492 { 1493 AslCommonError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, 1494 Op->Asl.LineNumber, 1495 Op->Asl.LogicalLineNumber, 1496 Op->Asl.LogicalByteOffset, 1497 Op->Asl.Column, 1498 Op->Asl.Filename, AslGbl_MsgBuffer); 1499 } 1500 else 1501 { 1502 AslCommonError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, 1503 0, 0, 0, 0, NULL, AslGbl_MsgBuffer); 1504 } 1505 1506 if (Abort) 1507 { 1508 AslAbort (); 1509 } 1510 } 1511 1512 1513 /******************************************************************************* 1514 * 1515 * FUNCTION: AslCompilererror 1516 * 1517 * PARAMETERS: CompilerMessage - Error message from the parser 1518 * 1519 * RETURN: Status (0 for now) 1520 * 1521 * DESCRIPTION: Report an error situation discovered in a production 1522 * NOTE: don't change the name of this function, it is called 1523 * from the auto-generated parser. 1524 * 1525 ******************************************************************************/ 1526 1527 int 1528 AslCompilererror ( 1529 const char *CompilerMessage) 1530 { 1531 1532 AslGbl_SyntaxError++; 1533 1534 AslCommonError (ASL_ERROR, ASL_MSG_SYNTAX, AslGbl_CurrentLineNumber, 1535 AslGbl_LogicalLineNumber, AslGbl_CurrentLineOffset, 1536 AslGbl_CurrentColumn, AslGbl_Files[ASL_FILE_INPUT].Filename, 1537 ACPI_CAST_PTR (char, CompilerMessage)); 1538 1539 return (0); 1540 } 1541