11 files changed, 1371 insertions, 771 deletions

diff --git a/source/common/acfileio.c b/source/common/acfileio.c
new file mode 100644
index 0000000000000..b94adf8c49006
--- /dev/null
+++ b/source/common/acfileio.c
@@ -0,0 +1,357 @@
+/******************************************************************************
+ *
+ * Module Name: acfileio - Get ACPI tables from file
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2015, 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.
+ */
+
+#include "acpi.h"
+#include "accommon.h"
+#include "acapps.h"
+#include "actables.h"
+#include "acutils.h"
+#include <errno.h>
+
+#define _COMPONENT          ACPI_UTILITIES
+        ACPI_MODULE_NAME    ("acfileio")
+
+
+/* Local prototypes */
+
+static ACPI_STATUS
+AcpiAcGetOneTableFromFile (
+    char                    *Filename,
+    FILE                    *File,
+    UINT8                   GetOnlyAmlTables,
+    ACPI_TABLE_HEADER       **Table);
+
+static ACPI_STATUS
+AcpiAcCheckTextModeCorruption (
+    ACPI_TABLE_HEADER       *Table);
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiAcGetAllTablesFromFile
+ *
+ * PARAMETERS:  Filename            - Table filename
+ *              GetOnlyAmlTables    - TRUE if the tables must be AML tables
+ *              ReturnListHead      - Where table list is returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Get all ACPI tables from within a single file.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiAcGetAllTablesFromFile (
+    char                    *Filename,
+    UINT8                   GetOnlyAmlTables,
+    ACPI_NEW_TABLE_DESC     **ReturnListHead)
+{
+    ACPI_NEW_TABLE_DESC     *ListHead = NULL;
+    ACPI_NEW_TABLE_DESC     *ListTail = NULL;
+    ACPI_NEW_TABLE_DESC     *TableDesc;
+    FILE                    *File;
+    ACPI_TABLE_HEADER       *Table = NULL;
+    UINT32                  FileSize;
+    ACPI_STATUS             Status = AE_OK;
+
+
+    File = fopen (Filename, "rb");
+    if (!File)
+    {
+        perror ("Could not open input file");
+        if (errno == ENOENT)
+        {
+            return (AE_NOT_EXIST);
+        }
+
+        return (AE_ERROR);
+    }
+
+    /* Get the file size */
+
+    FileSize = CmGetFileSize (File);
+    if (FileSize == ACPI_UINT32_MAX)
+    {
+        return (AE_ERROR);
+    }
+
+    if (FileSize < 4)
+    {
+        return (AE_BAD_HEADER);
+    }
+
+    /* Read all tables within the file */
+
+    while (ACPI_SUCCESS (Status))
+    {
+        /* Get one entire ACPI table */
+
+        Status = AcpiAcGetOneTableFromFile (
+            Filename, File, GetOnlyAmlTables, &Table);
+        if (Status == AE_CTRL_TERMINATE)
+        {
+            Status = AE_OK;
+            break;
+        }
+        else if (Status == AE_TYPE)
+        {
+            continue;
+        }
+        else if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+
+        /* Allocate and link a table descriptor */
+
+        TableDesc = AcpiOsAllocate (sizeof (ACPI_NEW_TABLE_DESC));
+        TableDesc->Table = Table;
+        TableDesc->Next = NULL;
+
+        /* Link at the end of the local table list */
+
+        if (!ListHead)
+        {
+            ListHead = TableDesc;
+            ListTail = TableDesc;
+        }
+        else
+        {
+            ListTail->Next = TableDesc;
+            ListTail = TableDesc;
+        }
+    }
+
+    /* Add the local table list to the end of the global list */
+
+    if (*ReturnListHead)
+    {
+        ListTail = *ReturnListHead;
+        while (ListTail->Next)
+        {
+            ListTail = ListTail->Next;
+        }
+
+        ListTail->Next = ListHead;
+    }
+    else
+    {
+        *ReturnListHead = ListHead;
+    }
+
+    fclose(File);
+    return (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiAcGetOneTableFromFile
+ *
+ * PARAMETERS:  Filename            - File where table is located
+ *              File                - Open FILE pointer to Filename
+ *              GetOnlyAmlTables    - TRUE if the tables must be AML tables.
+ *              ReturnTable         - Where a pointer to the table is returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Read the next ACPI table from a file. Implements support
+ *              for multiple tables within a single file. File must already
+ *              be open.
+ *
+ * Note: Loading an RSDP is not supported.
+ *
+ ******************************************************************************/
+
+static ACPI_STATUS
+AcpiAcGetOneTableFromFile (
+    char                    *Filename,
+    FILE                    *File,
+    UINT8                   GetOnlyAmlTables,
+    ACPI_TABLE_HEADER       **ReturnTable)
+{
+    ACPI_STATUS             Status = AE_OK;
+    ACPI_TABLE_HEADER       TableHeader;
+    ACPI_TABLE_HEADER       *Table;
+    INT32                   Count;
+    long                    Position;
+
+
+    *ReturnTable = NULL;
+
+
+    /* Get just the table header to get signature and length */
+
+    Position = ftell (File);
+    Count = fread (&TableHeader, 1, sizeof (ACPI_TABLE_HEADER), File);
+    if (Count != sizeof (ACPI_TABLE_HEADER))
+    {
+        return (AE_CTRL_TERMINATE);
+    }
+
+    if (GetOnlyAmlTables)
+    {
+        /* Table must be an AML table (DSDT/SSDT) or FADT */
+
+        if (!ACPI_COMPARE_NAME (TableHeader.Signature, ACPI_SIG_FADT) &&
+            !AcpiUtIsAmlTable (&TableHeader))
+        {
+            fprintf (stderr,
+                "    %s: [%4.4s] is not an AML table - ignoring\n",
+                Filename, TableHeader.Signature);
+
+            return (AE_TYPE);
+        }
+    }
+
+    /* Allocate a buffer for the entire table */
+
+    Table = AcpiOsAllocate ((size_t) TableHeader.Length);
+    if (!Table)
+    {
+        return (AE_NO_MEMORY);
+    }
+
+    /* Now read the entire table */
+
+    fseek (File, Position, SEEK_SET);
+
+    Count = fread (Table, 1, TableHeader.Length, File);
+    if (Count != (INT32) TableHeader.Length)
+    {
+        Status = AE_ERROR;
+        goto ErrorExit;
+    }
+
+    /* Validate the checksum (just issue a warning) */
+
+    Status = AcpiTbVerifyChecksum (Table, TableHeader.Length);
+    if (ACPI_FAILURE (Status))
+    {
+        Status = AcpiAcCheckTextModeCorruption (Table);
+        if (ACPI_FAILURE (Status))
+        {
+            goto ErrorExit;
+        }
+    }
+
+    fprintf (stderr,
+        "Loading ACPI table [%4.4s] from file %12s - Length 0x%06X (%u)\n",
+        TableHeader.Signature, Filename,
+        TableHeader.Length, TableHeader.Length);
+
+    *ReturnTable = Table;
+    return (AE_OK);
+
+
+ErrorExit:
+    AcpiOsFree (Table);
+    return (Status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiAcCheckTextModeCorruption
+ *
+ * PARAMETERS:  Table           - Table buffer starting with table header
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Check table for text mode file corruption where all linefeed
+ *              characters (LF) have been replaced by carriage return linefeed
+ *              pairs (CR/LF).
+ *
+ ******************************************************************************/
+
+static ACPI_STATUS
+AcpiAcCheckTextModeCorruption (
+    ACPI_TABLE_HEADER       *Table)
+{
+    UINT32                  i;
+    UINT32                  Pairs = 0;
+    UINT8                   *Buffer = ACPI_CAST_PTR (UINT8, Table);
+
+
+    /* Scan entire table to determine if each LF has been prefixed with a CR */
+
+    for (i = 1; i < Table->Length; i++)
+    {
+        if (Buffer[i] == 0x0A)
+        {
+            if (Buffer[i - 1] != 0x0D)
+            {
+                /* The LF does not have a preceding CR, table not corrupted */
+
+                return (AE_OK);
+            }
+            else
+            {
+                /* Found a CR/LF pair */
+
+                Pairs++;
+            }
+
+            i++;
+        }
+    }
+
+    if (!Pairs)
+    {
+        return (AE_OK);
+    }
+
+    /*
+     * Entire table scanned, each CR is part of a CR/LF pair --
+     * meaning that the table was treated as a text file somewhere.
+     *
+     * NOTE: We can't "fix" the table, because any existing CR/LF pairs in the
+     * original table are left untouched by the text conversion process --
+     * meaning that we cannot simply replace CR/LF pairs with LFs.
+     */
+    AcpiOsPrintf ("Table has been corrupted by text mode conversion\n");
+    AcpiOsPrintf ("All LFs (%u) were changed to CR/LF pairs\n", Pairs);
+    AcpiOsPrintf ("Table cannot be repaired!\n");
+
+    return (AE_BAD_VALUE);
+}
diff --git a/source/common/acgetline.c b/source/common/acgetline.c
index 5daa95a8be55c..2273db4066569 100644
--- a/source/common/acgetline.c
+++ b/source/common/acgetline.c
@@ -262,6 +262,7 @@ AcpiOsGetLine (
 
             ACPI_BACKUP_CURSOR (i, EndOfLine - CursorPosition + 1);
             EndOfLine--;
+
             if (CursorPosition > 0)
             {
                 CursorPosition--;
diff --git a/source/common/adisasm.c b/source/common/adisasm.c
index 8afabd5bcc12a..33500d6df4d60 100644
--- a/source/common/adisasm.c
+++ b/source/common/adisasm.c
@@ -42,16 +42,14 @@
  */
 
 #include "aslcompiler.h"
-#include "acparser.h"
 #include "amlcode.h"
 #include "acdisasm.h"
 #include "acdispat.h"
 #include "acnamesp.h"
-#include "actables.h"
+#include "acparser.h"
 #include "acapps.h"
 
 #include <stdio.h>
-#include <time.h>
 
 
 #define _COMPONENT          ACPI_TOOLS
@@ -59,17 +57,29 @@
 
 /* Local prototypes */
 
-static void
-AdCreateTableHeader (
+static ACPI_STATUS
+AdDoExternalFileList (
+    char                    *Filename);
+
+static ACPI_STATUS
+AdDisassembleOneTable (
+    ACPI_TABLE_HEADER       *Table,
+    FILE                    *File,
     char                    *Filename,
-    ACPI_TABLE_HEADER       *Table);
+    char                    *DisasmFilename);
 
 static ACPI_STATUS
-AdStoreTable (
+AdReparseOneTable (
     ACPI_TABLE_HEADER       *Table,
-    UINT32                  *TableIndex);
+    FILE                    *File,
+    ACPI_OWNER_ID           OwnerId);
 
-/* Stubs for ASL compiler */
+
+ACPI_TABLE_DESC             LocalTables[1];
+ACPI_PARSE_OBJECT           *AcpiGbl_ParseOpRoot;
+
+
+/* Stubs for everything except ASL compiler */
 
 #ifndef ACPI_ASL_COMPILER
 BOOLEAN
@@ -77,7 +87,7 @@ AcpiDsIsResultUsed (
     ACPI_PARSE_OBJECT       *Op,
     ACPI_WALK_STATE         *WalkState)
 {
-    return TRUE;
+    return (TRUE);
 }
 
 ACPI_STATUS
@@ -89,52 +99,6 @@ AcpiDsMethodError (
 }
 #endif
 
-ACPI_STATUS
-AcpiNsLoadTable (
-    UINT32                  TableIndex,
-    ACPI_NAMESPACE_NODE     *Node)
-{
-    return (AE_NOT_IMPLEMENTED);
-}
-
-ACPI_STATUS
-AcpiDsRestartControlMethod (
-    ACPI_WALK_STATE         *WalkState,
-    ACPI_OPERAND_OBJECT     *ReturnDesc)
-{
-    return (AE_OK);
-}
-
-void
-AcpiDsTerminateControlMethod (
-    ACPI_OPERAND_OBJECT     *MethodDesc,
-    ACPI_WALK_STATE         *WalkState)
-{
-    return;
-}
-
-ACPI_STATUS
-AcpiDsCallControlMethod (
-    ACPI_THREAD_STATE       *Thread,
-    ACPI_WALK_STATE         *WalkState,
-    ACPI_PARSE_OBJECT       *Op)
-{
-    return (AE_OK);
-}
-
-ACPI_STATUS
-AcpiDsMethodDataInitArgs (
-    ACPI_OPERAND_OBJECT     **Params,
-    UINT32                  MaxParamCount,
-    ACPI_WALK_STATE         *WalkState)
-{
-    return (AE_OK);
-}
-
-
-static ACPI_TABLE_DESC      LocalTables[1];
-static ACPI_PARSE_OBJECT    *AcpiGbl_ParseOpRoot;
-
 
 /*******************************************************************************
  *
@@ -202,7 +166,7 @@ AdInitialize (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Disassemble an entire ACPI table
+ * DESCRIPTION: Disassembler entry point. Disassemble an entire ACPI table.
  *
  *****************************************************************************/
 
@@ -214,14 +178,10 @@ AdAmlDisassemble (
     char                    **OutFilename)
 {
     ACPI_STATUS             Status;
-    ACPI_STATUS             GlobalStatus = AE_OK;
     char                    *DisasmFilename = NULL;
-    char                    *ExternalFilename;
-    ACPI_EXTERNAL_FILE      *ExternalFileList = AcpiGbl_ExternalFileList;
     FILE                    *File = NULL;
     ACPI_TABLE_HEADER       *Table = NULL;
-    ACPI_TABLE_HEADER       *ExternalTable;
-    ACPI_OWNER_ID           OwnerId;
+    ACPI_NEW_TABLE_DESC     *ListHead = NULL;
 
 
     /*
@@ -230,81 +190,22 @@ AdAmlDisassemble (
      */
     if (Filename)
     {
-        Status = AcpiDbGetTableFromFile (Filename, &Table, FALSE);
+        /* Get the list of all AML tables in the file */
+
+        Status = AcpiAcGetAllTablesFromFile (Filename,
+            ACPI_GET_ALL_TABLES, &ListHead);
         if (ACPI_FAILURE (Status))
         {
             return (Status);
         }
 
-        /*
-         * External filenames separated by commas
-         * Example: iasl -e file1,file2,file3 -d xxx.aml
-         */
-        while (ExternalFileList)
-        {
-            ExternalFilename = ExternalFileList->Path;
-            if (!strcmp (ExternalFilename, Filename))
-            {
-                /* Next external file */
-
-                ExternalFileList = ExternalFileList->Next;
-                continue;
-            }
-
-            Status = AcpiDbGetTableFromFile (ExternalFilename, &ExternalTable, TRUE);
-            if (ACPI_FAILURE (Status))
-            {
-                if (Status == AE_TYPE)
-                {
-                    ExternalFileList = ExternalFileList->Next;
-                    GlobalStatus = AE_TYPE;
-                    Status = AE_OK;
-                    continue;
-                }
-                return (Status);
-            }
-
-            /* Load external table for symbol resolution */
-
-            if (ExternalTable)
-            {
-                Status = AdParseTable (ExternalTable, &OwnerId, TRUE, TRUE);
-                if (ACPI_FAILURE (Status))
-                {
-                    AcpiOsPrintf ("Could not parse external ACPI tables, %s\n",
-                        AcpiFormatException (Status));
-                    return (Status);
-                }
-
-                /*
-                 * Load namespace from names created within control methods
-                 * Set owner id of nodes in external table
-                 */
-                AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
-                    AcpiGbl_RootNode, OwnerId);
-                AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
-            }
-
-            /* Next external file */
-
-            ExternalFileList = ExternalFileList->Next;
-        }
-
-        if (ACPI_FAILURE (GlobalStatus))
-        {
-            return (GlobalStatus);
-        }
-
-        /* Clear external list generated by Scope in external tables */
+        /* Process any user-specified files for external objects */
 
-        if (AcpiGbl_ExternalFileList)
+        Status = AdDoExternalFileList (Filename);
+        if (ACPI_FAILURE (Status))
         {
-            AcpiDmClearExternalList ();
+            return (Status);
         }
-
-        /* Load any externals defined in the optional external ref file */
-
-        AcpiDmGetExternalsFromFile ();
     }
     else
     {
@@ -353,7 +254,8 @@ AdAmlDisassemble (
         File = fopen (DisasmFilename, "w+");
         if (!File)
         {
-            fprintf (stderr, "Could not open output file %s\n", DisasmFilename);
+            fprintf (stderr, "Could not open output file %s\n",
+                DisasmFilename);
             Status = AE_ERROR;
             goto Cleanup;
         }
@@ -363,190 +265,32 @@ AdAmlDisassemble (
 
     *OutFilename = DisasmFilename;
 
-    /* ForceAmlDisassembly means to assume the table contains valid AML */
-
-    if (!AcpiGbl_ForceAmlDisassembly && !AcpiUtIsAmlTable (Table))
-    {
-        AdDisassemblerHeader (Filename, ACPI_IS_DATA_TABLE);
-        AcpiOsPrintf (" * ACPI Data Table [%4.4s]\n *\n",
-            Table->Signature);
-        AcpiOsPrintf (" * Format: [HexOffset DecimalOffset ByteLength]  "
-            "FieldName : FieldValue\n */\n\n");
-
-        AcpiDmDumpDataTable (Table);
-        fprintf (stderr, "Acpi Data Table [%4.4s] decoded\n",
-            Table->Signature);
+    /* Disassemble all AML tables within the file */
 
-        if (File)
-        {
-            fprintf (stderr, "Formatted output:  %s - %u bytes\n",
-                DisasmFilename, CmGetFileSize (File));
-        }
-    }
-    else
+    while (ListHead)
     {
-        /* Always parse the tables, only option is what to display */
-
-        Status = AdParseTable (Table, &OwnerId, TRUE, FALSE);
+        Status = AdDisassembleOneTable (ListHead->Table,
+            File, Filename, DisasmFilename);
         if (ACPI_FAILURE (Status))
         {
-            AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
-                AcpiFormatException (Status));
-            goto Cleanup;
-        }
-
-        if (AslCompilerdebug)
-        {
-            AcpiOsPrintf ("/**** Before second load\n");
-
-            if (File)
-            {
-                NsSetupNamespaceListing (File);
-                NsDisplayNamespace ();
-            }
-            AcpiOsPrintf ("*****/\n");
-        }
-
-        /* Load namespace from names created within control methods */
-
-        AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
-            AcpiGbl_RootNode, OwnerId);
-
-        /*
-         * Cross reference the namespace here, in order to
-         * generate External() statements
-         */
-        AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
-            AcpiGbl_RootNode, OwnerId);
-
-        if (AslCompilerdebug)
-        {
-            AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
-        }
-
-        /* Find possible calls to external control methods */
-
-        AcpiDmFindOrphanMethods (AcpiGbl_ParseOpRoot);
-
-        /*
-         * If we found any external control methods, we must reparse
-         * the entire tree with the new information (namely, the
-         * number of arguments per method)
-         */
-        if (AcpiDmGetExternalMethodCount ())
-        {
-            fprintf (stderr,
-                "\nFound %u external control methods, "
-                "reparsing with new information\n",
-                AcpiDmGetExternalMethodCount ());
-
-            /* Reparse, rebuild namespace */
-
-            AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
-            AcpiGbl_ParseOpRoot = NULL;
-            AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
-
-            AcpiGbl_RootNode                    = NULL;
-            AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
-            AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
-            AcpiGbl_RootNodeStruct.Type         = ACPI_TYPE_DEVICE;
-            AcpiGbl_RootNodeStruct.Parent       = NULL;
-            AcpiGbl_RootNodeStruct.Child        = NULL;
-            AcpiGbl_RootNodeStruct.Peer         = NULL;
-            AcpiGbl_RootNodeStruct.Object       = NULL;
-            AcpiGbl_RootNodeStruct.Flags        = 0;
-
-            Status = AcpiNsRootInitialize ();
-
-            /* New namespace, add the external definitions first */
-
-            AcpiDmAddExternalsToNamespace ();
-
-            /* Parse the table again. No need to reload it, however */
-
-            Status = AdParseTable (Table, NULL, FALSE, FALSE);
-            if (ACPI_FAILURE (Status))
-            {
-                AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
-                    AcpiFormatException (Status));
-                goto Cleanup;
-            }
-
-            /* Cross reference the namespace again */
-
-            AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
-                AcpiGbl_RootNode, OwnerId);
-
-            AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
-                AcpiGbl_RootNode, OwnerId);
-
-            if (AslCompilerdebug)
-            {
-                AcpiOsPrintf ("/**** After second load and resource conversion\n");
-                if (File)
-                {
-                    NsSetupNamespaceListing (File);
-                    NsDisplayNamespace ();
-                }
-                AcpiOsPrintf ("*****/\n");
-
-                AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
-            }
+            break;
         }
 
-        /*
-         * Now that the namespace is finalized, we can perform namespace
-         * transforms.
-         *
-         * 1) Convert fixed-offset references to resource descriptors
-         *    to symbolic references (Note: modifies namespace)
-         */
-        AcpiDmConvertResourceIndexes (AcpiGbl_ParseOpRoot, AcpiGbl_RootNode);
-
-        /* Optional displays */
-
-        if (AcpiGbl_DmOpt_Disasm)
-        {
-            /* This is the real disassembly */
-
-            AdDisplayTables (Filename, Table);
-
-            /* Dump hex table if requested (-vt) */
-
-            AcpiDmDumpDataTable (Table);
-
-            fprintf (stderr, "Disassembly completed\n");
-            if (File)
-            {
-                fprintf (stderr, "ASL Output:    %s - %u bytes\n",
-                    DisasmFilename, CmGetFileSize (File));
-            }
-
-            if (Gbl_MapfileFlag)
-            {
-                fprintf (stderr, "%14s %s - %u bytes\n",
-                    Gbl_Files[ASL_FILE_MAP_OUTPUT].ShortDescription,
-                    Gbl_Files[ASL_FILE_MAP_OUTPUT].Filename,
-                    FlGetFileSize (ASL_FILE_MAP_OUTPUT));
-            }
-        }
+        ListHead = ListHead->Next;
     }
 
 Cleanup:
 
-    if (Table && !AcpiGbl_ForceAmlDisassembly &&!AcpiUtIsAmlTable (Table))
+// check!
+#if 0
+    if (Table && !AcpiGbl_ForceAmlDisassembly && !AcpiUtIsAmlTable (Table))
     {
         ACPI_FREE (Table);
     }
+#endif
 
     if (File)
     {
-        if (AslCompilerdebug) /* Display final namespace, with transforms */
-        {
-            NsSetupNamespaceListing (File);
-            NsDisplayNamespace ();
-        }
-
         fclose (File);
         AcpiOsRedirectOutput (stdout);
     }
@@ -559,290 +303,243 @@ Cleanup:
 
 /******************************************************************************
  *
- * FUNCTION:    AdDisassemblerHeader
+ * FUNCTION:    AdDisassembleOneTable
  *
- * PARAMETERS:  Filename            - Input file for the table
- *              TableType           - Either AML or DataTable
+ * PARAMETERS:  Table               - Raw AML table
+ *              File                - Pointer for the input file
+ *              Filename            - AML input filename
+ *              DisasmFilename      - Output filename
  *
- * RETURN:      None
+ * RETURN:      Status
  *
- * DESCRIPTION: Create the disassembler header, including ACPICA signon with
- *              current time and date.
+ * DESCRIPTION: Disassemble a single ACPI table. AML or data table.
  *
  *****************************************************************************/
 
-void
-AdDisassemblerHeader (
+static ACPI_STATUS
+AdDisassembleOneTable (
+    ACPI_TABLE_HEADER       *Table,
+    FILE                    *File,
     char                    *Filename,
-    UINT8                   TableType)
+    char                    *DisasmFilename)
 {
-    time_t                  Timer;
-
-
-    time (&Timer);
+    ACPI_STATUS             Status;
+    ACPI_OWNER_ID           OwnerId;
 
-    /* Header and input table info */
 
-    AcpiOsPrintf ("/*\n");
-    AcpiOsPrintf (ACPI_COMMON_HEADER (AML_DISASSEMBLER_NAME, " * "));
+    /* ForceAmlDisassembly means to assume the table contains valid AML */
 
-    if (TableType == ACPI_IS_AML_TABLE)
+    if (!AcpiGbl_ForceAmlDisassembly && !AcpiUtIsAmlTable (Table))
     {
-        if (AcpiGbl_CstyleDisassembly)
-        {
-            AcpiOsPrintf (
-                " * Disassembling to symbolic ASL+ operators\n"
-                " *\n");
-        }
-        else
-        {
-            AcpiOsPrintf (
-                " * Disassembling to non-symbolic legacy ASL operators\n"
-                " *\n");
-        }
-    }
+        AdDisassemblerHeader (Filename, ACPI_IS_DATA_TABLE);
 
-    AcpiOsPrintf (" * Disassembly of %s, %s", Filename, ctime (&Timer));
-    AcpiOsPrintf (" *\n");
-}
+        /* This is a "Data Table" (non-AML table) */
 
+        AcpiOsPrintf (" * ACPI Data Table [%4.4s]\n *\n",
+            Table->Signature);
+        AcpiOsPrintf (" * Format: [HexOffset DecimalOffset ByteLength]  "
+            "FieldName : FieldValue\n */\n\n");
 
-/******************************************************************************
- *
- * FUNCTION:    AdCreateTableHeader
- *
- * PARAMETERS:  Filename            - Input file for the table
- *              Table               - Pointer to the raw table
- *
- * RETURN:      None
- *
- * DESCRIPTION: Create the ASL table header, including ACPICA signon with
- *              current time and date.
- *
- *****************************************************************************/
+        AcpiDmDumpDataTable (Table);
+        fprintf (stderr, "Acpi Data Table [%4.4s] decoded\n",
+            Table->Signature);
 
-static void
-AdCreateTableHeader (
-    char                    *Filename,
-    ACPI_TABLE_HEADER       *Table)
-{
-    char                    *NewFilename;
-    UINT8                   Checksum;
+        if (File)
+        {
+            fprintf (stderr, "Formatted output:  %s - %u bytes\n",
+                DisasmFilename, CmGetFileSize (File));
+        }
 
+        return (AE_OK);
+    }
 
     /*
-     * Print file header and dump original table header
+     * This is an AML table (DSDT or SSDT).
+     * Always parse the tables, only option is what to display
      */
-    AdDisassemblerHeader (Filename, ACPI_IS_AML_TABLE);
-
-    AcpiOsPrintf (" * Original Table Header:\n");
-    AcpiOsPrintf (" *     Signature        \"%4.4s\"\n",    Table->Signature);
-    AcpiOsPrintf (" *     Length           0x%8.8X (%u)\n", Table->Length, Table->Length);
-
-    /* Print and validate the revision */
+    Status = AdParseTable (Table, &OwnerId, TRUE, FALSE);
+    if (ACPI_FAILURE (Status))
+    {
+        AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
+            AcpiFormatException (Status));
+        return (Status);
+    }
 
-    AcpiOsPrintf (" *     Revision         0x%2.2X",      Table->Revision);
+    /* Debug output, namespace and parse tree */
 
-    switch (Table->Revision)
+    if (AslCompilerdebug && File)
     {
-    case 0:
+        AcpiOsPrintf ("/**** Before second load\n");
 
-        AcpiOsPrintf (" **** Invalid Revision");
-        break;
+        NsSetupNamespaceListing (File);
+        NsDisplayNamespace ();
 
-    case 1:
+        AcpiOsPrintf ("*****/\n");
+    }
 
-        /* Revision of DSDT controls the ACPI integer width */
+    /* Load namespace from names created within control methods */
 
-        if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_DSDT))
-        {
-            AcpiOsPrintf (" **** 32-bit table (V1), no 64-bit math support");
-        }
-        break;
+    AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
+        AcpiGbl_RootNode, OwnerId);
 
-    default:
+    /*
+     * Cross reference the namespace here, in order to
+     * generate External() statements
+     */
+    AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
+        AcpiGbl_RootNode, OwnerId);
 
-        break;
+    if (AslCompilerdebug)
+    {
+        AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
     }
-    AcpiOsPrintf ("\n");
 
-    /* Print and validate the table checksum */
+    /* Find possible calls to external control methods */
 
-    AcpiOsPrintf (" *     Checksum         0x%2.2X",        Table->Checksum);
+    AcpiDmFindOrphanMethods (AcpiGbl_ParseOpRoot);
 
-    Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Table->Length);
-    if (Checksum)
+    /*
+     * If we found any external control methods, we must reparse
+     * the entire tree with the new information (namely, the
+     * number of arguments per method)
+     */
+    if (AcpiDmGetExternalMethodCount ())
     {
-        AcpiOsPrintf (" **** Incorrect checksum, should be 0x%2.2X",
-            (UINT8) (Table->Checksum - Checksum));
+        Status = AdReparseOneTable (Table, File, OwnerId);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
     }
-    AcpiOsPrintf ("\n");
 
-    AcpiOsPrintf (" *     OEM ID           \"%.6s\"\n",     Table->OemId);
-    AcpiOsPrintf (" *     OEM Table ID     \"%.8s\"\n",     Table->OemTableId);
-    AcpiOsPrintf (" *     OEM Revision     0x%8.8X (%u)\n", Table->OemRevision, Table->OemRevision);
-    AcpiOsPrintf (" *     Compiler ID      \"%.4s\"\n",     Table->AslCompilerId);
-    AcpiOsPrintf (" *     Compiler Version 0x%8.8X (%u)\n", Table->AslCompilerRevision, Table->AslCompilerRevision);
-    AcpiOsPrintf (" */\n");
+    /*
+     * Now that the namespace is finalized, we can perform namespace
+     * transforms.
+     *
+     * 1) Convert fixed-offset references to resource descriptors
+     *    to symbolic references (Note: modifies namespace)
+     */
+    AcpiDmConvertResourceIndexes (AcpiGbl_ParseOpRoot, AcpiGbl_RootNode);
 
-    /* Create AML output filename based on input filename */
+    /* Optional displays */
 
-    if (Filename)
-    {
-        NewFilename = FlGenerateFilename (Filename, "aml");
-    }
-    else
+    if (AcpiGbl_DmOpt_Disasm)
     {
-        NewFilename = UtStringCacheCalloc (9);
-        if (NewFilename)
+        /* This is the real disassembly */
+
+        AdDisplayTables (Filename, Table);
+
+        /* Dump hex table if requested (-vt) */
+
+        AcpiDmDumpDataTable (Table);
+
+        fprintf (stderr, "Disassembly completed\n");
+        if (File)
         {
-            strncat (NewFilename, Table->Signature, 4);
-            strcat (NewFilename, ".aml");
+            fprintf (stderr, "ASL Output:    %s - %u bytes\n",
+                DisasmFilename, CmGetFileSize (File));
         }
-    }
 
-    if (!NewFilename)
-    {
-        AcpiOsPrintf (" **** Could not generate AML output filename\n");
-        return;
+        if (Gbl_MapfileFlag)
+        {
+            fprintf (stderr, "%14s %s - %u bytes\n",
+                Gbl_Files[ASL_FILE_MAP_OUTPUT].ShortDescription,
+                Gbl_Files[ASL_FILE_MAP_OUTPUT].Filename,
+                FlGetFileSize (ASL_FILE_MAP_OUTPUT));
+        }
     }
 
-    /* Open the ASL definition block */
-
-    AcpiOsPrintf (
-        "DefinitionBlock (\"%s\", \"%4.4s\", %hu, \"%.6s\", \"%.8s\", 0x%8.8X)\n",
-        NewFilename, Table->Signature, Table->Revision,
-        Table->OemId, Table->OemTableId, Table->OemRevision);
+    return (AE_OK);
 }
 
 
 /******************************************************************************
  *
- * FUNCTION:    AdDisplayTables
+ * FUNCTION:    AdReparseOneTable
  *
- * PARAMETERS:  Filename            - Input file for the table
- *              Table               - Pointer to the raw table
+ * PARAMETERS:  Table               - Raw AML table
+ *              File                - Pointer for the input file
+ *              OwnerId             - ID for this table
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Display (disassemble) loaded tables and dump raw tables
+ * DESCRIPTION: Reparse a table that has already been loaded. Used to
+ *              integrate information about external control methods.
+ *              These methods may have been previously parsed incorrectly.
  *
  *****************************************************************************/
 
-ACPI_STATUS
-AdDisplayTables (
-    char                    *Filename,
-    ACPI_TABLE_HEADER       *Table)
+static ACPI_STATUS
+AdReparseOneTable (
+    ACPI_TABLE_HEADER       *Table,
+    FILE                    *File,
+    ACPI_OWNER_ID           OwnerId)
 {
+    ACPI_STATUS             Status;
 
 
-    if (!AcpiGbl_ParseOpRoot)
-    {
-        return (AE_NOT_EXIST);
-    }
+    fprintf (stderr,
+        "\nFound %u external control methods, "
+        "reparsing with new information\n",
+        AcpiDmGetExternalMethodCount ());
 
-    if (!AcpiGbl_DmOpt_Listing)
-    {
-        AdCreateTableHeader (Filename, Table);
-    }
+    /* Reparse, rebuild namespace */
 
-    AcpiDmDisassemble (NULL, AcpiGbl_ParseOpRoot, ACPI_UINT32_MAX);
-    MpEmitMappingInfo ();
+    AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
+    AcpiGbl_ParseOpRoot = NULL;
+    AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
+
+    AcpiGbl_RootNode                    = NULL;
+    AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
+    AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
+    AcpiGbl_RootNodeStruct.Type         = ACPI_TYPE_DEVICE;
+    AcpiGbl_RootNodeStruct.Parent       = NULL;
+    AcpiGbl_RootNodeStruct.Child        = NULL;
+    AcpiGbl_RootNodeStruct.Peer         = NULL;
+    AcpiGbl_RootNodeStruct.Object       = NULL;
+    AcpiGbl_RootNodeStruct.Flags        = 0;
 
-    if (AcpiGbl_DmOpt_Listing)
+    Status = AcpiNsRootInitialize ();
+    if (ACPI_FAILURE (Status))
     {
-        AcpiOsPrintf ("\n\nTable Header:\n");
-        AcpiUtDebugDumpBuffer ((UINT8 *) Table, sizeof (ACPI_TABLE_HEADER),
-            DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
-
-        AcpiOsPrintf ("Table Body (Length 0x%X)\n", Table->Length);
-        AcpiUtDebugDumpBuffer (((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER)),
-            Table->Length, DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
+        return (Status);
     }
 
-    return (AE_OK);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AdStoreTable
- *
- * PARAMETERS:  Table               - Table header
- *              TableIndex          - Where the table index is returned
- *
- * RETURN:      Status and table index.
- *
- * DESCRIPTION: Add an ACPI table to the global table list
- *
- ******************************************************************************/
+    /* New namespace, add the external definitions first */
 
-static ACPI_STATUS
-AdStoreTable (
-    ACPI_TABLE_HEADER       *Table,
-    UINT32                  *TableIndex)
-{
-    ACPI_STATUS             Status;
-    ACPI_TABLE_DESC         *TableDesc;
+    AcpiDmAddExternalsToNamespace ();
 
+    /* Parse the table again. No need to reload it, however */
 
-    Status = AcpiTbGetNextTableDescriptor (TableIndex, &TableDesc);
+    Status = AdParseTable (Table, NULL, FALSE, FALSE);
     if (ACPI_FAILURE (Status))
     {
+        AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
+            AcpiFormatException (Status));
         return (Status);
     }
 
-    /* Initialize added table */
+    /* Cross reference the namespace again */
 
-    AcpiTbInitTableDescriptor (TableDesc, ACPI_PTR_TO_PHYSADDR (Table),
-        ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, Table);
-    Status = AcpiTbValidateTable (TableDesc);
-    return (Status);
-}
+    AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
+        AcpiGbl_RootNode, OwnerId);
 
+    AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
+        AcpiGbl_RootNode, OwnerId);
 
-/******************************************************************************
- *
- * FUNCTION:    AdGetLocalTables
- *
- * PARAMETERS:  None
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Get the ACPI tables from either memory or a file
- *
- *****************************************************************************/
-
-ACPI_STATUS
-AdGetLocalTables (
-    void)
-{
-    ACPI_STATUS             Status;
-    ACPI_TABLE_HEADER       TableHeader;
-    ACPI_TABLE_HEADER       *NewTable;
-    UINT32                  TableIndex;
-
+    /* Debug output - namespace and parse tree */
 
-    /* Get the DSDT via table override */
-
-    ACPI_MOVE_32_TO_32 (TableHeader.Signature, ACPI_SIG_DSDT);
-    AcpiOsTableOverride (&TableHeader, &NewTable);
-    if (!NewTable)
+    if (AslCompilerdebug)
     {
-        fprintf (stderr, "Could not obtain DSDT\n");
-        return (AE_NO_ACPI_TABLES);
-    }
-
-    AdWriteTable (NewTable, NewTable->Length,
-        ACPI_SIG_DSDT, NewTable->OemTableId);
-
-    /* Store DSDT in the Table Manager */
+        AcpiOsPrintf ("/**** After second load and resource conversion\n");
+        if (File)
+        {
+            NsSetupNamespaceListing (File);
+            NsDisplayNamespace ();
+        }
 
-    Status = AdStoreTable (NewTable, &TableIndex);
-    if (ACPI_FAILURE (Status))
-    {
-        fprintf (stderr, "Could not store DSDT\n");
-        return (AE_NO_ACPI_TABLES);
+        AcpiOsPrintf ("*****/\n");
+        AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
     }
 
     return (AE_OK);
@@ -851,134 +548,108 @@ AdGetLocalTables (
 
 /******************************************************************************
  *
- * FUNCTION:    AdParseTable
+ * FUNCTION:    AdDoExternalFileList
  *
- * PARAMETERS:  Table               - Pointer to the raw table
- *              OwnerId             - Returned OwnerId of the table
- *              LoadTable           - If add table to the global table list
- *              External            - If this is an external table
+ * PARAMETERS:  Filename            - Input file for the table
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Parse the DSDT.
+ * DESCRIPTION: Process all tables found in the -e external files list
  *
  *****************************************************************************/
 
-ACPI_STATUS
-AdParseTable (
-    ACPI_TABLE_HEADER       *Table,
-    ACPI_OWNER_ID           *OwnerId,
-    BOOLEAN                 LoadTable,
-    BOOLEAN                 External)
+static ACPI_STATUS
+AdDoExternalFileList (
+    char                    *Filename)
 {
-    ACPI_STATUS             Status = AE_OK;
-    ACPI_WALK_STATE         *WalkState;
-    UINT8                   *AmlStart;
-    UINT32                  AmlLength;
-    UINT32                  TableIndex;
-
-
-    if (!Table)
-    {
-        return (AE_NOT_EXIST);
-    }
-
-    /* Pass 1:  Parse everything except control method bodies */
-
-    fprintf (stderr, "Pass 1 parse of [%4.4s]\n", (char *) Table->Signature);
-
-    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
-    AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER));
-
-    /* Create the root object */
-
-    AcpiGbl_ParseOpRoot = AcpiPsCreateScopeOp (AmlStart);
-    if (!AcpiGbl_ParseOpRoot)
-    {
-        return (AE_NO_MEMORY);
-    }
-
-    /* Create and initialize a new walk state */
+    ACPI_EXTERNAL_FILE      *ExternalFileList;
+    char                    *ExternalFilename;
+    ACPI_NEW_TABLE_DESC     *ExternalListHead = NULL;
+    ACPI_STATUS             Status;
+    ACPI_STATUS             GlobalStatus = AE_OK;
+    ACPI_OWNER_ID           OwnerId;
 
-    WalkState = AcpiDsCreateWalkState (0,
-                        AcpiGbl_ParseOpRoot, NULL, NULL);
-    if (!WalkState)
-    {
-        return (AE_NO_MEMORY);
-    }
 
-    Status = AcpiDsInitAmlWalk (WalkState, AcpiGbl_ParseOpRoot,
-                NULL, AmlStart, AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
-    if (ACPI_FAILURE (Status))
-    {
-        return (Status);
-    }
+    /*
+     * External filenames are specified on the command line like this:
+     * Example: iasl -e file1,file2,file3 -d xxx.aml
+     */
+    ExternalFileList = AcpiGbl_ExternalFileList;
 
-    WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;
-    WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
+    /* Process each external file */
 
-    Status = AcpiPsParseAml (WalkState);
-    if (ACPI_FAILURE (Status))
+    while (ExternalFileList)
     {
-        return (Status);
-    }
-
-    /* If LoadTable is FALSE, we are parsing the last loaded table */
+        ExternalFilename = ExternalFileList->Path;
+        if (!strcmp (ExternalFilename, Filename))
+        {
+            /* Next external file */
 
-    TableIndex = AcpiGbl_RootTableList.CurrentTableCount - 1;
+            ExternalFileList = ExternalFileList->Next;
+            continue;
+        }
 
-    /* Pass 2 */
+        AcpiOsPrintf ("External object resolution file %16s\n",
+            ExternalFilename);
 
-    if (LoadTable)
-    {
-        Status = AdStoreTable (Table, &TableIndex);
-        if (ACPI_FAILURE (Status))
-        {
-            return (Status);
-        }
-        Status = AcpiTbAllocateOwnerId (TableIndex);
+        Status = AcpiAcGetAllTablesFromFile (
+            ExternalFilename, ACPI_GET_ONLY_AML_TABLES, &ExternalListHead);
         if (ACPI_FAILURE (Status))
         {
+            if (Status == AE_TYPE)
+            {
+                ExternalFileList = ExternalFileList->Next;
+                GlobalStatus = AE_TYPE;
+                Status = AE_OK;
+                continue;
+            }
+
             return (Status);
         }
-        if (OwnerId)
+
+        /* Load external tables for symbol resolution */
+
+        while (ExternalListHead)
         {
-            Status = AcpiTbGetOwnerId (TableIndex, OwnerId);
+            Status = AdParseTable (
+                ExternalListHead->Table, &OwnerId, TRUE, TRUE);
             if (ACPI_FAILURE (Status))
             {
+                AcpiOsPrintf ("Could not parse external ACPI tables, %s\n",
+                    AcpiFormatException (Status));
                 return (Status);
             }
+
+            /*
+             * Load namespace from names created within control methods
+             * Set owner id of nodes in external table
+             */
+            AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
+                AcpiGbl_RootNode, OwnerId);
+            AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
+
+            ExternalListHead = ExternalListHead->Next;
         }
-    }
 
-    fprintf (stderr, "Pass 2 parse of [%4.4s]\n", (char *) Table->Signature);
+        /* Next external file */
 
-    Status = AcpiNsOneCompleteParse (ACPI_IMODE_LOAD_PASS2, TableIndex, NULL);
-    if (ACPI_FAILURE (Status))
-    {
-        return (Status);
+        ExternalFileList = ExternalFileList->Next;
     }
 
-    /* No need to parse control methods of external table */
-
-    if (External)
+    if (ACPI_FAILURE (GlobalStatus))
     {
-        return (AE_OK);
+        return (GlobalStatus);
     }
 
-    /*
-     * Pass 3: Parse control methods and link their parse trees
-     * into the main parse tree
-     */
-    fprintf (stderr,
-        "Parsing Deferred Opcodes (Methods/Buffers/Packages/Regions)\n");
-    Status = AcpiDmParseDeferredOps (AcpiGbl_ParseOpRoot);
-    fprintf (stderr, "\n");
+    /* Clear external list generated by Scope in external tables */
 
-    /* Process Resource Templates */
+    if (AcpiGbl_ExternalFileList)
+    {
+        AcpiDmClearExternalList ();
+    }
 
-    AcpiDmFindResources (AcpiGbl_ParseOpRoot);
+    /* Load any externals defined in the optional external ref file */
 
-    fprintf (stderr, "Parsing completed\n");
+    AcpiDmGetExternalsFromFile ();
     return (AE_OK);
 }
diff --git a/source/common/adwalk.c b/source/common/adwalk.c
index 270367521c194..41499090c97a5 100644
--- a/source/common/adwalk.c
+++ b/source/common/adwalk.c
@@ -135,6 +135,7 @@ AcpiDmDumpTree (
     Info.Count = 0;
     Info.Level = 0;
     Info.WalkState = NULL;
+
     AcpiDmWalkParseTree (Origin, AcpiDmDumpDescending, NULL, &Info);
     AcpiOsPrintf ("*/\n\n");
 }
@@ -168,6 +169,7 @@ AcpiDmFindOrphanMethods (
     Info.Flags = 0;
     Info.Level = 0;
     Info.WalkState = NULL;
+
     AcpiDmWalkParseTree (Origin, AcpiDmFindOrphanDescending, NULL, &Info);
 }
 
@@ -211,7 +213,8 @@ AcpiDmFinishNamespaceLoad (
         return;
     }
 
-    Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type, WalkState);
+    Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type,
+        WalkState);
     if (ACPI_FAILURE (Status))
     {
         return;
@@ -220,6 +223,7 @@ AcpiDmFinishNamespaceLoad (
     Info.Flags = 0;
     Info.Level = 0;
     Info.WalkState = WalkState;
+
     AcpiDmWalkParseTree (ParseTreeRoot, AcpiDmLoadDescendingOp,
         AcpiDmCommonAscendingOp, &Info);
     ACPI_FREE (WalkState);
@@ -264,7 +268,8 @@ AcpiDmCrossReferenceNamespace (
         return;
     }
 
-    Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type, WalkState);
+    Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type,
+        WalkState);
     if (ACPI_FAILURE (Status))
     {
         return;
@@ -273,6 +278,7 @@ AcpiDmCrossReferenceNamespace (
     Info.Flags = 0;
     Info.Level = 0;
     Info.WalkState = WalkState;
+
     AcpiDmWalkParseTree (ParseTreeRoot, AcpiDmXrefDescendingOp,
         AcpiDmCommonAscendingOp, &Info);
     ACPI_FREE (WalkState);
@@ -317,7 +323,8 @@ AcpiDmConvertResourceIndexes (
         return;
     }
 
-    Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type, WalkState);
+    Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type,
+        WalkState);
     if (ACPI_FAILURE (Status))
     {
         return;
@@ -326,6 +333,7 @@ AcpiDmConvertResourceIndexes (
     Info.Flags = 0;
     Info.Level = 0;
     Info.WalkState = WalkState;
+
     AcpiDmWalkParseTree (ParseTreeRoot, AcpiDmResourceDescendingOp,
         AcpiDmCommonAscendingOp, &Info);
     ACPI_FREE (WalkState);
@@ -396,7 +404,7 @@ AcpiDmDumpDescending (
         if (Op->Common.Value.String)
         {
             AcpiNsExternalizeName (ACPI_UINT32_MAX, Op->Common.Value.String,
-                            NULL, &Path);
+                NULL, &Path);
             AcpiOsPrintf ("%s %p", Path, Op->Common.Node);
             ACPI_FREE (Path);
         }
@@ -655,6 +663,7 @@ AcpiDmLoadDescendingOp (
         {
             NextOp = NextOp->Common.Next;
         }
+
         Path = NextOp->Common.Value.String;
     }
 
@@ -666,8 +675,8 @@ AcpiDmLoadDescendingOp (
     /* Insert the name into the namespace */
 
     Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
-                ACPI_IMODE_LOAD_PASS2, ACPI_NS_DONT_OPEN_SCOPE,
-                WalkState, &Node);
+        ACPI_IMODE_LOAD_PASS2, ACPI_NS_DONT_OPEN_SCOPE,
+        WalkState, &Node);
 
     Op->Common.Node = Node;
 
@@ -708,7 +717,8 @@ Exit:
     {
         if (Op->Common.Node)
         {
-            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);
+            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType,
+                WalkState);
             if (ACPI_FAILURE (Status))
             {
                 return (Status);
@@ -825,8 +835,8 @@ AcpiDmXrefDescendingOp (
      */
     Node = NULL;
     Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY,
-                ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
-                WalkState, &Node);
+        ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
+        WalkState, &Node);
     if (ACPI_SUCCESS (Status) && (Node->Flags & ANOBJ_IS_EXTERNAL))
     {
         /* Node was created by an External() statement */
@@ -908,7 +918,8 @@ Exit:
     {
         if (Op->Common.Node)
         {
-            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);
+            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType,
+                WalkState);
             if (ACPI_FAILURE (Status))
             {
                 return (Status);
@@ -956,7 +967,8 @@ AcpiDmResourceDescendingOp (
         if (Op->Common.Node)
         {
 
-            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);
+            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType,
+                WalkState);
             if (ACPI_FAILURE (Status))
             {
                 return (Status);
diff --git a/source/common/ahuuids.c b/source/common/ahuuids.c
index d48ea40e6c576..a264ccb9f45b4 100644
--- a/source/common/ahuuids.c
+++ b/source/common/ahuuids.c
@@ -48,6 +48,7 @@
 #define _COMPONENT          ACPI_UTILITIES
         ACPI_MODULE_NAME    ("ahuuids")
 
+
 /*
  * Table of "known" (ACPI-related) UUIDs
  */
diff --git a/source/common/dmextern.c b/source/common/dmextern.c
index 30beba36d34e9..e09550b495f50 100644
--- a/source/common/dmextern.c
+++ b/source/common/dmextern.c
@@ -140,7 +140,6 @@ AcpiDmGetObjectTypeName (
     {
         Type = ACPI_TYPE_DEVICE;
     }
-
     else if (Type > ACPI_TYPE_LOCAL_INDEX_FIELD)
     {
         return ("");
@@ -410,6 +409,7 @@ AcpiDmGetExternalsFromFile (
         {
             continue;
         }
+
         if (strcmp (Token, "External"))
         {
             continue;
@@ -447,6 +447,7 @@ AcpiDmGetExternalsFromFile (
             fprintf (stderr, "Invalid argument count (%s)\n", Token);
             continue;
         }
+
         if (ArgCount > 7)
         {
             fprintf (stderr, "Invalid argument count (%u)\n", ArgCount);
@@ -465,7 +466,8 @@ AcpiDmGetExternalsFromFile (
 
     if (!ImportCount)
     {
-        fprintf (stderr, "Did not find any external methods in reference file \"%s\"\n",
+        fprintf (stderr,
+            "Did not find any external methods in reference file \"%s\"\n",
             Gbl_ExternalRefFilename);
     }
     else
@@ -815,7 +817,8 @@ AcpiDmCreateNewExternal (
                 (Value > 0))
             {
                 ACPI_ERROR ((AE_INFO,
-                    "External method arg count mismatch %s: Current %u, attempted %u",
+                    "External method arg count mismatch %s: "
+                    "Current %u, attempted %u",
                     NextExternal->Path, NextExternal->Value, Value));
             }
 
@@ -917,9 +920,9 @@ AcpiDmAddExternalsToNamespace (
         /* Add the external name (object) into the namespace */
 
         Status = AcpiNsLookup (NULL, External->InternalPath, External->Type,
-                   ACPI_IMODE_LOAD_PASS1,
-                   ACPI_NS_ERROR_IF_FOUND | ACPI_NS_EXTERNAL | ACPI_NS_DONT_OPEN_SCOPE,
-                   NULL, &Node);
+            ACPI_IMODE_LOAD_PASS1,
+            ACPI_NS_ERROR_IF_FOUND | ACPI_NS_EXTERNAL | ACPI_NS_DONT_OPEN_SCOPE,
+            NULL, &Node);
 
         if (ACPI_FAILURE (Status))
         {
diff --git a/source/common/dmrestag.c b/source/common/dmrestag.c
index de81db569646a..d051660729290 100644
--- a/source/common/dmrestag.c
+++ b/source/common/dmrestag.c
@@ -498,9 +498,9 @@ AcpiDmCheckResourceReference (
     /* Lookup the buffer in the namespace */
 
     Status = AcpiNsLookup (WalkState->ScopeInfo,
-                BufferNameOp->Common.Value.String, ACPI_TYPE_BUFFER,
-                ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState,
-                &BufferNode);
+        BufferNameOp->Common.Value.String, ACPI_TYPE_BUFFER,
+        ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState,
+        &BufferNode);
     if (ACPI_FAILURE (Status))
     {
         return;
@@ -621,8 +621,8 @@ AcpiGetTagPathname (
 
     /* Get the individual resource descriptor and validate it */
 
-    Aml = ACPI_CAST_PTR (AML_RESOURCE,
-            &Op->Named.Data[ResourceNode->Value]);
+    Aml = ACPI_CAST_PTR (
+        AML_RESOURCE, &Op->Named.Data[ResourceNode->Value]);
 
     Status = AcpiUtValidateResource (NULL, Aml, &ResourceTableIndex);
     if (ACPI_FAILURE (Status))
@@ -663,7 +663,7 @@ AcpiGetTagPathname (
     }
 
     (void) AcpiNsBuildNormalizedPath (BufferNode, Pathname,
-            RequiredSize, FALSE);
+        RequiredSize, FALSE);
 
     /*
      * Create the full path to the resource and tag by: remove the buffer name,
@@ -742,6 +742,7 @@ AcpiDmUpdateResourceName (
     {
         AcpiGbl_NextResourceId = 0;
         AcpiGbl_NextPrefix++;
+
         if (AcpiGbl_NextPrefix > ACPI_NUM_RES_PREFIX)
         {
             AcpiGbl_NextPrefix = 0;
@@ -1028,9 +1029,9 @@ AcpiDmAddResourceToNamespace (
 
     ScopeInfo.Scope.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Context);
     Status = AcpiNsLookup (&ScopeInfo, "_TMP", ACPI_TYPE_LOCAL_RESOURCE,
-                ACPI_IMODE_LOAD_PASS2,
-                ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE | ACPI_NS_PREFIX_IS_SCOPE,
-                NULL, &Node);
+        ACPI_IMODE_LOAD_PASS2,
+        ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE | ACPI_NS_PREFIX_IS_SCOPE,
+        NULL, &Node);
     if (ACPI_FAILURE (Status))
     {
         return (AE_OK);
diff --git a/source/common/dmtable.c b/source/common/dmtable.c
index 3f9e64dbdca35..b66734c8f2329 100644
--- a/source/common/dmtable.c
+++ b/source/common/dmtable.c
@@ -875,6 +875,7 @@ AcpiDmDumpTable (
                 AcpiOsPrintf ("\n");
                 LastOutputBlankLine = TRUE;
             }
+
             ByteLength = sizeof (ACPI_GENERIC_ADDRESS);
             break;
 
@@ -885,6 +886,7 @@ AcpiDmDumpTable (
                 AcpiOsPrintf ("\n");
                 LastOutputBlankLine = TRUE;
             }
+
             ByteLength = sizeof (ACPI_HEST_NOTIFY);
             break;
 
@@ -894,6 +896,7 @@ AcpiDmDumpTable (
             {
                 LastOutputBlankLine = FALSE;
             }
+
             ByteLength = sizeof (ACPI_IORT_MEMORY_ACCESS);
             break;
 
@@ -1027,6 +1030,7 @@ AcpiDmDumpTable (
                     }
                 }
             }
+
             AcpiOsPrintf ("\n");
             break;
 
@@ -1050,6 +1054,7 @@ AcpiDmDumpTable (
 
             AcpiDmCheckAscii (Target, RepairedName, 4);
             AcpiOsPrintf ("\"%.4s\"    ", RepairedName);
+
             TableData = AcpiAhGetTableInfo (ACPI_CAST_PTR (char, Target));
             if (TableData)
             {
@@ -1095,6 +1100,7 @@ AcpiDmDumpTable (
                 AcpiOsPrintf (
                     "     /* Incorrect checksum, should be %2.2X */", Temp8);
             }
+
             AcpiOsPrintf ("\n");
             break;
 
diff --git a/source/common/dmtables.c b/source/common/dmtables.c
new file mode 100644
index 0000000000000..0313068d29427
--- /dev/null
+++ b/source/common/dmtables.c
@@ -0,0 +1,499 @@
+/******************************************************************************
+ *
+ * Module Name: dmtables - disassembler ACPI table support
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2015, 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.
+ */
+
+#include "aslcompiler.h"
+#include "acapps.h"
+#include "acdispat.h"
+#include "acnamesp.h"
+#include "actables.h"
+#include "acparser.h"
+
+#include <stdio.h>
+#include <time.h>
+
+#define _COMPONENT          ACPI_TOOLS
+        ACPI_MODULE_NAME    ("dmtables")
+
+
+/* Local prototypes */
+
+static void
+AdCreateTableHeader (
+    char                    *Filename,
+    ACPI_TABLE_HEADER       *Table);
+
+static ACPI_STATUS
+AdStoreTable (
+    ACPI_TABLE_HEADER       *Table,
+    UINT32                  *TableIndex);
+
+
+extern ACPI_TABLE_DESC      LocalTables[1];
+extern ACPI_PARSE_OBJECT    *AcpiGbl_ParseOpRoot;
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AdDisassemblerHeader
+ *
+ * PARAMETERS:  Filename            - Input file for the table
+ *              TableType           - Either AML or DataTable
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Create the disassembler header, including ACPICA signon with
+ *              current time and date.
+ *
+ *****************************************************************************/
+
+void
+AdDisassemblerHeader (
+    char                    *Filename,
+    UINT8                   TableType)
+{
+    time_t                  Timer;
+
+
+    time (&Timer);
+
+    /* Header and input table info */
+
+    AcpiOsPrintf ("/*\n");
+    AcpiOsPrintf (ACPI_COMMON_HEADER (AML_DISASSEMBLER_NAME, " * "));
+
+    if (TableType == ACPI_IS_AML_TABLE)
+    {
+        if (AcpiGbl_CstyleDisassembly)
+        {
+            AcpiOsPrintf (
+                " * Disassembling to symbolic ASL+ operators\n"
+                " *\n");
+        }
+        else
+        {
+            AcpiOsPrintf (
+                " * Disassembling to non-symbolic legacy ASL operators\n"
+                " *\n");
+        }
+    }
+
+    AcpiOsPrintf (" * Disassembly of %s, %s", Filename, ctime (&Timer));
+    AcpiOsPrintf (" *\n");
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AdCreateTableHeader
+ *
+ * PARAMETERS:  Filename            - Input file for the table
+ *              Table               - Pointer to the raw table
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Create the ASL table header, including ACPICA signon with
+ *              current time and date.
+ *
+ *****************************************************************************/
+
+static void
+AdCreateTableHeader (
+    char                    *Filename,
+    ACPI_TABLE_HEADER       *Table)
+{
+    char                    *NewFilename;
+    UINT8                   Checksum;
+
+
+    /*
+     * Print file header and dump original table header
+     */
+    AdDisassemblerHeader (Filename, ACPI_IS_AML_TABLE);
+
+    AcpiOsPrintf (" * Original Table Header:\n");
+    AcpiOsPrintf (" *     Signature        \"%4.4s\"\n",    Table->Signature);
+    AcpiOsPrintf (" *     Length           0x%8.8X (%u)\n", Table->Length, Table->Length);
+
+    /* Print and validate the revision */
+
+    AcpiOsPrintf (" *     Revision         0x%2.2X",      Table->Revision);
+
+    switch (Table->Revision)
+    {
+    case 0:
+
+        AcpiOsPrintf (" **** Invalid Revision");
+        break;
+
+    case 1:
+
+        /* Revision of DSDT controls the ACPI integer width */
+
+        if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_DSDT))
+        {
+            AcpiOsPrintf (" **** 32-bit table (V1), no 64-bit math support");
+        }
+        break;
+
+    default:
+
+        break;
+    }
+    AcpiOsPrintf ("\n");
+
+    /* Print and validate the table checksum */
+
+    AcpiOsPrintf (" *     Checksum         0x%2.2X",        Table->Checksum);
+
+    Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Table->Length);
+    if (Checksum)
+    {
+        AcpiOsPrintf (" **** Incorrect checksum, should be 0x%2.2X",
+            (UINT8) (Table->Checksum - Checksum));
+    }
+
+    AcpiOsPrintf ("\n");
+    AcpiOsPrintf (" *     OEM ID           \"%.6s\"\n",     Table->OemId);
+    AcpiOsPrintf (" *     OEM Table ID     \"%.8s\"\n",     Table->OemTableId);
+    AcpiOsPrintf (" *     OEM Revision     0x%8.8X (%u)\n", Table->OemRevision, Table->OemRevision);
+    AcpiOsPrintf (" *     Compiler ID      \"%.4s\"\n",     Table->AslCompilerId);
+    AcpiOsPrintf (" *     Compiler Version 0x%8.8X (%u)\n", Table->AslCompilerRevision, Table->AslCompilerRevision);
+    AcpiOsPrintf (" */\n");
+
+    /* Create AML output filename based on input filename */
+
+    if (Filename)
+    {
+        NewFilename = FlGenerateFilename (Filename, "aml");
+    }
+    else
+    {
+        NewFilename = UtStringCacheCalloc (9);
+        if (NewFilename)
+        {
+            strncat (NewFilename, Table->Signature, 4);
+            strcat (NewFilename, ".aml");
+        }
+    }
+
+    if (!NewFilename)
+    {
+        AcpiOsPrintf (" **** Could not generate AML output filename\n");
+        return;
+    }
+
+    /* Open the ASL definition block */
+
+    AcpiOsPrintf (
+        "DefinitionBlock (\"%s\", \"%4.4s\", %hu, \"%.6s\", \"%.8s\", 0x%8.8X)\n",
+        NewFilename, Table->Signature, Table->Revision,
+        Table->OemId, Table->OemTableId, Table->OemRevision);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AdDisplayTables
+ *
+ * PARAMETERS:  Filename            - Input file for the table
+ *              Table               - Pointer to the raw table
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Display (disassemble) loaded tables and dump raw tables
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+AdDisplayTables (
+    char                    *Filename,
+    ACPI_TABLE_HEADER       *Table)
+{
+
+
+    if (!AcpiGbl_ParseOpRoot)
+    {
+        return (AE_NOT_EXIST);
+    }
+
+    if (!AcpiGbl_DmOpt_Listing)
+    {
+        AdCreateTableHeader (Filename, Table);
+    }
+
+    AcpiDmDisassemble (NULL, AcpiGbl_ParseOpRoot, ACPI_UINT32_MAX);
+    MpEmitMappingInfo ();
+
+    if (AcpiGbl_DmOpt_Listing)
+    {
+        AcpiOsPrintf ("\n\nTable Header:\n");
+        AcpiUtDebugDumpBuffer ((UINT8 *) Table, sizeof (ACPI_TABLE_HEADER),
+            DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
+
+        AcpiOsPrintf ("Table Body (Length 0x%X)\n", Table->Length);
+        AcpiUtDebugDumpBuffer (((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER)),
+            Table->Length, DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
+    }
+
+    return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AdStoreTable
+ *
+ * PARAMETERS:  Table               - Table header
+ *              TableIndex          - Where the table index is returned
+ *
+ * RETURN:      Status and table index.
+ *
+ * DESCRIPTION: Add an ACPI table to the global table list
+ *
+ ******************************************************************************/
+
+static ACPI_STATUS
+AdStoreTable (
+    ACPI_TABLE_HEADER       *Table,
+    UINT32                  *TableIndex)
+{
+    ACPI_STATUS             Status;
+    ACPI_TABLE_DESC         *TableDesc;
+
+
+    Status = AcpiTbGetNextTableDescriptor (TableIndex, &TableDesc);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* Initialize added table */
+
+    AcpiTbInitTableDescriptor (TableDesc, ACPI_PTR_TO_PHYSADDR (Table),
+        ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, Table);
+    Status = AcpiTbValidateTable (TableDesc);
+    return (Status);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AdGetLocalTables
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Get the ACPI tables from either memory or a file
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+AdGetLocalTables (
+    void)
+{
+    ACPI_STATUS             Status;
+    ACPI_TABLE_HEADER       TableHeader;
+    ACPI_TABLE_HEADER       *NewTable;
+    UINT32                  TableIndex;
+
+
+    /* Get the DSDT via table override */
+
+    ACPI_MOVE_32_TO_32 (TableHeader.Signature, ACPI_SIG_DSDT);
+    AcpiOsTableOverride (&TableHeader, &NewTable);
+    if (!NewTable)
+    {
+        fprintf (stderr, "Could not obtain DSDT\n");
+        return (AE_NO_ACPI_TABLES);
+    }
+
+    AdWriteTable (NewTable, NewTable->Length,
+        ACPI_SIG_DSDT, NewTable->OemTableId);
+
+    /* Store DSDT in the Table Manager */
+
+    Status = AdStoreTable (NewTable, &TableIndex);
+    if (ACPI_FAILURE (Status))
+    {
+        fprintf (stderr, "Could not store DSDT\n");
+        return (AE_NO_ACPI_TABLES);
+    }
+
+    return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AdParseTable
+ *
+ * PARAMETERS:  Table               - Pointer to the raw table
+ *              OwnerId             - Returned OwnerId of the table
+ *              LoadTable           - If add table to the global table list
+ *              External            - If this is an external table
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Parse an ACPI AML table
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+AdParseTable (
+    ACPI_TABLE_HEADER       *Table,
+    ACPI_OWNER_ID           *OwnerId,
+    BOOLEAN                 LoadTable,
+    BOOLEAN                 External)
+{
+    ACPI_STATUS             Status = AE_OK;
+    ACPI_WALK_STATE         *WalkState;
+    UINT8                   *AmlStart;
+    UINT32                  AmlLength;
+    UINT32                  TableIndex;
+
+
+    if (!Table)
+    {
+        return (AE_NOT_EXIST);
+    }
+
+    /* Pass 1:  Parse everything except control method bodies */
+
+    fprintf (stderr, "Pass 1 parse of [%4.4s]\n", (char *) Table->Signature);
+
+    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
+    AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER));
+
+    /* Create the root object */
+
+    AcpiGbl_ParseOpRoot = AcpiPsCreateScopeOp (AmlStart);
+    if (!AcpiGbl_ParseOpRoot)
+    {
+        return (AE_NO_MEMORY);
+    }
+
+    /* Create and initialize a new walk state */
+
+    WalkState = AcpiDsCreateWalkState (0, AcpiGbl_ParseOpRoot, NULL, NULL);
+    if (!WalkState)
+    {
+        return (AE_NO_MEMORY);
+    }
+
+    Status = AcpiDsInitAmlWalk (WalkState, AcpiGbl_ParseOpRoot,
+        NULL, AmlStart, AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;
+    WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
+
+    Status = AcpiPsParseAml (WalkState);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* If LoadTable is FALSE, we are parsing the last loaded table */
+
+    TableIndex = AcpiGbl_RootTableList.CurrentTableCount - 1;
+
+    /* Pass 2 */
+
+    if (LoadTable)
+    {
+        Status = AdStoreTable (Table, &TableIndex);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+        Status = AcpiTbAllocateOwnerId (TableIndex);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+        if (OwnerId)
+        {
+            Status = AcpiTbGetOwnerId (TableIndex, OwnerId);
+            if (ACPI_FAILURE (Status))
+            {
+                return (Status);
+            }
+        }
+    }
+
+    fprintf (stderr, "Pass 2 parse of [%4.4s]\n", (char *) Table->Signature);
+
+    Status = AcpiNsOneCompleteParse (ACPI_IMODE_LOAD_PASS2, TableIndex, NULL);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* No need to parse control methods of external table */
+
+    if (External)
+    {
+        return (AE_OK);
+    }
+
+    /*
+     * Pass 3: Parse control methods and link their parse trees
+     * into the main parse tree
+     */
+    fprintf (stderr,
+        "Parsing Deferred Opcodes (Methods/Buffers/Packages/Regions)\n");
+
+    Status = AcpiDmParseDeferredOps (AcpiGbl_ParseOpRoot);
+    fprintf (stderr, "\n");
+
+    /* Process Resource Templates */
+
+    AcpiDmFindResources (AcpiGbl_ParseOpRoot);
+
+    fprintf (stderr, "Parsing completed\n");
+    return (AE_OK);
+}
diff --git a/source/common/dmtbdump.c b/source/common/dmtbdump.c
index 7ec19bc960260..2ae3ca791bef1 100644
--- a/source/common/dmtbdump.c
+++ b/source/common/dmtbdump.c
@@ -178,6 +178,7 @@ AcpiDmDumpUnicode (
     {
         AcpiOsPrintf ("%c", Buffer[i]);
     }
+
     AcpiOsPrintf ("\"\n");
     return;
 
@@ -222,7 +223,7 @@ AcpiDmDumpRsdp (
     /* Validate the first checksum */
 
     Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
-                Rsdp->Checksum);
+        Rsdp->Checksum);
     if (Checksum != Rsdp->Checksum)
     {
         AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
@@ -243,7 +244,7 @@ AcpiDmDumpRsdp (
         /* Validate the extended checksum over entire RSDP */
 
         Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
-                    Rsdp->ExtendedChecksum);
+            Rsdp->ExtendedChecksum);
         if (Checksum != Rsdp->ExtendedChecksum)
         {
             AcpiOsPrintf (
@@ -361,7 +362,8 @@ AcpiDmDumpFadt (
 
     /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
 
-    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
+    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
+        AcpiDmTableInfoFadt1);
     if (ACPI_FAILURE (Status))
     {
         return;
@@ -372,7 +374,8 @@ AcpiDmDumpFadt (
     if ((Table->Length > ACPI_FADT_V1_SIZE) &&
         (Table->Length <= ACPI_FADT_V2_SIZE))
     {
-        Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
+        Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
+            AcpiDmTableInfoFadt2);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -383,7 +386,8 @@ AcpiDmDumpFadt (
 
     else if (Table->Length > ACPI_FADT_V2_SIZE)
     {
-        Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
+        Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
+            AcpiDmTableInfoFadt3);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -393,7 +397,8 @@ AcpiDmDumpFadt (
 
         if (Table->Length > ACPI_FADT_V3_SIZE)
         {
-            Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt5);
+            Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
+                AcpiDmTableInfoFadt5);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -404,7 +409,8 @@ AcpiDmDumpFadt (
 
         if (Table->Length > ACPI_FADT_V3_SIZE)
         {
-            Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt6);
+            Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
+                AcpiDmTableInfoFadt6);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -485,7 +491,8 @@ AcpiDmValidateFadtLength (
     }
 
     AcpiOsPrintf (
-        "\n// ACPI Warning: FADT revision %X does not match length: found %X expected %X\n",
+        "\n// ACPI Warning: FADT revision %X does not match length: "
+        "found %X expected %X\n",
         Revision, Length, ExpectedLength);
 }
 
@@ -527,7 +534,7 @@ AcpiDmDumpAsf (
         /* Common subtable header */
 
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
+            SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -579,12 +586,13 @@ AcpiDmDumpAsf (
 
         default:
 
-            AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n", SubTable->Header.Type);
+            AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",
+                SubTable->Header.Type);
             return;
         }
 
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    SubTable->Header.Length, InfoTable);
+            SubTable->Header.Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -601,7 +609,7 @@ AcpiDmDumpAsf (
             {
                 AcpiOsPrintf ("\n");
                 Status = AcpiDmDumpTable (Table->Length, DataOffset,
-                            DataTable, DataLength, DataInfoTable);
+                    DataTable, DataLength, DataInfoTable);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -624,9 +632,12 @@ AcpiDmDumpAsf (
                 AcpiOsPrintf ("%2.2X ", *DataTable);
                 DataTable++;
                 DataOffset++;
+
                 if (DataOffset > Table->Length)
                 {
-                    AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure! (ASF! table)\n");
+                    AcpiOsPrintf (
+                        "**** ACPI table terminates in the middle of a "
+                        "data structure! (ASF! table)\n");
                     return;
                 }
             }
@@ -650,7 +661,8 @@ AcpiDmDumpAsf (
         }
 
         Offset += SubTable->Header.Length;
-        SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
+        SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable,
+            SubTable->Header.Length);
     }
 }
 
@@ -693,7 +705,7 @@ AcpiDmDumpCpep (
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Header.Length, AcpiDmTableInfoCpep0);
+            SubTable->Header.Length, AcpiDmTableInfoCpep0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -703,7 +715,7 @@ AcpiDmDumpCpep (
 
         Offset += SubTable->Header.Length;
         SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
-                    SubTable->Header.Length);
+            SubTable->Header.Length);
     }
 }
 
@@ -747,7 +759,7 @@ AcpiDmDumpCsrt (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoCsrt0);
+            SubTable->Length, AcpiDmTableInfoCsrt0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -761,7 +773,7 @@ AcpiDmDumpCsrt (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
-                    sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
+            sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -779,7 +791,7 @@ AcpiDmDumpCsrt (
         {
             AcpiOsPrintf ("\n");
             Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable,
-                        SubSubTable->Length, AcpiDmTableInfoCsrt2);
+                SubSubTable->Length, AcpiDmTableInfoCsrt2);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -793,8 +805,8 @@ AcpiDmDumpCsrt (
             if (InfoLength)
             {
                 Status = AcpiDmDumpTable (Length,
-                            Offset + SubOffset + SubSubOffset, Table,
-                            InfoLength, AcpiDmTableInfoCsrt2a);
+                    Offset + SubOffset + SubSubOffset, Table,
+                    InfoLength, AcpiDmTableInfoCsrt2a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -806,14 +818,14 @@ AcpiDmDumpCsrt (
 
             SubOffset += SubSubTable->Length;
             SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable,
-                        SubSubTable->Length);
+                SubSubTable->Length);
         }
 
         /* Point to next subtable */
 
         Offset += SubTable->Length;
         SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable,
-                    SubTable->Length);
+            SubTable->Length);
     }
 }
 
@@ -860,7 +872,7 @@ AcpiDmDumpDbg2 (
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoDbg2Device);
+            SubTable->Length, AcpiDmTableInfoDbg2Device);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -876,7 +888,7 @@ AcpiDmDumpDbg2 (
             Array = (UINT8 *) SubTable + ArrayOffset;
 
             Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
-                        SubTable->Length, AcpiDmTableInfoDbg2Addr);
+                SubTable->Length, AcpiDmTableInfoDbg2Addr);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -893,7 +905,7 @@ AcpiDmDumpDbg2 (
             Array = (UINT8 *) SubTable + ArrayOffset;
 
             Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
-                        SubTable->Length, AcpiDmTableInfoDbg2Size);
+                SubTable->Length, AcpiDmTableInfoDbg2Size);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -908,7 +920,7 @@ AcpiDmDumpDbg2 (
         Array = (UINT8 *) SubTable + ArrayOffset;
 
         Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
-                    SubTable->Length, AcpiDmTableInfoDbg2Name);
+            SubTable->Length, AcpiDmTableInfoDbg2Name);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -919,8 +931,8 @@ AcpiDmDumpDbg2 (
         if (SubTable->OemDataOffset)
         {
             Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset,
-                        Table, SubTable->OemDataLength,
-                        AcpiDmTableInfoDbg2OemData);
+                Table, SubTable->OemDataLength,
+                AcpiDmTableInfoDbg2OemData);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -931,7 +943,7 @@ AcpiDmDumpDbg2 (
 
         Offset += SubTable->Length;
         SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
-                    SubTable->Length);
+            SubTable->Length);
     }
 }
 
@@ -981,11 +993,12 @@ AcpiDmDumpDmar (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoDmarHdr);
+            SubTable->Length, AcpiDmTableInfoDmarHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
         }
+
         AcpiOsPrintf ("\n");
 
         switch (SubTable->Type)
@@ -1022,12 +1035,13 @@ AcpiDmDumpDmar (
 
         default:
 
-            AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
+                SubTable->Type);
             return;
         }
 
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, InfoTable);
+            SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1049,7 +1063,7 @@ AcpiDmDumpDmar (
         {
             AcpiOsPrintf ("\n");
             Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
-                        ScopeTable->Length, AcpiDmTableInfoDmarScope);
+                ScopeTable->Length, AcpiDmTableInfoDmarScope);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -1065,7 +1079,8 @@ AcpiDmDumpDmar (
 
             while (PathOffset < ScopeTable->Length)
             {
-                AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
+                AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,
+                    "PCI Path");
                 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
 
                 /* Point to next PCI Path entry */
@@ -1086,7 +1101,8 @@ NextSubtable:
         /* Point to next subtable */
 
         Offset += SubTable->Length;
-        SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
+        SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable,
+            SubTable->Length);
     }
 }
 
