xref: /freebsd/sys/contrib/dev/acpica/compiler/dtio.c (revision f5f7c05209ca2c3748fd8b27c5e80ffad49120eb)
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 <contrib/dev/acpica/compiler/aslcompiler.h>
47 #include <contrib/dev/acpica/compiler/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             Start++;
293             continue;
294         }
295 
296         /* Found left bracket, go to the right bracket */
297 
298         if (*Start == '[')
299         {
300             while (Start < Colon && *Start != ']')
301             {
302                 Start++;
303             }
304 
305             if (Start == Colon)
306             {
307                 break;
308             }
309 
310             Start++;
311             continue;
312         }
313 
314         break;
315     }
316 
317     /*
318      * There are two column values. One for the field name,
319      * and one for the field value.
320      */
321     Column = ACPI_PTR_DIFF (Colon, LineBuffer) + 3;
322     NameColumn = ACPI_PTR_DIFF (Start, LineBuffer) + 1;
323 
324     Length = ACPI_PTR_DIFF (End, Start);
325 
326     TmpName = UtLocalCalloc (Length + 1);
327     ACPI_STRNCPY (TmpName, Start, Length);
328     Name = DtTrim (TmpName);
329     ACPI_FREE (TmpName);
330 
331     Start = End = (Colon + 1);
332     while (*End)
333     {
334         /* Found left quotation, go to the right quotation and break */
335 
336         if (*End == '"')
337         {
338             End++;
339 
340             /* Check for an explicit null string */
341 
342             if (*End == '"')
343             {
344                 IsNullString = TRUE;
345             }
346             while (*End && (*End != '"'))
347             {
348                 End++;
349             }
350 
351             End++;
352             break;
353         }
354 
355         /*
356          * Special "comment" fields at line end, ignore them.
357          * Note: normal slash-slash and slash-asterisk comments are
358          * stripped already by the DtGetNextLine parser.
359          *
360          * TBD: Perhaps DtGetNextLine should parse the following type
361          * of comments also.
362          */
363         if (*End == '[')
364         {
365             End--;
366             break;
367         }
368         End++;
369     }
370 
371     Length = ACPI_PTR_DIFF (End, Start);
372     TmpValue = UtLocalCalloc (Length + 1);
373 
374     ACPI_STRNCPY (TmpValue, Start, Length);
375     Value = DtTrim (TmpValue);
376     ACPI_FREE (TmpValue);
377 
378     /* Create a new field object only if we have a valid value field */
379 
380     if ((Value && *Value) || IsNullString)
381     {
382         Field = UtLocalCalloc (sizeof (DT_FIELD));
383         Field->Name = Name;
384         Field->Value = Value;
385         Field->Line = Line;
386         Field->ByteOffset = Offset;
387         Field->NameColumn = NameColumn;
388         Field->Column = Column;
389 
390         DtLinkField (Field);
391     }
392     else /* Ignore this field, it has no valid data */
393     {
394         ACPI_FREE (Name);
395         ACPI_FREE (Value);
396     }
397 
398     return (AE_OK);
399 }
400 
401 
402 /******************************************************************************
403  *
404  * FUNCTION:    DtGetNextLine
405  *
406  * PARAMETERS:  Handle              - Open file handle for the source file
407  *
408  * RETURN:      Filled line buffer and offset of start-of-line (ASL_EOF on EOF)
409  *
410  * DESCRIPTION: Get the next valid source line. Removes all comments.
411  *              Ignores empty lines.
412  *
413  * Handles both slash-asterisk and slash-slash comments.
414  * Also, quoted strings, but no escapes within.
415  *
416  * Line is returned in Gbl_CurrentLineBuffer.
417  * Line number in original file is returned in Gbl_CurrentLineNumber.
418  *
419  *****************************************************************************/
420 
421 UINT32
422 DtGetNextLine (
423     FILE                    *Handle)
424 {
425     BOOLEAN                 LineNotAllBlanks = FALSE;
426     UINT32                  State = DT_NORMAL_TEXT;
427     UINT32                  CurrentLineOffset;
428     UINT32                  i;
429     char                    c;
430 
431 
432     for (i = 0; ;)
433     {
434         /*
435          * If line is too long, expand the line buffers. Also increases
436          * Gbl_LineBufferSize.
437          */
438         if (i >= Gbl_LineBufferSize)
439         {
440             UtExpandLineBuffers ();
441         }
442 
443         c = (char) getc (Handle);
444         if (c == EOF)
445         {
446             switch (State)
447             {
448             case DT_START_QUOTED_STRING:
449             case DT_SLASH_ASTERISK_COMMENT:
450 
451                 AcpiOsPrintf ("**** EOF within comment/string %u\n", State);
452                 break;
453 
454             default:
455                 break;
456             }
457 
458             /* Standalone EOF is OK */
459 
460             if (i == 0)
461             {
462                 return (ASL_EOF);
463             }
464 
465             /*
466              * Received an EOF in the middle of a line. Terminate the
467              * line with a newline. The next call to this function will
468              * return a standalone EOF. Thus, the upper parsing software
469              * never has to deal with an EOF within a valid line (or
470              * the last line does not get tossed on the floor.)
471              */
472             c = '\n';
473             State = DT_NORMAL_TEXT;
474         }
475 
476         switch (State)
477         {
478         case DT_NORMAL_TEXT:
479 
480             /* Normal text, insert char into line buffer */
481 
482             Gbl_CurrentLineBuffer[i] = c;
483             switch (c)
484             {
485             case '/':
486                 State = DT_START_COMMENT;
487                 break;
488 
489             case '"':
490                 State = DT_START_QUOTED_STRING;
491                 LineNotAllBlanks = TRUE;
492                 i++;
493                 break;
494 
495             case '\\':
496                 /*
497                  * The continuation char MUST be last char on this line.
498                  * Otherwise, it will be assumed to be a valid ASL char.
499                  */
500                 State = DT_MERGE_LINES;
501                 break;
502 
503             case '\n':
504                 CurrentLineOffset = Gbl_NextLineOffset;
505                 Gbl_NextLineOffset = (UINT32) ftell (Handle);
506                 Gbl_CurrentLineNumber++;
507 
508                 /*
509                  * Exit if line is complete. Ignore empty lines (only \n)
510                  * or lines that contain nothing but blanks.
511                  */
512                 if ((i != 0) && LineNotAllBlanks)
513                 {
514                     if ((i + 1) >= Gbl_LineBufferSize)
515                     {
516                         UtExpandLineBuffers ();
517                     }
518 
519                     Gbl_CurrentLineBuffer[i+1] = 0; /* Terminate string */
520                     return (CurrentLineOffset);
521                 }
522 
523                 /* Toss this line and start a new one */
524 
525                 i = 0;
526                 LineNotAllBlanks = FALSE;
527                 break;
528 
529             default:
530                 if (c != ' ')
531                 {
532                     LineNotAllBlanks = TRUE;
533                 }
534 
535                 i++;
536                 break;
537             }
538             break;
539 
540         case DT_START_QUOTED_STRING:
541 
542             /* Insert raw chars until end of quoted string */
543 
544             Gbl_CurrentLineBuffer[i] = c;
545             i++;
546 
547             switch (c)
548             {
549             case '"':
550                 State = DT_NORMAL_TEXT;
551                 break;
552 
553             case '\\':
554                 State = DT_ESCAPE_SEQUENCE;
555                 break;
556 
557             case '\n':
558                 AcpiOsPrintf ("ERROR at line %u: Unterminated quoted string\n",
559                     Gbl_CurrentLineNumber++);
560                 State = DT_NORMAL_TEXT;
561                 break;
562 
563             default:    /* Get next character */
564                 break;
565             }
566             break;
567 
568         case DT_ESCAPE_SEQUENCE:
569 
570             /* Just copy the escaped character. TBD: sufficient for table compiler? */
571 
572             Gbl_CurrentLineBuffer[i] = c;
573             i++;
574             State = DT_START_QUOTED_STRING;
575             break;
576 
577         case DT_START_COMMENT:
578 
579             /* Open comment if this character is an asterisk or slash */
580 
581             switch (c)
582             {
583             case '*':
584                 State = DT_SLASH_ASTERISK_COMMENT;
585                 break;
586 
587             case '/':
588                 State = DT_SLASH_SLASH_COMMENT;
589                 break;
590 
591             default:    /* Not a comment */
592                 i++;    /* Save the preceding slash */
593                 if (i >= Gbl_LineBufferSize)
594                 {
595                     UtExpandLineBuffers ();
596                 }
597 
598                 Gbl_CurrentLineBuffer[i] = c;
599                 i++;
600                 State = DT_NORMAL_TEXT;
601                 break;
602             }
603             break;
604 
605         case DT_SLASH_ASTERISK_COMMENT:
606 
607             /* Ignore chars until an asterisk-slash is found */
608 
609             switch (c)
610             {
611             case '\n':
612                 Gbl_NextLineOffset = (UINT32) ftell (Handle);
613                 Gbl_CurrentLineNumber++;
614                 break;
615 
616             case '*':
617                 State = DT_END_COMMENT;
618                 break;
619 
620             default:
621                 break;
622             }
623             break;
624 
625         case DT_SLASH_SLASH_COMMENT:
626 
627             /* Ignore chars until end-of-line */
628 
629             if (c == '\n')
630             {
631                 /* We will exit via the NORMAL_TEXT path */
632 
633                 ungetc (c, Handle);
634                 State = DT_NORMAL_TEXT;
635             }
636             break;
637 
638         case DT_END_COMMENT:
639 
640             /* End comment if this char is a slash */
641 
642             switch (c)
643             {
644             case '/':
645                 State = DT_NORMAL_TEXT;
646                 break;
647 
648             case '\n':
649                 CurrentLineOffset = Gbl_NextLineOffset;
650                 Gbl_NextLineOffset = (UINT32) ftell (Handle);
651                 Gbl_CurrentLineNumber++;
652                 break;
653 
654             case '*':
655                 /* Consume all adjacent asterisks */
656                 break;
657 
658             default:
659                 State = DT_SLASH_ASTERISK_COMMENT;
660                 break;
661             }
662             break;
663 
664         case DT_MERGE_LINES:
665 
666             if (c != '\n')
667             {
668                 /*
669                  * This is not a continuation backslash, it is a normal
670                  * normal ASL backslash - for example: Scope(\_SB_)
671                  */
672                 i++; /* Keep the backslash that is already in the buffer */
673 
674                 ungetc (c, Handle);
675                 State = DT_NORMAL_TEXT;
676             }
677             else
678             {
679                 /*
680                  * This is a continuation line -- a backlash followed
681                  * immediately by a newline. Insert a space between the
682                  * lines (overwrite the backslash)
683                  */
684                 Gbl_CurrentLineBuffer[i] = ' ';
685                 i++;
686 
687                 /* Ignore newline, this will merge the lines */
688 
689                 CurrentLineOffset = Gbl_NextLineOffset;
690                 Gbl_NextLineOffset = (UINT32) ftell (Handle);
691                 Gbl_CurrentLineNumber++;
692                 State = DT_NORMAL_TEXT;
693             }
694             break;
695 
696         default:
697             DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, "Unknown input state");
698             return (ASL_EOF);
699         }
700     }
701 }
702 
703 
704 /******************************************************************************
705  *
706  * FUNCTION:    DtScanFile
707  *
708  * PARAMETERS:  Handle              - Open file handle for the source file
709  *
710  * RETURN:      Pointer to start of the constructed parse tree.
711  *
712  * DESCRIPTION: Scan source file, link all field names and values
713  *              to the global parse tree: Gbl_FieldList
714  *
715  *****************************************************************************/
716 
717 DT_FIELD *
718 DtScanFile (
719     FILE                    *Handle)
720 {
721     ACPI_STATUS             Status;
722     UINT32                  Offset;
723 
724 
725     ACPI_FUNCTION_NAME (DtScanFile);
726 
727 
728     /* Get the file size */
729 
730     Gbl_InputByteCount = DtGetFileSize (Handle);
731 
732     Gbl_CurrentLineNumber = 0;
733     Gbl_CurrentLineOffset = 0;
734     Gbl_NextLineOffset = 0;
735 
736     /* Scan line-by-line */
737 
738     while ((Offset = DtGetNextLine (Handle)) != ASL_EOF)
739     {
740         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Line %2.2u/%4.4X - %s",
741             Gbl_CurrentLineNumber, Offset, Gbl_CurrentLineBuffer));
742 
743         Status = DtParseLine (Gbl_CurrentLineBuffer, Gbl_CurrentLineNumber, Offset);
744         if (Status == AE_NOT_FOUND)
745         {
746             break;
747         }
748     }
749 
750     /* Dump the parse tree if debug enabled */
751 
752     DtDumpFieldList (Gbl_FieldList);
753     return (Gbl_FieldList);
754 }
755 
756 
757 /*
758  * Output functions
759  */
760 
761 /******************************************************************************
762  *
763  * FUNCTION:    DtWriteBinary
764  *
765  * PARAMETERS:  DT_WALK_CALLBACK
766  *
767  * RETURN:      Status
768  *
769  * DESCRIPTION: Write one subtable of a binary ACPI table
770  *
771  *****************************************************************************/
772 
773 static void
774 DtWriteBinary (
775     DT_SUBTABLE             *Subtable,
776     void                    *Context,
777     void                    *ReturnValue)
778 {
779 
780     FlWriteFile (ASL_FILE_AML_OUTPUT, Subtable->Buffer, Subtable->Length);
781 }
782 
783 
784 /******************************************************************************
785  *
786  * FUNCTION:    DtOutputBinary
787  *
788  * PARAMETERS:
789  *
790  * RETURN:      Status
791  *
792  * DESCRIPTION: Write entire binary ACPI table (result of compilation)
793  *
794  *****************************************************************************/
795 
796 void
797 DtOutputBinary (
798     DT_SUBTABLE             *RootTable)
799 {
800 
801     if (!RootTable)
802     {
803         return;
804     }
805 
806     /* Walk the entire parse tree, emitting the binary data */
807 
808     DtWalkTableTree (RootTable, DtWriteBinary, NULL, NULL);
809     Gbl_TableLength = DtGetFileSize (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
810 }
811 
812 
813 /*
814  * Listing support
815  */
816 
817 /******************************************************************************
818  *
819  * FUNCTION:    DtDumpBuffer
820  *
821  * PARAMETERS:  FileID              - Where to write buffer data
822  *              Buffer              - Buffer to dump
823  *              Offset              - Offset in current table
824  *              Length              - Buffer Length
825  *
826  * RETURN:      None
827  *
828  * DESCRIPTION: Another copy of DumpBuffer routine (unfortunately).
829  *
830  * TBD: merge dump buffer routines
831  *
832  *****************************************************************************/
833 
834 static void
835 DtDumpBuffer (
836     UINT32                  FileId,
837     UINT8                   *Buffer,
838     UINT32                  Offset,
839     UINT32                  Length)
840 {
841     UINT32                  i;
842     UINT32                  j;
843     UINT8                   BufChar;
844 
845 
846     FlPrintFile (FileId, "Output: [%3.3Xh %4.4d %3d] ",
847         Offset, Offset, Length);
848 
849     i = 0;
850     while (i < Length)
851     {
852         if (i >= 16)
853         {
854             FlPrintFile (FileId, "%24s", "");
855         }
856 
857         /* Print 16 hex chars */
858 
859         for (j = 0; j < 16;)
860         {
861             if (i + j >= Length)
862             {
863                 /* Dump fill spaces */
864 
865                 FlPrintFile (FileId, "   ");
866                 j++;
867                 continue;
868             }
869 
870             FlPrintFile (FileId, "%02X ", Buffer[i+j]);
871             j++;
872         }
873 
874         FlPrintFile (FileId, " ");
875         for (j = 0; j < 16; j++)
876         {
877             if (i + j >= Length)
878             {
879                 FlPrintFile (FileId, "\n\n");
880                 return;
881             }
882 
883             BufChar = Buffer[(ACPI_SIZE) i + j];
884             if (ACPI_IS_PRINT (BufChar))
885             {
886                 FlPrintFile (FileId, "%c", BufChar);
887             }
888             else
889             {
890                 FlPrintFile (FileId, ".");
891             }
892         }
893 
894         /* Done with that line. */
895 
896         FlPrintFile (FileId, "\n");
897         i += 16;
898     }
899 
900     FlPrintFile (FileId, "\n\n");
901 }
902 
903 
904 /******************************************************************************
905  *
906  * FUNCTION:    DtDumpFieldList
907  *
908  * PARAMETERS:  Field               - Root field
909  *
910  * RETURN:      None
911  *
912  * DESCRIPTION: Dump the entire field list
913  *
914  *****************************************************************************/
915 
916 void
917 DtDumpFieldList (
918     DT_FIELD                *Field)
919 {
920 
921     if (!Gbl_DebugFlag || !Field)
922     {
923         return;
924     }
925 
926     DbgPrint (ASL_DEBUG_OUTPUT,  "\nField List:\n"
927         "LineNo   ByteOff  NameCol  Column   TableOff "
928         "Flags    %32s : %s\n\n", "Name", "Value");
929     while (Field)
930     {
931         DbgPrint (ASL_DEBUG_OUTPUT,
932             "%.08X %.08X %.08X %.08X %.08X %.08X %32s : %s\n",
933             Field->Line, Field->ByteOffset, Field->NameColumn,
934             Field->Column, Field->TableOffset, Field->Flags,
935             Field->Name, Field->Value);
936 
937         Field = Field->Next;
938     }
939 
940     DbgPrint (ASL_DEBUG_OUTPUT,  "\n\n");
941 }
942 
943 
944 /******************************************************************************
945  *
946  * FUNCTION:    DtDumpSubtableInfo, DtDumpSubtableTree
947  *
948  * PARAMETERS:  DT_WALK_CALLBACK
949  *
950  * RETURN:      None
951  *
952  * DESCRIPTION: Info - dump a subtable tree entry with extra information.
953  *              Tree - dump a subtable tree formatted by depth indentation.
954  *
955  *****************************************************************************/
956 
957 static void
958 DtDumpSubtableInfo (
959     DT_SUBTABLE             *Subtable,
960     void                    *Context,
961     void                    *ReturnValue)
962 {
963 
964     DbgPrint (ASL_DEBUG_OUTPUT,
965         "[%.04X] %.08X %.08X %.08X %.08X %.08X %p %p %p\n",
966         Subtable->Depth, Subtable->Length, Subtable->TotalLength,
967         Subtable->SizeOfLengthField, Subtable->Flags, Subtable,
968         Subtable->Parent, Subtable->Child, Subtable->Peer);
969 }
970 
971 static void
972 DtDumpSubtableTree (
973     DT_SUBTABLE             *Subtable,
974     void                    *Context,
975     void                    *ReturnValue)
976 {
977 
978     DbgPrint (ASL_DEBUG_OUTPUT,
979         "[%.04X] %*s%08X (%.02X) - (%.02X)\n",
980         Subtable->Depth, (4 * Subtable->Depth), " ",
981         Subtable, Subtable->Length, Subtable->TotalLength);
982 }
983 
984 
985 /******************************************************************************
986  *
987  * FUNCTION:    DtDumpSubtableList
988  *
989  * PARAMETERS:  None
990  *
991  * RETURN:      None
992  *
993  * DESCRIPTION: Dump the raw list of subtables with information, and also
994  *              dump the subtable list in formatted tree format. Assists with
995  *              the development of new table code.
996  *
997  *****************************************************************************/
998 
999 void
1000 DtDumpSubtableList (
1001     void)
1002 {
1003 
1004     if (!Gbl_DebugFlag || !Gbl_RootTable)
1005     {
1006         return;
1007     }
1008 
1009     DbgPrint (ASL_DEBUG_OUTPUT,
1010         "Subtable Info:\n"
1011         "Depth  Length   TotalLen LenSize  Flags    "
1012         "This     Parent   Child    Peer\n\n");
1013     DtWalkTableTree (Gbl_RootTable, DtDumpSubtableInfo, NULL, NULL);
1014 
1015     DbgPrint (ASL_DEBUG_OUTPUT,
1016         "\nSubtable Tree: (Depth, Subtable, Length, TotalLength)\n\n");
1017     DtWalkTableTree (Gbl_RootTable, DtDumpSubtableTree, NULL, NULL);
1018 }
1019 
1020 
1021 /******************************************************************************
1022  *
1023  * FUNCTION:    DtWriteFieldToListing
1024  *
1025  * PARAMETERS:  Buffer              - Contains the compiled data
1026  *              Field               - Field node for the input line
1027  *              Length              - Length of the output data
1028  *
1029  * RETURN:      None
1030  *
1031  * DESCRIPTION: Write one field to the listing file (if listing is enabled).
1032  *
1033  *****************************************************************************/
1034 
1035 void
1036 DtWriteFieldToListing (
1037     UINT8                   *Buffer,
1038     DT_FIELD                *Field,
1039     UINT32                  Length)
1040 {
1041     UINT8                   FileByte;
1042 
1043 
1044     if (!Gbl_ListingFlag || !Field)
1045     {
1046         return;
1047     }
1048 
1049     /* Dump the original source line */
1050 
1051     FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Input:  ");
1052     FlSeekFile (ASL_FILE_INPUT, Field->ByteOffset);
1053 
1054     while (FlReadFile (ASL_FILE_INPUT, &FileByte, 1) == AE_OK)
1055     {
1056         FlWriteFile (ASL_FILE_LISTING_OUTPUT, &FileByte, 1);
1057         if (FileByte == '\n')
1058         {
1059             break;
1060         }
1061     }
1062 
1063     /* Dump the line as parsed and represented internally */
1064 
1065     FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Parsed: %*s : %.64s",
1066         Field->Column-4, Field->Name, Field->Value);
1067 
1068     if (strlen (Field->Value) > 64)
1069     {
1070         FlPrintFile (ASL_FILE_LISTING_OUTPUT, "...Additional data, length 0x%X\n",
1071             strlen (Field->Value));
1072     }
1073     FlPrintFile (ASL_FILE_LISTING_OUTPUT, "\n");
1074 
1075     /* Dump the hex data that will be output for this field */
1076 
1077     DtDumpBuffer (ASL_FILE_LISTING_OUTPUT, Buffer, Field->TableOffset, Length);
1078 }
1079 
1080 
1081 /******************************************************************************
1082  *
1083  * FUNCTION:    DtWriteTableToListing
1084  *
1085  * PARAMETERS:  None
1086  *
1087  * RETURN:      None
1088  *
1089  * DESCRIPTION: Write the entire compiled table to the listing file
1090  *              in hex format
1091  *
1092  *****************************************************************************/
1093 
1094 void
1095 DtWriteTableToListing (
1096     void)
1097 {
1098     UINT8                   *Buffer;
1099 
1100 
1101     if (!Gbl_ListingFlag)
1102     {
1103         return;
1104     }
1105 
1106     /* Read the entire table from the output file */
1107 
1108     Buffer = UtLocalCalloc (Gbl_TableLength);
1109     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
1110     FlReadFile (ASL_FILE_AML_OUTPUT, Buffer, Gbl_TableLength);
1111 
1112     /* Dump the raw table data */
1113 
1114     AcpiOsRedirectOutput (Gbl_Files[ASL_FILE_LISTING_OUTPUT].Handle);
1115 
1116     AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n",
1117         ACPI_RAW_TABLE_DATA_HEADER, Gbl_TableLength, Gbl_TableLength);
1118     AcpiUtDumpBuffer (Buffer, Gbl_TableLength, DB_BYTE_DISPLAY, 0);
1119 
1120     AcpiOsRedirectOutput (stdout);
1121 }
1122