自学教程：C++ AcpiNsOpensScope函数代码示例

static ACPI_STATUSLdCommonNamespaceEnd (    ACPI_PARSE_OBJECT       *Op,    UINT32                  Level,    void                    *Context){    ACPI_WALK_STATE         *WalkState = (ACPI_WALK_STATE *) Context;    ACPI_OBJECT_TYPE        ObjectType;    BOOLEAN                 ForceNewScope = FALSE;    ACPI_FUNCTION_NAME (LdCommonNamespaceEnd);    /* We are only interested in opcodes that have an associated name */    if (!Op->Asl.Namepath)    {        return (AE_OK);    }    /* Get the type to determine if we should pop the scope */    if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) &&        (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC))    {        /* TBD: Merge into AcpiDsMapNamedOpcodeToDataType */        ObjectType = ACPI_TYPE_LOCAL_RESOURCE;    }    else    {        ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);    }    /* Pop scope that was pushed for Resource Templates */    if (Op->Asl.ParseOpcode == PARSEOP_NAME)    {        if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)        {            ForceNewScope = TRUE;        }    }    /* Pop the scope stack */    if (ForceNewScope || AcpiNsOpensScope (ObjectType))    {        ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,            "(%s): Popping scope for Op [%s] %p/n",            AcpiUtGetTypeName (ObjectType), Op->Asl.ParseOpName, Op));        (void) AcpiDsScopeStackPop (WalkState);    }    return (AE_OK);}

static ACPI_STATUSXfNamespaceLocateEnd (    ACPI_PARSE_OBJECT       *Op,    UINT32                  Level,    void                    *Context){    ACPI_WALK_STATE         *WalkState = (ACPI_WALK_STATE *) Context;    const ACPI_OPCODE_INFO  *OpInfo;    ACPI_FUNCTION_TRACE (XfNamespaceLocateEnd);    /* We are only interested in opcodes that have an associated name */    OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);    if (!(OpInfo->Flags & AML_NAMED))    {        return_ACPI_STATUS (AE_OK);    }    /* Not interested in name references, we did not open a scope for them */    if ((Op->Asl.ParseOpcode == PARSEOP_NAMESTRING) ||        (Op->Asl.ParseOpcode == PARSEOP_NAMESEG)    ||        (Op->Asl.ParseOpcode == PARSEOP_METHODCALL) ||        (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL))    {        return_ACPI_STATUS (AE_OK);    }    /* Pop the scope stack if necessary */    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);}

static ACPI_STATUSAcpiDmResourceDescendingOp (    ACPI_PARSE_OBJECT       *Op,    UINT32                  Level,    void                    *Context){    ACPI_OP_WALK_INFO       *Info = Context;    const ACPI_OPCODE_INFO  *OpInfo;    ACPI_WALK_STATE         *WalkState;    ACPI_OBJECT_TYPE        ObjectType;    ACPI_STATUS             Status;    WalkState = Info->WalkState;    OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);    /* Open new scope if necessary */    ObjectType = OpInfo->ObjectType;    if (AcpiNsOpensScope (ObjectType))    {        if (Op->Common.Node)        {            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);            if (ACPI_FAILURE (Status))            {                return (Status);            }        }    }    /*     * Check if this operator contains a reference to a resource descriptor.     * If so, convert the reference into a symbolic reference.     */    AcpiDmCheckResourceReference (Op, WalkState);    return (AE_OK);}

static ACPI_STATUSAcpiDmCommonAscendingOp (    ACPI_PARSE_OBJECT       *Op,    UINT32                  Level,    void                    *Context){    ACPI_OP_WALK_INFO       *Info = Context;    const ACPI_OPCODE_INFO  *OpInfo;    ACPI_OBJECT_TYPE        ObjectType;    /* Close scope if necessary */    OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);    ObjectType = OpInfo->ObjectType;    ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);    if (AcpiNsOpensScope (ObjectType))    {        (void) AcpiDsScopeStackPop (Info->WalkState);    }    return (AE_OK);}

