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