summaryrefslogtreecommitdiffstats
path: root/source/compiler/dtio.c
diff options
context:
space:
mode:
Diffstat (limited to 'source/compiler/dtio.c')
-rw-r--r--source/compiler/dtio.c963
1 files changed, 963 insertions, 0 deletions
diff --git a/source/compiler/dtio.c b/source/compiler/dtio.c
new file mode 100644
index 0000000..0fe0f38
--- /dev/null
+++ b/source/compiler/dtio.c
@@ -0,0 +1,963 @@
+/******************************************************************************
+ *
+ * Module Name: dtio.c - File I/O support for data table compiler
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2012, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions, and the following disclaimer,
+ * without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ * substantially similar to the "NO WARRANTY" disclaimer below
+ * ("Disclaimer") and any redistribution must be conditioned upon
+ * including a substantially similar Disclaimer requirement for further
+ * binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ * of any contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#define __DTIO_C__
+
+#include "aslcompiler.h"
+#include "dtcompiler.h"
+
+#define _COMPONENT DT_COMPILER
+ ACPI_MODULE_NAME ("dtio")
+
+
+/* Local prototypes */
+
+static char *
+DtTrim (
+ char *String);
+
+static void
+DtLinkField (
+ DT_FIELD *Field);
+
+static ACPI_STATUS
+DtParseLine (
+ char *LineBuffer,
+ UINT32 Line,
+ UINT32 Offset);
+
+UINT32
+DtGetNextLine (
+ FILE *Handle);
+
+static void
+DtWriteBinary (
+ DT_SUBTABLE *Subtable,
+ void *Context,
+ void *ReturnValue);
+
+static void
+DtDumpBuffer (
+ UINT32 FileId,
+ UINT8 *Buffer,
+ UINT32 Offset,
+ UINT32 Length);
+
+
+/* States for DtGetNextLine */
+
+#define DT_NORMAL_TEXT 0
+#define DT_START_QUOTED_STRING 1
+#define DT_START_COMMENT 2
+#define DT_SLASH_ASTERISK_COMMENT 3
+#define DT_SLASH_SLASH_COMMENT 4
+#define DT_END_COMMENT 5
+#define DT_MERGE_LINES 6
+
+static UINT32 Gbl_NextLineOffset;
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtTrim
+ *
+ * PARAMETERS: String - Current source code line to trim
+ *
+ * RETURN: Trimmed line. Must be freed by caller.
+ *
+ * DESCRIPTION: Trim left and right spaces
+ *
+ *****************************************************************************/
+
+static char *
+DtTrim (
+ char *String)
+{
+ char *Start;
+ char *End;
+ char *ReturnString;
+ ACPI_SIZE Length;
+
+
+ /* Skip lines that start with a space */
+
+ if (!ACPI_STRCMP (String, " "))
+ {
+ ReturnString = UtLocalCalloc (1);
+ return (ReturnString);
+ }
+
+ /* Setup pointers to start and end of input string */
+
+ Start = String;
+ End = String + ACPI_STRLEN (String) - 1;
+
+ /* Find first non-whitespace character */
+
+ while ((Start <= End) && ((*Start == ' ') || (*Start == '\t')))
+ {
+ Start++;
+ }
+
+ /* Find last non-space character */
+
+ while (End >= Start)
+ {
+ if (*End == '\r' || *End == '\n')
+ {
+ End--;
+ continue;
+ }
+
+ if (*End != ' ')
+ {
+ break;
+ }
+
+ End--;
+ }
+
+ /* Remove any quotes around the string */
+
+ if (*Start == '\"')
+ {
+ Start++;
+ }
+ if (*End == '\"')
+ {
+ End--;
+ }
+
+ /* Create the trimmed return string */
+
+ Length = ACPI_PTR_DIFF (End, Start) + 1;
+ ReturnString = UtLocalCalloc (Length + 1);
+ if (ACPI_STRLEN (Start))
+ {
+ ACPI_STRNCPY (ReturnString, Start, Length);
+ }
+
+ ReturnString[Length] = 0;
+ return (ReturnString);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtLinkField
+ *
+ * PARAMETERS: Field - New field object to link
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Link one field name and value to the list
+ *
+ *****************************************************************************/
+
+static void
+DtLinkField (
+ DT_FIELD *Field)
+{
+ DT_FIELD *Prev;
+ DT_FIELD *Next;
+
+
+ Prev = Next = Gbl_FieldList;
+
+ while (Next)
+ {
+ Prev = Next;
+ Next = Next->Next;
+ }
+
+ if (Prev)
+ {
+ Prev->Next = Field;
+ }
+ else
+ {
+ Gbl_FieldList = Field;
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtParseLine
+ *
+ * PARAMETERS: LineBuffer - Current source code line
+ * Line - Current line number in the source
+ * Offset - Current byte offset of the line
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Parse one source line
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+DtParseLine (
+ char *LineBuffer,
+ UINT32 Line,
+ UINT32 Offset)
+{
+ char *Start;
+ char *End;
+ char *TmpName;
+ char *TmpValue;
+ char *Name;
+ char *Value;
+ char *Colon;
+ UINT32 Length;
+ DT_FIELD *Field;
+ UINT32 Column;
+ UINT32 NameColumn;
+ BOOLEAN IsNullString = FALSE;
+
+
+ if (!LineBuffer)
+ {
+ return (AE_OK);
+ }
+
+ /* All lines after "Raw Table Data" are ingored */
+
+ if (strstr (LineBuffer, ACPI_RAW_TABLE_DATA_HEADER))
+ {
+ return (AE_NOT_FOUND);
+ }
+
+ Colon = strchr (LineBuffer, ':');
+ if (!Colon)
+ {
+ return (AE_OK);
+ }
+
+ Start = LineBuffer;
+ End = Colon;
+
+ while (Start < Colon)
+ {
+ if (*Start == ' ')
+ {
+ Start++;
+ continue;
+ }
+
+ /* Found left bracket, go to the right bracket */
+
+ if (*Start == '[')
+ {
+ while (Start < Colon && *Start != ']')
+ {
+ Start++;
+ }
+
+ if (Start == Colon)
+ {
+ break;
+ }
+
+ Start++;
+ continue;
+ }
+
+ break;
+ }
+
+ /*
+ * There are two column values. One for the field name,
+ * and one for the field value.
+ */
+ Column = ACPI_PTR_DIFF (Colon, LineBuffer) + 3;
+ NameColumn = ACPI_PTR_DIFF (Start, LineBuffer) + 1;
+
+ Length = ACPI_PTR_DIFF (End, Start);
+
+ TmpName = UtLocalCalloc (Length + 1);
+ ACPI_STRNCPY (TmpName, Start, Length);
+ Name = DtTrim (TmpName);
+ ACPI_FREE (TmpName);
+
+ Start = End = (Colon + 1);
+ while (*End)
+ {
+ /* Found left quotation, go to the right quotation and break */
+
+ if (*End == '"')
+ {
+ End++;
+
+ /* Check for an explicit null string */
+
+ if (*End == '"')
+ {
+ IsNullString = TRUE;
+ }
+ while (*End && (*End != '"'))
+ {
+ End++;
+ }
+
+ End++;
+ break;
+ }
+
+ /*
+ * Special "comment" fields at line end, ignore them.
+ * Note: normal slash-slash and slash-asterisk comments are
+ * stripped already by the DtGetNextLine parser.
+ *
+ * TBD: Perhaps DtGetNextLine should parse the following type
+ * of comments also.
+ */
+ if (*End == '[')
+ {
+ End--;
+ break;
+ }
+ End++;
+ }
+
+ Length = ACPI_PTR_DIFF (End, Start);
+ TmpValue = UtLocalCalloc (Length + 1);
+
+ ACPI_STRNCPY (TmpValue, Start, Length);
+ Value = DtTrim (TmpValue);
+ ACPI_FREE (TmpValue);
+
+ /* Create a new field object only if we have a valid value field */
+
+ if ((Value && *Value) || IsNullString)
+ {
+ Field = UtLocalCalloc (sizeof (DT_FIELD));
+ Field->Name = Name;
+ Field->Value = Value;
+ Field->Line = Line;
+ Field->ByteOffset = Offset;
+ Field->NameColumn = NameColumn;
+ Field->Column = Column;
+
+ DtLinkField (Field);
+ }
+ else /* Ignore this field, it has no valid data */
+ {
+ ACPI_FREE (Name);
+ ACPI_FREE (Value);
+ }
+
+ return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtGetNextLine
+ *
+ * PARAMETERS: Handle - Open file handle for the source file
+ *
+ * RETURN: Filled line buffer and offset of start-of-line (ASL_EOF on EOF)
+ *
+ * DESCRIPTION: Get the next valid source line. Removes all comments.
+ * Ignores empty lines.
+ *
+ * Handles both slash-asterisk and slash-slash comments.
+ * Also, quoted strings, but no escapes within.
+ *
+ * Line is returned in Gbl_CurrentLineBuffer.
+ * Line number in original file is returned in Gbl_CurrentLineNumber.
+ *
+ *****************************************************************************/
+
+UINT32
+DtGetNextLine (
+ FILE *Handle)
+{
+ BOOLEAN LineNotAllBlanks = FALSE;
+ UINT32 State = DT_NORMAL_TEXT;
+ UINT32 CurrentLineOffset;
+ UINT32 i;
+ char c;
+
+
+ for (i = 0; i < ASL_LINE_BUFFER_SIZE;)
+ {
+ c = (char) getc (Handle);
+ if (c == EOF)
+ {
+ switch (State)
+ {
+ case DT_START_QUOTED_STRING:
+ case DT_SLASH_ASTERISK_COMMENT:
+ case DT_SLASH_SLASH_COMMENT:
+
+ AcpiOsPrintf ("**** EOF within comment/string %u\n", State);
+ break;
+
+ default:
+ break;
+ }
+
+ return (ASL_EOF);
+ }
+
+ switch (State)
+ {
+ case DT_NORMAL_TEXT:
+
+ /* Normal text, insert char into line buffer */
+
+ Gbl_CurrentLineBuffer[i] = c;
+ switch (c)
+ {
+ case '/':
+ State = DT_START_COMMENT;
+ break;
+
+ case '"':
+ State = DT_START_QUOTED_STRING;
+ LineNotAllBlanks = TRUE;
+ i++;
+ break;
+
+ case '\\':
+ /*
+ * The continuation char MUST be last char on this line.
+ * Otherwise, it will be assumed to be a valid ASL char.
+ */
+ State = DT_MERGE_LINES;
+ break;
+
+ case '\n':
+ CurrentLineOffset = Gbl_NextLineOffset;
+ Gbl_NextLineOffset = (UINT32) ftell (Handle);
+ Gbl_CurrentLineNumber++;
+
+ /*
+ * Exit if line is complete. Ignore empty lines (only \n)
+ * or lines that contain nothing but blanks.
+ */
+ if ((i != 0) && LineNotAllBlanks)
+ {
+ Gbl_CurrentLineBuffer[i+1] = 0; /* Terminate string */
+ return (CurrentLineOffset);
+ }
+
+ /* Toss this line and start a new one */
+
+ i = 0;
+ LineNotAllBlanks = FALSE;
+ break;
+
+ default:
+ if (c != ' ')
+ {
+ LineNotAllBlanks = TRUE;
+ }
+
+ i++;
+ break;
+ }
+ break;
+
+ case DT_START_QUOTED_STRING:
+
+ /* Insert raw chars until end of quoted string */
+
+ Gbl_CurrentLineBuffer[i] = c;
+ i++;
+
+ if (c == '"')
+ {
+ State = DT_NORMAL_TEXT;
+ }
+ break;
+
+ case DT_START_COMMENT:
+
+ /* Open comment if this character is an asterisk or slash */
+
+ switch (c)
+ {
+ case '*':
+ State = DT_SLASH_ASTERISK_COMMENT;
+ break;
+
+ case '/':
+ State = DT_SLASH_SLASH_COMMENT;
+ break;
+
+ default: /* Not a comment */
+ i++; /* Save the preceeding slash */
+ Gbl_CurrentLineBuffer[i] = c;
+ i++;
+ State = DT_NORMAL_TEXT;
+ break;
+ }
+ break;
+
+ case DT_SLASH_ASTERISK_COMMENT:
+
+ /* Ignore chars until an asterisk-slash is found */
+
+ switch (c)
+ {
+ case '\n':
+ Gbl_NextLineOffset = (UINT32) ftell (Handle);
+ Gbl_CurrentLineNumber++;
+ break;
+
+ case '*':
+ State = DT_END_COMMENT;
+ break;
+
+ default:
+ break;
+ }
+ break;
+
+ case DT_SLASH_SLASH_COMMENT:
+
+ /* Ignore chars until end-of-line */
+
+ if (c == '\n')
+ {
+ /* We will exit via the NORMAL_TEXT path */
+
+ ungetc (c, Handle);
+ State = DT_NORMAL_TEXT;
+ }
+ break;
+
+ case DT_END_COMMENT:
+
+ /* End comment if this char is a slash */
+
+ switch (c)
+ {
+ case '/':
+ State = DT_NORMAL_TEXT;
+ break;
+
+ case '\n':
+ CurrentLineOffset = Gbl_NextLineOffset;
+ Gbl_NextLineOffset = (UINT32) ftell (Handle);
+ Gbl_CurrentLineNumber++;
+ break;
+
+ case '*':
+ /* Consume all adjacent asterisks */
+ break;
+
+ default:
+ State = DT_SLASH_ASTERISK_COMMENT;
+ break;
+ }
+ break;
+
+ case DT_MERGE_LINES:
+
+ if (c != '\n')
+ {
+ /*
+ * This is not a continuation backslash, it is a normal
+ * normal ASL backslash - for example: Scope(\_SB_)
+ */
+ i++; /* Keep the backslash that is already in the buffer */
+
+ ungetc (c, Handle);
+ State = DT_NORMAL_TEXT;
+ }
+ else
+ {
+ /*
+ * This is a continuation line -- a backlash followed
+ * immediately by a newline. Insert a space between the
+ * lines (overwrite the backslash)
+ */
+ Gbl_CurrentLineBuffer[i] = ' ';
+ i++;
+
+ /* Ignore newline, this will merge the lines */
+
+ CurrentLineOffset = Gbl_NextLineOffset;
+ Gbl_NextLineOffset = (UINT32) ftell (Handle);
+ Gbl_CurrentLineNumber++;
+ State = DT_NORMAL_TEXT;
+ }
+ break;
+
+ default:
+ DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, "Unknown input state");
+ return (ASL_EOF);
+ }
+ }
+
+ printf ("ERROR - Input line is too long (max %u)\n", ASL_LINE_BUFFER_SIZE);
+ return (ASL_EOF);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtScanFile
+ *
+ * PARAMETERS: Handle - Open file handle for the source file
+ *
+ * RETURN: Pointer to start of the constructed parse tree.
+ *
+ * DESCRIPTION: Scan source file, link all field names and values
+ * to the global parse tree: Gbl_FieldList
+ *
+ *****************************************************************************/
+
+DT_FIELD *
+DtScanFile (
+ FILE *Handle)
+{
+ ACPI_STATUS Status;
+ UINT32 Offset;
+ DT_FIELD *Next;
+
+
+ ACPI_FUNCTION_NAME (DtScanFile);
+
+
+ /* Get the file size */
+
+ Gbl_InputByteCount = DtGetFileSize (Handle);
+
+ Gbl_CurrentLineNumber = 0;
+ Gbl_CurrentLineOffset = 0;
+ Gbl_NextLineOffset = 0;
+
+ /* Scan line-by-line */
+
+ while ((Offset = DtGetNextLine (Handle)) != ASL_EOF)
+ {
+ ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Line %2.2u/%4.4X - %s",
+ Gbl_CurrentLineNumber, Offset, Gbl_CurrentLineBuffer));
+
+ Status = DtParseLine (Gbl_CurrentLineBuffer, Gbl_CurrentLineNumber, Offset);
+ if (Status == AE_NOT_FOUND)
+ {
+ break;
+ }
+ }
+
+ /* Dump the parse tree if debug enabled */
+
+ if (Gbl_DebugFlag)
+ {
+ Next = Gbl_FieldList;
+ DbgPrint (ASL_DEBUG_OUTPUT, "Tree: %32s %32s %8s %8s %8s %8s %8s %8s\n\n",
+ "Name", "Value", "Line", "ByteOff", "NameCol", "Column", "TableOff", "Flags");
+
+ while (Next)
+ {
+ DbgPrint (ASL_DEBUG_OUTPUT, "Field: %32.32s %32.32s %.8X %.8X %.8X %.8X %.8X %.8X\n",
+ Next->Name,
+ Next->Value,
+ Next->Line,
+ Next->ByteOffset,
+ Next->NameColumn,
+ Next->Column,
+ Next->TableOffset,
+ Next->Flags);
+
+ Next = Next->Next;
+ }
+ }
+
+ return (Gbl_FieldList);
+}
+
+
+/*
+ * Output functions
+ */
+
+/******************************************************************************
+ *
+ * FUNCTION: DtWriteBinary
+ *
+ * PARAMETERS: DT_WALK_CALLBACK
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Write one subtable of a binary ACPI table
+ *
+ *****************************************************************************/
+
+static void
+DtWriteBinary (
+ DT_SUBTABLE *Subtable,
+ void *Context,
+ void *ReturnValue)
+{
+
+ FlWriteFile (ASL_FILE_AML_OUTPUT, Subtable->Buffer, Subtable->Length);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtOutputBinary
+ *
+ * PARAMETERS:
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Write entire binary ACPI table (result of compilation)
+ *
+ *****************************************************************************/
+
+void
+DtOutputBinary (
+ DT_SUBTABLE *RootTable)
+{
+
+ if (!RootTable)
+ {
+ return;
+ }
+
+ /* Walk the entire parse tree, emitting the binary data */
+
+ DtWalkTableTree (RootTable, DtWriteBinary, NULL, NULL);
+ Gbl_TableLength = DtGetFileSize (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
+}
+
+
+/*
+ * Listing support
+ */
+
+/******************************************************************************
+ *
+ * FUNCTION: DtDumpBuffer
+ *
+ * PARAMETERS: FileID - Where to write buffer data
+ * Buffer - Buffer to dump
+ * Offset - Offset in current table
+ * Length - Buffer Length
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Another copy of DumpBuffer routine (unfortunately).
+ *
+ * TBD: merge dump buffer routines
+ *
+ *****************************************************************************/
+
+static void
+DtDumpBuffer (
+ UINT32 FileId,
+ UINT8 *Buffer,
+ UINT32 Offset,
+ UINT32 Length)
+{
+ UINT32 i;
+ UINT32 j;
+ UINT8 BufChar;
+
+
+ FlPrintFile (FileId, "Output: [%3.3Xh %4.4d %3d] ",
+ Offset, Offset, Length);
+
+ i = 0;
+ while (i < Length)
+ {
+ if (i >= 16)
+ {
+ FlPrintFile (FileId, "%24s", "");
+ }
+
+ /* Print 16 hex chars */
+
+ for (j = 0; j < 16;)
+ {
+ if (i + j >= Length)
+ {
+ /* Dump fill spaces */
+
+ FlPrintFile (FileId, " ");
+ j++;
+ continue;
+ }
+
+ FlPrintFile (FileId, "%02X ", Buffer[i+j]);
+ j++;
+ }
+
+ FlPrintFile (FileId, " ");
+ for (j = 0; j < 16; j++)
+ {
+ if (i + j >= Length)
+ {
+ FlPrintFile (FileId, "\n\n");
+ return;
+ }
+
+ BufChar = Buffer[(ACPI_SIZE) i + j];
+ if (ACPI_IS_PRINT (BufChar))
+ {
+ FlPrintFile (FileId, "%c", BufChar);
+ }
+ else
+ {
+ FlPrintFile (FileId, ".");
+ }
+ }
+
+ /* Done with that line. */
+
+ FlPrintFile (FileId, "\n");
+ i += 16;
+ }
+
+ FlPrintFile (FileId, "\n\n");
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtWriteFieldToListing
+ *
+ * PARAMETERS: Buffer - Contains the compiled data
+ * Field - Field node for the input line
+ * Length - Length of the output data
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Write one field to the listing file (if listing is enabled).
+ *
+ *****************************************************************************/
+
+void
+DtWriteFieldToListing (
+ UINT8 *Buffer,
+ DT_FIELD *Field,
+ UINT32 Length)
+{
+ UINT8 FileByte;
+
+
+ if (!Gbl_ListingFlag || !Field)
+ {
+ return;
+ }
+
+ /* Dump the original source line */
+
+ FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Input: ");
+ FlSeekFile (ASL_FILE_INPUT, Field->ByteOffset);
+
+ while (FlReadFile (ASL_FILE_INPUT, &FileByte, 1) == AE_OK)
+ {
+ FlWriteFile (ASL_FILE_LISTING_OUTPUT, &FileByte, 1);
+ if (FileByte == '\n')
+ {
+ break;
+ }
+ }
+
+ /* Dump the line as parsed and represented internally */
+
+ FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Parsed: %*s : %.64s",
+ Field->Column-4, Field->Name, Field->Value);
+
+ if (strlen (Field->Value) > 64)
+ {
+ FlPrintFile (ASL_FILE_LISTING_OUTPUT, "...Additional data, length 0x%X\n",
+ strlen (Field->Value));
+ }
+ FlPrintFile (ASL_FILE_LISTING_OUTPUT, "\n");
+
+ /* Dump the hex data that will be output for this field */
+
+ DtDumpBuffer (ASL_FILE_LISTING_OUTPUT, Buffer, Field->TableOffset, Length);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: DtWriteTableToListing
+ *
+ * PARAMETERS: None
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Write the entire compiled table to the listing file
+ * in hex format
+ *
+ *****************************************************************************/
+
+void
+DtWriteTableToListing (
+ void)
+{
+ UINT8 *Buffer;
+
+
+ if (!Gbl_ListingFlag)
+ {
+ return;
+ }
+
+ /* Read the entire table from the output file */
+
+ Buffer = UtLocalCalloc (Gbl_TableLength);
+ FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
+ FlReadFile (ASL_FILE_AML_OUTPUT, Buffer, Gbl_TableLength);
+
+ /* Dump the raw table data */
+
+ AcpiOsRedirectOutput (Gbl_Files[ASL_FILE_LISTING_OUTPUT].Handle);
+
+ AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n",
+ ACPI_RAW_TABLE_DATA_HEADER, Gbl_TableLength, Gbl_TableLength);
+ AcpiUtDumpBuffer2 (Buffer, Gbl_TableLength, DB_BYTE_DISPLAY);
+
+ AcpiOsRedirectOutput (stdout);
+}
OpenPOWER on IntegriCloud