xref: /freebsd/sys/contrib/dev/acpica/compiler/aslerror.c (revision f4b37ed0f8b307b1f3f0f630ca725d68f1dff30d) 
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