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

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: asllisting - Listing file generation
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117
 118 #include <contrib/dev/acpica/compiler/aslcompiler.h>
 119 #include "aslcompiler.y.h"
 120 #include <contrib/dev/acpica/include/amlcode.h>
 121 #include <contrib/dev/acpica/include/acparser.h>
 122 #include <contrib/dev/acpica/include/acnamesp.h>
 123
 124 #define _COMPONENT          ACPI_COMPILER
 125         ACPI_MODULE_NAME    ("aslisting")
 126
 127 /* Local prototypes */
 128
 129 static void
 130 LsDumpAscii (
 131     UINT32                  FileId,
 132     UINT32                  Count,
 133     UINT8                   *Buffer);
 134
 135 static void
 136 LsDumpAsciiInComment (
 137     UINT32                  FileId,
 138     UINT32                  Count,
 139     UINT8                   *Buffer);
 140
 141 static ACPI_STATUS
 142 LsAmlListingWalk (
 143     ACPI_PARSE_OBJECT       *Op,
 144     UINT32                  Level,
 145     void                    *Context);
 146
 147 static void
 148 LsGenerateListing (
 149     UINT32                  FileId);
 150
 151 static void
 152 LsPushNode (
 153     char                    *Filename);
 154
 155 static ASL_LISTING_NODE *
 156 LsPopNode (
 157     void);
 158
 159 static void
 160 LsCheckException (
 161     UINT32                  LineNumber,
 162     UINT32                  FileId);
 163
 164 static void
 165 LsFlushListingBuffer (
 166     UINT32                  FileId);
 167
 168 static void
 169 LsWriteListingHexBytes (
 170     UINT8                   *Buffer,
 171     UINT32                  Length,
 172     UINT32                  FileId);
 173
 174 static UINT32
 175 LsWriteOneSourceLine (
 176     UINT32                  FileId);
 177
 178 static void
 179 LsFinishSourceListing (
 180     UINT32                  FileId);
 181
 182 static void
 183 LsWriteSourceLines (
 184     UINT32                  ToLineNumber,
 185     UINT32                  ToLogicalLineNumber,
 186     UINT32                  FileId);
 187
 188 static void
 189 LsWriteNodeToListing (
 190     ACPI_PARSE_OBJECT       *Op,
 191     UINT32                  FileId);
 192
 193 static void
 194 LsDoHexOutputC (
 195     void);
 196
 197 static void
 198 LsDoHexOutputAsm (
 199     void);
 200
 201 static void
 202 LsDoHexOutputAsl (
 203     void);
 204
 205 static ACPI_STATUS
 206 LsTreeWriteWalk (
 207     ACPI_PARSE_OBJECT       *Op,
 208     UINT32                  Level,
 209     void                    *Context);
 210
 211
 212 /*******************************************************************************
 213  *
 214  * FUNCTION:    LsTreeWriteWalk
 215  *
 216  * PARAMETERS:  ASL_WALK_CALLBACK
 217  *
 218  *
 219  * RETURN:      None.
 220  *
 221  * DESCRIPTION: Dump entire parse tree, for compiler debug only
 222  *
 223  ******************************************************************************/
 224
 225 static ACPI_STATUS
 226 LsTreeWriteWalk (
 227     ACPI_PARSE_OBJECT       *Op,
 228     UINT32                  Level,
 229     void                    *Context)
 230 {
 231
 232     /* Debug output */
 233
 234     DbgPrint (ASL_TREE_OUTPUT,
 235         "%5.5d [%2d]", Op->Asl.LogicalLineNumber, Level);
 236     UtPrintFormattedName (Op->Asl.ParseOpcode, Level);
 237
 238
 239     DbgPrint (ASL_TREE_OUTPUT, "\n");
 240     return (AE_OK);
 241 }
 242
 243
 244 void
 245 LsDumpParseTree (
 246     void)
 247 {
 248
 249     if (!Gbl_DebugFlag)
 250     {
 251         return;
 252     }
 253
 254     DbgPrint (ASL_TREE_OUTPUT, "\nOriginal parse tree from parser:\n\n");
 255     TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
 256         LsTreeWriteWalk, NULL, NULL);
 257 }
 258
 259
 260 /*******************************************************************************
 261  *
 262  * FUNCTION:    LsDumpAscii
 263  *
 264  * PARAMETERS:  FileId          - ID of current listing file
 265  *              Count           - Number of bytes to convert
 266  *              Buffer          - Buffer of bytes to convert
 267  *
 268  * RETURN:      None.
 269  *
 270  * DESCRIPTION: Convert hex bytes to ascii
 271  *
 272  ******************************************************************************/
 273
 274 static void
 275 LsDumpAscii (
 276     UINT32                  FileId,
 277     UINT32                  Count,
 278     UINT8                   *Buffer)
 279 {
 280     UINT8                   BufChar;
 281     UINT32                  i;
 282
 283
 284     FlPrintFile (FileId, "    \"");
 285     for (i = 0; i < Count; i++)
 286     {
 287         BufChar = Buffer[i];
 288         if (isprint (BufChar))
 289         {
 290             FlPrintFile (FileId, "%c", BufChar);
 291         }
 292         else
 293         {
 294             /* Not a printable character, just put out a dot */
 295
 296             FlPrintFile (FileId, ".");
 297         }
 298     }
 299     FlPrintFile (FileId, "\"");
 300 }
 301
 302
 303 /*******************************************************************************
 304  *
 305  * FUNCTION:    LsDumpAsciiInComment
 306  *
 307  * PARAMETERS:  FileId          - ID of current listing file
 308  *              Count           - Number of bytes to convert
 309  *              Buffer          - Buffer of bytes to convert
 310  *
 311  * RETURN:      None.
 312  *
 313  * DESCRIPTION: Convert hex bytes to ascii
 314  *
 315  ******************************************************************************/
 316
 317 static void
 318 LsDumpAsciiInComment (
 319     UINT32                  FileId,
 320     UINT32                  Count,
 321     UINT8                   *Buffer)
 322 {
 323     UINT8                   BufChar = 0;
 324     UINT8                   LastChar;
 325     UINT32                  i;
 326
 327
 328     FlPrintFile (FileId, "    \"");
 329     for (i = 0; i < Count; i++)
 330     {
 331         LastChar = BufChar;
 332         BufChar = Buffer[i];
 333
 334         if (isprint (BufChar))
 335         {
 336             /* Handle embedded C comment sequences */
 337
 338             if (((LastChar == '*') && (BufChar == '/')) ||
 339                 ((LastChar == '/') && (BufChar == '*')))
 340             {
 341                 /* Insert a space to break the sequence */
 342
 343                 FlPrintFile (FileId, ".", BufChar);
 344             }
 345
 346             FlPrintFile (FileId, "%c", BufChar);
 347         }
 348         else
 349         {
 350             /* Not a printable character, just put out a dot */
 351
 352             FlPrintFile (FileId, ".");
 353         }
 354     }
 355     FlPrintFile (FileId, "\"");
 356 }
 357
 358
 359 /*******************************************************************************
 360  *
 361  * FUNCTION:    LsAmlListingWalk
 362  *
 363  * PARAMETERS:  ASL_WALK_CALLBACK
 364  *
 365  * RETURN:      Status
 366  *
 367  * DESCRIPTION: Process one node during a listing file generation.
 368  *
 369  ******************************************************************************/
 370
 371 static ACPI_STATUS
 372 LsAmlListingWalk (
 373     ACPI_PARSE_OBJECT       *Op,
 374     UINT32                  Level,
 375     void                    *Context)
 376 {
 377     UINT8                   FileByte;
 378     UINT32                  i;
 379     UINT32                  FileId = (UINT32) ACPI_TO_INTEGER (Context);
 380
 381
 382     LsWriteNodeToListing (Op, FileId);
 383
 384     if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DATA)
 385     {
 386         /* Buffer is a resource template, don't dump the data all at once */
 387
 388         return (AE_OK);
 389     }
 390
 391     /* Write the hex bytes to the listing file(s) (if requested) */
 392
 393     for (i = 0; i < Op->Asl.FinalAmlLength; i++)
 394     {
 395         if (ACPI_FAILURE (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1)))
 396         {
 397             FlFileError (ASL_FILE_AML_OUTPUT, ASL_MSG_READ);
 398             AslAbort ();
 399         }
 400         LsWriteListingHexBytes (&FileByte, 1, FileId);
 401     }
 402
 403     return (AE_OK);
 404 }
 405
 406
 407 /*******************************************************************************
 408  *
 409  * FUNCTION:    LsGenerateListing
 410  *
 411  * PARAMETERS:  FileId      - ID of listing file
 412  *
 413  * RETURN:      None
 414  *
 415  * DESCRIPTION: Generate a listing file.  This can be one of the several types
 416  *              of "listings" supported.
 417  *
 418  ******************************************************************************/
 419
 420 static void
 421 LsGenerateListing (
 422     UINT32                  FileId)
 423 {
 424
 425     /* Start at the beginning of both the source and AML files */
 426
 427     FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0);
 428     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
 429     Gbl_SourceLine = 0;
 430     Gbl_CurrentHexColumn = 0;
 431     LsPushNode (Gbl_Files[ASL_FILE_INPUT].Filename);
 432
 433     /* Process all parse nodes */
 434
 435     TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD, LsAmlListingWalk,
 436                         NULL, (void *) ACPI_TO_POINTER (FileId));
 437
 438     /* Final processing */
 439
 440     LsFinishSourceListing (FileId);
 441 }
 442
 443
 444 /*******************************************************************************
 445  *
 446  * FUNCTION:    LsDoListings
 447  *
 448  * PARAMETERS:  None.
 449  *
 450  * RETURN:      None
 451  *
 452  * DESCRIPTION: Generate all requested listing files.
 453  *
 454  ******************************************************************************/
 455
 456 void
 457 LsDoListings (
 458     void)
 459 {
 460
 461     if (Gbl_C_OutputFlag)
 462     {
 463         LsGenerateListing (ASL_FILE_C_SOURCE_OUTPUT);
 464     }
 465
 466     if (Gbl_ListingFlag)
 467     {
 468         LsGenerateListing (ASL_FILE_LISTING_OUTPUT);
 469     }
 470
 471     if (Gbl_AsmOutputFlag)
 472     {
 473         LsGenerateListing (ASL_FILE_ASM_SOURCE_OUTPUT);
 474     }
 475
 476     if (Gbl_C_IncludeOutputFlag)
 477     {
 478         LsGenerateListing (ASL_FILE_C_INCLUDE_OUTPUT);
 479     }
 480
 481     if (Gbl_AsmIncludeOutputFlag)
 482     {
 483         LsGenerateListing (ASL_FILE_ASM_INCLUDE_OUTPUT);
 484     }
 485 }
 486
 487
 488 /*******************************************************************************
 489  *
 490  * FUNCTION:    LsPushNode
 491  *
 492  * PARAMETERS:  Filename        - Pointer to the include filename
 493  *
 494  * RETURN:      None
 495  *
 496  * DESCRIPTION: Push a listing node on the listing/include file stack.  This
 497  *              stack enables tracking of include files (infinitely nested)
 498  *              and resumption of the listing of the parent file when the
 499  *              include file is finished.
 500  *
 501  ******************************************************************************/
 502
 503 static void
 504 LsPushNode (
 505     char                    *Filename)
 506 {
 507     ASL_LISTING_NODE        *Lnode;
 508
 509
 510     /* Create a new node */
 511
 512     Lnode = UtLocalCalloc (sizeof (ASL_LISTING_NODE));
 513
 514     /* Initialize */
 515
 516     Lnode->Filename = Filename;
 517     Lnode->LineNumber = 0;
 518
 519     /* Link (push) */
 520
 521     Lnode->Next = Gbl_ListingNode;
 522     Gbl_ListingNode = Lnode;
 523 }
 524
 525
 526 /*******************************************************************************
 527  *
 528  * FUNCTION:    LsPopNode
 529  *
 530  * PARAMETERS:  None
 531  *
 532  * RETURN:      List head after current head is popped off
 533  *
 534  * DESCRIPTION: Pop the current head of the list, free it, and return the
 535  *              next node on the stack (the new current node).
 536  *
 537  ******************************************************************************/
 538
 539 static ASL_LISTING_NODE *
 540 LsPopNode (
 541     void)
 542 {
 543     ASL_LISTING_NODE        *Lnode;
 544
 545
 546     /* Just grab the node at the head of the list */
 547
 548     Lnode = Gbl_ListingNode;
 549     if ((!Lnode) ||
 550         (!Lnode->Next))
 551     {
 552         AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, NULL,
 553             "Could not pop empty listing stack");
 554         return Gbl_ListingNode;
 555     }
 556
 557     Gbl_ListingNode = Lnode->Next;
 558     ACPI_FREE (Lnode);
 559
 560     /* New "Current" node is the new head */
 561
 562     return (Gbl_ListingNode);
 563 }
 564
 565
 566 /*******************************************************************************
 567  *
 568  * FUNCTION:    LsCheckException
 569  *
 570  * PARAMETERS:  LineNumber          - Current logical (cumulative) line #
 571  *              FileId              - ID of output listing file
 572  *
 573  * RETURN:      None
 574  *
 575  * DESCRIPTION: Check if there is an exception for this line, and if there is,
 576  *              put it in the listing immediately.  Handles multiple errors
 577  *              per line.  Gbl_NextError points to the next error in the
 578  *              sorted (by line #) list of compile errors/warnings.
 579  *
 580  ******************************************************************************/
 581
 582 static void
 583 LsCheckException (
 584     UINT32                  LineNumber,
 585     UINT32                  FileId)
 586 {
 587
 588     if ((!Gbl_NextError) ||
 589         (LineNumber < Gbl_NextError->LogicalLineNumber ))
 590     {
 591         return;
 592     }
 593
 594     /* Handle multiple errors per line */
 595
 596     if (FileId == ASL_FILE_LISTING_OUTPUT)
 597     {
 598         while (Gbl_NextError &&
 599               (LineNumber >= Gbl_NextError->LogicalLineNumber))
 600         {
 601             AePrintException (FileId, Gbl_NextError, "\n[****iasl****]\n");
 602
 603             Gbl_NextError = Gbl_NextError->Next;
 604         }
 605
 606         FlPrintFile (FileId, "\n");
 607     }
 608 }
 609
 610
 611 /*******************************************************************************
 612  *
 613  * FUNCTION:    LsFlushListingBuffer
 614  *
 615  * PARAMETERS:  FileId          - ID of the listing file
 616  *
 617  * RETURN:      None
 618  *
 619  * DESCRIPTION: Flush out the current contents of the 16-byte hex AML code
 620  *              buffer.  Usually called at the termination of a single line
 621  *              of source code or when the buffer is full.
 622  *
 623  ******************************************************************************/
 624
 625 static void
 626 LsFlushListingBuffer (
 627     UINT32                  FileId)
 628 {
 629     UINT32                  i;
 630
 631
 632     if (Gbl_CurrentHexColumn == 0)
 633     {
 634         return;
 635     }
 636
 637     /* Write the hex bytes */
 638
 639     switch (FileId)
 640     {
 641     case ASL_FILE_LISTING_OUTPUT:
 642
 643         for (i = 0; i < Gbl_CurrentHexColumn; i++)
 644         {
 645             FlPrintFile (FileId, "%2.2X ", Gbl_AmlBuffer[i]);
 646         }
 647
 648         for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 3); i++)
 649         {
 650             FlWriteFile (FileId, ".", 1);
 651         }
 652
 653         /* Write the ASCII character associated with each of the bytes */
 654
 655         LsDumpAscii (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer);
 656         break;
 657
 658
 659     case ASL_FILE_ASM_SOURCE_OUTPUT:
 660
 661         for (i = 0; i < Gbl_CurrentHexColumn; i++)
 662         {
 663             if (i > 0)
 664             {
 665                 FlPrintFile (FileId, ",");
 666             }
 667             FlPrintFile (FileId, "0%2.2Xh", Gbl_AmlBuffer[i]);
 668         }
 669
 670         for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 5); i++)
 671         {
 672             FlWriteFile (FileId, " ", 1);
 673         }
 674
 675         FlPrintFile (FileId, "  ;%8.8X",
 676             Gbl_CurrentAmlOffset - HEX_LISTING_LINE_SIZE);
 677
 678         /* Write the ASCII character associated with each of the bytes */
 679
 680         LsDumpAscii (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer);
 681         break;
 682
 683
 684     case ASL_FILE_C_SOURCE_OUTPUT:
 685
 686         for (i = 0; i < Gbl_CurrentHexColumn; i++)
 687         {
 688             FlPrintFile (FileId, "0x%2.2X,", Gbl_AmlBuffer[i]);
 689         }
 690
 691         for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 5); i++)
 692         {
 693             FlWriteFile (FileId, " ", 1);
 694         }
 695
 696         FlPrintFile (FileId, "    /* %8.8X",
 697             Gbl_CurrentAmlOffset - HEX_LISTING_LINE_SIZE);
 698
 699         /* Write the ASCII character associated with each of the bytes */
 700
 701         LsDumpAsciiInComment (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer);
 702         FlPrintFile (FileId, " */");
 703         break;
 704
 705     default:
 706         /* No other types supported */
 707         return;
 708     }
 709
 710     FlPrintFile (FileId, "\n");
 711
 712     Gbl_CurrentHexColumn = 0;
 713     Gbl_HexBytesWereWritten = TRUE;
 714 }
 715
 716
 717 /*******************************************************************************
 718  *
 719  * FUNCTION:    LsWriteListingHexBytes
 720  *
 721  * PARAMETERS:  Buffer          - AML code buffer
 722  *              Length          - Number of AML bytes to write
 723  *              FileId          - ID of current listing file.
 724  *
 725  * RETURN:      None
 726  *
 727  * DESCRIPTION: Write the contents of the AML buffer to the listing file via
 728  *              the listing buffer.  The listing buffer is flushed every 16
 729  *              AML bytes.
 730  *
 731  ******************************************************************************/
 732
 733 static void
 734 LsWriteListingHexBytes (
 735     UINT8                   *Buffer,
 736     UINT32                  Length,
 737     UINT32                  FileId)
 738 {
 739     UINT32                  i;
 740
 741
 742     /* Transfer all requested bytes */
 743
 744     for (i = 0; i < Length; i++)
 745     {
 746         /* Print line header when buffer is empty */
 747
 748         if (Gbl_CurrentHexColumn == 0)
 749         {
 750             if (Gbl_HasIncludeFiles)
 751             {
 752                 FlPrintFile (FileId, "%*s", 10, " ");
 753             }
 754
 755             switch (FileId)
 756             {
 757             case ASL_FILE_LISTING_OUTPUT:
 758
 759                 FlPrintFile (FileId, "%8.8X....", Gbl_CurrentAmlOffset);
 760                 break;
 761
 762             case ASL_FILE_ASM_SOURCE_OUTPUT:
 763
 764                 FlPrintFile (FileId, "    db ");
 765                 break;
 766
 767             case ASL_FILE_C_SOURCE_OUTPUT:
 768
 769                 FlPrintFile (FileId, "        ");
 770                 break;
 771
 772             default:
 773                 /* No other types supported */
 774                 return;
 775             }
 776         }
 777
 778         /* Transfer AML byte and update counts */
 779
 780         Gbl_AmlBuffer[Gbl_CurrentHexColumn] = Buffer[i];
 781
 782         Gbl_CurrentHexColumn++;
 783         Gbl_CurrentAmlOffset++;
 784
 785         /* Flush buffer when it is full */
 786
 787         if (Gbl_CurrentHexColumn >= HEX_LISTING_LINE_SIZE)
 788         {
 789             LsFlushListingBuffer (FileId);
 790         }
 791     }
 792 }
 793
 794
 795 /*******************************************************************************
 796  *
 797  * FUNCTION:    LsWriteOneSourceLine
 798  *
 799  * PARAMETERS:  FileID          - ID of current listing file
 800  *
 801  * RETURN:      FALSE on EOF (input source file), TRUE otherwise
 802  *
 803  * DESCRIPTION: Read one line from the input source file and echo it to the
 804  *              listing file, prefixed with the line number, and if the source
 805  *              file contains include files, prefixed with the current filename
 806  *
 807  ******************************************************************************/
 808
 809 static UINT32
 810 LsWriteOneSourceLine (
 811     UINT32                  FileId)
 812 {
 813     UINT8                   FileByte;
 814
 815
 816     Gbl_SourceLine++;
 817     Gbl_ListingNode->LineNumber++;
 818
 819     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 820     {
 821         FlPrintFile (FileId, "     *");
 822     }
 823     if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT)
 824     {
 825         FlPrintFile (FileId, "; ");
 826     }
 827
 828     if (Gbl_HasIncludeFiles)
 829     {
 830         /*
 831          * This file contains "include" statements, print the current
 832          * filename and line number within the current file
 833          */
 834         FlPrintFile (FileId, "%12s %5d....",
 835                     Gbl_ListingNode->Filename, Gbl_ListingNode->LineNumber);
 836     }
 837     else
 838     {
 839         /* No include files, just print the line number */
 840
 841         FlPrintFile (FileId, "%8d....", Gbl_SourceLine);
 842     }
 843
 844     /* Read one line (up to a newline or EOF) */
 845
 846     while (FlReadFile (ASL_FILE_SOURCE_OUTPUT, &FileByte, 1) == AE_OK)
 847     {
 848         if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 849         {
 850             if (FileByte == '/')
 851             {
 852                 FileByte = '*';
 853             }
 854         }
 855
 856         FlWriteFile (FileId, &FileByte, 1);
 857         if (FileByte == '\n')
 858         {
 859             /*
 860              * Check if an error occurred on this source line during the compile.
 861              * If so, we print the error message after the source line.
 862              */
 863             LsCheckException (Gbl_SourceLine, FileId);
 864             return (1);
 865         }
 866     }
 867
 868     /* EOF on the input file was reached */
 869
 870     return (0);
 871 }
 872
 873
 874 /*******************************************************************************
 875  *
 876  * FUNCTION:    LsFinishSourceListing
 877  *
 878  * PARAMETERS:  FileId          - ID of current listing file.
 879  *
 880  * RETURN:      None
 881  *
 882  * DESCRIPTION: Cleanup routine for the listing file.  Flush the hex AML
 883  *              listing buffer, and flush out any remaining lines in the
 884  *              source input file.
 885  *
 886  ******************************************************************************/
 887
 888 static void
 889 LsFinishSourceListing (
 890     UINT32                  FileId)
 891 {
 892
 893     if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) ||
 894         (FileId == ASL_FILE_C_INCLUDE_OUTPUT))
 895     {
 896         return;
 897     }
 898
 899     LsFlushListingBuffer (FileId);
 900     Gbl_CurrentAmlOffset = 0;
 901
 902     /* Flush any remaining text in the source file */
 903
 904     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 905     {
 906         FlPrintFile (FileId, "    /*\n");
 907     }
 908
 909     while (LsWriteOneSourceLine (FileId))
 910     { ; }
 911
 912     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 913     {
 914         FlPrintFile (FileId, "\n     */\n    };\n");
 915     }
 916
 917     FlPrintFile (FileId, "\n");
 918
 919     if (FileId == ASL_FILE_LISTING_OUTPUT)
 920     {
 921         /* Print a summary of the compile exceptions */
 922
 923         FlPrintFile (FileId, "\n\nSummary of errors and warnings\n\n");
 924         AePrintErrorLog (FileId);
 925         FlPrintFile (FileId, "\n\n");
 926         UtDisplaySummary (FileId);
 927         FlPrintFile (FileId, "\n\n");
 928     }
 929 }
 930
 931
 932 /*******************************************************************************
 933  *
 934  * FUNCTION:    LsWriteSourceLines
 935  *
 936  * PARAMETERS:  ToLineNumber            -
 937  *              ToLogicalLineNumber     - Write up to this source line number
 938  *              FileId                  - ID of current listing file
 939  *
 940  * RETURN:      None
 941  *
 942  * DESCRIPTION: Read then write source lines to the listing file until we have
 943  *              reached the specified logical (cumulative) line number.  This
 944  *              automatically echos out comment blocks and other non-AML
 945  *              generating text until we get to the actual AML-generating line
 946  *              of ASL code specified by the logical line number.
 947  *
 948  ******************************************************************************/
 949
 950 static void
 951 LsWriteSourceLines (
 952     UINT32                  ToLineNumber,
 953     UINT32                  ToLogicalLineNumber,
 954     UINT32                  FileId)
 955 {
 956
 957     if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) ||
 958         (FileId == ASL_FILE_C_INCLUDE_OUTPUT))
 959     {
 960         return;
 961     }
 962
 963     Gbl_CurrentLine = ToLogicalLineNumber;
 964
 965     /* Flush any hex bytes remaining from the last opcode */
 966
 967     LsFlushListingBuffer (FileId);
 968
 969     /* Read lines and write them as long as we are not caught up */
 970
 971     if (Gbl_SourceLine < Gbl_CurrentLine)
 972     {
 973         /*
 974          * If we just completed writing some AML hex bytes, output a linefeed
 975          * to add some whitespace for readability.
 976          */
 977         if (Gbl_HexBytesWereWritten)
 978         {
 979             FlPrintFile (FileId, "\n");
 980             Gbl_HexBytesWereWritten = FALSE;
 981         }
 982
 983         if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 984         {
 985             FlPrintFile (FileId, "    /*\n");
 986         }
 987
 988         /* Write one line at a time until we have reached the target line # */
 989
 990         while ((Gbl_SourceLine < Gbl_CurrentLine) &&
 991                 LsWriteOneSourceLine (FileId))
 992         { ; }
 993
 994         if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 995         {
 996             FlPrintFile (FileId, "     */");
 997         }
 998         FlPrintFile (FileId, "\n");
 999     }
