aslcompile.c revision 218590 
1
2/******************************************************************************
3 *
4 * Module Name: aslcompile - top level compile module
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions, and the following disclaimer,
17 *    without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 *    substantially similar to the "NO WARRANTY" disclaimer below
20 *    ("Disclaimer") and any redistribution must be conditioned upon
21 *    including a substantially similar Disclaimer requirement for further
22 *    binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 *    of any contributors may be used to endorse or promote products derived
25 *    from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45#include <contrib/dev/acpica/compiler/aslcompiler.h>
46
47#include <stdio.h>
48#include <time.h>
49#include <contrib/dev/acpica/include/acapps.h>
50
51#define _COMPONENT          ACPI_COMPILER
52        ACPI_MODULE_NAME    ("aslcompile")
53
54/* Local prototypes */
55
56static void
57CmFlushSourceCode (
58    void);
59
60static void
61FlConsumeAnsiComment (
62    ASL_FILE_INFO           *FileInfo,
63    ASL_FILE_STATUS         *Status);
64
65static void
66FlConsumeNewComment (
67    ASL_FILE_INFO           *FileInfo,
68    ASL_FILE_STATUS         *Status);
69
70
71/*******************************************************************************
72 *
73 * FUNCTION:    AslCompilerSignon
74 *
75 * PARAMETERS:  FileId      - ID of the output file
76 *
77 * RETURN:      None
78 *
79 * DESCRIPTION: Display compiler signon
80 *
81 ******************************************************************************/
82
83void
84AslCompilerSignon (
85    UINT32                  FileId)
86{
87    char                    *Prefix = "";
88    char                    *UtilityName;
89
90
91    /* Set line prefix depending on the destination file type */
92
93    switch (FileId)
94    {
95    case ASL_FILE_ASM_SOURCE_OUTPUT:
96    case ASL_FILE_ASM_INCLUDE_OUTPUT:
97
98        Prefix = "; ";
99        break;
100
101    case ASL_FILE_HEX_OUTPUT:
102
103        if (Gbl_HexOutputFlag == HEX_OUTPUT_ASM)
104        {
105            Prefix = "; ";
106        }
107        else if ((Gbl_HexOutputFlag == HEX_OUTPUT_C) ||
108                 (Gbl_HexOutputFlag == HEX_OUTPUT_ASL))
109        {
110            FlPrintFile (ASL_FILE_HEX_OUTPUT, "/*\n");
111            Prefix = " * ";
112        }
113        break;
114
115    case ASL_FILE_C_SOURCE_OUTPUT:
116    case ASL_FILE_C_INCLUDE_OUTPUT:
117
118        Prefix = " * ";
119        break;
120
121    default:
122        /* No other output types supported */
123        break;
124    }
125
126    /* Running compiler or disassembler? */
127
128    if (Gbl_DisasmFlag)
129    {
130        UtilityName = AML_DISASSEMBLER_NAME;
131    }
132    else
133    {
134        UtilityName = ASL_COMPILER_NAME;
135    }
136
137    /* Compiler signon with copyright */
138
139    FlPrintFile (FileId, "%s\n", Prefix);
140    FlPrintFile (FileId, ACPI_COMMON_HEADER (UtilityName, Prefix));
141}
142
143
144/*******************************************************************************
145 *
146 * FUNCTION:    AslCompilerFileHeader
147 *
148 * PARAMETERS:  FileId      - ID of the output file
149 *
150 * RETURN:      None
151 *
152 * DESCRIPTION: Header used at the beginning of output files
153 *
154 ******************************************************************************/
155
156void
157AslCompilerFileHeader (
158    UINT32                  FileId)
159{
160    struct tm               *NewTime;
161    time_t                  Aclock;
162    char                    *Prefix = "";
163
164
165    /* Set line prefix depending on the destination file type */
166
167    switch (FileId)
168    {
169    case ASL_FILE_ASM_SOURCE_OUTPUT:
170    case ASL_FILE_ASM_INCLUDE_OUTPUT:
171
172        Prefix = "; ";
173        break;
174
175    case ASL_FILE_HEX_OUTPUT:
176
177        if (Gbl_HexOutputFlag == HEX_OUTPUT_ASM)
178        {
179            Prefix = "; ";
180        }
181        else if ((Gbl_HexOutputFlag == HEX_OUTPUT_C) ||
182                 (Gbl_HexOutputFlag == HEX_OUTPUT_ASL))
183        {
184            Prefix = " * ";
185        }
186        break;
187
188    case ASL_FILE_C_SOURCE_OUTPUT:
189    case ASL_FILE_C_INCLUDE_OUTPUT:
190
191        Prefix = " * ";
192        break;
193
194    default:
195        /* No other output types supported */
196        break;
197    }
198
199    /* Compilation header with timestamp */
200
201    (void) time (&Aclock);
202    NewTime = localtime (&Aclock);
203
204    FlPrintFile (FileId,
205        "%sCompilation of \"%s\" - %s%s\n",
206        Prefix, Gbl_Files[ASL_FILE_INPUT].Filename, asctime (NewTime),
207        Prefix);
208
209    switch (FileId)
210    {
211    case ASL_FILE_C_SOURCE_OUTPUT:
212    case ASL_FILE_C_INCLUDE_OUTPUT:
213        FlPrintFile (FileId, " */\n");
214        break;
215
216    default:
217        /* Nothing to do for other output types */
218        break;
219    }
220}
221
222
223/*******************************************************************************
224 *
225 * FUNCTION:    CmFlushSourceCode
226 *
227 * PARAMETERS:  None
228 *
229 * RETURN:      None
230 *
231 * DESCRIPTION: Read in any remaining source code after the parse tree
232 *              has been constructed.
233 *
234 ******************************************************************************/
235
236static void
237CmFlushSourceCode (
238    void)
239{
240    char                    Buffer;
241
242
243    while (FlReadFile (ASL_FILE_INPUT, &Buffer, 1) != AE_ERROR)
244    {
245        InsertLineBuffer ((int) Buffer);
246    }
247
248    ResetCurrentLineBuffer ();
249}
250
251
252/*******************************************************************************
253 *
254 * FUNCTION:    FlConsume*
255 *
256 * PARAMETERS:  FileInfo        - Points to an open input file
257 *
258 * RETURN:      Number of lines consumed
259 *
260 * DESCRIPTION: Step over both types of comment during check for ascii chars
261 *
262 ******************************************************************************/
263
264static void
265FlConsumeAnsiComment (
266    ASL_FILE_INFO           *FileInfo,
267    ASL_FILE_STATUS         *Status)
268{
269    UINT8                   Byte;
270    BOOLEAN                 ClosingComment = FALSE;
271
272
273    while (fread (&Byte, 1, 1, FileInfo->Handle))
274    {
275        /* Scan until comment close is found */
276
277        if (ClosingComment)
278        {
279            if (Byte == '/')
280            {
281                return;
282            }
283
284            if (Byte != '*')
285            {
286                /* Reset */
287
288                ClosingComment = FALSE;
289            }
290        }
291        else if (Byte == '*')
292        {
293            ClosingComment = TRUE;
294        }
295
296        /* Maintain line count */
297
298        if (Byte == 0x0A)
299        {
300            Status->Line++;
301        }
302
303        Status->Offset++;
304    }
305}
306
307
308static void
309FlConsumeNewComment (
310    ASL_FILE_INFO           *FileInfo,
311    ASL_FILE_STATUS         *Status)
312{
313    UINT8                   Byte;
314
315
316    while (fread (&Byte, 1, 1, FileInfo->Handle))
317    {
318        Status->Offset++;
319
320        /* Comment ends at newline */
321
322        if (Byte == 0x0A)
323        {
324            Status->Line++;
325            return;
326        }
327    }
328}
329
330
331/*******************************************************************************
332 *
333 * FUNCTION:    FlCheckForAscii
334 *
335 * PARAMETERS:  FileInfo        - Points to an open input file
336 *
337 * RETURN:      Status
338 *
339 * DESCRIPTION: Verify that the input file is entirely ASCII. Ignores characters
340 *              within comments. Note: does not handle nested comments and does
341 *              not handle comment delimiters within string literals. However,
342 *              on the rare chance this happens and an invalid character is
343 *              missed, the parser will catch the error by failing in some
344 *              spectactular manner.
345 *
346 ******************************************************************************/
347
348ACPI_STATUS
349FlCheckForAscii (
350    ASL_FILE_INFO           *FileInfo)
351{
352    UINT8                   Byte;
353    ACPI_SIZE               BadBytes = 0;
354    BOOLEAN                 OpeningComment = FALSE;
355    ASL_FILE_STATUS         Status;
356
357
358    Status.Line = 1;
359    Status.Offset = 0;
360
361    /* Read the entire file */
362
363    while (fread (&Byte, 1, 1, FileInfo->Handle))
364    {
365        /* Ignore comment fields (allow non-ascii within) */
366
367        if (OpeningComment)
368        {
369            /* Check for second comment open delimiter */
370
371            if (Byte == '*')
372            {
373                FlConsumeAnsiComment (FileInfo, &Status);
374            }
375
376            if (Byte == '/')
377            {
378                FlConsumeNewComment (FileInfo, &Status);
379            }
380
381            /* Reset */
382
383            OpeningComment = FALSE;
384        }
385        else if (Byte == '/')
386        {
387            OpeningComment = TRUE;
388        }
389
390        /* Check for an ASCII character */
391
392        if (!ACPI_IS_ASCII (Byte))
393        {
394            if (BadBytes < 10)
395            {
396                AcpiOsPrintf (
397                    "Non-ASCII character [0x%2.2X] found in line %u, file offset 0x%.2X\n",
398                    Byte, Status.Line, Status.Offset);
399            }
400
401            BadBytes++;
402        }
403
404        /* Update line counter */
405
406        else if (Byte == 0x0A)
407        {
408            Status.Line++;
409        }
410
411        Status.Offset++;
412    }
413
414    /* Seek back to the beginning of the source file */
415
416    fseek (FileInfo->Handle, 0, SEEK_SET);
417
418    /* Were there any non-ASCII characters in the file? */
419
420    if (BadBytes)
421    {
422        AcpiOsPrintf (
423            "%u non-ASCII characters found in input source text, could be a binary file\n",
424            BadBytes);
425        AslError (ASL_ERROR, ASL_MSG_NON_ASCII, NULL, FileInfo->Filename);
426        return (AE_BAD_CHARACTER);
427    }
428
429    /* File is OK */
430
431    return (AE_OK);
432}
433
434
435/*******************************************************************************
436 *
437 * FUNCTION:    CmDoCompile
438 *
439 * PARAMETERS:  None
440 *
441 * RETURN:      Status (0 = OK)
442 *
443 * DESCRIPTION: This procedure performs the entire compile
444 *
445 ******************************************************************************/
446
447int
448CmDoCompile (
449    void)
450{
451    ACPI_STATUS             Status;
452    UINT8                   FullCompile;
453    UINT8                   Event;
454
455
456    FullCompile = UtBeginEvent ("*** Total Compile time ***");
457    Event = UtBeginEvent ("Open input and output files");
458    UtEndEvent (Event);
459
460    /* Build the parse tree */
461
462    Event = UtBeginEvent ("Parse source code and build parse tree");
463    AslCompilerparse();
464    UtEndEvent (Event);
465
466    /* Flush out any remaining source after parse tree is complete */
467
468    Event = UtBeginEvent ("Flush source input");
469    CmFlushSourceCode ();
470
471    /* Did the parse tree get successfully constructed? */
472
473    if (!RootNode)
474    {
475        CmCleanupAndExit ();
476        return -1;
477    }
478
479    /* Optional parse tree dump, compiler debug output only */
480
481    LsDumpParseTree ();
482
483    OpcGetIntegerWidth (RootNode);
484    UtEndEvent (Event);
485
486    /* Pre-process parse tree for any operator transforms */
487
488    Event = UtBeginEvent ("Parse tree transforms");
489    DbgPrint (ASL_DEBUG_OUTPUT, "\nParse tree transforms\n\n");
490    TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
491        TrAmlTransformWalk, NULL, NULL);
492    UtEndEvent (Event);
493
494    /* Generate AML opcodes corresponding to the parse tokens */
495
496    Event = UtBeginEvent ("Generate AML opcodes");
497    DbgPrint (ASL_DEBUG_OUTPUT, "\nGenerating AML opcodes\n\n");
498    TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD, NULL,
499        OpcAmlOpcodeWalk, NULL);
500    UtEndEvent (Event);
501
502    /*
503     * Now that the input is parsed, we can open the AML output file.
504     * Note: by default, the name of this file comes from the table descriptor
505     * within the input file.
506     */
507    Event = UtBeginEvent ("Open AML output file");
508    Status = FlOpenAmlOutputFile (Gbl_OutputFilenamePrefix);
509    if (ACPI_FAILURE (Status))
510    {
511        AePrintErrorLog (ASL_FILE_STDERR);
512        return -1;
513    }
514    UtEndEvent (Event);
515
516    /* Interpret and generate all compile-time constants */
517
518    Event = UtBeginEvent ("Constant folding via AML interpreter");
519    DbgPrint (ASL_DEBUG_OUTPUT,
520        "\nInterpreting compile-time constant expressions\n\n");
521    TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
522        OpcAmlConstantWalk, NULL, NULL);
523    UtEndEvent (Event);
524
525    /* Update AML opcodes if necessary, after constant folding */
526
527    Event = UtBeginEvent ("Updating AML opcodes after constant folding");
528    DbgPrint (ASL_DEBUG_OUTPUT,
529        "\nUpdating AML opcodes after constant folding\n\n");
530    TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD,
531        NULL, OpcAmlOpcodeUpdateWalk, NULL);
532    UtEndEvent (Event);
533
534    /* Calculate all AML package lengths */
535
536    Event = UtBeginEvent ("Generate AML package lengths");
537    DbgPrint (ASL_DEBUG_OUTPUT, "\nGenerating Package lengths\n\n");
538    TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD, NULL,
539        LnPackageLengthWalk, NULL);
540    UtEndEvent (Event);
541
542    if (Gbl_ParseOnlyFlag)
543    {
544        AePrintErrorLog (ASL_FILE_STDOUT);
545        UtDisplaySummary (ASL_FILE_STDOUT);
546        if (Gbl_DebugFlag)
547        {
548            /* Print error summary to the debug file */
549
550            AePrintErrorLog (ASL_FILE_STDERR);
551            UtDisplaySummary (ASL_FILE_STDERR);
552        }
553        return 0;
554    }
555
556    /*
557     * Create an internal namespace and use it as a symbol table
558     */
559
560    /* Namespace loading */
561
562    Event = UtBeginEvent ("Create ACPI Namespace");
563    Status = LdLoadNamespace (RootNode);
564    UtEndEvent (Event);
565    if (ACPI_FAILURE (Status))
566    {
567        return -1;
568    }
569
570    /* Namespace cross-reference */
571
572    AslGbl_NamespaceEvent = UtBeginEvent ("Cross reference parse tree and Namespace");
573    Status = LkCrossReferenceNamespace ();
574    if (ACPI_FAILURE (Status))
575    {
576        return -1;
577    }
578
579    /* Namespace - Check for non-referenced objects */
580
581    LkFindUnreferencedObjects ();
582    UtEndEvent (AslGbl_NamespaceEvent);
583
584    /*
585     * Semantic analysis.  This can happen only after the
586     * namespace has been loaded and cross-referenced.
587     *
588     * part one - check control methods
589     */
590    Event = UtBeginEvent ("Analyze control method return types");
591    AnalysisWalkInfo.MethodStack = NULL;
592
593    DbgPrint (ASL_DEBUG_OUTPUT, "\nSemantic analysis - Method analysis\n\n");
594    TrWalkParseTree (RootNode, ASL_WALK_VISIT_TWICE,
595        AnMethodAnalysisWalkBegin,
596        AnMethodAnalysisWalkEnd, &AnalysisWalkInfo);
597    UtEndEvent (Event);
598
599    /* Semantic error checking part two - typing of method returns */
600
601    Event = UtBeginEvent ("Determine object types returned by methods");
602    DbgPrint (ASL_DEBUG_OUTPUT, "\nSemantic analysis - Method typing\n\n");
603    TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD,
604        NULL, AnMethodTypingWalkEnd, NULL);
605    UtEndEvent (Event);
606
607    /* Semantic error checking part three - operand type checking */
608
609    Event = UtBeginEvent ("Analyze AML operand types");
610    DbgPrint (ASL_DEBUG_OUTPUT, "\nSemantic analysis - Operand type checking\n\n");
611    TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD,
612        NULL, AnOperandTypecheckWalkEnd, &AnalysisWalkInfo);
613    UtEndEvent (Event);
614
615    /* Semantic error checking part four - other miscellaneous checks */
616
617    Event = UtBeginEvent ("Miscellaneous analysis");
618    DbgPrint (ASL_DEBUG_OUTPUT, "\nSemantic analysis - miscellaneous\n\n");
619    TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
620        AnOtherSemanticAnalysisWalkBegin,
621        NULL, &AnalysisWalkInfo);
622    UtEndEvent (Event);
623
624    /* Calculate all AML package lengths */
625
626    Event = UtBeginEvent ("Finish AML package length generation");
627    DbgPrint (ASL_DEBUG_OUTPUT, "\nGenerating Package lengths\n\n");
628    TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD, NULL,
629        LnInitLengthsWalk, NULL);
630    TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD, NULL,
631        LnPackageLengthWalk, NULL);
632    UtEndEvent (Event);
633
634    /* Code generation - emit the AML */
635
636    Event = UtBeginEvent ("Generate AML code and write output files");
637    CgGenerateAmlOutput ();
638    UtEndEvent (Event);
639
640    Event = UtBeginEvent ("Write optional output files");
641    CmDoOutputFiles ();
642    UtEndEvent (Event);
643
644    UtEndEvent (FullCompile);
645    CmCleanupAndExit ();
646    return 0;
647}
648
649
650/*******************************************************************************
651 *
652 * FUNCTION:    CmDoOutputFiles
653 *
654 * PARAMETERS:  None
655 *
656 * RETURN:      None.
657 *
658 * DESCRIPTION: Create all "listing" type files
659 *
660 ******************************************************************************/
661
662void
663CmDoOutputFiles (
664    void)
665{
666
667    /* Create listings and hex files */
668
669    LsDoListings ();
670    LsDoHexOutput ();
671
672    /* Dump the namespace to the .nsp file if requested */
673
674    (void) LsDisplayNamespace ();
675}
676
677
678/*******************************************************************************
679 *
680 * FUNCTION:    CmDumpEvent
681 *
682 * PARAMETERS:  Event           - A compiler event struct
683 *
684 * RETURN:      None.
685 *
686 * DESCRIPTION: Dump a compiler event struct
687 *
688 ******************************************************************************/
689
690static void
691CmDumpEvent (
692    ASL_EVENT_INFO          *Event)
693{
694    UINT32                  Delta;
695    UINT32                  USec;
696    UINT32                  MSec;
697
698    if (!Event->Valid)
699    {
700        return;
701    }
702
703    /* Delta will be in 100-nanosecond units */
704
705    Delta = (UINT32) (Event->EndTime - Event->StartTime);
706
707    USec = Delta / 10;
708    MSec = Delta / 10000;
709
710    /* Round milliseconds up */
711
712    if ((USec - (MSec * 1000)) >= 500)
713    {
714        MSec++;
715    }
716
717    DbgPrint (ASL_DEBUG_OUTPUT, "%8u usec %8u msec - %s\n",
718        USec, MSec, Event->EventName);
719}
720
721
722/*******************************************************************************
723 *
724 * FUNCTION:    CmCleanupAndExit
725 *
726 * PARAMETERS:  None
727 *
728 * RETURN:      None.
729 *
730 * DESCRIPTION: Close all open files and exit the compiler
731 *
732 ******************************************************************************/
733
734void
735CmCleanupAndExit (
736    void)
737{
738    UINT32                  i;
739
740
741    AePrintErrorLog (ASL_FILE_STDOUT);
742    if (Gbl_DebugFlag)
743    {
744        /* Print error summary to the debug file */
745
746        AePrintErrorLog (ASL_FILE_STDERR);
747    }
748
749    DbgPrint (ASL_DEBUG_OUTPUT, "\n\nElapsed time for major events\n\n");
750    for (i = 0; i < AslGbl_NextEvent; i++)
751    {
752        CmDumpEvent (&AslGbl_Events[i]);
753    }
754
755    if (Gbl_CompileTimesFlag)
756    {
757        printf ("\nElapsed time for major events\n\n");
758        for (i = 0; i < AslGbl_NextEvent; i++)
759        {
760            CmDumpEvent (&AslGbl_Events[i]);
761        }
762
763        printf ("\nMiscellaneous compile statistics\n\n");
764        printf ("%11u : %s\n", TotalParseNodes, "Parse nodes");
765        printf ("%11u : %s\n", Gbl_NsLookupCount, "Namespace searches");
766        printf ("%11u : %s\n", TotalNamedObjects, "Named objects");
767        printf ("%11u : %s\n", TotalMethods, "Control methods");
768        printf ("%11u : %s\n", TotalAllocations, "Memory Allocations");
769        printf ("%11u : %s\n", TotalAllocated, "Total allocated memory");
770        printf ("%11u : %s\n", TotalFolds, "Constant subtrees folded");
771        printf ("\n");
772    }
773
774    if (Gbl_NsLookupCount)
775    {
776        DbgPrint (ASL_DEBUG_OUTPUT,
777            "\n\nMiscellaneous compile statistics\n\n");
778
779        DbgPrint (ASL_DEBUG_OUTPUT,
780            "%32s : %u\n", "Total Namespace searches",
781            Gbl_NsLookupCount);
782
783        DbgPrint (ASL_DEBUG_OUTPUT,
784            "%32s : %u usec\n", "Time per search", ((UINT32)
785            (AslGbl_Events[AslGbl_NamespaceEvent].EndTime -
786                AslGbl_Events[AslGbl_NamespaceEvent].StartTime) / 10) /
787                Gbl_NsLookupCount);
788    }
789
790    if (Gbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT)
791    {
792        printf ("\nMaximum error count (%u) exceeded\n",
793            ASL_MAX_ERROR_COUNT);
794    }
795
796    UtDisplaySummary (ASL_FILE_STDOUT);
797
798    /* Close all open files */
799
800    for (i = 2; i < ASL_MAX_FILE_TYPE; i++)
801    {
802        FlCloseFile (i);
803    }
804
805    /* Delete AML file if there are errors */
806
807    if ((Gbl_ExceptionCount[ASL_ERROR] > 0) && (!Gbl_IgnoreErrors) &&
808        Gbl_Files[ASL_FILE_AML_OUTPUT].Handle)
809    {
810        if (remove (Gbl_Files[ASL_FILE_AML_OUTPUT].Filename))
811        {
812            printf ("%s: ",
813                Gbl_Files[ASL_FILE_AML_OUTPUT].Filename);
814            perror ("Could not delete AML file");
815        }
816    }
817
818    /*
819     * Delete intermediate ("combined") source file (if -ls flag not set)
820     * This file is created during normal ASL/AML compiles. It is not
821     * created by the data table compiler.
822     *
823     * If the -ls flag is set, then the .SRC file should not be deleted.
824     * In this case, Gbl_SourceOutputFlag is set to TRUE.
825     *
826     * Note: Handles are cleared by FlCloseFile above, so we look at the
827     * filename instead, to determine if the .SRC file was actually
828     * created.
829     *
830     * TBD: SourceOutput should be .TMP, then rename if we want to keep it?
831     */
832    if (!Gbl_SourceOutputFlag && Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename)
833    {
834        if (remove (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename))
835        {
836            printf ("%s: ",
837                Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Filename);
838            perror ("Could not delete SRC file");
839        }
840    }
841}
842
843
844