@@ -1118,7 +1134,7 @@ AcpiDmDumpDrtm (
     /* Main table */
 
     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
-                AcpiDmTableInfoDrtm);
+        AcpiDmTableInfoDrtm);
     if (ACPI_FAILURE (Status))
     {
         return;
@@ -1133,12 +1149,13 @@ AcpiDmDumpDrtm (
     DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
     AcpiOsPrintf ("\n");
     Status = AcpiDmDumpTable (Table->Length, Offset,
-                DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
-                AcpiDmTableInfoDrtm0);
+        DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
+        AcpiDmTableInfoDrtm0);
     if (ACPI_FAILURE (Status))
     {
             return;
     }
+
     Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);
 
     /* Dump Validated table addresses */
@@ -1148,12 +1165,13 @@ AcpiDmDumpDrtm (
             (DrtmVtl->ValidatedTableCount > Count))
     {
         Status = AcpiDmDumpTable (Table->Length, Offset,
-                    ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
-                    AcpiDmTableInfoDrtm0a);
+            ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
+            AcpiDmTableInfoDrtm0a);
         if (ACPI_FAILURE (Status))
         {
             return;
         }
+
         Offset += sizeof (UINT64);
         Count++;
     }
@@ -1163,8 +1181,8 @@ AcpiDmDumpDrtm (
     DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
     AcpiOsPrintf ("\n");
     Status = AcpiDmDumpTable (Table->Length, Offset,
-                DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
-                AcpiDmTableInfoDrtm1);
+        DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
+        AcpiDmTableInfoDrtm1);
     if (ACPI_FAILURE (Status))
     {
         return;
@@ -1179,9 +1197,8 @@ AcpiDmDumpDrtm (
            (DrtmRl->ResourceCount > Count))
     {
         Status = AcpiDmDumpTable (Table->Length, Offset,
-                    ACPI_ADD_PTR (void, Table, Offset),
-                    sizeof (ACPI_DRTM_RESOURCE),
-                    AcpiDmTableInfoDrtm1a);
+            ACPI_ADD_PTR (void, Table, Offset),
+            sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1196,8 +1213,7 @@ AcpiDmDumpDrtm (
     DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
     AcpiOsPrintf ("\n");
     (void) AcpiDmDumpTable (Table->Length, Offset,
-                DrtmDps, sizeof (ACPI_DRTM_DPS_ID),
-                AcpiDmTableInfoDrtm2);
+        DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
 }
 
 
@@ -1239,7 +1255,7 @@ AcpiDmDumpEinj (
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
+            sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1249,7 +1265,7 @@ AcpiDmDumpEinj (
 
         Offset += sizeof (ACPI_WHEA_HEADER);
         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
-                        sizeof (ACPI_WHEA_HEADER));
+            sizeof (ACPI_WHEA_HEADER));
     }
 }
 
@@ -1292,7 +1308,7 @@ AcpiDmDumpErst (
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
+            sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1302,7 +1318,7 @@ AcpiDmDumpErst (
 
         Offset += sizeof (ACPI_WHEA_HEADER);
         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
-                        sizeof (ACPI_WHEA_HEADER));
+            sizeof (ACPI_WHEA_HEADER));
     }
 }
 
@@ -1342,7 +1358,7 @@ AcpiDmDumpFpdt (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoFpdtHdr);
+            SubTable->Length, AcpiDmTableInfoFpdtHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1362,7 +1378,8 @@ AcpiDmDumpFpdt (
 
         default:
 
-            AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
+                SubTable->Type);
 
             /* Attempt to continue */
 
@@ -1375,7 +1392,7 @@ AcpiDmDumpFpdt (
         }
 
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, InfoTable);
+            SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1385,7 +1402,8 @@ NextSubTable:
         /* Point to next subtable */
 
         Offset += SubTable->Length;
-        SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length);
+        SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable,
+            SubTable->Length);
     }
 }
 
@@ -1434,7 +1452,7 @@ AcpiDmDumpGtdt (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoGtdtHdr);
+            SubTable->Length, AcpiDmTableInfoGtdtHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1447,7 +1465,7 @@ AcpiDmDumpGtdt (
 
             SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
             GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
-                        SubTable))->TimerCount;
+                SubTable))->TimerCount;
 
             InfoTable = AcpiDmTableInfoGtdt0;
             break;
@@ -1463,12 +1481,13 @@ AcpiDmDumpGtdt (
 
             /* Cannot continue on unknown type - no length */
 
-            AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n",
+                SubTable->Type);
             return;
         }
 
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, InfoTable);
+            SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1482,14 +1501,15 @@ AcpiDmDumpGtdt (
 
         if (GtCount)
         {
-            GtxTable = ACPI_ADD_PTR (ACPI_GTDT_TIMER_ENTRY, SubTable, SubTableLength);
+            GtxTable = ACPI_ADD_PTR (
+                ACPI_GTDT_TIMER_ENTRY, SubTable, SubTableLength);
             SubTableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
 
             while (GtCount)
             {
                 AcpiOsPrintf ("\n");
                 Status = AcpiDmDumpTable (Length, Offset, GtxTable,
-                            sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
+                    sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -1555,7 +1575,7 @@ AcpiDmDumpHest (
             InfoTable = AcpiDmTableInfoHest0;
             SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
-                            SubTable))->NumHardwareBanks;
+                SubTable))->NumHardwareBanks;
             break;
 
         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
@@ -1563,7 +1583,7 @@ AcpiDmDumpHest (
             InfoTable = AcpiDmTableInfoHest1;
             SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
-                            SubTable))->NumHardwareBanks;
+                SubTable))->NumHardwareBanks;
             break;
 
         case ACPI_HEST_TYPE_IA32_NMI:
@@ -1600,13 +1620,14 @@ AcpiDmDumpHest (
 
             /* Cannot continue on unknown type - no length */
 
-            AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
+                SubTable->Type);
             return;
         }
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTableLength, InfoTable);
+            SubTableLength, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1620,18 +1641,20 @@ AcpiDmDumpHest (
 
         if (BankCount)
         {
-            BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
+            BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable,
+                SubTableLength);
             SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
 
             while (BankCount)
             {
                 AcpiOsPrintf ("\n");
                 Status = AcpiDmDumpTable (Length, Offset, BankTable,
-                            sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
+                    sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
                 }
+
                 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
                 BankTable++;
                 BankCount--;
@@ -1690,7 +1713,7 @@ AcpiDmDumpIort (
     if (Iort->NodeOffset > Offset)
     {
         Status = AcpiDmDumpTable (Table->Length, Offset, Table,
-                    Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
+            Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1706,7 +1729,7 @@ AcpiDmDumpIort (
         AcpiOsPrintf ("\n");
         Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
         Status = AcpiDmDumpTable (Table->Length, Offset,
-                    IortNode, Length, AcpiDmTableInfoIortHdr);
+            IortNode, Length, AcpiDmTableInfoIortHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1763,8 +1786,8 @@ AcpiDmDumpIort (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
-                    ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
-                    Length, InfoTable);
+            ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
+            Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1785,8 +1808,8 @@ AcpiDmDumpIort (
                 for (i = 0; i < IortItsGroup->ItsCount; i++)
                 {
                     Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
-                                ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
-                                4, AcpiDmTableInfoIort0a);
+                        ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
+                        4, AcpiDmTableInfoIort0a);
                     NodeOffset += 4;
                 }
             }
@@ -1799,8 +1822,8 @@ AcpiDmDumpIort (
             if (IortNode->Length > NodeOffset)
             {
                 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
-                            Table, IortNode->Length - NodeOffset,
-                            AcpiDmTableInfoIort1a);
+                    Table, IortNode->Length - NodeOffset,
+                    AcpiDmTableInfoIort1a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -1819,8 +1842,8 @@ AcpiDmDumpIort (
                 Length = 2 * sizeof (UINT64);
                 NodeOffset = IortSmmu->GlobalInterruptOffset;
                 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
-                            ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
-                            Length, AcpiDmTableInfoIort3a);
+                    ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
+                    Length, AcpiDmTableInfoIort3a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -1830,12 +1853,13 @@ AcpiDmDumpIort (
                 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
                 {
                     Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
-                                ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
-                                8, AcpiDmTableInfoIort3b);
+                        ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
+                        8, AcpiDmTableInfoIort3b);
                     if (ACPI_FAILURE (Status))
                     {
                         return;
                     }
+
                     NodeOffset += 8;
                 }
 
@@ -1843,12 +1867,13 @@ AcpiDmDumpIort (
                 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
                 {
                     Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
-                                ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
-                                8, AcpiDmTableInfoIort3c);
+                        ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
+                        8, AcpiDmTableInfoIort3c);
                     if (ACPI_FAILURE (Status))
                     {
                         return;
                     }
+
                     NodeOffset += 8;
                 }
             }
@@ -1867,12 +1892,13 @@ AcpiDmDumpIort (
             AcpiOsPrintf ("\n");
             Length = sizeof (ACPI_IORT_ID_MAPPING);
             Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
-                        ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
-                        Length, AcpiDmTableInfoIortMap);
+                ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
+                Length, AcpiDmTableInfoIortMap);
             if (ACPI_FAILURE (Status))
             {
                 return;
             }
+
             NodeOffset += Length;
         }
 
@@ -1930,7 +1956,7 @@ AcpiDmDumpIvrs (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoIvrsHdr);
+            SubTable->Length, AcpiDmTableInfoIvrsHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1969,7 +1995,7 @@ AcpiDmDumpIvrs (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    SubTable->Length, InfoTable);
+            SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -1981,7 +2007,7 @@ AcpiDmDumpIvrs (
         {
             EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
             DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
-                            sizeof (ACPI_IVRS_HARDWARE));
+                sizeof (ACPI_IVRS_HARDWARE));
 
             while (EntryOffset < (Offset + SubTable->Length))
             {
@@ -2046,7 +2072,7 @@ AcpiDmDumpIvrs (
                 /* Dump the Device Entry */
 
                 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
-                            DeviceEntry, EntryLength, InfoTable);
+                    DeviceEntry, EntryLength, InfoTable);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -2054,7 +2080,7 @@ AcpiDmDumpIvrs (
 
                 EntryOffset += EntryLength;
                 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
-                                EntryLength);
+                    EntryLength);
             }
         }
 
