 @@ -79,42 +79,26 @@ XfCompareOneNamespaceObject (
     ACPI_HANDLE             ObjHandle,
     UINT32                  Level,
     void                    *Context,
     void                    **ReturnValue);
 static void
 XfCheckFieldRange (
     ACPI_PARSE_OBJECT       *Op,
     UINT32                  RegionBitLength,
     UINT32                  FieldBitOffset,
     UINT32                  FieldBitLength,
     UINT32                  AccessBitWidth);
 #ifdef __UNDER_DEVELOPMENT
 static ACPI_PARSE_OBJECT *
 XfGetParentMethod (
     ACPI_PARSE_OBJECT       *Op);
 static void
 XfCheckIllegalReference (
     ACPI_PARSE_OBJECT       *Op,
     ACPI_NAMESPACE_NODE     *Node);
 static BOOLEAN
 XfIsObjectParental (
     ACPI_PARSE_OBJECT       *MethodOp1,
     ACPI_PARSE_OBJECT       *MethodOp2);
 #endif
 /*******************************************************************************
+ *
  * FUNCTION:    XfCrossReferenceNamespace
+ *
  * PARAMETERS:  None
+ *
  * RETURN:      Status
+ *
  * DESCRIPTION: Perform a cross reference check of the parse tree against the
  *              namespace. Every named referenced within the parse tree
  *              should be get resolved with a namespace lookup. If not, the
  *              original reference in the ASL code is invalid -- i.e., refers
 @@ -584,27 +568,27 @@ XfNamespaceLocateBegin (
     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
         "Type=%s\n", AcpiUtGetTypeName (ObjectType)));
     /*
      * Lookup the name in the namespace. Name must exist at this point, or it
      * is an invalid reference.
+     *
      * The namespace is also used as a lookup table for references to resource
      * descriptors and the fields within them.
      */
     Gbl_NsLookupCount++;
     Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
-        ACPI_IMODE_EXECUTE, Flags, WalkState, &(Node));
+        ACPI_IMODE_EXECUTE, Flags, WalkState, &Node);
     if (ACPI_FAILURE (Status))
+    {
         if (Status == AE_NOT_FOUND)
+        {
             /*
              * We didn't find the name reference by path -- we can qualify this
              * a little better before we print an error message
              */
             if (strlen (Path) == ACPI_NAME_SIZE)
+            {
                 /* A simple, one-segment ACPI name */
                 if (XfObjectExists (Path))
 @@ -642,41 +626,54 @@ XfNamespaceLocateBegin (
                      * can't be reached.
                      */
                     AslError (ASL_ERROR, ASL_MSG_NOT_FOUND, Op,
                         Op->Asl.ExternalName);
+                }
+            }
             Status = AE_OK;
+        }
         return_ACPI_STATUS (Status);
+    }
     /* Object was found above, check for an illegal forward reference */
     if (Op->Asl.CompileFlags & OP_NOT_FOUND_DURING_LOAD)
+    {
         /*
          * During the load phase, this Op was flagged as a possible
          * illegal forward reference
+         *
          * Note: Allow "forward references" from within a method to an
          * object that is not within any method (module-level code)
          */
         if (!WalkState->ScopeInfo || (UtGetParentMethod (Node) &&
             !UtNodeIsDescendantOf (WalkState->ScopeInfo->Scope.Node,
                 UtGetParentMethod (Node))))
+        {
             AslError (ASL_ERROR, ASL_MSG_ILLEGAL_FORWARD_REF, Op,
                 Op->Asl.ExternalName);
+        }
+    }
     /* Check for a reference vs. name declaration */
     if (!(OpInfo->Flags & AML_NAMED) &&
         !(OpInfo->Flags & AML_CREATE))
+    {
         /* This node has been referenced, mark it for reference check */
         Node->Flags |= ANOBJ_IS_REFERENCED;
 #ifdef __UNDER_DEVELOPMENT
         /* Check for an illegal reference */
         XfCheckIllegalReference (Op, Node);
 #endif
+    }
     /* Attempt to optimize the NamePath */
     OptOptimizeNamePath (Op, OpInfo->Flags, WalkState, Path, Node);
     /*
      * 1) Dereference an alias (A name reference that is an alias)
      *    Aliases are not nested, the alias always points to the final object
      */
     if ((Op->Asl.ParseOpcode != PARSEOP_ALIAS) &&
         (Node->Type == ACPI_TYPE_LOCAL_ALIAS))
+    {
 @@ -1087,188 +1084,13 @@ XfNamespaceLocateEnd (
     if (AcpiNsOpensScope (AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode)))
+    {
         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
             "%s: Popping scope for Op %p\n",
             AcpiUtGetTypeName (OpInfo->ObjectType), Op));
         (void) AcpiDsScopeStackPop (WalkState);
+    }
     return_ACPI_STATUS (AE_OK);
+}
 #ifdef __UNDER_DEVELOPMENT
 /*******************************************************************************
  * FUNCTION:    XfIsObjectParental
  * PARAMETERS:  ChildOp                 - Op to be checked
  *              PossibleParentOp        - Determine if this op is in the family
  * RETURN:      TRUE if ChildOp is a descendent of PossibleParentOp
  * DESCRIPTION: Determine if an Op is a descendent of another Op. Used to
  *              detect if a method is declared within another method.
  ******************************************************************************/
 static BOOLEAN
 XfIsObjectParental (
     ACPI_PARSE_OBJECT       *ChildOp,
     ACPI_PARSE_OBJECT       *PossibleParentOp)
     ACPI_PARSE_OBJECT       *ParentOp;
     /* Search upwards through the tree for possible parent */
     ParentOp = ChildOp;
     while (ParentOp)
         if (ParentOp == PossibleParentOp)
             return (TRUE);
         ParentOp = ParentOp->Asl.Parent;
     return (FALSE);
 /*******************************************************************************
  * FUNCTION:    XfGetParentMethod
  * PARAMETERS:  Op                      - Op to be checked
  * RETURN:      Op for parent method. NULL if object is not within a method.
  * DESCRIPTION: Determine if an object is within a control method. Used to
  *              implement special rules for named references from within a
  *              control method.
  * NOTE: It would be better to have the parser set a flag in the Op if possible.
  ******************************************************************************/
 static ACPI_PARSE_OBJECT *
 XfGetParentMethod (
     ACPI_PARSE_OBJECT       *Op)
     ACPI_PARSE_OBJECT       *ParentOp;
     if (!Op)
         return (NULL);
     if (Op->Asl.ParseOpcode == PARSEOP_METHOD)
         return (NULL);
     /* Walk upwards through the parse tree, up to the root if necessary */
     ParentOp = Op;
     while (ParentOp)
         if (ParentOp->Asl.ParseOpcode == PARSEOP_METHOD)
             return (ParentOp);
         ParentOp = ParentOp->Asl.Parent;
     /* Object is not within a method */
     return (NULL);
 /*******************************************************************************
  * FUNCTION:    XfCheckIllegalReference
  * PARAMETERS:  Op                      - Op referring to the target
  *              TargetNode              - Target of the reference
  * RETURN:      None. Emits error message for an illegal reference
  * DESCRIPTION: Determine if a named reference is legal. A "named" reference
  *              is something like: Store(ABCD, ...), where ABCD is an AML
  *              Nameseg or Namepath.
  * NOTE: Caller must ensure that the name Op is in fact a reference, and not
  *       an actual name declaration (creation of a named object).
  ******************************************************************************/
 static void
 XfCheckIllegalReference (
     ACPI_PARSE_OBJECT       *Op,
     ACPI_NAMESPACE_NODE     *TargetNode)
     ACPI_PARSE_OBJECT       *MethodOp1;
     ACPI_PARSE_OBJECT       *MethodOp2;
     ACPI_PARSE_OBJECT       *TargetOp;
     /*
      * Check for an illegal reference to a named object:
      * 1) References from one control method to another, non-parent
      *    method are not allowed, they will fail at runtime.
      * 2) Forward references within a control method are not allowed.
      *    AML interpreters use a one-pass parse of control methods
      *    so these forward references will fail at runtime.
      */
     TargetOp = TargetNode->Op;
     MethodOp1 = XfGetParentMethod (Op);
     MethodOp2 = XfGetParentMethod (TargetOp);
     /* Are both objects within control method(s)? */
     if (!MethodOp1 || !MethodOp2)
         return;
     /* Objects not in the same method? */
     if (MethodOp1 != MethodOp2)
         /*
          * 1) Cross-method named reference
          * This is OK if and only if the target reference is within in a
          * method that is a parent of current method
          */
         if (!XfIsObjectParental (MethodOp1, MethodOp2))
             AslError (ASL_ERROR, ASL_MSG_ILLEGAL_METHOD_REF, Op,
                 Op->Asl.ExternalName);
     /*
      * 2) Both reference and target are in the same method. Check if this is
      * an (illegal) forward reference by examining the exact source code
      * location of each (the referenced object and the object declaration).
      * This is a bit nasty, yet effective.
      */
     else if (Op->Asl.LogicalByteOffset < TargetOp->Asl.LogicalByteOffset)
         AslError (ASL_ERROR, ASL_MSG_ILLEGAL_FORWARD_REF, Op,
             Op->Asl.ExternalName);
 #endif

 @@ -35,29 +35,30 @@
  * 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 "amlcode.h"
 #include "acdispat.h"
 #include "acnamesp.h"
 #include "acparser.h"
 #include "aslcompiler.y.h"
 #define _COMPONENT          ACPI_COMPILER
         ACPI_MODULE_NAME    ("aslload")
 /* Local prototypes */
 static ACPI_STATUS
 LdLoadFieldElements (
     ACPI_PARSE_OBJECT       *Op,
     ACPI_WALK_STATE         *WalkState);
 static ACPI_STATUS
 LdLoadResourceElements (
     ACPI_PARSE_OBJECT       *Op,
 @@ -352,29 +353,33 @@ LdNamespace1Begin (
+{
     ACPI_WALK_STATE         *WalkState = (ACPI_WALK_STATE *) Context;
     ACPI_NAMESPACE_NODE     *Node;
     ACPI_PARSE_OBJECT       *MethodOp;
     ACPI_STATUS             Status;
     ACPI_OBJECT_TYPE        ObjectType;
     ACPI_OBJECT_TYPE        ActualObjectType = ACPI_TYPE_ANY;
     char                    *Path;
     UINT32                  Flags = ACPI_NS_NO_UPSEARCH;
     ACPI_PARSE_OBJECT       *Arg;
     UINT32                  i;
     BOOLEAN                 ForceNewScope = FALSE;
     ACPI_OWNER_ID           OwnerId = 0;
     const ACPI_OPCODE_INFO  *OpInfo;
     ACPI_PARSE_OBJECT       *ParentOp;
     ACPI_FUNCTION_NAME (LdNamespace1Begin);
     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op %p [%s]\n",
         Op, Op->Asl.ParseOpName));
     if (Op->Asl.ParseOpcode == PARSEOP_DEFINITION_BLOCK)
+    {
         /*
          * Allocate an OwnerId for this block. This helps identify the owners
          * of each namespace node. This is used in determining whether if
          * certain external declarations cause redefinition errors.
          */
         Status = AcpiUtAllocateOwnerId (&OwnerId);
         WalkState->OwnerId = OwnerId;
         if (ACPI_FAILURE (Status))
 @@ -430,26 +435,89 @@ LdNamespace1Begin (
         /* All other opcodes go below */
         break;
+    }
     /* Check if this object has already been installed in the namespace */
     if (Op->Asl.Node)
+    {
         return (AE_OK);
+    }
     /* Check for a possible illegal forward reference */
     if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG) ||
         (Op->Asl.ParseOpcode == PARSEOP_NAMESTRING))
+    {
         /*
          * Op->Asl.Namepath will be NULL for these opcodes.
          * These opcodes are guaranteed to have a parent.
          * Examine the parent opcode.
          */
         Status = AE_OK;
         ParentOp = Op->Asl.Parent;
         OpInfo = AcpiPsGetOpcodeInfo (ParentOp->Asl.AmlOpcode);
         /*
          * Exclude all operators that actually declare a new name:
          *      Name (ABCD, 1) -> Ignore (AML_CLASS_NAMED_OBJECT)
          * We only want references to named objects:
          *      Store (2, WXYZ) -> Attempt to resolve the name
          */
         if (OpInfo->Class == AML_CLASS_NAMED_OBJECT)
+        {
             return (AE_OK);
+        }
         /*
          * Check if the referenced object exists at this point during
          * the load:
          * 1) If it exists, then this cannot be a forward reference.
          * 2) If it does not exist, it could be a forward reference or
          * it truly does not exist (and no external declaration).
          */
         Status = AcpiNsLookup (WalkState->ScopeInfo,
             Op->Asl.Value.Name, ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
             ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
             WalkState, &Node);
         if (Status == AE_NOT_FOUND)
+        {
             /*
              * This is either a foward reference or the object truly
              * does not exist. The two cases can only be differentiated
              * during the cross-reference stage later. Mark the Op/Name
              * as not-found for now to indicate the need for further
              * processing.
+             *
              * Special case: Allow forward references from elements of
              * Package objects. This provides compatibility with other
              * ACPI implementations. To correctly implement this, the
              * ACPICA table load defers package resolution until the entire
              * namespace has been loaded.
              */
             if ((ParentOp->Asl.ParseOpcode != PARSEOP_PACKAGE) &&
                 (ParentOp->Asl.ParseOpcode != PARSEOP_VAR_PACKAGE))
+            {
                 Op->Asl.CompileFlags |= OP_NOT_FOUND_DURING_LOAD;
+            }
             return (AE_OK);
+        }
         return (Status);
+    }
     Path = Op->Asl.Namepath;
     if (!Path)
+    {
         return (AE_OK);
+    }
     /* Map the raw opcode into an internal object type */
     switch (Op->Asl.ParseOpcode)
+    {
     case PARSEOP_NAME:
         Arg = Op->Asl.Child;  /* Get the NameSeg/NameString node */
 @@ -466,27 +534,26 @@ LdNamespace1Begin (
+        }
         /* Get the data type associated with the named object, not the name itself */
         /* Log2 loop to convert from Btype (binary) to Etype (encoded) */
         ObjectType = 1;
         for (i = 1; i < Arg->Asl.AcpiBtype; i *= 2)
+        {
             ObjectType++;
+        }
         break;
     case PARSEOP_EXTERNAL:
         /*
          * "External" simply enters a name and type into the namespace.
          * We must be careful to not open a new scope, however, no matter
          * what type the external name refers to (e.g., a method)
+         *
          * first child is name, next child is ObjectType
          */
         ActualObjectType = (UINT8) Op->Asl.Child->Asl.Next->Asl.Value.Integer;
         ObjectType = ACPI_TYPE_ANY;
         /*
          * We will mark every new node along the path as "External". This
 @@ -648,27 +715,26 @@ LdNamespace1Begin (
             Node->Type = ACPI_TYPE_LOCAL_SCOPE;
             Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE,
                 WalkState);
             if (ACPI_FAILURE (Status))
+            {
                 return_ACPI_STATUS (Status);
+            }
             break;
+        }
         Status = AE_OK;
         goto FinishNode;
     default:
         ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
         break;
+    }
     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Loading name: %s, (%s)\n",
         Op->Asl.ExternalName, AcpiUtGetTypeName (ObjectType)));
     /* The name must not already exist */
     Flags |= ACPI_NS_ERROR_IF_FOUND;

 @@ -120,26 +120,117 @@ UtQueryForOverwrite (
         if (getchar () != 'y')
+        {
             return (FALSE);
+        }
+    }
     return (TRUE);
+}
 /*******************************************************************************
+ *
  * FUNCTION:    UtNodeIsDescendantOf
+ *
  * PARAMETERS:  Node1                   - Child node
  *              Node2                   - Possible parent node
+ *
  * RETURN:      Boolean
+ *
  * DESCRIPTION: Returns TRUE if Node1 is a descendant of Node2. Otherwise,
  *              return FALSE. Note, we assume a NULL Node2 element to be the
  *              topmost (root) scope. All nodes are descendants of the root.
  *              Note: Nodes at the same level (siblings) are not considered
  *              descendants.
+ *
  ******************************************************************************/
 BOOLEAN
 UtNodeIsDescendantOf (
     ACPI_NAMESPACE_NODE     *Node1,
     ACPI_NAMESPACE_NODE     *Node2)
+{
     if (Node1 == Node2)
+    {
         return (FALSE);
+    }
     if (!Node2)
+    {
         return (TRUE); /* All nodes descend from the root */
+    }
     /* Walk upward until the root is reached or parent is found */
     while (Node1)
+    {
         if (Node1 == Node2)
+        {
             return (TRUE);
+        }
         Node1 = Node1->Parent;
+    }
     return (FALSE);
+}
 /*******************************************************************************
+ *
  * FUNCTION:    UtGetParentMethod
+ *
  * PARAMETERS:  Node                    - Namespace node for any object
+ *
  * RETURN:      Namespace node for the parent method
  *              NULL - object is not within a method
+ *
  * DESCRIPTION: Find the parent (owning) method node for a namespace object
+ *
  ******************************************************************************/
 void *
 UtGetParentMethod (
     ACPI_NAMESPACE_NODE     *Node)
+{
     ACPI_NAMESPACE_NODE     *ParentNode;
     if (!Node)
+    {
         return (NULL);
+    }
     /* Walk upward until a method is found, or the root is reached */
     ParentNode = Node->Parent;
     while (ParentNode)
+    {
         if (ParentNode->Type == ACPI_TYPE_METHOD)
+        {
             return (ParentNode);
+        }
         ParentNode = ParentNode->Parent;
+    }
     return (NULL); /* Object is not within a control method */
+}
 /*******************************************************************************
+ *
  * FUNCTION:    UtDisplaySupportedTables
+ *
  * PARAMETERS:  None
+ *
  * RETURN:      None
+ *
  * DESCRIPTION: Print all supported ACPI table names.
+ *
  ******************************************************************************/
 void
 UtDisplaySupportedTables (
     void)

 @@ -71,26 +71,30 @@ AcpiDbTestIntegerType (
     UINT32                  BitLength);
 static ACPI_STATUS
 AcpiDbTestBufferType (
     ACPI_NAMESPACE_NODE     *Node,
     UINT32                  BitLength);
 static ACPI_STATUS
 AcpiDbTestStringType (
     ACPI_NAMESPACE_NODE     *Node,
     UINT32                  ByteLength);
 static ACPI_STATUS
 AcpiDbTestPackageType (
     ACPI_NAMESPACE_NODE     *Node);
 static ACPI_STATUS
 AcpiDbReadFromObject (
     ACPI_NAMESPACE_NODE     *Node,
     ACPI_OBJECT_TYPE        ExpectedType,
     ACPI_OBJECT             **Value);
 static ACPI_STATUS
 AcpiDbWriteToObject (
     ACPI_NAMESPACE_NODE     *Node,
     ACPI_OBJECT             *Value);
 static void
 AcpiDbEvaluateAllPredefinedNames (
     char                    *CountArg);
 @@ -338,26 +342,31 @@ AcpiDbTestOneObject (
     case ACPI_TYPE_STRING:
         LocalType = ACPI_TYPE_STRING;
         ByteLength = ObjDesc->String.Length;
         break;
     case ACPI_TYPE_BUFFER:
         LocalType = ACPI_TYPE_BUFFER;
         ByteLength = ObjDesc->Buffer.Length;
         BitLength = ByteLength * 8;
         break;
     case ACPI_TYPE_PACKAGE:
         LocalType = ACPI_TYPE_PACKAGE;
         break;
     case ACPI_TYPE_FIELD_UNIT:
     case ACPI_TYPE_BUFFER_FIELD:
     case ACPI_TYPE_LOCAL_REGION_FIELD:
     case ACPI_TYPE_LOCAL_INDEX_FIELD:
     case ACPI_TYPE_LOCAL_BANK_FIELD:
         LocalType = ACPI_TYPE_INTEGER;
         if (ObjDesc)
+        {
             /*
              * Returned object will be a Buffer if the field length
              * is larger than the size of an Integer (32 or 64 bits
              * depending on the DSDT version).
 @@ -372,53 +381,53 @@ AcpiDbTestOneObject (
         break;
     default:
         /* Ignore all other types */
         return (AE_OK);
+    }
     /* Emit the common prefix: Type:Name */
     AcpiOsPrintf ("%14s: %4.4s",
         AcpiUtGetTypeName (Node->Type), Node->Name.Ascii);
     if (!ObjDesc)
+    {
         AcpiOsPrintf (" Ignoring, no attached object\n");
         return (AE_OK);
+    }
     /*
      * Check for unsupported region types. Note: AcpiExec simulates
      * access to SystemMemory, SystemIO, PCI_Config, and EC.
      */
     switch (Node->Type)
+    {
     case ACPI_TYPE_LOCAL_REGION_FIELD:
         RegionObj = ObjDesc->Field.RegionObj;
         switch (RegionObj->Region.SpaceId)
+        {
         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
         case ACPI_ADR_SPACE_SYSTEM_IO:
         case ACPI_ADR_SPACE_PCI_CONFIG:
         case ACPI_ADR_SPACE_EC:
             break;
         default:
-            AcpiOsPrintf ("      %s space is not supported [%4.4s]\n",
+            AcpiOsPrintf ("      %s space is not supported in this command [%4.4s]\n",
                 AcpiUtGetRegionName (RegionObj->Region.SpaceId),
                 RegionObj->Region.Node->Name.Ascii);
             return (AE_OK);
+        }
         break;
     default:
         break;
+    }
     /* At this point, we have resolved the object to one of the major types */
     switch (LocalType)
 @@ -428,46 +437,61 @@ AcpiDbTestOneObject (
         Status = AcpiDbTestIntegerType (Node, BitLength);
         break;
     case ACPI_TYPE_STRING:
         Status = AcpiDbTestStringType (Node, ByteLength);
         break;
     case ACPI_TYPE_BUFFER:
         Status = AcpiDbTestBufferType (Node, BitLength);
         break;
     case ACPI_TYPE_PACKAGE:
         Status = AcpiDbTestPackageType (Node);
         break;
     default:
         AcpiOsPrintf (" Ignoring, type not implemented (%2.2X)",
             LocalType);
         break;
+    }
     /* Exit on error, but don't abort the namespace walk */
     if (ACPI_FAILURE (Status))
+    {
         Status = AE_OK;
         goto Exit;
+    }
     switch (Node->Type)
+    {
     case ACPI_TYPE_LOCAL_REGION_FIELD:
         RegionObj = ObjDesc->Field.RegionObj;
         AcpiOsPrintf (" (%s)",
             AcpiUtGetRegionName (RegionObj->Region.SpaceId));
         break;
     default:
         break;
+    }
 Exit:
     AcpiOsPrintf ("\n");
     return (Status);
+}
 /*******************************************************************************
+ *
  * FUNCTION:    AcpiDbTestIntegerType
+ *
  * PARAMETERS:  Node                - Parent NS node for the object
  *              BitLength           - Actual length of the object. Used for
  *                                    support of arbitrary length FieldUnit
  *                                    and BufferField objects.
 @@ -506,27 +530,26 @@ AcpiDbTestIntegerType (
+    {
         return (Status);
+    }
     AcpiOsPrintf (" (%4.4X/%3.3X) %8.8X%8.8X",
         BitLength, ACPI_ROUND_BITS_UP_TO_BYTES (BitLength),
         ACPI_FORMAT_UINT64 (Temp1->Integer.Value));
     ValueToWrite = ACPI_UINT64_MAX >> (64 - BitLength);
     if (Temp1->Integer.Value == ValueToWrite)
+    {
         ValueToWrite = 0;
+    }
     /* Write a new value */
     WriteValue.Type = ACPI_TYPE_INTEGER;
     WriteValue.Integer.Value = ValueToWrite;
     Status = AcpiDbWriteToObject (Node, &WriteValue);
     if (ACPI_FAILURE (Status))
+    {
         goto Exit;
+    }
     /* Ensure that we can read back the new value */
     Status = AcpiDbReadFromObject (Node, ACPI_TYPE_INTEGER, &Temp2);
 @@ -799,26 +822,60 @@ AcpiDbTestStringType (
             Temp3->String.Pointer, Temp1->String.Pointer);
+    }
 Exit:
     if (Temp1) {AcpiOsFree (Temp1);}
     if (Temp2) {AcpiOsFree (Temp2);}
     if (Temp3) {AcpiOsFree (Temp3);}
     return (Status);
+}
 /*******************************************************************************
+ *
  * FUNCTION:    AcpiDbTestPackageType
+ *
  * PARAMETERS:  Node                - Parent NS node for the object
+ *
  * RETURN:      Status
+ *
  * DESCRIPTION: Test read for a Package object.
+ *
  ******************************************************************************/
 static ACPI_STATUS
 AcpiDbTestPackageType (
     ACPI_NAMESPACE_NODE     *Node)
+{
     ACPI_OBJECT             *Temp1 = NULL;
     ACPI_STATUS             Status;
     /* Read the original value */
     Status = AcpiDbReadFromObject (Node, ACPI_TYPE_PACKAGE, &Temp1);
     if (ACPI_FAILURE (Status))
+    {
         return (Status);
+    }
     AcpiOsPrintf (" %8.8X Elements", Temp1->Package.Count);
     AcpiOsFree (Temp1);
     return (Status);
+}
 /*******************************************************************************
+ *
  * FUNCTION:    AcpiDbReadFromObject
+ *
  * PARAMETERS:  Node                - Parent NS node for the object
  *              ExpectedType        - Object type expected from the read
  *              Value               - Where the value read is returned
+ *
  * RETURN:      Status
+ *
  * DESCRIPTION: Performs a read from the specified object by invoking the
  *              special debugger control method that reads the object. Thus,
  *              the AML interpreter is doing all of the work, increasing the
  *              validity of the test.
+ *
 @@ -839,53 +896,55 @@ AcpiDbReadFromObject (
     Params[0].Type = ACPI_TYPE_LOCAL_REFERENCE;
     Params[0].Reference.ActualType = Node->Type;
     Params[0].Reference.Handle = ACPI_CAST_PTR (ACPI_HANDLE, Node);
     ParamObjects.Count = 1;
     ParamObjects.Pointer = Params;
     ReturnObj.Length  = ACPI_ALLOCATE_BUFFER;
     AcpiGbl_MethodExecuting = TRUE;
     Status = AcpiEvaluateObject (ReadHandle, NULL,
         &ParamObjects, &ReturnObj);
     AcpiGbl_MethodExecuting = FALSE;
     AcpiGbl_MethodExecuting = FALSE;
     if (ACPI_FAILURE (Status))
+    {
         AcpiOsPrintf ("Could not read from object, %s",
             AcpiFormatException (Status));
         return (Status);
+    }
     RetValue = (ACPI_OBJECT *) ReturnObj.Pointer;
     switch (RetValue->Type)
+    {
     case ACPI_TYPE_INTEGER:
     case ACPI_TYPE_BUFFER:
     case ACPI_TYPE_STRING:
     case ACPI_TYPE_PACKAGE:
         /*
          * Did we receive the type we wanted? Most important for the
          * Integer/Buffer case (when a field is larger than an Integer,
          * it should return a Buffer).
          */
         if (RetValue->Type != ExpectedType)
