1/******************************************************************************
2 *
3 * Module Name: aslerror - Error handling and statistics
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2016, 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
51static void
52AeAddToErrorLog (
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
69void
70AslAbort (
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
98void
99AeClearErrorLog (
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
132static void
133AeAddToErrorLog (
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
196void
197AePrintException (
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        /*
271         * Use the merged header/source file if present, otherwise
272         * use input file
273         */
274        SourceFile = Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle;
275        if (!SourceFile)
276        {
277            SourceFile = Gbl_Files[ASL_FILE_INPUT].Handle;
278        }
279
280        if (SourceFile)
281        {
282            /* Determine if the error occurred at source file EOF */
283
284            fseek (SourceFile, 0, SEEK_END);
285            FileSize = ftell (SourceFile);
286
287            if ((long) Enode->LogicalByteOffset >= FileSize)
288            {
289                PrematureEOF = TRUE;
290            }
291        }
292    }
293
294    if (Header)
295    {
296        fprintf (OutputFile, "%s", Header);
297    }
298
299    /* Print filename and line number if present and valid */
300
301    if (Enode->Filename)
302    {
303        if (Gbl_VerboseErrors)
304        {
305            fprintf (OutputFile, "%-8s", Enode->Filename);
306
307            if (Enode->LineNumber)
308            {
309                if (Enode->SourceLine)
310                {
311                    fprintf (OutputFile, " %6u: %s",
312                        Enode->LineNumber, Enode->SourceLine);
313                }
314                else
315                {
316                    fprintf (OutputFile, " %6u: ", Enode->LineNumber);
317
318                    /*
319                     * If not at EOF, get the corresponding source code line
320                     * and display it. Don't attempt this if we have a
321                     * premature EOF condition.
322                     */
323                    if (!PrematureEOF)
324                    {
325                        /*
326                         * Seek to the offset in the combined source file,
327                         * read the source line, and write it to the output.
328                         */
329                        Actual = fseek (SourceFile,
330                            (long) Enode->LogicalByteOffset, (int) SEEK_SET);
331                        if (Actual)
332                        {
333                            fprintf (OutputFile,
334                                "[*** iASL: Seek error on source code temp file %s ***]",
335                                Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename);
336                        }
337                        else
338                        {
339                            RActual = fread (&SourceByte, 1, 1, SourceFile);
340                            if (RActual != 1)
341                            {
342                                fprintf (OutputFile,
343                                    "[*** iASL: Read error on source code temp file %s ***]",
344                                    Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename);
345                            }
346                            else
347                            {
348                                /* Read/write the source line, up to the maximum line length */
349
350                                while (RActual && SourceByte && (SourceByte != '\n'))
351                                {
352                                    if (Total < 256)
353                                    {
354                                        /* After the max line length, we will just read the line, no write */
355
356                                        if (fwrite (&SourceByte, 1, 1, OutputFile) != 1)
357                                        {
358                                            printf ("[*** iASL: Write error on output file ***]\n");
359                                            return;
360                                        }
361                                    }
362                                    else if (Total == 256)
363                                    {
364                                        fprintf (OutputFile,
365                                            "\n[*** iASL: Very long input line, message below refers to column %u ***]",
366                                            Enode->Column);
367                                    }
368
369                                    RActual = fread (&SourceByte, 1, 1, SourceFile);
370                                    if (RActual != 1)
371                                    {
372                                        fprintf (OutputFile,
373                                            "[*** iASL: Read error on source code temp file %s ***]",
374                                            Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename);
375                                        return;
376                                    }
377                                    Total++;
378                                }
379                            }
380                        }
381                    }
382
383                    fprintf (OutputFile, "\n");
384                }
385            }
386        }
387        else
388        {
389            /*
390             * Less verbose version of the error message, enabled via the
391             * -vi switch. The format is compatible with MS Visual Studio.
392             */
393            fprintf (OutputFile, "%s", Enode->Filename);
394
395            if (Enode->LineNumber)
396            {
397                fprintf (OutputFile, "(%u) : ",
398                    Enode->LineNumber);
399            }
400        }
401    }
402
403    /* If a NULL message ID, just print the raw message */
404
405    if (Enode->MessageId == 0)
406    {
407        fprintf (OutputFile, "%s\n", Enode->Message);
408        return;
409    }
410
411    /* Decode the message ID */
412
413    fprintf (OutputFile, "%s %4.4d -",
414        AeDecodeExceptionLevel (Enode->Level),
415        AeBuildFullExceptionCode (Enode->Level, Enode->MessageId));
416
417    MainMessage = AeDecodeMessageId (Enode->MessageId);
418    ExtraMessage = Enode->Message;
419
420    /* If a NULL line number, just print the decoded message */
421
422    if (!Enode->LineNumber)
423    {
424        fprintf (OutputFile, " %s %s\n\n", MainMessage, ExtraMessage);
425        return;
426    }
427
428    MsgLength = strlen (MainMessage);
429    if (MsgLength == 0)
430    {
431        /* Use the secondary/extra message as main message */
432
433        MainMessage = Enode->Message;
434        if (!MainMessage)
435        {
436            MainMessage = "";
437        }
438
439        MsgLength = strlen (MainMessage);
440        ExtraMessage = NULL;
441    }
442
443    if (Gbl_VerboseErrors && !PrematureEOF)
444    {
445        if (Total >= 256)
446        {
447            fprintf (OutputFile, "    %s",
448                MainMessage);
449        }
450        else
451        {
452            SourceColumn = Enode->Column + Enode->FilenameLength + 6 + 2;
453            ErrorColumn = ASL_ERROR_LEVEL_LENGTH + 5 + 2 + 1;
454
455            if ((MsgLength + ErrorColumn) < (SourceColumn - 1))
456            {
457                fprintf (OutputFile, "%*s%s",
458                    (int) ((SourceColumn - 1) - ErrorColumn),
459                    MainMessage, " ^ ");
460            }
461            else
462            {
463                fprintf (OutputFile, "%*s %s",
464                    (int) ((SourceColumn - ErrorColumn) + 1), "^",
465                    MainMessage);
466            }
467        }
468    }
469    else
470    {
471        fprintf (OutputFile, " %s", MainMessage);
472    }
473
474    /* Print the extra info message if present */
475
476    if (ExtraMessage)
477    {
478        fprintf (OutputFile, " (%s)", ExtraMessage);
479    }
480
481    if (PrematureEOF)
482    {
483        fprintf (OutputFile, " and premature End-Of-File");
484    }
485
486    fprintf (OutputFile, "\n");
487    if (Gbl_VerboseErrors)
488    {
489        fprintf (OutputFile, "\n");
490    }
491}
492
493
494/*******************************************************************************
495 *
496 * FUNCTION:    AePrintErrorLog
497 *
498 * PARAMETERS:  FileId           - Where to output the error log
499 *
500 * RETURN:      None
501 *
502 * DESCRIPTION: Print the entire contents of the error log
503 *
504 ******************************************************************************/
505
506void
507AePrintErrorLog (
508    UINT32                  FileId)
509{
510    ASL_ERROR_MSG           *Enode = Gbl_ErrorLog;
511
512
513    /* Walk the error node list */
514
515    while (Enode)
516    {
517        AePrintException (FileId, Enode, NULL);
518        Enode = Enode->Next;
519    }
520}
521
522
523/*******************************************************************************
524 *
525 * FUNCTION:    AslCommonError2
526 *
527 * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
528 *              MessageId           - Index into global message buffer
529 *              LineNumber          - Actual file line number
530 *              Column              - Column in current line
531 *              SourceLine          - Actual source code line
532 *              Filename            - source filename
533 *              ExtraMessage        - additional error message
534 *
535 * RETURN:      None
536 *
537 * DESCRIPTION: Create a new error node and add it to the error log
538 *
539 ******************************************************************************/
540
541void
542AslCommonError2 (
543    UINT8                   Level,
544    UINT16                  MessageId,
545    UINT32                  LineNumber,
546    UINT32                  Column,
547    char                    *SourceLine,
548    char                    *Filename,
549    char                    *ExtraMessage)
550{
551    char                    *MessageBuffer = NULL;
552    char                    *LineBuffer;
553    ASL_ERROR_MSG           *Enode;
554
555
556    Enode = UtLocalCalloc (sizeof (ASL_ERROR_MSG));
557
558    if (ExtraMessage)
559    {
560        /* Allocate a buffer for the message and a new error node */
561
562        MessageBuffer = UtStringCacheCalloc (strlen (ExtraMessage) + 1);
563
564        /* Keep a copy of the extra message */
565
566        strcpy (MessageBuffer, ExtraMessage);
567    }
568
569    LineBuffer = UtLocalCalloc (strlen (SourceLine) + 1);
570    strcpy (LineBuffer, SourceLine);
571
572    /* Initialize the error node */
573
574    if (Filename)
575    {
576        Enode->Filename = Filename;
577        Enode->FilenameLength = strlen (Filename);
578        if (Enode->FilenameLength < 6)
579        {
580            Enode->FilenameLength = 6;
581        }
582    }
583
584    Enode->MessageId            = MessageId;
585    Enode->Level                = Level;
586    Enode->LineNumber           = LineNumber;
587    Enode->LogicalLineNumber    = LineNumber;
588    Enode->LogicalByteOffset    = 0;
589    Enode->Column               = Column;
590    Enode->Message              = MessageBuffer;
591    Enode->SourceLine           = LineBuffer;
592
593    /* Add the new node to the error node list */
594
595    AeAddToErrorLog (Enode);
596
597    if (Gbl_DebugFlag)
598    {
599        /* stderr is a file, send error to it immediately */
600
601        AePrintException (ASL_FILE_STDERR, Enode, NULL);
602    }
603
604    Gbl_ExceptionCount[Level]++;
605}
606
607
608/*******************************************************************************
609 *
610 * FUNCTION:    AslCommonError
611 *
612 * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
613 *              MessageId           - Index into global message buffer
614 *              CurrentLineNumber   - Actual file line number
615 *              LogicalLineNumber   - Cumulative line number
616 *              LogicalByteOffset   - Byte offset in source file
617 *              Column              - Column in current line
618 *              Filename            - source filename
619 *              ExtraMessage        - additional error message
620 *
621 * RETURN:      None
622 *
623 * DESCRIPTION: Create a new error node and add it to the error log
624 *
625 ******************************************************************************/
626
627void
628AslCommonError (
629    UINT8                   Level,
630    UINT16                  MessageId,
631    UINT32                  CurrentLineNumber,
632    UINT32                  LogicalLineNumber,
633    UINT32                  LogicalByteOffset,
634    UINT32                  Column,
635    char                    *Filename,
636    char                    *ExtraMessage)
637{
638    char                    *MessageBuffer = NULL;
639    ASL_ERROR_MSG           *Enode;
640
641
642    Enode = UtLocalCalloc (sizeof (ASL_ERROR_MSG));
643
644    if (ExtraMessage)
645    {
646        /* Allocate a buffer for the message and a new error node */
647
648        MessageBuffer = UtStringCacheCalloc (strlen (ExtraMessage) + 1);
649
650        /* Keep a copy of the extra message */
651
652        strcpy (MessageBuffer, ExtraMessage);
653    }
654
655    /* Initialize the error node */
656
657    if (Filename)
658    {
659        Enode->Filename = Filename;
660        Enode->FilenameLength = strlen (Filename);
661        if (Enode->FilenameLength < 6)
662        {
663            Enode->FilenameLength = 6;
664        }
665    }
666
667    Enode->MessageId            = MessageId;
668    Enode->Level                = Level;
669    Enode->LineNumber           = CurrentLineNumber;
670    Enode->LogicalLineNumber    = LogicalLineNumber;
671    Enode->LogicalByteOffset    = LogicalByteOffset;
672    Enode->Column               = Column;
673    Enode->Message              = MessageBuffer;
674    Enode->SourceLine           = NULL;
675
676    /* Add the new node to the error node list */
677
678    AeAddToErrorLog (Enode);
679
680    if (Gbl_DebugFlag)
681    {
682        /* stderr is a file, send error to it immediately */
683
684        AePrintException (ASL_FILE_STDERR, Enode, NULL);
685    }
686
687    Gbl_ExceptionCount[Level]++;
688    if (Gbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT)
689    {
690        printf ("\nMaximum error count (%u) exceeded\n", ASL_MAX_ERROR_COUNT);
691
692        Gbl_SourceLine = 0;
693        Gbl_NextError = Gbl_ErrorLog;
694        CmCleanupAndExit ();
695        exit(1);
696    }
697
698    return;
699}
700
701
702/*******************************************************************************
703 *
704 * FUNCTION:    AslDisableException
705 *
706 * PARAMETERS:  MessageIdString     - ID to be disabled
707 *
708 * RETURN:      Status
709 *
710 * DESCRIPTION: Enter a message ID into the global disabled messages table
711 *
712 ******************************************************************************/
713
714ACPI_STATUS
715AslDisableException (
716    char                    *MessageIdString)
717{
718    UINT32                  MessageId;
719
720
721    /* Convert argument to an integer and validate it */
722
723    MessageId = (UINT32) strtoul (MessageIdString, NULL, 0);
724
725    if ((MessageId < 2000) || (MessageId > 5999))
726    {
727        printf ("\"%s\" is not a valid warning/remark ID\n",
728            MessageIdString);
729        return (AE_BAD_PARAMETER);
730    }
731
732    /* Insert value into the global disabled message array */
733
734    if (Gbl_DisabledMessagesIndex >= ASL_MAX_DISABLED_MESSAGES)
735    {
736        printf ("Too many messages have been disabled (max %u)\n",
737            ASL_MAX_DISABLED_MESSAGES);
738        return (AE_LIMIT);
739    }
740
741    Gbl_DisabledMessages[Gbl_DisabledMessagesIndex] = MessageId;
742    Gbl_DisabledMessagesIndex++;
743    return (AE_OK);
744}
745
746
747/*******************************************************************************
748 *
749 * FUNCTION:    AslIsExceptionDisabled
750 *
751 * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
752 *              MessageId           - Index into global message buffer
753 *
754 * RETURN:      TRUE if exception/message should be ignored
755 *
756 * DESCRIPTION: Check if the user has specified options such that this
757 *              exception should be ignored
758 *
759 ******************************************************************************/
760
761BOOLEAN
762AslIsExceptionDisabled (
763    UINT8                   Level,
764    UINT16                  MessageId)
765{
766    UINT32                  EncodedMessageId;
767    UINT32                  i;
768
769
770    switch (Level)
771    {
772    case ASL_WARNING2:
773    case ASL_WARNING3:
774
775        /* Check for global disable via -w1/-w2/-w3 options */
776
777        if (Level > Gbl_WarningLevel)
778        {
779            return (TRUE);
780        }
781        /* Fall through */
782
783    case ASL_WARNING:
784    case ASL_REMARK:
785        /*
786         * Ignore this warning/remark if it has been disabled by
787         * the user (-vw option)
788         */
789        EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId);
790        for (i = 0; i < Gbl_DisabledMessagesIndex; i++)
791        {
792            /* Simple implementation via fixed array */
793
794            if (EncodedMessageId == Gbl_DisabledMessages[i])
795            {
796                return (TRUE);
797            }
798        }
799        break;
800
801    default:
802        break;
803    }
804
805    return (FALSE);
806}
807
808
809/*******************************************************************************
810 *
811 * FUNCTION:    AslError
812 *
813 * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
814 *              MessageId           - Index into global message buffer
815 *              Op                  - Parse node where error happened
816 *              ExtraMessage        - additional error message
817 *
818 * RETURN:      None
819 *
820 * DESCRIPTION: Main error reporting routine for the ASL compiler (all code
821 *              except the parser.)
822 *
823 ******************************************************************************/
824
825void
826AslError (
827    UINT8                   Level,
828    UINT16                  MessageId,
829    ACPI_PARSE_OBJECT       *Op,
830    char                    *ExtraMessage)
831{
832
833    /* Check if user wants to ignore this exception */
834
835    if (Gbl_AllExceptionsDisabled ||
836        AslIsExceptionDisabled (Level, MessageId))
837    {
838        return;
839    }
840
841    if (Op)
842    {
843        AslCommonError (Level, MessageId, Op->Asl.LineNumber,
844            Op->Asl.LogicalLineNumber,
845            Op->Asl.LogicalByteOffset,
846            Op->Asl.Column,
847            Op->Asl.Filename, ExtraMessage);
848    }
849    else
850    {
851        AslCommonError (Level, MessageId, 0,
852            0, 0, 0, NULL, ExtraMessage);
853    }
854}
855
856
857/*******************************************************************************
858 *
859 * FUNCTION:    AslCoreSubsystemError
860 *
861 * PARAMETERS:  Op                  - Parse node where error happened
862 *              Status              - The ACPICA Exception
863 *              ExtraMessage        - additional error message
864 *              Abort               - TRUE -> Abort compilation
865 *
866 * RETURN:      None
867 *
868 * DESCRIPTION: Error reporting routine for exceptions returned by the ACPICA
869 *              core subsystem.
870 *
871 ******************************************************************************/
872
873void
874AslCoreSubsystemError (
875    ACPI_PARSE_OBJECT       *Op,
876    ACPI_STATUS             Status,
877    char                    *ExtraMessage,
878    BOOLEAN                 Abort)
879{
880
881    sprintf (MsgBuffer, "%s %s", AcpiFormatException (Status), ExtraMessage);
882
883    if (Op)
884    {
885        AslCommonError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION,
886            Op->Asl.LineNumber,
887            Op->Asl.LogicalLineNumber,
888            Op->Asl.LogicalByteOffset,
889            Op->Asl.Column,
890            Op->Asl.Filename, MsgBuffer);
891    }
892    else
893    {
894        AslCommonError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION,
895            0, 0, 0, 0, NULL, MsgBuffer);
896    }
897
898    if (Abort)
899    {
900        AslAbort ();
901    }
902}
903
904
905/*******************************************************************************
906 *
907 * FUNCTION:    AslCompilererror
908 *
909 * PARAMETERS:  CompilerMessage         - Error message from the parser
910 *
911 * RETURN:      Status (0 for now)
912 *
913 * DESCRIPTION: Report an error situation discovered in a production
914 *              NOTE: don't change the name of this function, it is called
915 *              from the auto-generated parser.
916 *
917 ******************************************************************************/
918
919int
920AslCompilererror (
921    const char              *CompilerMessage)
922{
923
924    Gbl_SyntaxError++;
925
926    AslCommonError (ASL_ERROR, ASL_MSG_SYNTAX, Gbl_CurrentLineNumber,
927        Gbl_LogicalLineNumber, Gbl_CurrentLineOffset,
928        Gbl_CurrentColumn, Gbl_Files[ASL_FILE_INPUT].Filename,
929        ACPI_CAST_PTR (char, CompilerMessage));
930
931    return (0);
932}
933