static ACPI_STATUSLdNamespace2Begin (    ACPI_PARSE_OBJECT       *Op,    UINT32                  Level,    void                    *Context){    ACPI_WALK_STATE         *WalkState = (ACPI_WALK_STATE *) Context;    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    ACPI_OBJECT_TYPE        ObjectType;    BOOLEAN                 ForceNewScope = FALSE;    ACPI_PARSE_OBJECT       *Arg;    char                    *Path;    ACPI_NAMESPACE_NODE     *TargetNode;    ACPI_FUNCTION_NAME (LdNamespace2Begin);    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op %p [%s]/n",        Op, Op->Asl.ParseOpName));    /* Ignore Ops with no namespace node */    Node = Op->Asl.Node;    if (!Node)    {        return (AE_OK);    }    /* Get the type to determine if we should push the scope */    if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) &&        (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC))    {        ObjectType = ACPI_TYPE_LOCAL_RESOURCE;    }    else    {        ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);    }    /* Push scope for Resource Templates */    if (Op->Asl.ParseOpcode == PARSEOP_NAME)    {        if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)        {            ForceNewScope = TRUE;        }    }    /* Push the scope stack */    if (ForceNewScope || AcpiNsOpensScope (ObjectType))    {        Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }    if (Op->Asl.ParseOpcode == PARSEOP_ALIAS)    {        /* Complete the alias node by getting and saving the target node */        /* First child is the alias target */        Arg = Op->Asl.Child;        /* Get the target pathname */        Path = Arg->Asl.Namepath;        if (!Path)        {            Status = UtInternalizeName (Arg->Asl.ExternalName, &Path);            if (ACPI_FAILURE (Status))            {                return (Status);            }        }        /* Get the NS node associated with the target. It must exist. */        Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY,                    ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,                    WalkState, &TargetNode);        if (ACPI_FAILURE (Status))        {            if (Status == AE_NOT_FOUND)            {                AslError (ASL_ERROR, ASL_MSG_NOT_FOUND, Op,                    Op->Asl.ExternalName);                /*                 * The name was not found, go ahead and create it.                 * This prevents more errors later.                 */                Status = AcpiNsLookup (WalkState->ScopeInfo, Path,                            ACPI_TYPE_ANY,//.........这里部分代码省略.........

//.........这里部分代码省略.........    /* The name must not already exist */    Flags |= ACPI_NS_ERROR_IF_FOUND;    /*     * Enter the named type into the internal namespace. We enter the name     * as we go downward in the parse tree. Any necessary subobjects that     * involve arguments to the opcode must be created as we go back up the     * parse tree later.     */    Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,                    ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);    if (ACPI_FAILURE (Status))    {        if (Status == AE_ALREADY_EXISTS)        {            /* The name already exists in this scope */            if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)            {                /* Allow multiple references to the same scope */                Node->Type = (UINT8) ObjectType;                Status = AE_OK;            }            else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&                     (Op->Asl.ParseOpcode != PARSEOP_EXTERNAL))            {                /*                 * Allow one create on an object or segment that was                 * previously declared External                 */                Node->Flags &= ~ANOBJ_IS_EXTERNAL;                Node->Type = (UINT8) ObjectType;                /* Just retyped a node, probably will need to open a scope */                if (AcpiNsOpensScope (ObjectType))                {                    Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);                    if (ACPI_FAILURE (Status))                    {                        return_ACPI_STATUS (Status);                    }                }                Status = AE_OK;            }            else            {                /* Valid error, object already exists */                AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Op,                    Op->Asl.ExternalName);                return_ACPI_STATUS (AE_OK);            }        }        else        {            AslCoreSubsystemError (Op, Status,                "Failure from namespace lookup", FALSE);            return_ACPI_STATUS (Status);        }    }    if (ForceNewScope)    {        Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }FinishNode:    /*     * Point the parse node to the new namespace node, and point     * the Node back to the original Parse node     */    Op->Asl.Node = Node;    Node->Op = Op;    /* Set the actual data type if appropriate (EXTERNAL term only) */    if (ActualObjectType != ACPI_TYPE_ANY)    {        Node->Type = (UINT8) ActualObjectType;        Node->Value = ASL_EXTERNAL_METHOD;    }    if (Op->Asl.ParseOpcode == PARSEOP_METHOD)    {        /*         * Get the method argument count from "Extra" and save         * it in the namespace node         */        Node->Value = (UINT32) Op->Asl.Extra;    }    return_ACPI_STATUS (Status);}

//.........这里部分代码省略.........            if (WalkState->NamespaceOverride)            {                Flags |= ACPI_NS_OVERRIDE_IF_FOUND;                ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Override allowed/n",                        AcpiUtGetTypeName (ObjectType)));            }            else            {                Flags |= ACPI_NS_ERROR_IF_FOUND;                ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Cannot already exist/n",                        AcpiUtGetTypeName (ObjectType)));            }        }        else        {            ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,                "[%s] Both Find or Create allowed/n",                    AcpiUtGetTypeName (ObjectType)));        }        /*         * Enter the named type into the internal namespace. We enter the name         * as we go downward in the parse tree. Any necessary subobjects that         * involve arguments to the opcode must be created as we go back up the         * parse tree later.         */        Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,                        ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);        if (ACPI_FAILURE (Status))        {            if (Status == AE_ALREADY_EXISTS)            {                /* The name already exists in this scope */                if (Node->Flags & ANOBJ_IS_EXTERNAL)                {                    /*                     * Allow one create on an object or segment that was                     * previously declared External                     */                    Node->Flags &= ~ANOBJ_IS_EXTERNAL;                    Node->Type = (UINT8) ObjectType;                    /* Just retyped a node, probably will need to open a scope */                    if (AcpiNsOpensScope (ObjectType))                    {                        Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);                        if (ACPI_FAILURE (Status))                        {                            return_ACPI_STATUS (Status);                        }                    }                    Status = AE_OK;                }            }            if (ACPI_FAILURE (Status))            {                ACPI_ERROR_NAMESPACE (Path, Status);                return_ACPI_STATUS (Status);            }        }        break;    }    /* Common exit */    if (!Op)    {        /* Create a new op */        Op = AcpiPsAllocOp (WalkState->Opcode);        if (!Op)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }    }    /* Initialize the op */#if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))    Op->Named.Path = ACPI_CAST_PTR (UINT8, Path);#endif    if (Node)    {        /*         * Put the Node in the "op" object that the parser uses, so we         * can get it again quickly when this scope is closed         */        Op->Common.Node = Node;        Op->Named.Name = Node->Name.Integer;    }    AcpiPsAppendArg (AcpiPsGetParentScope (&WalkState->ParserState), Op);    *OutOp = Op;    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiNsLookup (    ACPI_GENERIC_STATE      *ScopeInfo,    char                    *Pathname,    ACPI_OBJECT_TYPE        Type,    ACPI_INTERPRETER_MODE   InterpreterMode,    UINT32                  Flags,    ACPI_WALK_STATE         *WalkState,    ACPI_NAMESPACE_NODE     **ReturnNode){    ACPI_STATUS             Status;    char                    *Path = Pathname;    ACPI_NAMESPACE_NODE     *PrefixNode;    ACPI_NAMESPACE_NODE     *CurrentNode = NULL;    ACPI_NAMESPACE_NODE     *ThisNode = NULL;    UINT32                  NumSegments;    UINT32                  NumCarats;    ACPI_NAME               SimpleName;    ACPI_OBJECT_TYPE        TypeToCheckFor;    ACPI_OBJECT_TYPE        ThisSearchType;    UINT32                  SearchParentFlag = ACPI_NS_SEARCH_PARENT;    UINT32                  LocalFlags;    ACPI_FUNCTION_TRACE (NsLookup);    if (!ReturnNode)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    LocalFlags = Flags &        ~(ACPI_NS_ERROR_IF_FOUND | ACPI_NS_OVERRIDE_IF_FOUND |          ACPI_NS_SEARCH_PARENT);    *ReturnNode = ACPI_ENTRY_NOT_FOUND;    AcpiGbl_NsLookupCount++;    if (!AcpiGbl_RootNode)    {        return_ACPI_STATUS (AE_NO_NAMESPACE);    }    /* Get the prefix scope. A null scope means use the root scope */    if ((!ScopeInfo) ||        (!ScopeInfo->Scope.Node))    {        ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,            "Null scope prefix, using root node (%p)/n",            AcpiGbl_RootNode));        PrefixNode = AcpiGbl_RootNode;    }    else    {        PrefixNode = ScopeInfo->Scope.Node;        if (ACPI_GET_DESCRIPTOR_TYPE (PrefixNode) != ACPI_DESC_TYPE_NAMED)        {            ACPI_ERROR ((AE_INFO, "%p is not a namespace node [%s]",                PrefixNode, AcpiUtGetDescriptorName (PrefixNode)));            return_ACPI_STATUS (AE_AML_INTERNAL);        }        if (!(Flags & ACPI_NS_PREFIX_IS_SCOPE))        {            /*             * This node might not be a actual "scope" node (such as a             * Device/Method, etc.)  It could be a Package or other object             * node. Backup up the tree to find the containing scope node.             */            while (!AcpiNsOpensScope (PrefixNode->Type) &&                    PrefixNode->Type != ACPI_TYPE_ANY)            {                PrefixNode = PrefixNode->Parent;            }        }    }    /* Save type. TBD: may be no longer necessary */    TypeToCheckFor = Type;    /*     * Begin examination of the actual pathname     */    if (!Pathname)    {        /* A Null NamePath is allowed and refers to the root */        NumSegments = 0;        ThisNode = AcpiGbl_RootNode;        Path = "";        ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,            "Null Pathname (Zero segments), Flags=%X/n", Flags));    }    else    {        /*//.........这里部分代码省略.........

ACPI_STATUSAcpiDsExecBeginOp (    ACPI_WALK_STATE         *WalkState,    ACPI_PARSE_OBJECT       **OutOp){    ACPI_PARSE_OBJECT       *Op;    ACPI_STATUS             Status = AE_OK;    UINT32                  OpcodeClass;    ACPI_FUNCTION_TRACE_PTR (DsExecBeginOp, WalkState);    Op = WalkState->Op;    if (!Op)    {        Status = AcpiDsLoad2BeginOp (WalkState, OutOp);        if (ACPI_FAILURE (Status))        {            goto ErrorExit;        }        Op = *OutOp;        WalkState->Op = Op;        WalkState->Opcode = Op->Common.AmlOpcode;        WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);        if (AcpiNsOpensScope (WalkState->OpInfo->ObjectType))        {            ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,                "(%s) Popping scope for Op %p/n",                AcpiUtGetTypeName (WalkState->OpInfo->ObjectType), Op));            Status = AcpiDsScopeStackPop (WalkState);            if (ACPI_FAILURE (Status))            {                goto ErrorExit;            }        }    }    if (Op == WalkState->Origin)    {        if (OutOp)        {            *OutOp = Op;        }        return_ACPI_STATUS (AE_OK);    }    /*     * If the previous opcode was a conditional, this opcode     * must be the beginning of the associated predicate.     * Save this knowledge in the current scope descriptor     */    if ((WalkState->ControlState) &&        (WalkState->ControlState->Common.State ==            ACPI_CONTROL_CONDITIONAL_EXECUTING))    {        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,            "Exec predicate Op=%p State=%p/n",            Op, WalkState));        WalkState->ControlState->Common.State =            ACPI_CONTROL_PREDICATE_EXECUTING;        /* Save start of predicate */        WalkState->ControlState->Control.PredicateOp = Op;    }    OpcodeClass = WalkState->OpInfo->Class;    /* We want to send namepaths to the load code */    if (Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP)    {        OpcodeClass = AML_CLASS_NAMED_OBJECT;    }    /*     * Handle the opcode based upon the opcode type     */    switch (OpcodeClass)    {    case AML_CLASS_CONTROL:        Status = AcpiDsExecBeginControlOp (WalkState, Op);        break;    case AML_CLASS_NAMED_OBJECT:        if (WalkState->WalkType & ACPI_WALK_METHOD)        {            /*             * Found a named object declaration during method execution;             * we must enter this object into the namespace. The created             * object is temporary and will be deleted upon completion of//.........这里部分代码省略.........

//.........这里部分代码省略.........            Path = (char *) Op->Named.Path;        }    }    else if (OpInfo->Flags & AML_CREATE)    {        /* Referenced Buffer Name is the first child */        NextOp = Op->Common.Value.Arg;        if (NextOp->Common.AmlOpcode == AML_INT_NAMEPATH_OP)        {            Path = NextOp->Common.Value.String;        }    }    else    {        Path = Op->Common.Value.String;    }    if (!Path)    {        goto Exit;    }    /*     * 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.     */    Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY,                ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,                WalkState, &Node);    if (ACPI_FAILURE (Status))    {        if (Status == AE_NOT_FOUND)        {            AcpiDmAddToExternalList (Path, (UINT8) ObjectType, 0);            /*             * We could install this into the namespace, but we catch duplicate             * externals when they are added to the list.             */#if 0            Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY,                       ACPI_IMODE_LOAD_PASS1, ACPI_NS_DONT_OPEN_SCOPE,                       WalkState, &Node);#endif        }    }    /*     * Found the node in external table, add it to external list     * Node->OwnerId == 0 indicates built-in ACPI Names, _OS_ etc     */    else if (Node->OwnerId && WalkState->OwnerId != Node->OwnerId)    {        ObjectType2 = ObjectType;        Object = AcpiNsGetAttachedObject (Node);        if (Object)        {            ObjectType2 = Object->Common.Type;        }        if (ObjectType2 == ACPI_TYPE_METHOD)        {            AcpiDmAddToExternalList (Path, ACPI_TYPE_METHOD,                Object->Method.ParamCount);        }        else        {            AcpiDmAddToExternalList (Path, (UINT8) ObjectType2, 0);        }        Op->Common.Node = Node;    }    else    {        Op->Common.Node = Node;    }Exit:    /* Open new scope if necessary */    if (AcpiNsOpensScope (ObjectType))    {        if (Op->Common.Node)        {            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);            if (ACPI_FAILURE (Status))            {                return (Status);            }        }    }    return (AE_OK);}

//.........这里部分代码省略.........    OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);    ObjectType = OpInfo->ObjectType;    ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);    /* Only interested in operators that create new names */    if (!(OpInfo->Flags & AML_NAMED) &&        !(OpInfo->Flags & AML_CREATE))    {        goto Exit;    }    /* Get the NamePath from the appropriate place */    if (OpInfo->Flags & AML_NAMED)    {        /* For all named operators, get the new name */        Path = (char *) Op->Named.Path;        if (!Path && Op->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP)        {            *ACPI_CAST_PTR (UINT32, &FieldPath[0]) = Op->Named.Name;            FieldPath[4] = 0;            Path = FieldPath;        }    }    else if (OpInfo->Flags & AML_CREATE)    {        /* New name is the last child */        NextOp = Op->Common.Value.Arg;        while (NextOp->Common.Next)        {            NextOp = NextOp->Common.Next;        }        Path = NextOp->Common.Value.String;    }    if (!Path)    {        goto Exit;    }    /* Insert the name into the namespace */    Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,                ACPI_IMODE_LOAD_PASS2, ACPI_NS_DONT_OPEN_SCOPE,                WalkState, &Node);    Op->Common.Node = Node;    if (ACPI_SUCCESS (Status))    {        /* Check if it's a predefined node */        while (AcpiGbl_PreDefinedNames[PreDefineIndex].Name)        {            if (!ACPI_STRNCMP (Node->Name.Ascii,                AcpiGbl_PreDefinedNames[PreDefineIndex].Name, 4))            {                PreDefined = TRUE;                break;            }            PreDefineIndex++;        }        /*         * Set node owner id if it satisfies all the following conditions:         * 1) Not a predefined node, _SB_ etc         * 2) Not the root node         * 3) Not a node created by Scope         */        if (!PreDefined && Node != AcpiGbl_RootNode &&            Op->Common.AmlOpcode != AML_SCOPE_OP)        {            Node->OwnerId = WalkState->OwnerId;        }    }Exit:    if (AcpiNsOpensScope (ObjectType))    {        if (Op->Common.Node)        {            Status = AcpiDsScopeStackPush (Op->Common.Node, ObjectType, WalkState);            if (ACPI_FAILURE (Status))            {                return (Status);            }        }    }    return (AE_OK);}

//.........这里部分代码省略.........    /*     * Enter the named type into the internal namespace. We enter the name     * as we go downward in the parse tree. Any necessary subobjects that     * involve arguments to the opcode must be created as we go back up the     * parse tree later.     */    Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,        ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);    if (ACPI_FAILURE (Status))    {        if (Status == AE_ALREADY_EXISTS)        {            /* The name already exists in this scope */            if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)            {                /* Allow multiple references to the same scope */                Node->Type = (UINT8) ObjectType;                Status = AE_OK;            }            else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&                     (Op->Asl.ParseOpcode != PARSEOP_EXTERNAL))            {                /*                 * Allow one create on an object or segment that was                 * previously declared External                 */                Node->Flags &= ~ANOBJ_IS_EXTERNAL;                Node->Type = (UINT8) ObjectType;                /* Just retyped a node, probably will need to open a scope */                if (AcpiNsOpensScope (ObjectType))                {                    Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);                    if (ACPI_FAILURE (Status))                    {                        return_ACPI_STATUS (Status);                    }                }                Status = AE_OK;            }            else if (!(Node->Flags & ANOBJ_IS_EXTERNAL) &&                     (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL))            {                /*                 * Allow externals in same scope as the definition of the                 * actual object. Similar to C. Allows multiple definition                 * blocks that refer to each other in the same file.                 */                Status = AE_OK;            }            else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&                     (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) &&                     (ObjectType == ACPI_TYPE_ANY))            {                /* Allow update of externals of unknown type. */                if (AcpiNsOpensScope (ActualObjectType))                {                    Node->Type = (UINT8) ActualObjectType;                    Status = AE_OK;                }                else

//.........这里部分代码省略.........     * as we go downward in the parse tree. Any necessary subobjects that     * involve arguments to the opcode must be created as we go back up the     * parse tree later.     */    Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,        ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);    if (ACPI_FAILURE (Status))    {        if (Status == AE_ALREADY_EXISTS)        {            /* The name already exists in this scope */            if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)            {                /* Allow multiple references to the same scope */                Node->Type = (UINT8) ObjectType;                Status = AE_OK;            }            else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&                     (Op->Asl.ParseOpcode != PARSEOP_EXTERNAL))            {                /*                 * Allow one create on an object or segment that was                 * previously declared External only if WalkState->OwnerId and                 * Node->OwnerId are different (meaning that the current WalkState                 * and the Node are in different tables).                 */                Node->Flags &= ~ANOBJ_IS_EXTERNAL;                Node->Type = (UINT8) ObjectType;                /* Just retyped a node, probably will need to open a scope */                if (AcpiNsOpensScope (ObjectType))                {                    Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);                    if (ACPI_FAILURE (Status))                    {                        return_ACPI_STATUS (Status);                    }                }                Status = AE_OK;                if (Node->OwnerId == WalkState->OwnerId &&                    !(Node->Flags & IMPLICIT_EXTERNAL))                {                    AslDualParseOpError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Op,                        Op->Asl.ExternalName, ASL_MSG_FOUND_HERE, Node->Op,                        Node->Op->Asl.ExternalName);                }                if (Node->Flags & IMPLICIT_EXTERNAL)                {                    Node->Flags &= ~IMPLICIT_EXTERNAL;                }            }            else if (!(Node->Flags & ANOBJ_IS_EXTERNAL) &&                     (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL))            {                /*                 * Allow externals in same scope as the definition of the                 * actual object. Similar to C. Allows multiple definition                 * blocks that refer to each other in the same file. However,                 * do not allow name declaration and an external declaration                 * within the same table. This is considered a re-declaration.                 */

//.........这里部分代码省略.........            {                /*                 * ACPI_PARSE_MODULE_LEVEL means that we are loading a table by                 * executing it as a control method. However, if we encounter                 * an error while loading the table, we need to keep trying to                 * load the table rather than aborting the table load. Set the                 * status to AE_OK to proceed with the table load.                 */                if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&                    Status == AE_ALREADY_EXISTS)                {                    Status = AE_OK;                }                if (Status == AE_CTRL_PARSE_CONTINUE)                {                    continue;                }                if (Status == AE_CTRL_PARSE_PENDING)                {                    Status = AE_OK;                }                if (Status == AE_CTRL_TERMINATE)                {                    return_ACPI_STATUS (Status);                }                Status = AcpiPsCompleteOp (WalkState, &Op, Status);                if (ACPI_FAILURE (Status))                {                    return_ACPI_STATUS (Status);                }                if (AcpiNsOpensScope (                    AcpiPsGetOpcodeInfo (WalkState->Opcode)->ObjectType))                {                    /*                     * If the scope/device op fails to parse, skip the body of                     * the scope op because the parse failure indicates that                     * the device may not exist.                     */                    ACPI_ERROR ((AE_INFO, "Skip parsing opcode %s",                        AcpiPsGetOpcodeName (WalkState->Opcode)));                    WalkState->ParserState.Aml = WalkState->Aml + 1;                    WalkState->ParserState.Aml =                        AcpiPsGetNextPackageEnd(&WalkState->ParserState);                    WalkState->Aml = WalkState->ParserState.Aml;                }                continue;            }            AcpiExStartTraceOpcode (Op, WalkState);        }        /*         * Start ArgCount at zero because we don't know if there are         * any args yet         */        WalkState->ArgCount = 0;        switch (Op->Common.AmlOpcode)        {        case AML_BYTE_OP:        case AML_WORD_OP:        case AML_DWORD_OP: