arch/all-pc/acpica/source/compiler/dtio.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dtio.c - File I/O support for data table compiler
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #define __DTIO_C__
  45
  46 #include "aslcompiler.h"
  47 #include "dtcompiler.h"
  48
  49 #define _COMPONENT          DT_COMPILER
  50         ACPI_MODULE_NAME    ("dtio")
  51
  52
  53 /* Local prototypes */
  54
  55 static char *
  56 DtTrim (
  57     char                    *String);
  58
  59 static void
  60 DtLinkField (
  61     DT_FIELD                *Field);
  62
  63 static ACPI_STATUS
  64 DtParseLine (
  65     char                    *LineBuffer,
  66     UINT32                  Line,
  67     UINT32                  Offset);
  68
  69 static void
  70 DtWriteBinary (
  71     DT_SUBTABLE             *Subtable,
  72     void                    *Context,
  73     void                    *ReturnValue);
  74
  75 static void
  76 DtDumpBuffer (
  77     UINT32                  FileId,
  78     UINT8                   *Buffer,
  79     UINT32                  Offset,
  80     UINT32                  Length);
  81
  82 static void
  83 DtDumpSubtableInfo (
  84     DT_SUBTABLE             *Subtable,
  85     void                    *Context,
  86     void                    *ReturnValue);
  87
  88 static void
  89 DtDumpSubtableTree (
  90     DT_SUBTABLE             *Subtable,
  91     void                    *Context,
  92     void                    *ReturnValue);
  93
  94
  95 /* States for DtGetNextLine */
  96
  97 #define DT_NORMAL_TEXT              0
  98 #define DT_START_QUOTED_STRING      1
  99 #define DT_START_COMMENT            2
 100 #define DT_SLASH_ASTERISK_COMMENT   3
 101 #define DT_SLASH_SLASH_COMMENT      4
 102 #define DT_END_COMMENT              5
 103 #define DT_MERGE_LINES              6
 104 #define DT_ESCAPE_SEQUENCE          7
 105
 106 static UINT32  Gbl_NextLineOffset;
 107
 108
 109 /******************************************************************************
 110  *
 111  * FUNCTION:    DtTrim
 112  *
 113  * PARAMETERS:  String              - Current source code line to trim
 114  *
 115  * RETURN:      Trimmed line. Must be freed by caller.
 116  *
 117  * DESCRIPTION: Trim left and right spaces
 118  *
 119  *****************************************************************************/
 120
 121 static char *
 122 DtTrim (
 123     char                    *String)
 124 {
 125     char                    *Start;
 126     char                    *End;
 127     char                    *ReturnString;
 128     ACPI_SIZE               Length;
 129
 130
 131     /* Skip lines that start with a space */
 132
 133     if (!ACPI_STRCMP (String, " "))
 134     {
 135         ReturnString = UtLocalCalloc (1);
 136         return (ReturnString);
 137     }
 138
 139     /* Setup pointers to start and end of input string */
 140
 141     Start = String;
 142     End = String + ACPI_STRLEN (String) - 1;
 143
 144     /* Find first non-whitespace character */
 145
 146     while ((Start <= End) && ((*Start == ' ') || (*Start == '\t')))
 147     {
 148         Start++;
 149     }
 150
 151     /* Find last non-space character */
 152
 153     while (End >= Start)
 154     {
 155         if (*End == '\r' || *End == '\n')
 156         {
 157             End--;
 158             continue;
 159         }
 160
 161         if (*End != ' ')
 162         {
 163             break;
 164         }
 165
 166         End--;
 167     }
 168
 169     /* Remove any quotes around the string */
 170
 171     if (*Start == '\"')
 172     {
 173         Start++;
 174     }
 175     if (*End == '\"')
 176     {
 177         End--;
 178     }
 179
 180     /* Create the trimmed return string */
 181
 182     Length = ACPI_PTR_DIFF (End, Start) + 1;
 183     ReturnString = UtLocalCalloc (Length + 1);
 184     if (ACPI_STRLEN (Start))
 185     {
 186         ACPI_STRNCPY (ReturnString, Start, Length);
 187     }
 188
 189     ReturnString[Length] = 0;
 190     return (ReturnString);
 191 }
 192
 193
 194 /******************************************************************************
 195  *
 196  * FUNCTION:    DtLinkField
 197  *
 198  * PARAMETERS:  Field               - New field object to link
 199  *
 200  * RETURN:      None
 201  *
 202  * DESCRIPTION: Link one field name and value to the list
 203  *
 204  *****************************************************************************/
 205
 206 static void
 207 DtLinkField (
 208     DT_FIELD                *Field)
 209 {
 210     DT_FIELD                *Prev;
 211     DT_FIELD                *Next;
 212
 213
 214     Prev = Next = Gbl_FieldList;
 215
 216     while (Next)
 217     {
 218         Prev = Next;
 219         Next = Next->Next;
 220     }
 221
 222     if (Prev)
 223     {
 224         Prev->Next = Field;
 225     }
 226     else
 227     {
 228         Gbl_FieldList = Field;
 229     }
 230 }
 231
 232
 233 /******************************************************************************
 234  *
 235  * FUNCTION:    DtParseLine
 236  *
 237  * PARAMETERS:  LineBuffer          - Current source code line
 238  *              Line                - Current line number in the source
 239  *              Offset              - Current byte offset of the line
 240  *
 241  * RETURN:      Status
 242  *
 243  * DESCRIPTION: Parse one source line
 244  *
 245  *****************************************************************************/
 246
 247 static ACPI_STATUS
 248 DtParseLine (
 249     char                    *LineBuffer,
 250     UINT32                  Line,
 251     UINT32                  Offset)
 252 {
 253     char                    *Start;
 254     char                    *End;
 255     char                    *TmpName;
 256     char                    *TmpValue;
 257     char                    *Name;
 258     char                    *Value;
 259     char                    *Colon;
 260     UINT32                  Length;
 261     DT_FIELD                *Field;
 262     UINT32                  Column;
 263     UINT32                  NameColumn;
 264     BOOLEAN                 IsNullString = FALSE;
 265
 266
 267     if (!LineBuffer)
 268     {
 269         return (AE_OK);
 270     }
 271
 272     /* All lines after "Raw Table Data" are ingored */
 273
 274     if (strstr (LineBuffer, ACPI_RAW_TABLE_DATA_HEADER))
 275     {
 276         return (AE_NOT_FOUND);
 277     }
 278
 279     Colon = strchr (LineBuffer, ':');
 280     if (!Colon)
 281     {
 282         return (AE_OK);
 283     }
 284
 285     Start = LineBuffer;
 286     End = Colon;
 287
 288     while (Start < Colon)
 289     {
 290         if (*Start == '[')
 291         {
 292             /* Found left bracket, go to the right bracket */
 293
 294             while (Start < Colon && *Start != ']')
 295             {
 296                 Start++;
 297             }
 298         }
 299         else if (*Start != ' ')
 300         {
 301             break;
 302         }
 303
 304         Start++;
 305     }
 306
 307     /*
 308      * There are two column values. One for the field name,
 309      * and one for the field value.
 310      */
 311     Column = ACPI_PTR_DIFF (Colon, LineBuffer) + 3;
 312     NameColumn = ACPI_PTR_DIFF (Start, LineBuffer) + 1;
 313
 314     Length = ACPI_PTR_DIFF (End, Start);
 315
 316     TmpName = UtLocalCalloc (Length + 1);
 317     ACPI_STRNCPY (TmpName, Start, Length);
 318     Name = DtTrim (TmpName);
 319     ACPI_FREE (TmpName);
 320
 321     Start = End = (Colon + 1);
 322     while (*End)
 323     {
 324         /* Found left quotation, go to the right quotation and break */
 325
 326         if (*End == '"')
 327         {
 328             End++;
 329
 330             /* Check for an explicit null string */
 331
 332             if (*End == '"')
 333             {
 334                 IsNullString = TRUE;
 335             }
 336             while (*End && (*End != '"'))
 337             {
 338                 End++;
 339             }
 340
 341             End++;
 342             break;
 343         }
 344
 345         /*
 346          * Special "comment" fields at line end, ignore them.
 347          * Note: normal slash-slash and slash-asterisk comments are
 348          * stripped already by the DtGetNextLine parser.
 349          *
 350          * TBD: Perhaps DtGetNextLine should parse the following type
 351          * of comments also.
 352          */
 353         if (*End == '[')
 354         {
 355             End--;
 356             break;
 357         }
 358         End++;
 359     }
 360
 361     Length = ACPI_PTR_DIFF (End, Start);
 362     TmpValue = UtLocalCalloc (Length + 1);
 363
 364     ACPI_STRNCPY (TmpValue, Start, Length);
 365     Value = DtTrim (TmpValue);
 366     ACPI_FREE (TmpValue);
 367
 368     /* Create a new field object only if we have a valid value field */
 369
 370     if ((Value && *Value) || IsNullString)
 371     {
 372         Field = UtLocalCalloc (sizeof (DT_FIELD));
 373         Field->Name = Name;
 374         Field->Value = Value;
 375         Field->Line = Line;
 376         Field->ByteOffset = Offset;
 377         Field->NameColumn = NameColumn;
 378         Field->Column = Column;
 379
 380         DtLinkField (Field);
 381     }
 382     else /* Ignore this field, it has no valid data */
 383     {
 384         ACPI_FREE (Name);
 385         ACPI_FREE (Value);
 386     }
 387
 388     return (AE_OK);
 389 }
 390
 391
 392 /******************************************************************************
 393  *
 394  * FUNCTION:    DtGetNextLine
 395  *
 396  * PARAMETERS:  Handle              - Open file handle for the source file
 397  *
 398  * RETURN:      Filled line buffer and offset of start-of-line (ASL_EOF on EOF)
 399  *
 400  * DESCRIPTION: Get the next valid source line. Removes all comments.
 401  *              Ignores empty lines.
 402  *
 403  * Handles both slash-asterisk and slash-slash comments.
 404  * Also, quoted strings, but no escapes within.
 405  *
 406  * Line is returned in Gbl_CurrentLineBuffer.
 407  * Line number in original file is returned in Gbl_CurrentLineNumber.
 408  *
 409  *****************************************************************************/
 410
 411 UINT32
 412 DtGetNextLine (
 413     FILE                    *Handle)
 414 {
 415     BOOLEAN                 LineNotAllBlanks = FALSE;
 416     UINT32                  State = DT_NORMAL_TEXT;
 417     UINT32                  CurrentLineOffset;
 418     UINT32                  i;
 419     int                     c;
 420
 421
 422     for (i = 0; ;)
 423     {
 424         /*
 425          * If line is too long, expand the line buffers. Also increases
 426          * Gbl_LineBufferSize.
 427          */
 428         if (i >= Gbl_LineBufferSize)
 429         {
 430             UtExpandLineBuffers ();
 431         }
 432
 433         c = getc (Handle);
 434         if (c == EOF)
 435         {
 436             switch (State)
 437             {
 438             case DT_START_QUOTED_STRING:
 439             case DT_SLASH_ASTERISK_COMMENT:
 440
 441                 AcpiOsPrintf ("**** EOF within comment/string %u\n", State);
 442                 break;
 443
 444             default:
 445
 446                 break;
 447             }
 448
 449             /* Standalone EOF is OK */
 450
 451             if (i == 0)
 452             {
 453                 return (ASL_EOF);
 454             }
 455
 456             /*
 457              * Received an EOF in the middle of a line. Terminate the
 458              * line with a newline. The next call to this function will
 459              * return a standalone EOF. Thus, the upper parsing software
 460              * never has to deal with an EOF within a valid line (or
 461              * the last line does not get tossed on the floor.)
 462              */
 463             c = '\n';
 464             State = DT_NORMAL_TEXT;
 465         }
 466
 467         switch (State)
 468         {
 469         case DT_NORMAL_TEXT:
 470
 471             /* Normal text, insert char into line buffer */
 472
 473             Gbl_CurrentLineBuffer[i] = (char) c;
 474             switch (c)
 475             {
 476             case '/':
 477
 478                 State = DT_START_COMMENT;
 479                 break;
 480
 481             case '"':
 482
 483                 State = DT_START_QUOTED_STRING;
 484                 LineNotAllBlanks = TRUE;
 485                 i++;
 486                 break;
 487
 488             case '\\':
 489                 /*
 490                  * The continuation char MUST be last char on this line.
 491                  * Otherwise, it will be assumed to be a valid ASL char.
 492                  */
 493                 State = DT_MERGE_LINES;
 494                 break;
 495
 496             case '\n':
 497
 498                 CurrentLineOffset = Gbl_NextLineOffset;
 499                 Gbl_NextLineOffset = (UINT32) ftell (Handle);
 500                 Gbl_CurrentLineNumber++;
 501
 502                 /*
 503                  * Exit if line is complete. Ignore empty lines (only \n)
 504                  * or lines that contain nothing but blanks.
 505                  */
 506                 if ((i != 0) && LineNotAllBlanks)
 507                 {
 508                     if ((i + 1) >= Gbl_LineBufferSize)
 509                     {
 510                         UtExpandLineBuffers ();
 511                     }
 512
 513                     Gbl_CurrentLineBuffer[i+1] = 0; /* Terminate string */
 514                     return (CurrentLineOffset);
 515                 }
 516
 517                 /* Toss this line and start a new one */
 518
 519                 i = 0;
 520                 LineNotAllBlanks = FALSE;
 521                 break;
 522
 523             default:
 524
 525                 if (c != ' ')
 526                 {
 527                     LineNotAllBlanks = TRUE;
 528                 }
 529
 530                 i++;
 531                 break;
 532             }
 533             break;
 534
 535         case DT_START_QUOTED_STRING:
 536
 537             /* Insert raw chars until end of quoted string */
 538
 539             Gbl_CurrentLineBuffer[i] = (char) c;
 540             i++;
 541
 542             switch (c)
 543             {
 544             case '"':
 545
 546                 State = DT_NORMAL_TEXT;
 547                 break;
 548
 549             case '\\':
 550
 551                 State = DT_ESCAPE_SEQUENCE;
 552                 break;
 553
 554             case '\n':
 555
 556                 AcpiOsPrintf ("ERROR at line %u: Unterminated quoted string\n",
 557                     Gbl_CurrentLineNumber++);
 558                 State = DT_NORMAL_TEXT;
 559                 break;
 560
 561             default:    /* Get next character */
 562
 563                 break;
 564             }
 565             break;
 566
 567         case DT_ESCAPE_SEQUENCE:
 568
 569             /* Just copy the escaped character. TBD: sufficient for table compiler? */
 570
 571             Gbl_CurrentLineBuffer[i] = (char) c;
 572             i++;
 573             State = DT_START_QUOTED_STRING;
 574             break;
 575
 576         case DT_START_COMMENT:
 577
 578             /* Open comment if this character is an asterisk or slash */
 579
 580             switch (c)
 581             {
 582             case '*':
 583
 584                 State = DT_SLASH_ASTERISK_COMMENT;
 585                 break;
 586
 587             case '/':
 588
 589                 State = DT_SLASH_SLASH_COMMENT;
 590                 break;
 591
 592             default:    /* Not a comment */
 593
 594                 i++;    /* Save the preceding slash */
 595                 if (i >= Gbl_LineBufferSize)
 596                 {
 597                     UtExpandLineBuffers ();
 598                 }
 599
 600                 Gbl_CurrentLineBuffer[i] = (char) c;
 601                 i++;
 602                 State = DT_NORMAL_TEXT;
 603                 break;
 604             }
 605             break;
 606
 607         case DT_SLASH_ASTERISK_COMMENT:
 608
 609             /* Ignore chars until an asterisk-slash is found */
 610
 611             switch (c)
 612             {
 613             case '\n':
 614
 615                 Gbl_NextLineOffset = (UINT32) ftell (Handle);
 616                 Gbl_CurrentLineNumber++;
 617                 break;
 618
 619             case '*':
 620
 621                 State = DT_END_COMMENT;
 622                 break;
 623
 624             default:
 625
 626                 break;
 627             }
 628             break;
 629
 630         case DT_SLASH_SLASH_COMMENT:
 631
 632             /* Ignore chars until end-of-line */
 633
 634             if (c == '\n')
 635             {
 636                 /* We will exit via the NORMAL_TEXT path */
 637
 638                 ungetc (c, Handle);
 639                 State = DT_NORMAL_TEXT;
 640             }
 641             break;
 642
 643         case DT_END_COMMENT:
 644
 645             /* End comment if this char is a slash */
 646
 647             switch (c)
 648             {
 649             case '/':
 650
 651                 State = DT_NORMAL_TEXT;
 652                 break;
 653
 654             case '\n':
 655
 656                 CurrentLineOffset = Gbl_NextLineOffset;
 657                 Gbl_NextLineOffset = (UINT32) ftell (Handle);
 658                 Gbl_CurrentLineNumber++;
 659                 break;
 660
 661             case '*':
 662
 663                 /* Consume all adjacent asterisks */
 664                 break;
 665
 666             default:
 667
 668                 State = DT_SLASH_ASTERISK_COMMENT;
 669                 break;
 670             }
 671             break;
 672
 673         case DT_MERGE_LINES:
 674
 675             if (c != '\n')
 676             {
 677                 /*
 678                  * This is not a continuation backslash, it is a normal
 679                  * normal ASL backslash - for example: Scope(\_SB_)
 680                  */
 681                 i++; /* Keep the backslash that is already in the buffer */
 682
 683                 ungetc (c, Handle);
 684                 State = DT_NORMAL_TEXT;
 685             }
 686             else
 687             {
 688                 /*
 689                  * This is a continuation line -- a backlash followed
 690                  * immediately by a newline. Insert a space between the
 691                  * lines (overwrite the backslash)
 692                  */
 693                 Gbl_CurrentLineBuffer[i] = ' ';
 694                 i++;
 695
 696                 /* Ignore newline, this will merge the lines */
 697
 698                 CurrentLineOffset = Gbl_NextLineOffset;
 699                 Gbl_NextLineOffset = (UINT32) ftell (Handle);
 700                 Gbl_CurrentLineNumber++;
 701                 State = DT_NORMAL_TEXT;
 702             }
 703             break;
 704
 705         default:
 706
 707             DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, "Unknown input state");
 708             return (ASL_EOF);
 709         }
 710     }
 711 }
 712
 713
 714 /******************************************************************************
 715  *
 716  * FUNCTION:    DtScanFile
 717  *
 718  * PARAMETERS:  Handle              - Open file handle for the source file
 719  *
 720  * RETURN:      Pointer to start of the constructed parse tree.
 721  *
 722  * DESCRIPTION: Scan source file, link all field names and values
 723  *              to the global parse tree: Gbl_FieldList
 724  *
 725  *****************************************************************************/
 726
 727 DT_FIELD *
 728 DtScanFile (
 729     FILE                    *Handle)
 730 {
 731     ACPI_STATUS             Status;
 732     UINT32                  Offset;
 733
 734
 735     ACPI_FUNCTION_NAME (DtScanFile);
 736
 737
 738     /* Get the file size */
 739
 740     Gbl_InputByteCount = DtGetFileSize (Handle);
 741
 742     Gbl_CurrentLineNumber = 0;
 743     Gbl_CurrentLineOffset = 0;
 744     Gbl_NextLineOffset = 0;
 745
 746     /* Scan line-by-line */
 747
 748     while ((Offset = DtGetNextLine (Handle)) != ASL_EOF)
 749     {
 750         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Line %2.2u/%4.4X - %s",
 751             Gbl_CurrentLineNumber, Offset, Gbl_CurrentLineBuffer));
 752
 753         Status = DtParseLine (Gbl_CurrentLineBuffer, Gbl_CurrentLineNumber, Offset);
 754         if (Status == AE_NOT_FOUND)
 755         {
 756             break;
 757         }
 758     }
 759
 760     /* Dump the parse tree if debug enabled */
 761
 762     DtDumpFieldList (Gbl_FieldList);
 763     return (Gbl_FieldList);
 764 }
 765
 766
 767 /*
 768  * Output functions
 769  */
 770
 771 /******************************************************************************
 772  *
 773  * FUNCTION:    DtWriteBinary
 774  *
 775  * PARAMETERS:  DT_WALK_CALLBACK
 776  *
 777  * RETURN:      Status
 778  *
 779  * DESCRIPTION: Write one subtable of a binary ACPI table
 780  *
 781  *****************************************************************************/
 782
 783 static void
 784 DtWriteBinary (
 785     DT_SUBTABLE             *Subtable,
 786     void                    *Context,
 787     void                    *ReturnValue)
 788 {
 789
 790     FlWriteFile (ASL_FILE_AML_OUTPUT, Subtable->Buffer, Subtable->Length);
 791 }
 792
 793
 794 /******************************************************************************
 795  *
 796  * FUNCTION:    DtOutputBinary
 797  *
 798  * PARAMETERS:
 799  *
 800  * RETURN:      Status
 801  *
 802  * DESCRIPTION: Write entire binary ACPI table (result of compilation)
 803  *
 804  *****************************************************************************/
 805
 806 void
 807 DtOutputBinary (
 808     DT_SUBTABLE             *RootTable)
 809 {
 810
 811     if (!RootTable)
 812     {
 813         return;
 814     }
 815
 816     /* Walk the entire parse tree, emitting the binary data */
 817
 818     DtWalkTableTree (RootTable, DtWriteBinary, NULL, NULL);
 819     Gbl_TableLength = DtGetFileSize (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
 820 }
 821
 822
 823 /*
 824  * Listing support
 825  */
 826
 827 /******************************************************************************
 828  *
 829  * FUNCTION:    DtDumpBuffer
 830  *
 831  * PARAMETERS:  FileID              - Where to write buffer data
 832  *              Buffer              - Buffer to dump
 833  *              Offset              - Offset in current table
 834  *              Length              - Buffer Length
 835  *
 836  * RETURN:      None
 837  *
 838  * DESCRIPTION: Another copy of DumpBuffer routine (unfortunately).
 839  *
 840  * TBD: merge dump buffer routines
 841  *
 842  *****************************************************************************/
 843
 844 static void
 845 DtDumpBuffer (
 846     UINT32                  FileId,
 847     UINT8                   *Buffer,
 848     UINT32                  Offset,
 849     UINT32                  Length)
 850 {
 851     UINT32                  i;
 852     UINT32                  j;
 853     UINT8                   BufChar;
 854
 855
 856     FlPrintFile (FileId, "Output: [%3.3Xh %4.4d %3d] ",
 857         Offset, Offset, Length);
 858
 859     i = 0;
 860     while (i < Length)
 861     {
 862         if (i >= 16)
 863         {
 864             FlPrintFile (FileId, "%24s", "");
 865         }
 866
 867         /* Print 16 hex chars */
 868
 869         for (j = 0; j < 16;)
 870         {
 871             if (i + j >= Length)
 872             {
 873                 /* Dump fill spaces */
 874
 875                 FlPrintFile (FileId, "   ");
 876                 j++;
 877                 continue;
 878             }
 879
 880             FlPrintFile (FileId, "%02X ", Buffer[i+j]);
 881             j++;
 882         }
 883
 884         FlPrintFile (FileId, " ");
 885         for (j = 0; j < 16; j++)
 886         {
 887             if (i + j >= Length)
 888             {
 889                 FlPrintFile (FileId, "\n\n");
 890                 return;
 891             }
 892
 893             BufChar = Buffer[(ACPI_SIZE) i + j];
 894             if (ACPI_IS_PRINT (BufChar))
 895             {
 896                 FlPrintFile (FileId, "%c", BufChar);
 897             }
 898             else
 899             {
 900                 FlPrintFile (FileId, ".");
 901             }
 902         }
 903
 904         /* Done with that line. */
 905
 906         FlPrintFile (FileId, "\n");
 907         i += 16;
 908     }
 909
 910     FlPrintFile (FileId, "\n\n");
 911 }
 912
 913
 914 /******************************************************************************
 915  *
 916  * FUNCTION:    DtDumpFieldList
 917  *
 918  * PARAMETERS:  Field               - Root field
 919  *
 920  * RETURN:      None
 921  *
 922  * DESCRIPTION: Dump the entire field list
 923  *
 924  *****************************************************************************/
 925
 926 void
 927 DtDumpFieldList (
 928     DT_FIELD                *Field)
 929 {
 930
 931     if (!Gbl_DebugFlag || !Field)
 932     {
 933         return;
 934     }
 935
 936     DbgPrint (ASL_DEBUG_OUTPUT,  "\nField List:\n"
 937         "LineNo   ByteOff  NameCol  Column   TableOff "
 938         "Flags    %32s : %s\n\n", "Name", "Value");
 939     while (Field)
 940     {
 941         DbgPrint (ASL_DEBUG_OUTPUT,
 942             "%.08X %.08X %.08X %.08X %.08X %.08X %32s : %s\n",
 943             Field->Line, Field->ByteOffset, Field->NameColumn,
 944             Field->Column, Field->TableOffset, Field->Flags,
 945             Field->Name, Field->Value);
 946
 947         Field = Field->Next;
 948     }
 949
 950     DbgPrint (ASL_DEBUG_OUTPUT,  "\n\n");
 951 }
 952
 953
 954 /******************************************************************************
 955  *
 956  * FUNCTION:    DtDumpSubtableInfo, DtDumpSubtableTree
 957  *
 958  * PARAMETERS:  DT_WALK_CALLBACK
 959  *
 960  * RETURN:      None
 961  *
 962  * DESCRIPTION: Info - dump a subtable tree entry with extra information.
 963  *              Tree - dump a subtable tree formatted by depth indentation.
 964  *
 965  *****************************************************************************/
 966
 967 static void
 968 DtDumpSubtableInfo (
 969     DT_SUBTABLE             *Subtable,
 970     void                    *Context,
 971     void                    *ReturnValue)
 972 {
 973
 974     DbgPrint (ASL_DEBUG_OUTPUT,
 975         "[%.04X] %.08X %.08X %.08X %.08X %.08X %p %p %p\n",
 976         Subtable->Depth, Subtable->Length, Subtable->TotalLength,
 977         Subtable->SizeOfLengthField, Subtable->Flags, Subtable,
 978         Subtable->Parent, Subtable->Child, Subtable->Peer);
 979 }
 980
 981 static void
 982 DtDumpSubtableTree (
 983     DT_SUBTABLE             *Subtable,
 984     void                    *Context,
 985     void                    *ReturnValue)
 986 {
 987
 988     DbgPrint (ASL_DEBUG_OUTPUT,
 989         "[%.04X] %*s%08X (%.02X) - (%.02X)\n",
 990         Subtable->Depth, (4 * Subtable->Depth), " ",
 991         Subtable, Subtable->Length, Subtable->TotalLength);
 992 }
 993
 994
 995 /******************************************************************************
 996  *
 997  * FUNCTION:    DtDumpSubtableList
 998  *
 999  * PARAMETERS:  None
1000  *
1001  * RETURN:      None
1002  *
1003  * DESCRIPTION: Dump the raw list of subtables with information, and also
1004  *              dump the subtable list in formatted tree format. Assists with
1005  *              the development of new table code.
1006  *
1007  *****************************************************************************/
1008
1009 void
1010 DtDumpSubtableList (
1011     void)
1012 {
1013
1014     if (!Gbl_DebugFlag || !Gbl_RootTable)
1015     {
1016         return;
1017     }
1018
1019     DbgPrint (ASL_DEBUG_OUTPUT,
1020         "Subtable Info:\n"
1021         "Depth  Length   TotalLen LenSize  Flags    "
1022         "This     Parent   Child    Peer\n\n");
1023     DtWalkTableTree (Gbl_RootTable, DtDumpSubtableInfo, NULL, NULL);
1024
1025     DbgPrint (ASL_DEBUG_OUTPUT,
1026         "\nSubtable Tree: (Depth, Subtable, Length, TotalLength)\n\n");
1027     DtWalkTableTree (Gbl_RootTable, DtDumpSubtableTree, NULL, NULL);
1028 }
1029
1030
1031 /******************************************************************************
1032  *
1033  * FUNCTION:    DtWriteFieldToListing
1034  *
1035  * PARAMETERS:  Buffer              - Contains the compiled data
1036  *              Field               - Field node for the input line
1037  *              Length              - Length of the output data
1038  *
1039  * RETURN:      None
1040  *
1041  * DESCRIPTION: Write one field to the listing file (if listing is enabled).
1042  *
1043  *****************************************************************************/
1044
1045 void
1046 DtWriteFieldToListing (
1047     UINT8                   *Buffer,
1048     DT_FIELD                *Field,
1049     UINT32                  Length)
1050 {
1051     UINT8                   FileByte;
1052
1053
1054     if (!Gbl_ListingFlag || !Field)
1055     {
1056         return;
1057     }
1058
1059     /* Dump the original source line */
1060
1061     FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Input:  ");
1062     FlSeekFile (ASL_FILE_INPUT, Field->ByteOffset);
1063
1064     while (FlReadFile (ASL_FILE_INPUT, &FileByte, 1) == AE_OK)
1065     {
1066         FlWriteFile (ASL_FILE_LISTING_OUTPUT, &FileByte, 1);
1067         if (FileByte == '\n')
1068         {
1069             break;
1070         }
1071     }
1072
1073     /* Dump the line as parsed and represented internally */
1074
1075     FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Parsed: %*s : %.64s",
1076         Field->Column-4, Field->Name, Field->Value);
1077
1078     if (strlen (Field->Value) > 64)
1079     {
1080         FlPrintFile (ASL_FILE_LISTING_OUTPUT, "...Additional data, length 0x%X\n",
1081             strlen (Field->Value));
1082     }
1083     FlPrintFile (ASL_FILE_LISTING_OUTPUT, "\n");
1084
1085     /* Dump the hex data that will be output for this field */
1086
1087     DtDumpBuffer (ASL_FILE_LISTING_OUTPUT, Buffer, Field->TableOffset, Length);
1088 }
1089
1090
1091 /******************************************************************************
1092  *
1093  * FUNCTION:    DtWriteTableToListing
1094  *
1095  * PARAMETERS:  None
1096  *
1097  * RETURN:      None
1098  *
1099  * DESCRIPTION: Write the entire compiled table to the listing file
1100  *              in hex format
1101  *
1102  *****************************************************************************/
1103
1104 void
1105 DtWriteTableToListing (
1106     void)
1107 {
1108     UINT8                   *Buffer;
1109
1110
1111     if (!Gbl_ListingFlag)
1112     {
1113         return;
1114     }
1115
1116     /* Read the entire table from the output file */
1117
1118     Buffer = UtLocalCalloc (Gbl_TableLength);
1119     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
1120     FlReadFile (ASL_FILE_AML_OUTPUT, Buffer, Gbl_TableLength);
1121
1122     /* Dump the raw table data */
1123
1124     AcpiOsRedirectOutput (Gbl_Files[ASL_FILE_LISTING_OUTPUT].Handle);
1125
1126     AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n",
1127         ACPI_RAW_TABLE_DATA_HEADER, Gbl_TableLength, Gbl_TableLength);
1128     AcpiUtDumpBuffer (Buffer, Gbl_TableLength, DB_BYTE_DISPLAY, 0);
1129
1130     AcpiOsRedirectOutput (stdout);
1131     ACPI_FREE (Buffer);
1132 }