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