sys/contrib/dev/acpica/source/compiler/aslerror.c

   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 }