WebSVN – Kolibri OS – Diff – /drivers/devman/acpica/compiler/dtio.c

 /******************************************************************************
+ *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  * All rights reserved.
+ *
  * 2. License
+ *
 #define _COMPONENT          DT_COMPILER
-        ACPI_MODULE_NAME    ("dtio")
+        ACPI_MODULE_NAME    ("dtio")
-/******************************************************************************
- *
- * FUNCTION:    DtIsComment
- *
- * PARAMETERS:  Line                - Current source code line
- *
- * RETURN:      TRUE if comment, FALSE otherwise
- *
- * DESCRIPTION: Detect a comment in the source module
+/* Local prototypes */
- *
- *****************************************************************************/
+static char *
+DtTrim (
-/* TBD: Temporary: very simple code to detect comments */
+    char                    *String);
-static int
+static void
-DtIsComment(
+DtLinkField (
-    char                    *Line)
+    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 */
-    if (!ACPI_STRNCMP (Line, "/*", 2) ||
+#define DT_NORMAL_TEXT              0
+#define DT_START_QUOTED_STRING      1
-        !ACPI_STRNCMP (Line, " *", 2))
+#define DT_START_COMMENT            2
 #define DT_SLASH_ASTERISK_COMMENT   3
-        return 1;
+#define DT_SLASH_SLASH_COMMENT      4
+ *
  * PARAMETERS:  LineBuffer          - Current source code line
  *              Line                - Current line number in the source
  *              Offset              - Current byte offset of the line
+ *
- * RETURN:      None
+ * RETURN:      Status
+ *
  * DESCRIPTION: Parse one source line
+ *
  *****************************************************************************/
-static void
+static ACPI_STATUS
 DtParseLine (
     char                    *LineBuffer,
     UINT32                  Line,
     UINT32                  Offset)
     char                    *Colon;
     UINT32                  Length;
     DT_FIELD                *Field;
     UINT32                  Column;
     UINT32                  NameColumn;
+    BOOLEAN                 IsNullString = FALSE;
-    if (!LineBuffer || DtIsComment (LineBuffer))
+    if (!LineBuffer)
+    {
+        return (AE_OK);
+    }
+    /* All lines after "Raw Table Data" are ingored */
+    if (strstr (LineBuffer, ACPI_RAW_TABLE_DATA_HEADER))
+    {
-        return;
+        return (AE_NOT_FOUND);
     }
     Colon = strchr (LineBuffer, ':');
-    if (!Colon || *(Colon - 1) != ' ')
+    if (!Colon)
+    {
-        return;
+        return (AE_OK);
                 Start++;
+            }
             if (Start == Colon)
-            {
                 MYDEBUG ("ERROR: right bracket reaches colon position\n");
                 break;
+            }
     ACPI_STRNCPY (TmpName, Start, Length);
     Name = DtTrim (TmpName);
     ACPI_FREE (TmpName);
-    Start = End = (Colon + 1);
     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;
             End++;
-            while (*End && *End != '"')
+            while (*End && (*End != '"'))
+            {
                 End++;
+            }
+            End++;
+            break;
+        }
-            End++;
+        /*
+         * Special "comment" fields at line end, ignore them.
-            break;
+         * 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 == '<' ||
+        if (*End == '[')
-            *End == '/')
+        {
-            break;
+            End--;
             break;
+        }
+        End++;
         End++;
     Length = ACPI_PTR_DIFF (End, Start);
+    TmpValue = UtLocalCalloc (Length + 1);
-    Length = ACPI_PTR_DIFF (End, Start);
+    ACPI_STRNCPY (TmpValue, Start, Length);
-    TmpValue = UtLocalCalloc (Length + 1);
+    Value = DtTrim (TmpValue);
-    ACPI_STRNCPY (TmpValue, Start, Length);
+    ACPI_FREE (TmpValue);
     Value = DtTrim (TmpValue);
-    ACPI_FREE (TmpValue);
+    /* Create a new field object only if we have a valid value field */
         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);
+}
+ *
  * 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 name and value
+ * DESCRIPTION: Scan source file, link all field names and values
  *              to the global parse tree: Gbl_FieldList
+ *
  *****************************************************************************/
 DT_FIELD *
 DtScanFile (
     FILE                    *Handle)
 {
-    UINT32                  Line = 0;
+    ACPI_STATUS             Status;
+    UINT32                  Offset;
+    DT_FIELD                *Next;
-    UINT32                  Offset = 0;
+    ACPI_FUNCTION_NAME (DtScanFile);
+    /* Get the file size */
+    Gbl_InputByteCount = DtGetFileSize (Handle);
-    /* Get the file size */
+    Gbl_CurrentLineNumber = 0;
     Gbl_CurrentLineOffset = 0;
-    Gbl_InputByteCount = DtGetFileSize (Handle);
+    Gbl_NextLineOffset = 0;
-    /* Scan line-by-line */
+    /* 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,
-    while (fgets (Gbl_CurrentLineBuffer, ASL_LINE_BUFFER_SIZE, Handle))
+                Next->NameColumn,
                 Next->Column,
-        Line++;
+                Next->TableOffset,
-        Gbl_CurrentLineNumber++;
+                Next->Flags);
         DtParseLine (Gbl_CurrentLineBuffer, Line, Offset);
             Next = Next->Next;
-        Offset = (UINT32) ftell (Handle);
+        }
+    }
     return (Gbl_FieldList);
     return (Gbl_FieldList);
+}
     /* 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);

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpica/compiler/dtio.c – Rev 1498 → 2216