+        {
             AcpiOsPrintf (" Type mismatch:  Expected %s, Received %s",
                 AcpiUtGetTypeName (ExpectedType),
                 AcpiUtGetTypeName (RetValue->Type));
             AcpiOsFree (ReturnObj.Pointer);
             return (AE_TYPE);
+        }
         *Value = RetValue;
         break;
     default:
         AcpiOsPrintf (" Unsupported return object type, %s",
             AcpiUtGetTypeName (RetValue->Type));
         AcpiOsFree (ReturnObj.Pointer);
         return (AE_TYPE);

 @@ -1069,26 +1069,35 @@ UtDumpStringOp (
     UINT32                  Level);
 void
 UtDumpIntegerOp (
     ACPI_PARSE_OBJECT       *Op,
     UINT32                  Level,
     UINT32                  IntegerLength);
 void
 UtDumpBasicOp (
     ACPI_PARSE_OBJECT       *Op,
     UINT32                  Level);
 void *
 UtGetParentMethod (
     ACPI_NAMESPACE_NODE     *Node);
 BOOLEAN
 UtNodeIsDescendantOf (
     ACPI_NAMESPACE_NODE     *Node1,
     ACPI_NAMESPACE_NODE     *Node2);
 void
 UtDisplaySupportedTables (
     void);
 void
 UtDisplayConstantOpcodes (
     void);
 UINT8
 UtBeginEvent (
     char                    *Name);
 void

	@@ -254,28 +254,37 @@ AcpiDbDumpNamespace (		@@ -254,28 +254,37 @@ AcpiDbDumpNamespace (
254	{	254	{
255	return;	255	return;
256	}	256	}
257		257
258	/* Now we can check for the depth argument */	258	/* Now we can check for the depth argument */
259		259
260	if (DepthArg)	260	if (DepthArg)
261	{	261	{
262	MaxDepth = strtoul (DepthArg, NULL, 0);	262	MaxDepth = strtoul (DepthArg, NULL, 0);
263	}	263	}
264	}	264	}
265		265
266	AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);	266	AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
267	AcpiOsPrintf ("ACPI Namespace (from %4.4s (%p) subtree):\n",	267
268	((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Name.Ascii, SubtreeEntry);	268	if (((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Parent)
		269	{
		270	AcpiOsPrintf ("ACPI Namespace (from %4.4s (%p) subtree):\n",
		271	((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Name.Ascii, SubtreeEntry);
		272	}
		273	else
		274	{
		275	AcpiOsPrintf ("ACPI Namespace (from %s):\n",
		276	ACPI_NAMESPACE_ROOT);
		277	}
269		278
270	/* Display the subtree */	279	/* Display the subtree */
271		280
272	AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);	281	AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
273	AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth,	282	AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth,
274	ACPI_OWNER_ID_MAX, SubtreeEntry);	283	ACPI_OWNER_ID_MAX, SubtreeEntry);
275	AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);	284	AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
276	}	285	}
277		286
278		287
279	/*******************************************************************************	288	/*******************************************************************************
280	*	289	*
281	* FUNCTION: AcpiDbDumpNamespacePaths	290	* FUNCTION: AcpiDbDumpNamespacePaths

 @@ -214,25 +214,29 @@ AdInitialize (
 char *
 FlGenerateFilename (
     char                    *InputFilename,
     char                    *Suffix);
 ACPI_STATUS
 FlSplitInputPathname (
     char                    *InputPath,
     char                    **OutDirectoryPath,
     char                    **OutFilename);
 char *
 FlGetFileBasename (
     char                    *FilePathname);
 char *
 AdGenerateFilename (
     char                    *Prefix,
     char                    *TableId);
 void
 AdWriteTable (
     ACPI_TABLE_HEADER       *Table,
     UINT32                  Length,
     char                    *TableName,
     char                    *OemTableId);
 #endif /* _ACAPPS */

	@@ -650,27 +650,27 @@ AcpiRsOutTitle (		@@ -650,27 +650,27 @@ AcpiRsOutTitle (
650	* Data - Start of the list	650	* Data - Start of the list
651	*	651	*
652	* RETURN: None	652	* RETURN: None
653	*	653	*
654	* DESCRIPTION: Miscellaneous functions to dump lists of raw data	654	* DESCRIPTION: Miscellaneous functions to dump lists of raw data
655	*	655	*
656	******************************************************************************/	656	******************************************************************************/
657		657
658	static void	658	static void
659	AcpiRsDumpByteList (	659	AcpiRsDumpByteList (
660	UINT16 Length,	660	UINT16 Length,
661	UINT8 *Data)	661	UINT8 *Data)
662	{	662	{
663	UINT8 i;	663	UINT16 i;
664		664
665		665
666	for (i = 0; i < Length; i++)	666	for (i = 0; i < Length; i++)
667	{	667	{
668	AcpiOsPrintf ("%25s%2.2X : %2.2X\n", "Byte", i, Data[i]);	668	AcpiOsPrintf ("%25s%2.2X : %2.2X\n", "Byte", i, Data[i]);
669	}	669	}
670	}	670	}
671		671
672	static void	672	static void
673	AcpiRsDumpShortByteList (	673	AcpiRsDumpShortByteList (
674	UINT8 Length,	674	UINT8 Length,
675	UINT8 *Data)	675	UINT8 *Data)
676	{	676	{

 @@ -118,27 +118,27 @@ AcpiTbInstallTableWithOverride (
+ *
  * PARAMETERS:  Address             - Address of the table (might be a virtual
  *                                    address depending on the TableFlags)
  *              Flags               - Flags for the table
  *              Reload              - Whether reload should be performed
  *              Override            - Whether override should be performed
  *              TableIndex          - Where the table index is returned
+ *
  * RETURN:      Status
+ *
  * DESCRIPTION: This function is called to verify and install an ACPI table.
  *              When this function is called by "Load" or "LoadTable" opcodes,
  *              or by AcpiLoadTable() API, the "Reload" parameter is set.
- *              After sucessfully returning from this function, table is
+ *              After successfully returning from this function, table is
  *              "INSTALLED" but not "VALIDATED".
+ *
  ******************************************************************************/
 ACPI_STATUS
 AcpiTbInstallStandardTable (
     ACPI_PHYSICAL_ADDRESS   Address,
     UINT8                   Flags,
     BOOLEAN                 Reload,
     BOOLEAN                 Override,
     UINT32                  *TableIndex)
+{
     UINT32                  i;

 @@ -36,27 +36,27 @@
  * 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.
  */
 #ifndef __ACXFACE_H__
 #define __ACXFACE_H__
 /* Current ACPICA subsystem version in YYYYMMDD format */
-#define ACPI_CA_VERSION                 0x20180313
+#define ACPI_CA_VERSION                 0x20180427
 #include "acconfig.h"
 #include "actypes.h"
 #include "actbl.h"
 #include "acbuffer.h"
 /*****************************************************************************
+ *
  * Macros used for ACPICA globals and configuration
+ *
  ****************************************************************************/

 @@ -607,26 +607,27 @@ vsnprintf (
+            {
                 Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
+            }
             continue;
         case 'o':
             Base = 8;
             break;
         case 'X':
             Type |= ACPI_FORMAT_UPPER;
             /* FALLTHROUGH */
         case 'x':
             Base = 16;
             break;
         case 'd':
         case 'i':
             Type |= ACPI_FORMAT_SIGN;
         case 'u':