1000 }
1001
1002
1003 /*******************************************************************************
1004  *
1005  * FUNCTION:    LsWriteNodeToListing
1006  *
1007  * PARAMETERS:  Op            - Parse node to write to the listing file.
1008  *              FileId          - ID of current listing file
1009  *
1010  * RETURN:      None.
1011  *
1012  * DESCRIPTION: Write "a node" to the listing file.  This means to
1013  *              1) Write out all of the source text associated with the node
1014  *              2) Write out all of the AML bytes associated with the node
1015  *              3) Write any compiler exceptions associated with the node
1016  *
1017  ******************************************************************************/
1018
1019 static void
1020 LsWriteNodeToListing (
1021     ACPI_PARSE_OBJECT       *Op,
1022     UINT32                  FileId)
1023 {
1024     const ACPI_OPCODE_INFO  *OpInfo;
1025     UINT32                  OpClass;
1026     char                    *Pathname;
1027     UINT32                  Length;
1028     UINT32                  i;
1029
1030
1031     OpInfo  = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
1032     OpClass = OpInfo->Class;
1033
1034     /* TBD: clean this up with a single flag that says:
1035      * I start a named output block
1036      */
1037     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
1038     {
1039         switch (Op->Asl.ParseOpcode)
1040         {
1041         case PARSEOP_DEFINITIONBLOCK:
1042         case PARSEOP_METHODCALL:
1043         case PARSEOP_INCLUDE:
1044         case PARSEOP_INCLUDE_END:
1045         case PARSEOP_DEFAULT_ARG:
1046
1047             break;
1048
1049         default:
1050             switch (OpClass)
1051             {
1052             case AML_CLASS_NAMED_OBJECT:
1053                 switch (Op->Asl.AmlOpcode)
1054                 {
1055                 case AML_SCOPE_OP:
1056                 case AML_ALIAS_OP:
1057                     break;
1058
1059                 default:
1060                     if (Op->Asl.ExternalName)
1061                     {
1062                         LsFlushListingBuffer (FileId);
1063                         FlPrintFile (FileId, "    };\n");
1064                     }
1065                     break;
1066                 }
1067                 break;
1068
1069             default:
1070                 /* Don't care about other objects */
1071                 break;
1072             }
1073             break;
1074         }
1075     }
1076
1077     /* These cases do not have a corresponding AML opcode */
1078
1079     switch (Op->Asl.ParseOpcode)
1080     {
1081     case PARSEOP_DEFINITIONBLOCK:
1082
1083         LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine, FileId);
1084
1085         /* Use the table Signature and TableId to build a unique name */
1086
1087         if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT)
1088         {
1089             FlPrintFile (FileId,
1090                 "%s_%s_Header \\\n",
1091                 Gbl_TableSignature, Gbl_TableId);
1092         }
1093         if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
1094         {
1095             FlPrintFile (FileId,
1096                 "    unsigned char    %s_%s_Header [] =\n    {\n",
1097                 Gbl_TableSignature, Gbl_TableId);
1098         }
1099         if (FileId == ASL_FILE_ASM_INCLUDE_OUTPUT)
1100         {
1101             FlPrintFile (FileId,
1102                 "extrn %s_%s_Header : byte\n",
1103                 Gbl_TableSignature, Gbl_TableId);
1104         }
1105         if (FileId == ASL_FILE_C_INCLUDE_OUTPUT)
1106         {
1107             FlPrintFile (FileId,
1108                 "extern unsigned char    %s_%s_Header [];\n",
1109                 Gbl_TableSignature, Gbl_TableId);
1110         }
1111         return;
1112
1113
1114     case PARSEOP_METHODCALL:
1115
1116         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
1117             FileId);
1118         return;
1119
1120
1121     case PARSEOP_INCLUDE:
1122
1123         /* Flush everything up to and including the include source line */
1124
1125         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
1126             FileId);
1127
1128         /* Create a new listing node and push it */
1129
1130         LsPushNode (Op->Asl.Child->Asl.Value.String);
1131         return;
1132
1133
1134     case PARSEOP_INCLUDE_END:
1135
1136         /* Flush out the rest of the include file */
1137
1138         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
1139             FileId);
1140
1141         /* Pop off this listing node and go back to the parent file */
1142
1143         (void) LsPopNode ();
1144         return;
1145
1146
1147     case PARSEOP_DEFAULT_ARG:
1148
1149         if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
1150         {
1151             LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.EndLogicalLine,
1152                 FileId);
1153         }
1154         return;
1155
1156
1157     default:
1158         /* All other opcodes have an AML opcode */
1159         break;
1160     }
1161
1162     /*
1163      * Otherwise, we look at the AML opcode because we can
1164      * switch on the opcode type, getting an entire class
1165      * at once
1166      */
1167     switch (OpClass)
1168     {
1169     case AML_CLASS_ARGUMENT:       /* argument type only */
1170     case AML_CLASS_INTERNAL:
1171
1172         break;
1173
1174
1175     case AML_CLASS_NAMED_OBJECT:
1176
1177         switch (Op->Asl.AmlOpcode)
1178         {
1179         case AML_FIELD_OP:
1180         case AML_INDEX_FIELD_OP:
1181         case AML_BANK_FIELD_OP:
1182
1183             /*
1184              * For fields, we want to dump all the AML after the
1185              * entire definition
1186              */
1187             LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
1188                 FileId);
1189             break;
1190
1191         case AML_NAME_OP:
1192
1193             if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
1194             {
1195                 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
1196                     FileId);
1197             }
1198             else
1199             {
1200                 /*
1201                  * For fields, we want to dump all the AML after the
1202                  * entire definition
1203                  */
1204                 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
1205                     FileId);
1206             }
1207             break;
1208
1209         default:
1210             LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
1211                 FileId);
1212             break;
1213         }
1214
1215         switch (Op->Asl.AmlOpcode)
1216         {
1217         case AML_SCOPE_OP:
1218         case AML_ALIAS_OP:
1219
1220             /* These opcodes do not declare a new object, ignore them */
1221
1222             break;
1223
1224         default:
1225
1226             /* All other named object opcodes come here */
1227
1228             switch (FileId)
1229             {
1230             case ASL_FILE_ASM_SOURCE_OUTPUT:
1231             case ASL_FILE_C_SOURCE_OUTPUT:
1232             case ASL_FILE_ASM_INCLUDE_OUTPUT:
1233             case ASL_FILE_C_INCLUDE_OUTPUT:
1234
1235                 /*
1236                  * For named objects, we will create a valid symbol so that the
1237                  * AML code can be referenced from C or ASM
1238                  */
1239                 if (Op->Asl.ExternalName)
1240                 {
1241                     /* Get the full pathname associated with this node */
1242
1243                     Pathname = AcpiNsGetExternalPathname (Op->Asl.Node);
1244                     Length = strlen (Pathname);
1245                     if (Length >= 4)
1246                     {
1247                         /* Convert all dots in the path to underscores */
1248
1249                         for (i = 0; i < Length; i++)
1250                         {
1251                             if (Pathname[i] == '.')
1252                             {
1253                                 Pathname[i] = '_';
1254                             }
1255                         }
1256
1257                         /* Create the appropriate symbol in the output file */
1258
1259                         if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT)
1260                         {
1261                             FlPrintFile (FileId,
1262                                 "%s_%s_%s  \\\n",
1263                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
1264                         }
1265                         if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
1266                         {
1267                             FlPrintFile (FileId,
1268                                 "    unsigned char    %s_%s_%s [] =\n    {\n",
1269                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
1270                         }
1271                         if (FileId == ASL_FILE_ASM_INCLUDE_OUTPUT)
1272                         {
1273                             FlPrintFile (FileId,
1274                                 "extrn %s_%s_%s : byte\n",
1275                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
1276                         }
1277                         if (FileId == ASL_FILE_C_INCLUDE_OUTPUT)
1278                         {
1279                             FlPrintFile (FileId,
1280                                 "extern unsigned char    %s_%s_%s [];\n",
1281                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
1282                         }
1283                     }
1284                     ACPI_FREE (Pathname);
1285                 }
1286                 break;
1287
1288             default:
1289                 /* Nothing to do for listing file */
1290                 break;
1291             }
1292         }
1293         break;
1294
1295     case AML_CLASS_EXECUTE:
1296     case AML_CLASS_CREATE:
1297     default:
1298
1299         if ((Op->Asl.ParseOpcode == PARSEOP_BUFFER) &&
1300             (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC))
1301         {
1302             return;
1303         }
1304
1305         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
1306             FileId);
1307         break;
1308
1309     case AML_CLASS_UNKNOWN:
1310         break;
1311     }
1312 }
1313
1314
1315 /*******************************************************************************
1316  *
1317  * FUNCTION:    LsDoHexOutput
1318  *
1319  * PARAMETERS:  None
1320  *
1321  * RETURN:      None.
1322  *
1323  * DESCRIPTION: Create the hex output file.
1324  *
1325  ******************************************************************************/
1326
1327 void
1328 LsDoHexOutput (
1329     void)
1330 {
1331
1332     switch (Gbl_HexOutputFlag)
1333     {
1334     case HEX_OUTPUT_C:
1335
1336         LsDoHexOutputC ();
1337         break;
1338
1339     case HEX_OUTPUT_ASM:
1340
1341         LsDoHexOutputAsm ();
1342         break;
1343
1344     case HEX_OUTPUT_ASL:
1345
1346         LsDoHexOutputAsl ();
1347         break;
1348
1349     default:
1350         /* No other output types supported */
1351         break;
1352     }
1353 }
1354
1355
1356 /*******************************************************************************
1357  *
1358  * FUNCTION:    LsDoHexOutputC
1359  *
1360  * PARAMETERS:  None
1361  *
1362  * RETURN:      None.
1363  *
1364  * DESCRIPTION: Create the hex output file.  This is the same data as the AML
1365  *              output file, but formatted into hex/ascii bytes suitable for
1366  *              inclusion into a C source file.
1367  *
1368  ******************************************************************************/
1369
1370 static void
1371 LsDoHexOutputC (
1372     void)
1373 {
1374     UINT8                   FileData[HEX_TABLE_LINE_SIZE];
1375     UINT32                  LineLength;
1376     UINT32                  Offset = 0;
1377     UINT32                  AmlFileSize;
1378     UINT32                  i;
1379
1380
1381     /* Get AML size, seek back to start */
1382
1383     AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
1384
1385     FlPrintFile (ASL_FILE_HEX_OUTPUT, " * C source code output\n");
1386     FlPrintFile (ASL_FILE_HEX_OUTPUT, " * AML code block contains 0x%X bytes\n *\n */\n",
1387         AmlFileSize);
1388     FlPrintFile (ASL_FILE_HEX_OUTPUT, "unsigned char AmlCode[] =\n{\n");
1389
1390     while (Offset < AmlFileSize)
1391     {
1392         /* Read enough bytes needed for one output line */
1393
1394         LineLength = fread (FileData, 1, HEX_TABLE_LINE_SIZE,
1395                         Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
1396         if (!LineLength)
1397         {
1398             break;
1399         }
1400
1401         FlPrintFile (ASL_FILE_HEX_OUTPUT, "    ");
1402
1403         for (i = 0; i < LineLength; i++)
1404         {
1405             /*
1406              * Print each hex byte.
1407              * Add a comma until the very last byte of the AML file
1408              * (Some C compilers complain about a trailing comma)
1409              */
1410             FlPrintFile (ASL_FILE_HEX_OUTPUT, "0x%2.2X", FileData[i]);
1411             if ((Offset + i + 1) < AmlFileSize)
1412             {
1413                 FlPrintFile (ASL_FILE_HEX_OUTPUT, ",");
1414             }
1415             else
1416             {
1417                 FlPrintFile (ASL_FILE_HEX_OUTPUT, " ");
1418             }
1419         }
1420
1421         /* Add fill spaces if needed for last line */
1422
1423         if (LineLength < HEX_TABLE_LINE_SIZE)
1424         {
1425             FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s",
1426                 5 * (HEX_TABLE_LINE_SIZE - LineLength), " ");
1427         }
1428
1429         /* Emit the offset and ascii dump for the entire line */
1430
1431         FlPrintFile (ASL_FILE_HEX_OUTPUT, "  /* %8.8X", Offset);
1432         LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData);
1433         FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s*/\n",
1434             HEX_TABLE_LINE_SIZE - LineLength + 1, " ");
1435
1436         Offset += LineLength;
1437     }
1438
1439     FlPrintFile (ASL_FILE_HEX_OUTPUT, "};\n");
1440     FlCloseFile (ASL_FILE_HEX_OUTPUT);
1441 }
1442
1443
1444 /*******************************************************************************
1445  *
1446  * FUNCTION:    LsDoHexOutputAsl
1447  *
1448  * PARAMETERS:  None
1449  *
1450  * RETURN:      None.
1451  *
1452  * DESCRIPTION: Create the hex output file.  This is the same data as the AML
1453  *              output file, but formatted into hex/ascii bytes suitable for
1454  *              inclusion into a C source file.
1455  *
1456  ******************************************************************************/
1457
1458 static void
1459 LsDoHexOutputAsl (
1460     void)
1461 {
1462     UINT8                   FileData[HEX_TABLE_LINE_SIZE];
1463     UINT32                  LineLength;
1464     UINT32                  Offset = 0;
1465     UINT32                  AmlFileSize;
1466     UINT32                  i;
1467
1468
1469     /* Get AML size, seek back to start */
1470
1471     AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
1472
1473     FlPrintFile (ASL_FILE_HEX_OUTPUT, " * ASL source code output\n");
1474     FlPrintFile (ASL_FILE_HEX_OUTPUT, " * AML code block contains 0x%X bytes\n *\n */\n",
1475         AmlFileSize);
1476     FlPrintFile (ASL_FILE_HEX_OUTPUT, "    Name (BUF1, Buffer()\n    {\n");
1477
1478     while (Offset < AmlFileSize)
1479     {
1480         /* Read enough bytes needed for one output line */
1481
1482         LineLength = fread (FileData, 1, HEX_TABLE_LINE_SIZE,
1483                         Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
1484         if (!LineLength)
1485         {
1486             break;
1487         }
1488
1489         FlPrintFile (ASL_FILE_HEX_OUTPUT, "        ");
1490
1491         for (i = 0; i < LineLength; i++)
1492         {
1493             /*
1494              * Print each hex byte.
1495              * Add a comma until the very last byte of the AML file
1496              * (Some C compilers complain about a trailing comma)
1497              */
1498             FlPrintFile (ASL_FILE_HEX_OUTPUT, "0x%2.2X", FileData[i]);
1499             if ((Offset + i + 1) < AmlFileSize)
1500             {
1501                 FlPrintFile (ASL_FILE_HEX_OUTPUT, ",");
1502             }
1503             else
1504             {
1505                 FlPrintFile (ASL_FILE_HEX_OUTPUT, " ");
1506             }
1507         }
1508
1509         /* Add fill spaces if needed for last line */
1510
1511         if (LineLength < HEX_TABLE_LINE_SIZE)
1512         {
1513             FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s",
1514                 5 * (HEX_TABLE_LINE_SIZE - LineLength), " ");
1515         }
1516
1517         /* Emit the offset and ascii dump for the entire line */
1518
1519         FlPrintFile (ASL_FILE_HEX_OUTPUT, "  /* %8.8X", Offset);
1520         LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData);
1521         FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s*/\n",
1522             HEX_TABLE_LINE_SIZE - LineLength + 1, " ");
1523
1524         Offset += LineLength;
1525     }
1526
1527     FlPrintFile (ASL_FILE_HEX_OUTPUT, "    })\n");
1528     FlCloseFile (ASL_FILE_HEX_OUTPUT);
1529 }
1530
1531
1532 /*******************************************************************************
1533  *
1534  * FUNCTION:    LsDoHexOutputAsm
1535  *
1536  * PARAMETERS:  None
1537  *
1538  * RETURN:      None.
1539  *
1540  * DESCRIPTION: Create the hex output file.  This is the same data as the AML
1541  *              output file, but formatted into hex/ascii bytes suitable for
1542  *              inclusion into a ASM source file.
1543  *
1544  ******************************************************************************/
1545
1546 static void
1547 LsDoHexOutputAsm (
1548     void)
1549 {
1550     UINT8                   FileData[HEX_TABLE_LINE_SIZE];
1551     UINT32                  LineLength;
1552     UINT32                  Offset = 0;
1553     UINT32                  AmlFileSize;
1554     UINT32                  i;
1555
1556
1557     /* Get AML size, seek back to start */
1558
1559     AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
1560
1561     FlPrintFile (ASL_FILE_HEX_OUTPUT, "; Assembly code source output\n");
1562     FlPrintFile (ASL_FILE_HEX_OUTPUT, "; AML code block contains 0x%X bytes\n;\n",
1563         AmlFileSize);
1564
1565     while (Offset < AmlFileSize)
1566     {
1567         /* Read enough bytes needed for one output line */
1568
1569         LineLength = fread (FileData, 1, HEX_TABLE_LINE_SIZE,
1570                         Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
1571         if (!LineLength)
1572         {
1573             break;
1574         }
1575
1576         FlPrintFile (ASL_FILE_HEX_OUTPUT, "  db  ");
1577
1578         for (i = 0; i < LineLength; i++)
1579         {
1580             /*
1581              * Print each hex byte.
1582              * Add a comma until the last byte of the line
1583              */
1584             FlPrintFile (ASL_FILE_HEX_OUTPUT, "0%2.2Xh", FileData[i]);
1585             if ((i + 1) < LineLength)
1586             {
1587                 FlPrintFile (ASL_FILE_HEX_OUTPUT, ",");
1588             }
1589         }
1590
1591         FlPrintFile (ASL_FILE_HEX_OUTPUT, " ");
1592
1593         /* Add fill spaces if needed for last line */
1594
1595         if (LineLength < HEX_TABLE_LINE_SIZE)
1596         {
1597             FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s",
1598                 5 * (HEX_TABLE_LINE_SIZE - LineLength), " ");
1599         }
1600
1601         /* Emit the offset and ascii dump for the entire line */
1602
1603         FlPrintFile (ASL_FILE_HEX_OUTPUT, "  ; %8.8X", Offset);
1604         LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData);
1605         FlPrintFile (ASL_FILE_HEX_OUTPUT, "\n");
1606
1607         Offset += LineLength;
1608     }
1609
1610     FlPrintFile (ASL_FILE_HEX_OUTPUT, "\n");
1611     FlCloseFile (ASL_FILE_HEX_OUTPUT);
1612 }
1613
1614