sys/contrib/dev/acpica/compiler/asllisting.c

   1 /******************************************************************************
   2  *
   3  * Module Name: asllisting - Listing file generation
   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 #include "aslcompiler.y.h"
  46 #include <contrib/dev/acpica/include/amlcode.h>
  47 #include <contrib/dev/acpica/include/acparser.h>
  48 #include <contrib/dev/acpica/include/acnamesp.h>
  49
  50
  51 #define _COMPONENT          ACPI_COMPILER
  52         ACPI_MODULE_NAME    ("asllisting")
  53
  54
  55 /* Local prototypes */
  56
  57 static void
  58 LsGenerateListing (
  59     UINT32                  FileId);
  60
  61 static ACPI_STATUS
  62 LsAmlListingWalk (
  63     ACPI_PARSE_OBJECT       *Op,
  64     UINT32                  Level,
  65     void                    *Context);
  66
  67 static ACPI_STATUS
  68 LsTreeWriteWalk (
  69     ACPI_PARSE_OBJECT       *Op,
  70     UINT32                  Level,
  71     void                    *Context);
  72
  73 static void
  74 LsWriteNodeToListing (
  75     ACPI_PARSE_OBJECT       *Op,
  76     UINT32                  FileId);
  77
  78 static void
  79 LsFinishSourceListing (
  80     UINT32                  FileId);
  81
  82
  83 /*******************************************************************************
  84  *
  85  * FUNCTION:    LsDoListings
  86  *
  87  * PARAMETERS:  None. Examines the various output file global flags.
  88  *
  89  * RETURN:      None
  90  *
  91  * DESCRIPTION: Generate all requested listing files.
  92  *
  93  ******************************************************************************/
  94
  95 void
  96 LsDoListings (
  97     void)
  98 {
  99
 100     if (Gbl_C_OutputFlag)
 101     {
 102         LsGenerateListing (ASL_FILE_C_SOURCE_OUTPUT);
 103     }
 104
 105     if (Gbl_ListingFlag)
 106     {
 107         LsGenerateListing (ASL_FILE_LISTING_OUTPUT);
 108     }
 109
 110     if (Gbl_AsmOutputFlag)
 111     {
 112         LsGenerateListing (ASL_FILE_ASM_SOURCE_OUTPUT);
 113     }
 114
 115     if (Gbl_C_IncludeOutputFlag)
 116     {
 117         LsGenerateListing (ASL_FILE_C_INCLUDE_OUTPUT);
 118     }
 119
 120     if (Gbl_AsmIncludeOutputFlag)
 121     {
 122         LsGenerateListing (ASL_FILE_ASM_INCLUDE_OUTPUT);
 123     }
 124
 125     if (Gbl_C_OffsetTableFlag)
 126     {
 127         LsGenerateListing (ASL_FILE_C_OFFSET_OUTPUT);
 128     }
 129 }
 130
 131
 132 /*******************************************************************************
 133  *
 134  * FUNCTION:    LsGenerateListing
 135  *
 136  * PARAMETERS:  FileId      - ID of listing file
 137  *
 138  * RETURN:      None
 139  *
 140  * DESCRIPTION: Generate a listing file. This can be one of the several types
 141  *              of "listings" supported.
 142  *
 143  ******************************************************************************/
 144
 145 static void
 146 LsGenerateListing (
 147     UINT32                  FileId)
 148 {
 149
 150     /* Start at the beginning of both the source and AML files */
 151
 152     FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0);
 153     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
 154     Gbl_SourceLine = 0;
 155     Gbl_CurrentHexColumn = 0;
 156     LsPushNode (Gbl_Files[ASL_FILE_INPUT].Filename);
 157
 158     if (FileId == ASL_FILE_C_OFFSET_OUTPUT)
 159     {
 160         Gbl_CurrentAmlOffset = 0;
 161
 162         /* Offset table file has a special header and footer */
 163
 164         LsDoOffsetTableHeader (FileId);
 165
 166         TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
 167             LsAmlOffsetWalk, NULL, (void *) ACPI_TO_POINTER (FileId));
 168         LsDoOffsetTableFooter (FileId);
 169         return;
 170     }
 171
 172     /* Process all parse nodes */
 173
 174     TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
 175         LsAmlListingWalk, NULL, (void *) ACPI_TO_POINTER (FileId));
 176
 177     /* Final processing */
 178
 179     LsFinishSourceListing (FileId);
 180 }
 181
 182
 183 /*******************************************************************************
 184  *
 185  * FUNCTION:    LsAmlListingWalk
 186  *
 187  * PARAMETERS:  ASL_WALK_CALLBACK
 188  *
 189  * RETURN:      Status
 190  *
 191  * DESCRIPTION: Process one node during a listing file generation.
 192  *
 193  ******************************************************************************/
 194
 195 static ACPI_STATUS
 196 LsAmlListingWalk (
 197     ACPI_PARSE_OBJECT       *Op,
 198     UINT32                  Level,
 199     void                    *Context)
 200 {
 201     UINT8                   FileByte;
 202     UINT32                  i;
 203     UINT32                  FileId = (UINT32) ACPI_TO_INTEGER (Context);
 204
 205
 206     LsWriteNodeToListing (Op, FileId);
 207
 208     if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DATA)
 209     {
 210         /* Buffer is a resource template, don't dump the data all at once */
 211
 212         return (AE_OK);
 213     }
 214
 215     if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) ||
 216         (FileId == ASL_FILE_C_INCLUDE_OUTPUT))
 217     {
 218         return (AE_OK);
 219     }
 220
 221     /* Write the hex bytes to the listing file(s) (if requested) */
 222
 223     for (i = 0; i < Op->Asl.FinalAmlLength; i++)
 224     {
 225         if (ACPI_FAILURE (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1)))
 226         {
 227             FlFileError (ASL_FILE_AML_OUTPUT, ASL_MSG_READ);
 228             AslAbort ();
 229         }
 230
 231         LsWriteListingHexBytes (&FileByte, 1, FileId);
 232     }
 233
 234     return (AE_OK);
 235 }
 236
 237
 238 /*******************************************************************************
 239  *
 240  * FUNCTION:    LsDumpParseTree, LsTreeWriteWalk
 241  *
 242  * PARAMETERS:  None
 243  *
 244  * RETURN:      None
 245  *
 246  * DESCRIPTION: Dump entire parse tree, for compiler debug only
 247  *
 248  ******************************************************************************/
 249
 250 void
 251 LsDumpParseTree (
 252     void)
 253 {
 254
 255     if (!Gbl_DebugFlag)
 256     {
 257         return;
 258     }
 259
 260     DbgPrint (ASL_TREE_OUTPUT, "\nOriginal parse tree from parser:\n\n");
 261     DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER1);
 262
 263     TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
 264         LsTreeWriteWalk, NULL, NULL);
 265
 266     DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER1);
 267 }
 268
 269
 270 static ACPI_STATUS
 271 LsTreeWriteWalk (
 272     ACPI_PARSE_OBJECT       *Op,
 273     UINT32                  Level,
 274     void                    *Context)
 275 {
 276
 277     /* Dump ParseOp name and possible value */
 278
 279     switch (Op->Asl.ParseOpcode)
 280     {
 281         case PARSEOP_NAMESEG:
 282         case PARSEOP_NAMESTRING:
 283         case PARSEOP_METHODCALL:
 284         case PARSEOP_STRING_LITERAL:
 285
 286         UtDumpStringOp (Op, Level);
 287         break;
 288
 289     case PARSEOP_BYTECONST:
 290
 291         UtDumpIntegerOp (Op, Level, 2);
 292         break;
 293
 294     case PARSEOP_WORDCONST:
 295     case PARSEOP_PACKAGE_LENGTH:
 296
 297         UtDumpIntegerOp (Op, Level, 4);
 298         break;
 299
 300     case PARSEOP_DWORDCONST:
 301     case PARSEOP_EISAID:
 302
 303         UtDumpIntegerOp (Op, Level, 8);
 304         break;
 305
 306     case PARSEOP_QWORDCONST:
 307     case PARSEOP_INTEGER:
 308     case PARSEOP_ONE:
 309     case PARSEOP_ZERO:
 310     case PARSEOP_ONES:
 311
 312         UtDumpIntegerOp (Op, Level, 16);
 313         break;
 314
 315     case PARSEOP_INCLUDE:
 316
 317         DbgPrint (ASL_TREE_OUTPUT,
 318             "Open: %s\n", Op->Asl.Value.String);
 319         return (AE_OK);
 320
 321     case PARSEOP_INCLUDE_END:
 322
 323         DbgPrint (ASL_TREE_OUTPUT,
 324             "Close: %s\n", Op->Asl.Filename);
 325         return (AE_OK);
 326
 327     default:
 328
 329         UtDumpBasicOp (Op, Level);
 330         break;
 331     }
 332
 333     /* Dump the remaining data */
 334
 335     DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_DEBUG1,
 336         Op->Asl.ParseOpcode, Op->Asl.CompileFlags,
 337         Op->Asl.LineNumber, Op->Asl.EndLine,
 338         Op->Asl.LogicalLineNumber, Op->Asl.EndLogicalLine);
 339
 340     TrPrintNodeCompileFlags (Op->Asl.CompileFlags);
 341     DbgPrint (ASL_TREE_OUTPUT, "\n");
 342     return (AE_OK);
 343 }
 344
 345
 346 /*******************************************************************************
 347  *
 348  * FUNCTION:    LsWriteNodeToListing
 349  *
 350  * PARAMETERS:  Op              - Parse node to write to the listing file.
 351  *              FileId          - ID of current listing file
 352  *
 353  * RETURN:      None.
 354  *
 355  * DESCRIPTION: Write "a node" to the listing file. This means to
 356  *              1) Write out all of the source text associated with the node
 357  *              2) Write out all of the AML bytes associated with the node
 358  *              3) Write any compiler exceptions associated with the node
 359  *
 360  ******************************************************************************/
 361
 362 static void
 363 LsWriteNodeToListing (
 364     ACPI_PARSE_OBJECT       *Op,
 365     UINT32                  FileId)
 366 {
 367     const ACPI_OPCODE_INFO  *OpInfo;
 368     UINT32                  OpClass;
 369     char                    *Pathname;
 370     UINT32                  Length;
 371     UINT32                  i;
 372
 373
 374     OpInfo  = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
 375     OpClass = OpInfo->Class;
 376
 377     /* TBD: clean this up with a single flag that says:
 378      * I start a named output block
 379      */
 380     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 381     {
 382         switch (Op->Asl.ParseOpcode)
 383         {
 384         case PARSEOP_DEFINITION_BLOCK:
 385         case PARSEOP_METHODCALL:
 386         case PARSEOP_INCLUDE:
 387         case PARSEOP_INCLUDE_END:
 388         case PARSEOP_DEFAULT_ARG:
 389
 390             break;
 391
 392         default:
 393
 394             switch (OpClass)
 395             {
 396             case AML_CLASS_NAMED_OBJECT:
 397
 398                 switch (Op->Asl.AmlOpcode)
 399                 {
 400                 case AML_SCOPE_OP:
 401                 case AML_ALIAS_OP:
 402
 403                     break;
 404
 405                 default:
 406
 407                     if (Op->Asl.ExternalName)
 408                     {
 409                         LsFlushListingBuffer (FileId);
 410                         FlPrintFile (FileId, "    };\n");
 411                     }
 412                     break;
 413                 }
 414                 break;
 415
 416             default:
 417
 418                 /* Don't care about other objects */
 419
 420                 break;
 421             }
 422             break;
 423         }
 424     }
 425
 426     /* These cases do not have a corresponding AML opcode */
 427
 428     switch (Op->Asl.ParseOpcode)
 429     {
 430     case PARSEOP_DEFINITION_BLOCK:
 431
 432         /* Always start a definition block at AML offset zero */
 433
 434         Gbl_CurrentAmlOffset = 0;
 435         LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine, FileId);
 436
 437         /* Use the table Signature and TableId to build a unique name */
 438
 439         switch (FileId)
 440         {
 441         case ASL_FILE_ASM_SOURCE_OUTPUT:
 442
 443             FlPrintFile (FileId,
 444                 "%s_%s_Header \\\n",
 445                 Gbl_TableSignature, Gbl_TableId);
 446             break;
 447
 448         case ASL_FILE_C_SOURCE_OUTPUT:
 449
 450             FlPrintFile (FileId,
 451                 "    unsigned char    %s_%s_Header [] =\n    {\n",
 452                 Gbl_TableSignature, Gbl_TableId);
 453             break;
 454
 455         case ASL_FILE_ASM_INCLUDE_OUTPUT:
 456
 457             FlPrintFile (FileId,
 458                 "extrn %s_%s_Header : byte\n",
 459                 Gbl_TableSignature, Gbl_TableId);
 460             break;
 461
 462         case ASL_FILE_C_INCLUDE_OUTPUT:
 463
 464             FlPrintFile (FileId,
 465                 "extern unsigned char    %s_%s_Header [];\n",
 466                 Gbl_TableSignature, Gbl_TableId);
 467             break;
 468
 469         default:
 470             break;
 471         }
 472
 473         return;
 474
 475
 476     case PARSEOP_METHODCALL:
 477
 478         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 479             FileId);
 480         return;
 481
 482
 483     case PARSEOP_INCLUDE:
 484
 485         /* Flush everything up to and including the include source line */
 486
 487         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 488             FileId);
 489
 490         /* Create a new listing node and push it */
 491
 492         LsPushNode (Op->Asl.Value.String);
 493         return;
 494
 495
 496     case PARSEOP_INCLUDE_END:
 497
 498         /* Flush out the rest of the include file */
 499
 500         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 501             FileId);
 502
 503         /* Pop off this listing node and go back to the parent file */
 504
 505         (void) LsPopNode ();
 506         return;
 507
 508
 509     case PARSEOP_DEFAULT_ARG:
 510
 511         if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
 512         {
 513             LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.EndLogicalLine,
 514                 FileId);
 515         }
 516         return;
 517
 518
 519     default:
 520
 521         /* All other opcodes have an AML opcode */
 522
 523         break;
 524     }
 525
 526     /*
 527      * Otherwise, we look at the AML opcode because we can
 528      * switch on the opcode type, getting an entire class
 529      * at once
 530      */
 531     switch (OpClass)
 532     {
 533     case AML_CLASS_ARGUMENT:       /* argument type only */
 534     case AML_CLASS_INTERNAL:
 535
 536         break;
 537
 538     case AML_CLASS_NAMED_OBJECT:
 539
 540         switch (Op->Asl.AmlOpcode)
 541         {
 542         case AML_FIELD_OP:
 543         case AML_INDEX_FIELD_OP:
 544         case AML_BANK_FIELD_OP:
 545             /*
 546              * For fields, we want to dump all the AML after the
 547              * entire definition
 548              */
 549             LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
 550                 FileId);
 551             break;
 552
 553         case AML_NAME_OP:
 554
 555             if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
 556             {
 557                 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 558                     FileId);
 559             }
 560             else
 561             {
 562                 /*
 563                  * For fields, we want to dump all the AML after the
 564                  * entire definition
 565                  */
 566                 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
 567                     FileId);
 568             }
 569             break;
 570
 571         default:
 572
 573             LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 574                 FileId);
 575             break;
 576         }
 577
 578         switch (Op->Asl.AmlOpcode)
 579         {
 580         case AML_SCOPE_OP:
 581         case AML_ALIAS_OP:
 582
 583             /* These opcodes do not declare a new object, ignore them */
 584
 585             break;
 586
 587         default:
 588
 589             /* All other named object opcodes come here */
 590
 591             switch (FileId)
 592             {
 593             case ASL_FILE_ASM_SOURCE_OUTPUT:
 594             case ASL_FILE_C_SOURCE_OUTPUT:
 595             case ASL_FILE_ASM_INCLUDE_OUTPUT:
 596             case ASL_FILE_C_INCLUDE_OUTPUT:
 597                 /*
 598                  * For named objects, we will create a valid symbol so that the
 599                  * AML code can be referenced from C or ASM
 600                  */
 601                 if (Op->Asl.ExternalName)
 602                 {
 603                     /* Get the full pathname associated with this node */
 604
 605                     Pathname = AcpiNsGetExternalPathname (Op->Asl.Node);
 606                     Length = strlen (Pathname);
 607                     if (Length >= 4)
 608                     {
 609                         /* Convert all dots in the path to underscores */
 610
 611                         for (i = 0; i < Length; i++)
 612                         {
 613                             if (Pathname[i] == '.')
 614                             {
 615                                 Pathname[i] = '_';
 616                             }
 617                         }
 618
 619                         /* Create the appropriate symbol in the output file */
 620
 621                         switch (FileId)
 622                         {
 623                         case ASL_FILE_ASM_SOURCE_OUTPUT:
 624
 625                             FlPrintFile (FileId,
 626                                 "%s_%s_%s  \\\n",
 627                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
 628                             break;
 629
 630                         case ASL_FILE_C_SOURCE_OUTPUT:
 631
 632                             FlPrintFile (FileId,
 633                                 "    unsigned char    %s_%s_%s [] =\n    {\n",
 634                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
 635                             break;
 636
 637                         case ASL_FILE_ASM_INCLUDE_OUTPUT:
 638
 639                             FlPrintFile (FileId,
 640                                 "extrn %s_%s_%s : byte\n",
 641                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
 642                             break;
 643
 644                         case ASL_FILE_C_INCLUDE_OUTPUT:
 645
 646                             FlPrintFile (FileId,
 647                                 "extern unsigned char    %s_%s_%s [];\n",
 648                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
 649                             break;
 650
 651                         default:
 652                             break;
 653                         }
 654                     }
 655
 656                     ACPI_FREE (Pathname);
 657                 }
 658                 break;
 659
 660             default:
 661
 662                 /* Nothing to do for listing file */
 663
 664                 break;
 665             }
 666         }
 667         break;
 668
 669     case AML_CLASS_EXECUTE:
 670     case AML_CLASS_CREATE:
 671     default:
 672
 673         if ((Op->Asl.ParseOpcode == PARSEOP_BUFFER) &&
 674             (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC))
 675         {
 676             return;
 677         }
 678
 679         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 680             FileId);
 681         break;
 682
 683     case AML_CLASS_UNKNOWN:
 684
 685         break;
 686     }
 687 }
 688
 689
 690 /*******************************************************************************
 691  *
 692  * FUNCTION:    LsFinishSourceListing
 693  *
 694  * PARAMETERS:  FileId          - ID of current listing file.
 695  *
 696  * RETURN:      None
 697  *
 698  * DESCRIPTION: Cleanup routine for the listing file. Flush the hex AML
 699  *              listing buffer, and flush out any remaining lines in the
 700  *              source input file.
 701  *
 702  ******************************************************************************/
 703
 704 static void
 705 LsFinishSourceListing (
 706     UINT32                  FileId)
 707 {
 708
 709     if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) ||
 710         (FileId == ASL_FILE_C_INCLUDE_OUTPUT))
 711     {
 712         return;
 713     }
 714
 715     LsFlushListingBuffer (FileId);
 716     Gbl_CurrentAmlOffset = 0;
 717
 718     /* Flush any remaining text in the source file */
 719
 720     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 721     {
 722         FlPrintFile (FileId, "    /*\n");
 723     }
 724
 725     while (LsWriteOneSourceLine (FileId))
 726     { ; }
 727
 728     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 729     {
 730         FlPrintFile (FileId, "\n     */\n    };\n");
 731     }
 732
 733     FlPrintFile (FileId, "\n");
 734
 735     if (FileId == ASL_FILE_LISTING_OUTPUT)
 736     {
 737         /* Print a summary of the compile exceptions */
 738
 739         FlPrintFile (FileId, "\n\nSummary of errors and warnings\n\n");
 740         AePrintErrorLog (FileId);
 741         FlPrintFile (FileId, "\n");
 742         UtDisplaySummary (FileId);
 743         FlPrintFile (FileId, "\n");
 744     }
 745 }