@@ -2102,7 +2128,7 @@ AcpiDmDumpLpit (
         /* Common subtable header */
 
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
+            sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2120,16 +2146,18 @@ AcpiDmDumpLpit (
 
             /* Cannot continue on unknown type - no length */
 
-            AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
+                SubTable->Type);
             return;
         }
 
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTableLength, InfoTable);
+            SubTableLength, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
         }
+
         AcpiOsPrintf ("\n");
 
         /* Point to next subtable */
@@ -2181,7 +2209,7 @@ AcpiDmDumpMadt (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoMadtHdr);
+            SubTable->Length, AcpiDmTableInfoMadtHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2271,7 +2299,8 @@ AcpiDmDumpMadt (
 
         default:
 
-            AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
+                SubTable->Type);
 
             /* Attempt to continue */
 
@@ -2280,11 +2309,12 @@ AcpiDmDumpMadt (
                 AcpiOsPrintf ("Invalid zero length subtable\n");
                 return;
             }
+
             goto NextSubTable;
         }
 
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, InfoTable);
+            SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2294,7 +2324,8 @@ NextSubTable:
         /* Point to next subtable */
 
         Offset += SubTable->Length;
-        SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
+        SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
+            SubTable->Length);
     }
 }
 
@@ -2342,7 +2373,7 @@ AcpiDmDumpMcfg (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
+            sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2352,7 +2383,7 @@ AcpiDmDumpMcfg (
 
         Offset += sizeof (ACPI_MCFG_ALLOCATION);
         SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
-                        sizeof (ACPI_MCFG_ALLOCATION));
+            sizeof (ACPI_MCFG_ALLOCATION));
     }
 }
 
@@ -2402,7 +2433,7 @@ AcpiDmDumpMpst (
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
-                    sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
+            sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2423,7 +2454,7 @@ AcpiDmDumpMpst (
         {
             AcpiOsPrintf ("\n");
             Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
-                        sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
+                sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -2446,7 +2477,7 @@ AcpiDmDumpMpst (
         while (ComponentCount)
         {
             Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
-                        sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
+                sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -2471,7 +2502,7 @@ AcpiDmDumpMpst (
     AcpiOsPrintf ("\n");
     SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
     Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
-                sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
+        sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
     if (ACPI_FAILURE (Status))
     {
         return;
@@ -2482,13 +2513,14 @@ AcpiDmDumpMpst (
 
     /* Subtable: Memory Power State Characteristics structure(s) */
 
-    SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, sizeof (ACPI_MPST_DATA_HDR));
+    SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1,
+        sizeof (ACPI_MPST_DATA_HDR));
 
     while ((Offset < Table->Length) && SubtableCount)
     {
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
-                    sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
+            sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2539,7 +2571,7 @@ AcpiDmDumpMsct (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
+            sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2548,7 +2580,8 @@ AcpiDmDumpMsct (
         /* Point to next subtable */
 
         Offset += sizeof (ACPI_MSCT_PROXIMITY);
-        SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
+        SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable,
+            sizeof (ACPI_MSCT_PROXIMITY));
     }
 }
 
@@ -2591,7 +2624,7 @@ AcpiDmDumpMtmr (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
+            sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2600,7 +2633,8 @@ AcpiDmDumpMtmr (
         /* Point to next subtable */
 
         Offset += sizeof (ACPI_MTMR_ENTRY);
-        SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable, sizeof (ACPI_MTMR_ENTRY));
+        SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable,
+            sizeof (ACPI_MTMR_ENTRY));
     }
 }
 
@@ -2650,7 +2684,7 @@ AcpiDmDumpNfit (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoNfitHdr);
+            SubTable->Length, AcpiDmTableInfoNfitHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2703,7 +2737,8 @@ AcpiDmDumpNfit (
             break;
 
         default:
-            AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
+                SubTable->Type);
 
             /* Attempt to continue */
 
@@ -2717,7 +2752,7 @@ AcpiDmDumpNfit (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    SubTable->Length, InfoTable);
+            SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2732,8 +2767,8 @@ AcpiDmDumpNfit (
             for (i = 0; i < Interleave->LineCount; i++)
             {
                 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
-                            &Interleave->LineOffset[i],
-                            sizeof (UINT32), AcpiDmTableInfoNfit2a);
+                    &Interleave->LineOffset[i],
+                    sizeof (UINT32), AcpiDmTableInfoNfit2a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -2745,13 +2780,15 @@ AcpiDmDumpNfit (
 
         case ACPI_NFIT_TYPE_SMBIOS:
 
-            Length = SubTable->Length - sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
+            Length = SubTable->Length -
+                sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
+
             if (Length)
             {
                 Status = AcpiDmDumpTable (Table->Length,
-                            sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
-                            SmbiosInfo,
-                            Length, AcpiDmTableInfoNfit3a);
+                    sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
+                    SmbiosInfo,
+                    Length, AcpiDmTableInfoNfit3a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -2765,8 +2802,8 @@ AcpiDmDumpNfit (
             for (i = 0; i < Hint->HintCount; i++)
             {
                 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
-                            &Hint->HintAddress[i],
-                            sizeof (UINT64), AcpiDmTableInfoNfit6a);
+                    &Hint->HintAddress[i],
+                    sizeof (UINT64), AcpiDmTableInfoNfit6a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -2830,7 +2867,7 @@ AcpiDmDumpPcct (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Header.Length, AcpiDmTableInfoPcctHdr);
+            SubTable->Header.Length, AcpiDmTableInfoPcctHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2858,7 +2895,7 @@ AcpiDmDumpPcct (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Header.Length, InfoTable);
+            SubTable->Header.Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2868,7 +2905,7 @@ AcpiDmDumpPcct (
 
         Offset += SubTable->Header.Length;
         SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable,
-                    SubTable->Header.Length);
+            SubTable->Header.Length);
     }
 }
 
@@ -2920,7 +2957,7 @@ AcpiDmDumpPmtt (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoPmttHdr);
+            SubTable->Length, AcpiDmTableInfoPmttHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2939,7 +2976,7 @@ AcpiDmDumpPmtt (
         /* Dump the fixed-length portion of the subtable */
 
         Status = AcpiDmDumpTable (Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoPmtt0);
+            SubTable->Length, AcpiDmTableInfoPmtt0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -2958,8 +2995,8 @@ AcpiDmDumpPmtt (
 
             AcpiOsPrintf ("\n");
             Status = AcpiDmDumpTable (Length,
-                        Offset + MemOffset, MemSubTable,
-                        MemSubTable->Length, AcpiDmTableInfoPmttHdr);
+                Offset + MemOffset, MemSubTable,
+                MemSubTable->Length, AcpiDmTableInfoPmttHdr);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -2978,8 +3015,8 @@ AcpiDmDumpPmtt (
             /* Dump the fixed-length portion of the controller subtable */
 
             Status = AcpiDmDumpTable (Length,
-                        Offset + MemOffset, MemSubTable,
-                        MemSubTable->Length, AcpiDmTableInfoPmtt1);
+                Offset + MemOffset, MemSubTable,
+                MemSubTable->Length, AcpiDmTableInfoPmtt1);
             if (ACPI_FAILURE (Status))
             {
                 return;
@@ -2997,8 +3034,8 @@ AcpiDmDumpPmtt (
                 DomainCount)
             {
                 Status = AcpiDmDumpTable (Length,
-                            Offset + MemOffset + DomainOffset, DomainArray,
-                            sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
+                    Offset + MemOffset + DomainOffset, DomainArray,
+                    sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -3028,8 +3065,8 @@ AcpiDmDumpPmtt (
 
                 AcpiOsPrintf ("\n");
                 Status = AcpiDmDumpTable (Length,
-                            Offset + MemOffset + DimmOffset, DimmSubTable,
-                            DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
+                    Offset + MemOffset + DimmOffset, DimmSubTable,
+                    DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -3048,8 +3085,8 @@ AcpiDmDumpPmtt (
                 /* Dump the fixed-length DIMM subtable */
 
                 Status = AcpiDmDumpTable (Length,
-                            Offset + MemOffset + DimmOffset, DimmSubTable,
-                            DimmSubTable->Length, AcpiDmTableInfoPmtt2);
+                    Offset + MemOffset + DimmOffset, DimmSubTable,
+                    DimmSubTable->Length, AcpiDmTableInfoPmtt2);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
@@ -3116,7 +3153,7 @@ AcpiDmDumpS3pt (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoS3ptHdr);
+            SubTable->Length, AcpiDmTableInfoS3ptHdr);
         if (ACPI_FAILURE (Status))
         {
             return 0;
@@ -3136,7 +3173,8 @@ AcpiDmDumpS3pt (
 
         default:
 
-            AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
+                SubTable->Type);
 
             /* Attempt to continue */
 
@@ -3150,7 +3188,7 @@ AcpiDmDumpS3pt (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
-                    SubTable->Length, InfoTable);
+            SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return 0;
@@ -3183,8 +3221,9 @@ void
 AcpiDmDumpSlic (
     ACPI_TABLE_HEADER       *Table)
 {
+
     (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
-                Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
+        Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
 }
 
 
@@ -3237,7 +3276,8 @@ AcpiDmDumpSlit (
 
             if (Offset >= Table->Length)
             {
-                AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
+                AcpiOsPrintf (
+                    "\n**** Not enough room in table for all localities\n");
                 return;
             }
 
@@ -3305,7 +3345,7 @@ AcpiDmDumpSrat (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    SubTable->Length, AcpiDmTableInfoSratHdr);
+            SubTable->Length, AcpiDmTableInfoSratHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -3334,7 +3374,8 @@ AcpiDmDumpSrat (
             break;
 
         default:
-            AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n", SubTable->Type);
+            AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n",
+                SubTable->Type);
 
             /* Attempt to continue */
 
@@ -3348,7 +3389,7 @@ AcpiDmDumpSrat (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    SubTable->Length, InfoTable);
+            SubTable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -3358,7 +3399,8 @@ NextSubTable:
         /* Point to next subtable */
 
         Offset += SubTable->Length;
-        SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
+        SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
+            SubTable->Length);
     }
 }
 
@@ -3522,7 +3564,7 @@ AcpiDmDumpVrtc (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
+            sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -3531,7 +3573,8 @@ AcpiDmDumpVrtc (
         /* Point to next subtable */
 
         Offset += sizeof (ACPI_VRTC_ENTRY);
-        SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable, sizeof (ACPI_VRTC_ENTRY));
+        SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable,
+            sizeof (ACPI_VRTC_ENTRY));
     }
 }
 
@@ -3574,7 +3617,7 @@ AcpiDmDumpWdat (
 
         AcpiOsPrintf ("\n");
         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
-                    sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
+            sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -3583,10 +3626,12 @@ AcpiDmDumpWdat (
         /* Point to next subtable */
 
         Offset += sizeof (ACPI_WDAT_ENTRY);
-        SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));
+        SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable,
+            sizeof (ACPI_WDAT_ENTRY));
     }
 }
 
+
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDmDumpWpbt
diff --git a/source/common/getopt.c b/source/common/getopt.c
index df069728533f6..e5b72174c0318 100644
--- a/source/common/getopt.c
+++ b/source/common/getopt.c
@@ -90,6 +90,7 @@ AcpiGetoptArgument (
     int                     argc,
     char                    **argv)
 {
+
     AcpiGbl_Optind--;
     CurrentCharPtr++;
 
@@ -182,7 +183,8 @@ AcpiGetopt(
         }
         else if (++AcpiGbl_Optind >= argc)
         {
-            ACPI_OPTION_ERROR ("Option requires an argument: -", CurrentChar);
+            ACPI_OPTION_ERROR (
+                "Option requires an argument: -", CurrentChar);
 
             CurrentCharPtr = 1;
             return ('?');
@@ -243,7 +245,9 @@ AcpiGetopt(
         }
         else
         {
-            ACPI_OPTION_ERROR ("Option requires a single-character suboption: -", CurrentChar);
+            ACPI_OPTION_ERROR (
+                "Option requires a single-character suboption: -",
+                CurrentChar);
 
             CurrentCharPtr = 1;
             return ('?');