1 /****************************************************************************** 2 * 3 * Module Name: aslerror - Error handling and statistics 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <contrib/dev/acpica/compiler/aslcompiler.h> 45 46 #define _COMPONENT ACPI_COMPILER 47 ACPI_MODULE_NAME ("aslerror") 48 49 /* Local prototypes */ 50 51 static void 52 AeAddToErrorLog ( 53 ASL_ERROR_MSG *Enode); 54 55 56 /******************************************************************************* 57 * 58 * FUNCTION: AslAbort 59 * 60 * PARAMETERS: None 61 * 62 * RETURN: None 63 * 64 * DESCRIPTION: Dump the error log and abort the compiler. Used for serious 65 * I/O errors. 66 * 67 ******************************************************************************/ 68 69 void 70 AslAbort ( 71 void) 72 { 73 74 AePrintErrorLog (ASL_FILE_STDERR); 75 if (Gbl_DebugFlag) 76 { 77 /* Print error summary to stdout also */ 78 79 AePrintErrorLog (ASL_FILE_STDOUT); 80 } 81 82 exit (1); 83 } 84 85 86 /******************************************************************************* 87 * 88 * FUNCTION: AeClearErrorLog 89 * 90 * PARAMETERS: None 91 * 92 * RETURN: None 93 * 94 * DESCRIPTION: Empty the error list 95 * 96 ******************************************************************************/ 97 98 void 99 AeClearErrorLog ( 100 void) 101 { 102 ASL_ERROR_MSG *Enode = Gbl_ErrorLog; 103 ASL_ERROR_MSG *Next; 104 105 /* Walk the error node list */ 106 107 while (Enode) 108 { 109 Next = Enode->Next; 110 ACPI_FREE (Enode); 111 Enode = Next; 112 } 113 114 Gbl_ErrorLog = NULL; 115 } 116 117 118 /******************************************************************************* 119 * 120 * FUNCTION: AeAddToErrorLog 121 * 122 * PARAMETERS: Enode - An error node to add to the log 123 * 124 * RETURN: None 125 * 126 * DESCRIPTION: Add a new error node to the error log. The error log is 127 * ordered by the "logical" line number (cumulative line number 128 * including all include files.) 129 * 130 ******************************************************************************/ 131 132 static void 133 AeAddToErrorLog ( 134 ASL_ERROR_MSG *Enode) 135 { 136 ASL_ERROR_MSG *Next; 137 ASL_ERROR_MSG *Prev; 138 139 140 /* If Gbl_ErrorLog is null, this is the first error node */ 141 142 if (!Gbl_ErrorLog) 143 { 144 Gbl_ErrorLog = Enode; 145 return; 146 } 147 148 /* 149 * Walk error list until we find a line number greater than ours. 150 * List is sorted according to line number. 151 */ 152 Prev = NULL; 153 Next = Gbl_ErrorLog; 154 155 while ((Next) && 156 (Next->LogicalLineNumber <= Enode->LogicalLineNumber)) 157 { 158 Prev = Next; 159 Next = Next->Next; 160 } 161 162 /* Found our place in the list */ 163 164 Enode->Next = Next; 165 166 if (Prev) 167 { 168 Prev->Next = Enode; 169 } 170 else 171 { 172 Gbl_ErrorLog = Enode; 173 } 174 } 175 176 177 /******************************************************************************* 178 * 179 * FUNCTION: AePrintException 180 * 181 * PARAMETERS: FileId - ID of output file 182 * Enode - Error node to print 183 * Header - Additional text before each message 184 * 185 * RETURN: None 186 * 187 * DESCRIPTION: Print the contents of an error node. 188 * 189 * NOTE: We don't use the FlxxxFile I/O functions here because on error 190 * they abort the compiler and call this function! Since we 191 * are reporting errors here, we ignore most output errors and 192 * just try to get out as much as we can. 193 * 194 ******************************************************************************/ 195 196 void 197 AePrintException ( 198 UINT32 FileId, 199 ASL_ERROR_MSG *Enode, 200 char *Header) 201 { 202 UINT8 SourceByte; 203 int Actual; 204 size_t RActual; 205 UINT32 MsgLength; 206 const char *MainMessage; 207 char *ExtraMessage; 208 UINT32 SourceColumn; 209 UINT32 ErrorColumn; 210 FILE *OutputFile; 211 FILE *SourceFile = NULL; 212 long FileSize; 213 BOOLEAN PrematureEOF = FALSE; 214 UINT32 Total = 0; 215 216 217 if (Gbl_NoErrors) 218 { 219 return; 220 } 221 222 /* 223 * Only listing files have a header, and remarks/optimizations 224 * are always output 225 */ 226 if (!Header) 227 { 228 /* Ignore remarks if requested */ 229 230 switch (Enode->Level) 231 { 232 case ASL_WARNING: 233 case ASL_WARNING2: 234 case ASL_WARNING3: 235 236 if (!Gbl_DisplayWarnings) 237 { 238 return; 239 } 240 break; 241 242 case ASL_REMARK: 243 244 if (!Gbl_DisplayRemarks) 245 { 246 return; 247 } 248 break; 249 250 case ASL_OPTIMIZATION: 251 252 if (!Gbl_DisplayOptimizations) 253 { 254 return; 255 } 256 break; 257 258 default: 259 260 break; 261 } 262 } 263 264 /* Get the various required file handles */ 265 266 OutputFile = Gbl_Files[FileId].Handle; 267 268 if (!Enode->SourceLine) 269 { 270 /* Use the merged header/source file if present, otherwise use input file */ 271 272 SourceFile = Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle; 273 if (!SourceFile) 274 { 275 SourceFile = Gbl_Files[ASL_FILE_INPUT].Handle; 276 } 277 278 if (SourceFile) 279 { 280 /* Determine if the error occurred at source file EOF */ 281 282 fseek (SourceFile, 0, SEEK_END); 283 FileSize = ftell (SourceFile); 284 285 if ((long) Enode->LogicalByteOffset >= FileSize) 286 { 287 PrematureEOF = TRUE; 288 } 289 } 290 } 291 292 if (Header) 293 { 294 fprintf (OutputFile, "%s", Header); 295 } 296 297 /* Print filename and line number if present and valid */ 298 299 if (Enode->Filename) 300 { 301 if (Gbl_VerboseErrors) 302 { 303 fprintf (OutputFile, "%-8s", Enode->Filename); 304 305 if (Enode->LineNumber) 306 { 307 if (Enode->SourceLine) 308 { 309 fprintf (OutputFile, " %6u: %s", 310 Enode->LineNumber, Enode->SourceLine); 311 } 312 else 313 { 314 fprintf (OutputFile, " %6u: ", Enode->LineNumber); 315 316 /* 317 * If not at EOF, get the corresponding source code line and 318 * display it. Don't attempt this if we have a premature EOF 319 * condition. 320 */ 321 if (!PrematureEOF) 322 { 323 /* 324 * Seek to the offset in the combined source file, read 325 * the source line, and write it to the output. 326 */ 327 Actual = fseek (SourceFile, (long) Enode->LogicalByteOffset, 328 (int) SEEK_SET); 329 if (Actual) 330 { 331 fprintf (OutputFile, 332 "[*** iASL: Seek error on source code temp file %s ***]", 333 Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 334 } 335 else 336 { 337 RActual = fread (&SourceByte, 1, 1, SourceFile); 338 if (RActual != 1) 339 { 340 fprintf (OutputFile, 341 "[*** iASL: Read error on source code temp file %s ***]", 342 Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 343 } 344 else 345 { 346 /* Read/write the source line, up to the maximum line length */ 347 348 while (RActual && SourceByte && (SourceByte != '\n')) 349 { 350 if (Total < 256) 351 { 352 /* After the max line length, we will just read the line, no write */ 353 354 if (fwrite (&SourceByte, 1, 1, OutputFile) != 1) 355 { 356 printf ("[*** iASL: Write error on output file ***]\n"); 357 return; 358 } 359 } 360 else if (Total == 256) 361 { 362 fprintf (OutputFile, 363 "\n[*** iASL: Very long input line, message below refers to column %u ***]", 364 Enode->Column); 365 } 366 367 RActual = fread (&SourceByte, 1, 1, SourceFile); 368 if (RActual != 1) 369 { 370 fprintf (OutputFile, 371 "[*** iASL: Read error on source code temp file %s ***]", 372 Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename); 373 return; 374 } 375 Total++; 376 } 377 } 378 } 379 } 380 381 fprintf (OutputFile, "\n"); 382 } 383 } 384 } 385 else 386 { 387 /* 388 * Less verbose version of the error message, enabled via the 389 * -vi switch. The format is compatible with MS Visual Studio. 390 */ 391 fprintf (OutputFile, "%s", Enode->Filename); 392 393 if (Enode->LineNumber) 394 { 395 fprintf (OutputFile, "(%u) : ", 396 Enode->LineNumber); 397 } 398 } 399 } 400 401 /* If a NULL message ID, just print the raw message */ 402 403 if (Enode->MessageId == 0) 404 { 405 fprintf (OutputFile, "%s\n", Enode->Message); 406 return; 407 } 408 409 /* Decode the message ID */ 410 411 fprintf (OutputFile, "%s %4.4d -", 412 AeDecodeExceptionLevel (Enode->Level), 413 AeBuildFullExceptionCode (Enode->Level, Enode->MessageId)); 414 415 MainMessage = AeDecodeMessageId (Enode->MessageId); 416 ExtraMessage = Enode->Message; 417 418 /* If a NULL line number, just print the decoded message */ 419 420 if (!Enode->LineNumber) 421 { 422 fprintf (OutputFile, " %s %s\n\n", MainMessage, ExtraMessage); 423 return; 424 } 425 426 MsgLength = strlen (MainMessage); 427 if (MsgLength == 0) 428 { 429 /* Use the secondary/extra message as main message */ 430 431 MainMessage = Enode->Message; 432 if (!MainMessage) 433 { 434 MainMessage = ""; 435 } 436 437 MsgLength = strlen (MainMessage); 438 ExtraMessage = NULL; 439 } 440 441 if (Gbl_VerboseErrors && !PrematureEOF) 442 { 443 if (Total >= 256) 444 { 445 fprintf (OutputFile, " %s", 446 MainMessage); 447 } 448 else 449 { 450 SourceColumn = Enode->Column + Enode->FilenameLength + 6 + 2; 451 ErrorColumn = ASL_ERROR_LEVEL_LENGTH + 5 + 2 + 1; 452 453 if ((MsgLength + ErrorColumn) < (SourceColumn - 1)) 454 { 455 fprintf (OutputFile, "%*s%s", 456 (int) ((SourceColumn - 1) - ErrorColumn), 457 MainMessage, " ^ "); 458 } 459 else 460 { 461 fprintf (OutputFile, "%*s %s", 462 (int) ((SourceColumn - ErrorColumn) + 1), "^", 463 MainMessage); 464 } 465 } 466 } 467 else 468 { 469 fprintf (OutputFile, " %s", MainMessage); 470 } 471 472 /* Print the extra info message if present */ 473 474 if (ExtraMessage) 475 { 476 fprintf (OutputFile, " (%s)", ExtraMessage); 477 } 478 479 if (PrematureEOF) 480 { 481 fprintf (OutputFile, " and premature End-Of-File"); 482 } 483 484 fprintf (OutputFile, "\n"); 485 if (Gbl_VerboseErrors) 486 { 487 fprintf (OutputFile, "\n"); 488 } 489 } 490 491 492 /******************************************************************************* 493 * 494 * FUNCTION: AePrintErrorLog 495 * 496 * PARAMETERS: FileId - Where to output the error log 497 * 498 * RETURN: None 499 * 500 * DESCRIPTION: Print the entire contents of the error log 501 * 502 ******************************************************************************/ 503 504 void 505 AePrintErrorLog ( 506 UINT32 FileId) 507 { 508 ASL_ERROR_MSG *Enode = Gbl_ErrorLog; 509 510 511 /* Walk the error node list */ 512 513 while (Enode) 514 { 515 AePrintException (FileId, Enode, NULL); 516 Enode = Enode->Next; 517 } 518 } 519 520 521 /******************************************************************************* 522 * 523 * FUNCTION: AslCommonError2 524 * 525 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 526 * MessageId - Index into global message buffer 527 * LineNumber - Actual file line number 528 * Column - Column in current line 529 * SourceLine - Actual source code line 530 * Filename - source filename 531 * ExtraMessage - additional error message 532 * 533 * RETURN: None 534 * 535 * DESCRIPTION: Create a new error node and add it to the error log 536 * 537 ******************************************************************************/ 538 539 void 540 AslCommonError2 ( 541 UINT8 Level, 542 UINT16 MessageId, 543 UINT32 LineNumber, 544 UINT32 Column, 545 char *SourceLine, 546 char *Filename, 547 char *ExtraMessage) 548 { 549 char *MessageBuffer = NULL; 550 char *LineBuffer; 551 ASL_ERROR_MSG *Enode; 552 553 554 Enode = UtLocalCalloc (sizeof (ASL_ERROR_MSG)); 555 556 if (ExtraMessage) 557 { 558 /* Allocate a buffer for the message and a new error node */ 559 560 MessageBuffer = UtStringCacheCalloc (strlen (ExtraMessage) + 1); 561 562 /* Keep a copy of the extra message */ 563 564 strcpy (MessageBuffer, ExtraMessage); 565 } 566 567 LineBuffer = UtLocalCalloc (strlen (SourceLine) + 1); 568 strcpy (LineBuffer, SourceLine); 569 570 /* Initialize the error node */ 571 572 if (Filename) 573 { 574 Enode->Filename = Filename; 575 Enode->FilenameLength = strlen (Filename); 576 if (Enode->FilenameLength < 6) 577 { 578 Enode->FilenameLength = 6; 579 } 580 } 581 582 Enode->MessageId = MessageId; 583 Enode->Level = Level; 584 Enode->LineNumber = LineNumber; 585 Enode->LogicalLineNumber = LineNumber; 586 Enode->LogicalByteOffset = 0; 587 Enode->Column = Column; 588 Enode->Message = MessageBuffer; 589 Enode->SourceLine = LineBuffer; 590 591 /* Add the new node to the error node list */ 592 593 AeAddToErrorLog (Enode); 594 595 if (Gbl_DebugFlag) 596 { 597 /* stderr is a file, send error to it immediately */ 598 599 AePrintException (ASL_FILE_STDERR, Enode, NULL); 600 } 601 602 Gbl_ExceptionCount[Level]++; 603 } 604 605 606 /******************************************************************************* 607 * 608 * FUNCTION: AslCommonError 609 * 610 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 611 * MessageId - Index into global message buffer 612 * CurrentLineNumber - Actual file line number 613 * LogicalLineNumber - Cumulative line number 614 * LogicalByteOffset - Byte offset in source file 615 * Column - Column in current line 616 * Filename - source filename 617 * ExtraMessage - additional error message 618 * 619 * RETURN: None 620 * 621 * DESCRIPTION: Create a new error node and add it to the error log 622 * 623 ******************************************************************************/ 624 625 void 626 AslCommonError ( 627 UINT8 Level, 628 UINT16 MessageId, 629 UINT32 CurrentLineNumber, 630 UINT32 LogicalLineNumber, 631 UINT32 LogicalByteOffset, 632 UINT32 Column, 633 char *Filename, 634 char *ExtraMessage) 635 { 636 char *MessageBuffer = NULL; 637 ASL_ERROR_MSG *Enode; 638 639 640 Enode = UtLocalCalloc (sizeof (ASL_ERROR_MSG)); 641 642 if (ExtraMessage) 643 { 644 /* Allocate a buffer for the message and a new error node */ 645 646 MessageBuffer = UtStringCacheCalloc (strlen (ExtraMessage) + 1); 647 648 /* Keep a copy of the extra message */ 649 650 strcpy (MessageBuffer, ExtraMessage); 651 } 652 653 /* Initialize the error node */ 654 655 if (Filename) 656 { 657 Enode->Filename = Filename; 658 Enode->FilenameLength = strlen (Filename); 659 if (Enode->FilenameLength < 6) 660 { 661 Enode->FilenameLength = 6; 662 } 663 } 664 665 Enode->MessageId = MessageId; 666 Enode->Level = Level; 667 Enode->LineNumber = CurrentLineNumber; 668 Enode->LogicalLineNumber = LogicalLineNumber; 669 Enode->LogicalByteOffset = LogicalByteOffset; 670 Enode->Column = Column; 671 Enode->Message = MessageBuffer; 672 Enode->SourceLine = NULL; 673 674 /* Add the new node to the error node list */ 675 676 AeAddToErrorLog (Enode); 677 678 if (Gbl_DebugFlag) 679 { 680 /* stderr is a file, send error to it immediately */ 681 682 AePrintException (ASL_FILE_STDERR, Enode, NULL); 683 } 684 685 Gbl_ExceptionCount[Level]++; 686 if (Gbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT) 687 { 688 printf ("\nMaximum error count (%u) exceeded\n", ASL_MAX_ERROR_COUNT); 689 690 Gbl_SourceLine = 0; 691 Gbl_NextError = Gbl_ErrorLog; 692 CmCleanupAndExit (); 693 exit(1); 694 } 695 696 return; 697 } 698 699 700 /******************************************************************************* 701 * 702 * FUNCTION: AslDisableException 703 * 704 * PARAMETERS: MessageIdString - ID to be disabled 705 * 706 * RETURN: Status 707 * 708 * DESCRIPTION: Enter a message ID into the global disabled messages table 709 * 710 ******************************************************************************/ 711 712 ACPI_STATUS 713 AslDisableException ( 714 char *MessageIdString) 715 { 716 UINT32 MessageId; 717 718 719 /* Convert argument to an integer and validate it */ 720 721 MessageId = (UINT32) strtoul (MessageIdString, NULL, 0); 722 723 if ((MessageId < 2000) || (MessageId > 5999)) 724 { 725 printf ("\"%s\" is not a valid warning/remark ID\n", 726 MessageIdString); 727 return (AE_BAD_PARAMETER); 728 } 729 730 /* Insert value into the global disabled message array */ 731 732 if (Gbl_DisabledMessagesIndex >= ASL_MAX_DISABLED_MESSAGES) 733 { 734 printf ("Too many messages have been disabled (max %u)\n", 735 ASL_MAX_DISABLED_MESSAGES); 736 return (AE_LIMIT); 737 } 738 739 Gbl_DisabledMessages[Gbl_DisabledMessagesIndex] = MessageId; 740 Gbl_DisabledMessagesIndex++; 741 return (AE_OK); 742 } 743 744 745 /******************************************************************************* 746 * 747 * FUNCTION: AslIsExceptionDisabled 748 * 749 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 750 * MessageId - Index into global message buffer 751 * 752 * RETURN: TRUE if exception/message should be ignored 753 * 754 * DESCRIPTION: Check if the user has specified options such that this 755 * exception should be ignored 756 * 757 ******************************************************************************/ 758 759 BOOLEAN 760 AslIsExceptionDisabled ( 761 UINT8 Level, 762 UINT16 MessageId) 763 { 764 UINT32 EncodedMessageId; 765 UINT32 i; 766 767 768 switch (Level) 769 { 770 case ASL_WARNING2: 771 case ASL_WARNING3: 772 773 /* Check for global disable via -w1/-w2/-w3 options */ 774 775 if (Level > Gbl_WarningLevel) 776 { 777 return (TRUE); 778 } 779 /* Fall through */ 780 781 case ASL_WARNING: 782 case ASL_REMARK: 783 /* 784 * Ignore this warning/remark if it has been disabled by 785 * the user (-vw option) 786 */ 787 EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId); 788 for (i = 0; i < Gbl_DisabledMessagesIndex; i++) 789 { 790 /* Simple implementation via fixed array */ 791 792 if (EncodedMessageId == Gbl_DisabledMessages[i]) 793 { 794 return (TRUE); 795 } 796 } 797 break; 798 799 default: 800 break; 801 } 802 803 return (FALSE); 804 } 805 806 807 /******************************************************************************* 808 * 809 * FUNCTION: AslError 810 * 811 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 812 * MessageId - Index into global message buffer 813 * Op - Parse node where error happened 814 * ExtraMessage - additional error message 815 * 816 * RETURN: None 817 * 818 * DESCRIPTION: Main error reporting routine for the ASL compiler (all code 819 * except the parser.) 820 * 821 ******************************************************************************/ 822 823 void 824 AslError ( 825 UINT8 Level, 826 UINT16 MessageId, 827 ACPI_PARSE_OBJECT *Op, 828 char *ExtraMessage) 829 { 830 831 /* Check if user wants to ignore this exception */ 832 833 if (Gbl_AllExceptionsDisabled || 834 AslIsExceptionDisabled (Level, MessageId)) 835 { 836 return; 837 } 838 839 if (Op) 840 { 841 AslCommonError (Level, MessageId, Op->Asl.LineNumber, 842 Op->Asl.LogicalLineNumber, 843 Op->Asl.LogicalByteOffset, 844 Op->Asl.Column, 845 Op->Asl.Filename, ExtraMessage); 846 } 847 else 848 { 849 AslCommonError (Level, MessageId, 0, 850 0, 0, 0, NULL, ExtraMessage); 851 } 852 } 853 854 855 /******************************************************************************* 856 * 857 * FUNCTION: AslCoreSubsystemError 858 * 859 * PARAMETERS: Op - Parse node where error happened 860 * Status - The ACPICA Exception 861 * ExtraMessage - additional error message 862 * Abort - TRUE -> Abort compilation 863 * 864 * RETURN: None 865 * 866 * DESCRIPTION: Error reporting routine for exceptions returned by the ACPICA 867 * core subsystem. 868 * 869 ******************************************************************************/ 870 871 void 872 AslCoreSubsystemError ( 873 ACPI_PARSE_OBJECT *Op, 874 ACPI_STATUS Status, 875 char *ExtraMessage, 876 BOOLEAN Abort) 877 { 878 879 sprintf (MsgBuffer, "%s %s", AcpiFormatException (Status), ExtraMessage); 880 881 if (Op) 882 { 883 AslCommonError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, Op->Asl.LineNumber, 884 Op->Asl.LogicalLineNumber, 885 Op->Asl.LogicalByteOffset, 886 Op->Asl.Column, 887 Op->Asl.Filename, MsgBuffer); 888 } 889 else 890 { 891 AslCommonError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, 0, 892 0, 0, 0, NULL, MsgBuffer); 893 } 894 895 if (Abort) 896 { 897 AslAbort (); 898 } 899 } 900 901 902 /******************************************************************************* 903 * 904 * FUNCTION: AslCompilererror 905 * 906 * PARAMETERS: CompilerMessage - Error message from the parser 907 * 908 * RETURN: Status (0 for now) 909 * 910 * DESCRIPTION: Report an error situation discovered in a production 911 * NOTE: don't change the name of this function, it is called 912 * from the auto-generated parser. 913 * 914 ******************************************************************************/ 915 916 int 917 AslCompilererror ( 918 const char *CompilerMessage) 919 { 920 921 Gbl_SyntaxError++; 922 923 AslCommonError (ASL_ERROR, ASL_MSG_SYNTAX, Gbl_CurrentLineNumber, 924 Gbl_LogicalLineNumber, Gbl_CurrentLineOffset, 925 Gbl_CurrentColumn, Gbl_Files[ASL_FILE_INPUT].Filename, 926 ACPI_CAST_PTR (char, CompilerMessage)); 927 928 return (0); 929 } 930