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

ACPI_STATUSXfCrossReferenceNamespace (    void){    ACPI_WALK_STATE         *WalkState;    /*     * Create a new walk state for use when looking up names     * within the namespace (Passed as context to the callbacks)     */    WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);    if (!WalkState)    {        return (AE_NO_MEMORY);    }    /* Walk the entire parse tree */    TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_TWICE,        XfNamespaceLocateBegin, XfNamespaceLocateEnd, WalkState);    ACPI_FREE (WalkState);    return (AE_OK);}

ACPI_STATUSLkCrossReferenceNamespace (    void){    ACPI_WALK_STATE         *WalkState;    DbgPrint (ASL_DEBUG_OUTPUT, "/nCross referencing namespace/n/n");    /*     * Create a new walk state for use when looking up names     * within the namespace (Passed as context to the callbacks)     */    WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);    if (!WalkState)    {        return (AE_NO_MEMORY);    }    /* Walk the entire parse tree */    TrWalkParseTree (RootNode, ASL_WALK_VISIT_TWICE, LkNamespaceLocateBegin,                        LkNamespaceLocateEnd, WalkState);    return (AE_OK);}

ACPI_STATUSLdLoadNamespace (    ACPI_PARSE_OBJECT       *RootOp){    ACPI_WALK_STATE         *WalkState;    DbgPrint (ASL_DEBUG_OUTPUT, "/nCreating namespace/n/n");    /* Create a new walk state */    WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);    if (!WalkState)    {        return (AE_NO_MEMORY);    }    /* Walk the entire parse tree, first pass */    TrWalkParseTree (RootOp, ASL_WALK_VISIT_TWICE, LdNamespace1Begin,        LdCommonNamespaceEnd, WalkState);    /* Second pass to handle forward references */    TrWalkParseTree (RootOp, ASL_WALK_VISIT_TWICE, LdNamespace2Begin,        LdCommonNamespaceEnd, WalkState);    /* Dump the namespace if debug is enabled */    AcpiNsDumpTables (ACPI_NS_ALL, ACPI_UINT32_MAX);    return (AE_OK);}

ACPI_STATUSAcpiDsAutoSerializeMethod (    ACPI_NAMESPACE_NODE     *Node,    ACPI_OPERAND_OBJECT     *ObjDesc){    ACPI_STATUS             Status;    ACPI_PARSE_OBJECT       *Op = NULL;    ACPI_WALK_STATE         *WalkState;    ACPI_FUNCTION_TRACE_PTR (DsAutoSerializeMethod, Node);    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,        "Method auto-serialization parse [%4.4s] %p/n",        AcpiUtGetNodeName (Node), Node));    /* Create/Init a root op for the method parse tree */    Op = AcpiPsAllocOp (AML_METHOD_OP);    if (!Op)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    AcpiPsSetName (Op, Node->Name.Integer);    Op->Common.Node = Node;    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (Node->OwnerId, NULL, NULL, NULL);    if (!WalkState)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, Op, Node, ObjDesc->Method.AmlStart,                ObjDesc->Method.AmlLength, NULL, 0);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        return_ACPI_STATUS (Status);    }    WalkState->DescendingCallback = AcpiDsDetectNamedOpcodes;    /* Parse the method, scan for creation of named objects */    Status = AcpiPsParseAml (WalkState);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    AcpiPsDeleteParseTree (Op);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiDbDisassembleMethod (    char                    *Name){    ACPI_STATUS             Status;    ACPI_PARSE_OBJECT       *Op;    ACPI_WALK_STATE         *WalkState;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_NAMESPACE_NODE     *Method;    Method = AcpiDbConvertToNode (Name);    if (!Method)    {        return (AE_BAD_PARAMETER);    }    ObjDesc = Method->Object;    Op = AcpiPsCreateScopeOp ();    if (!Op)    {        return (AE_NO_MEMORY);    }    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (0, Op, NULL, NULL);    if (!WalkState)    {        return (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, Op, NULL,                    ObjDesc->Method.AmlStart,                    ObjDesc->Method.AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Parse the AML */    WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;    WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;    Status = AcpiPsParseAml (WalkState);    AcpiDmDisassemble (NULL, Op, 0);    AcpiPsDeleteParseTree (Op);    return (AE_OK);}

ACPI_STATUSAcpiNsOneCompleteParse (    UINT32                  PassNumber,    ACPI_TABLE_DESC         *TableDesc){    ACPI_PARSE_OBJECT       *ParseRoot;    ACPI_STATUS             Status;    ACPI_WALK_STATE         *WalkState;    ACPI_FUNCTION_TRACE ("NsOneCompleteParse");    /* Create and init a Root Node */    ParseRoot = AcpiPsCreateScopeOp ();    if (!ParseRoot)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (TABLE_ID_DSDT,                                    NULL, NULL, NULL);    if (!WalkState)    {        AcpiPsFreeOp (ParseRoot);        return_ACPI_STATUS (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, ParseRoot, NULL, TableDesc->AmlStart,                    TableDesc->AmlLength, NULL, NULL, PassNumber);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        return_ACPI_STATUS (Status);    }    /* Parse the AML */    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "*PARSE* pass %d parse/n", PassNumber));    Status = AcpiPsParseAml (WalkState);    AcpiPsDeleteParseTree (ParseRoot);    return_ACPI_STATUS (Status);}

voidAeDoObjectOverrides (    void){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_WALK_STATE         *WalkState;    int                     i;    if (!InitFile)    {        return;    }    /* Create needed objects to be reused for each init entry */    ObjDesc = AcpiUtCreateIntegerObject (0);    WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);    NameBuffer[0] = '//';    /* Read the entire file line-by-line */    while (fgets (LineBuffer, AE_FILE_BUFFER_SIZE, InitFile) != NULL)    {        if (sscanf (LineBuffer, "%s %s/n",                &NameBuffer[1], ValueBuffer) != 2)        {            goto CleanupAndExit;        }        /* Add a root prefix if not present in the string */        i = 0;        if (NameBuffer[1] == '//')        {            i = 1;        }        AeDoOneOverride (&NameBuffer[i], ValueBuffer, ObjDesc, WalkState);    }    /* Cleanup */CleanupAndExit:    fclose (InitFile);    AcpiDsDeleteWalkState (WalkState);    AcpiUtRemoveReference (ObjDesc);}

voidAcpiDmConvertResourceIndexes (    ACPI_PARSE_OBJECT       *ParseTreeRoot,    ACPI_NAMESPACE_NODE     *NamespaceRoot){    ACPI_STATUS             Status;    ACPI_OP_WALK_INFO       Info;    ACPI_WALK_STATE         *WalkState;    if (!ParseTreeRoot)    {        return;    }    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (0, ParseTreeRoot, NULL, NULL);    if (!WalkState)    {        return;    }    Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type, WalkState);    if (ACPI_FAILURE (Status))    {        return;    }    Info.Flags = 0;    Info.Level = 0;    Info.WalkState = WalkState;    AcpiDmWalkParseTree (ParseTreeRoot, AcpiDmResourceDescendingOp,        AcpiDmCommonAscendingOp, &Info);    ACPI_FREE (WalkState);    return;}

voidAcpiDmCrossReferenceNamespace (    ACPI_PARSE_OBJECT       *ParseTreeRoot,    ACPI_NAMESPACE_NODE     *NamespaceRoot,    ACPI_OWNER_ID           OwnerId){    ACPI_STATUS             Status;    ACPI_OP_WALK_INFO       Info;    ACPI_WALK_STATE         *WalkState;    if (!ParseTreeRoot)    {        return;    }    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (OwnerId, ParseTreeRoot, NULL, NULL);    if (!WalkState)    {        return;    }    Status = AcpiDsScopeStackPush (NamespaceRoot, NamespaceRoot->Type, WalkState);    if (ACPI_FAILURE (Status))    {        return;    }    Info.Flags = 0;    Info.Level = 0;    Info.WalkState = WalkState;    AcpiDmWalkParseTree (ParseTreeRoot, AcpiDmXrefDescendingOp,        AcpiDmCommonAscendingOp, &Info);    ACPI_FREE (WalkState);}

ACPI_STATUSAcpiDsCallControlMethod (    ACPI_THREAD_STATE       *Thread,    ACPI_WALK_STATE         *ThisWalkState,    ACPI_PARSE_OBJECT       *Op){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *MethodNode;    ACPI_WALK_STATE         *NextWalkState = NULL;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_EVALUATE_INFO      *Info;    UINT32                  i;    ACPI_FUNCTION_TRACE_PTR (DsCallControlMethod, ThisWalkState);    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Calling method %p, currentstate=%p/n",        ThisWalkState->PrevOp, ThisWalkState));    /*     * Get the namespace entry for the control method we are about to call     */    MethodNode = ThisWalkState->MethodCallNode;    if (!MethodNode)    {        return_ACPI_STATUS (AE_NULL_ENTRY);    }    ObjDesc = AcpiNsGetAttachedObject (MethodNode);    if (!ObjDesc)    {        return_ACPI_STATUS (AE_NULL_OBJECT);    }    /* Init for new method, possibly wait on method mutex */    Status = AcpiDsBeginMethodExecution (MethodNode, ObjDesc,                ThisWalkState);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Begin method parse/execution. Create a new walk state */    NextWalkState = AcpiDsCreateWalkState (ObjDesc->Method.OwnerId,                        NULL, ObjDesc, Thread);    if (!NextWalkState)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    /*     * The resolved arguments were put on the previous walk state's operand     * stack. Operands on the previous walk state stack always     * start at index 0. Also, null terminate the list of arguments     */    ThisWalkState->Operands [ThisWalkState->NumOperands] = NULL;    /*     * Allocate and initialize the evaluation information block     * TBD: this is somewhat inefficient, should change interface to     * DsInitAmlWalk. For now, keeps this struct off the CPU stack     */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Info->Parameters = &ThisWalkState->Operands[0];    Status = AcpiDsInitAmlWalk (NextWalkState, NULL, MethodNode,                ObjDesc->Method.AmlStart, ObjDesc->Method.AmlLength,                Info, ACPI_IMODE_EXECUTE);    ACPI_FREE (Info);    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }    /*     * Delete the operands on the previous walkstate operand stack     * (they were copied to new objects)     */    for (i = 0; i < ObjDesc->Method.ParamCount; i++)    {        AcpiUtRemoveReference (ThisWalkState->Operands [i]);        ThisWalkState->Operands [i] = NULL;    }    /* Clear the operand stack */    ThisWalkState->NumOperands = 0;    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,        "**** Begin nested execution of [%4.4s] **** WalkState=%p/n",        MethodNode->Name.Ascii, NextWalkState));//.........这里部分代码省略.........

ACPI_STATUSAcpiDbSecondPassParse (    ACPI_PARSE_OBJECT       *Root){    ACPI_PARSE_OBJECT       *Op = Root;    ACPI_PARSE_OBJECT       *Method;    ACPI_PARSE_OBJECT       *SearchOp;    ACPI_PARSE_OBJECT       *StartOp;    ACPI_STATUS             Status = AE_OK;    UINT32                  BaseAmlOffset;    ACPI_WALK_STATE         *WalkState;    ACPI_FUNCTION_ENTRY ();    AcpiOsPrintf ("Pass two parse ..../n");    while (Op)    {        if (Op->Common.AmlOpcode == AML_METHOD_OP)        {            Method = Op;            /* Create a new walk state for the parse */            WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);            if (!WalkState)            {                return (AE_NO_MEMORY);            }            /* Init the Walk State */            WalkState->ParserState.Aml          =            WalkState->ParserState.AmlStart     = Method->Named.Data;            WalkState->ParserState.AmlEnd       =            WalkState->ParserState.PkgEnd       = Method->Named.Data +                                                  Method->Named.Length;            WalkState->ParserState.StartScope   = Op;            WalkState->DescendingCallback       = AcpiDsLoad1BeginOp;            WalkState->AscendingCallback        = AcpiDsLoad1EndOp;            /* Perform the AML parse */            Status = AcpiPsParseAml (WalkState);            BaseAmlOffset = (Method->Common.Value.Arg)->Common.AmlOffset + 1;            StartOp = (Method->Common.Value.Arg)->Common.Next;            SearchOp = StartOp;            while (SearchOp)            {                SearchOp->Common.AmlOffset += BaseAmlOffset;                SearchOp = AcpiPsGetDepthNext (StartOp, SearchOp);            }        }        if (Op->Common.AmlOpcode == AML_REGION_OP)        {            /* TBD: [Investigate] this isn't quite the right thing to do! */            /*             *             * Method = (ACPI_DEFERRED_OP *) Op;             * Status = AcpiPsParseAml (Op, Method->Body, Method->BodyLength);             */        }        if (ACPI_FAILURE (Status))        {            break;        }        Op = AcpiPsGetDepthNext (Root, Op);    }    return (Status);}

static ACPI_STATUSAcpiDmDeferredParse (    ACPI_PARSE_OBJECT       *Op,    UINT8                   *Aml,    UINT32                  AmlLength){    ACPI_WALK_STATE         *WalkState;    ACPI_STATUS             Status;    ACPI_PARSE_OBJECT       *SearchOp;    ACPI_PARSE_OBJECT       *StartOp;    UINT32                  BaseAmlOffset;    ACPI_PARSE_OBJECT       *NewRootOp;    ACPI_PARSE_OBJECT       *ExtraOp;    ACPI_FUNCTION_TRACE (DmDeferredParse);    if (!Aml || !AmlLength)    {        return_ACPI_STATUS (AE_OK);    }    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Parsing deferred opcode %s [%4.4s]/n",        Op->Common.AmlOpName, (char *) &Op->Named.Name));    /* Need a new walk state to parse the AML */    WalkState = AcpiDsCreateWalkState (0, Op, NULL, NULL);    if (!WalkState)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, Aml,        AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Parse the AML for this deferred opcode */    WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;    WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;    Status = AcpiPsParseAml (WalkState);    /*     * We need to update all of the AML offsets, since the parser thought     * that the method began at offset zero. In reality, it began somewhere     * within the ACPI table, at the BaseAmlOffset. Walk the entire tree that     * was just created and update the AmlOffset in each Op.     */    BaseAmlOffset = (Op->Common.Value.Arg)->Common.AmlOffset + 1;    StartOp = (Op->Common.Value.Arg)->Common.Next;    SearchOp = StartOp;    while (SearchOp)    {        SearchOp->Common.AmlOffset += BaseAmlOffset;        SearchOp = AcpiPsGetDepthNext (StartOp, SearchOp);    }    /*     * For Buffer and Package opcodes, link the newly parsed subtree     * into the main parse tree     */    switch (Op->Common.AmlOpcode)    {    case AML_BUFFER_OP:    case AML_PACKAGE_OP:    case AML_VAR_PACKAGE_OP:        switch (Op->Common.AmlOpcode)        {        case AML_PACKAGE_OP:            ExtraOp = Op->Common.Value.Arg;            NewRootOp = ExtraOp->Common.Next;            ACPI_FREE (ExtraOp);            break;        case AML_VAR_PACKAGE_OP:        case AML_BUFFER_OP:        default:            NewRootOp = Op->Common.Value.Arg;            break;        }        Op->Common.Value.Arg = NewRootOp->Common.Value.Arg;        /* Must point all parents to the main tree */        StartOp = Op;        SearchOp = StartOp;        while (SearchOp)        {            if (SearchOp->Common.Parent == NewRootOp)            {//.........这里部分代码省略.........

static ACPI_STATUSAcpiDsExecuteArguments (    ACPI_NAMESPACE_NODE     *Node,    ACPI_NAMESPACE_NODE     *ScopeNode,    UINT32                  AmlLength,    UINT8                   *AmlStart){    ACPI_STATUS             Status;    ACPI_PARSE_OBJECT       *Op;    ACPI_WALK_STATE         *WalkState;    ACPI_FUNCTION_TRACE (DsExecuteArguments);    /*     * Allocate a new parser op to be the root of the parsed tree     */    Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);    if (!Op)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Save the Node for use in AcpiPsParseAml */    Op->Common.Node = ScopeNode;    /* Create and initialize a new parser state */    WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);    if (!WalkState)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,                    AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        goto Cleanup;    }    /* Mark this parse as a deferred opcode */    WalkState->ParseFlags = ACPI_PARSE_DEFERRED_OP;    WalkState->DeferredNode = Node;    /* Pass1: Parse the entire declaration */    Status = AcpiPsParseAml (WalkState);    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }    /* Get and init the Op created above */    Op->Common.Node = Node;    AcpiPsDeleteParseTree (Op);    /* Evaluate the deferred arguments */    Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);    if (!Op)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Op->Common.Node = ScopeNode;    /* Create and initialize a new parser state */    WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);    if (!WalkState)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    /* Execute the opcode and arguments */    Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,                    AmlLength, NULL, ACPI_IMODE_EXECUTE);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        goto Cleanup;    }    /* Mark this execution as a deferred opcode */    WalkState->DeferredNode = Node;    Status = AcpiPsParseAml (WalkState);Cleanup:    AcpiPsDeleteParseTree (Op);    return_ACPI_STATUS (Status);//.........这里部分代码省略.........

ACPI_STATUSOpcAmlConstantWalk (    ACPI_PARSE_OBJECT       *Op,    UINT32                  Level,    void                    *Context){    ACPI_WALK_STATE         *WalkState;    ACPI_STATUS             Status = AE_OK;    if (Op->Asl.CompileFlags == 0)    {        return (AE_OK);    }    /*     * Only interested in subtrees that could possibly contain     * expressions that can be evaluated at this time     */    if ((!(Op->Asl.CompileFlags & NODE_COMPILE_TIME_CONST)) ||          (Op->Asl.CompileFlags & NODE_IS_TARGET))    {        return (AE_OK);    }    /* Create a new walk state */    WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);    if (!WalkState)    {        return (AE_NO_MEMORY);    }    WalkState->NextOp = NULL;    WalkState->Params = NULL;    /*     * Examine the entire subtree -- all nodes must be constants     * or type 3/4/5 opcodes     */    Status = TrWalkParseTree (Op, ASL_WALK_VISIT_DOWNWARD,        OpcAmlCheckForConstant, NULL, WalkState);    /*     * Did we find an entire subtree that contains all constants     * and type 3/4/5 opcodes?     */    switch (Status)    {    case AE_OK:        /* Simple case, like Add(3,4) -> 7 */        Status = TrSimpleConstantReduction (Op, WalkState);        break;    case AE_CTRL_RETURN_VALUE:        /* More complex case, like Add(3,4,Local0) -> Store(7,Local0) */        Status = TrTransformToStoreOp (Op, WalkState);        break;    case AE_TYPE:        AcpiDsDeleteWalkState (WalkState);        return (AE_OK);    default:        AcpiDsDeleteWalkState (WalkState);        break;    }    if (ACPI_FAILURE (Status))    {        DbgPrint (ASL_PARSE_OUTPUT, "Cannot resolve, %s/n",            AcpiFormatException (Status));        /* We could not resolve the subtree for some reason */        AslError (ASL_ERROR, ASL_MSG_CONSTANT_EVALUATION, Op,            (char *) AcpiFormatException (Status));        /* Set the subtree value to ZERO anyway. Eliminates further errors */        OpcUpdateIntegerNode (Op, 0);    }    return (AE_OK);}

ACPI_STATUSAcpiNsOneCompleteParse (    UINT32                  PassNumber,    UINT32                  TableIndex,    ACPI_NAMESPACE_NODE     *StartNode){    ACPI_PARSE_OBJECT       *ParseRoot;    ACPI_STATUS             Status;    UINT32                  AmlLength;    UINT8                   *AmlStart;    ACPI_WALK_STATE         *WalkState;    ACPI_TABLE_HEADER       *Table;    ACPI_OWNER_ID           OwnerId;    ACPI_FUNCTION_TRACE (NsOneCompleteParse);    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Table must consist of at least a complete header */    if (Table->Length < sizeof (ACPI_TABLE_HEADER))    {        return_ACPI_STATUS (AE_BAD_HEADER);    }    AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER);    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);    Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Create and init a Root Node */    ParseRoot = AcpiPsCreateScopeOp (AmlStart);    if (!ParseRoot)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (OwnerId, NULL, NULL, NULL);    if (!WalkState)    {        AcpiPsFreeOp (ParseRoot);        return_ACPI_STATUS (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, ParseRoot, NULL,        AmlStart, AmlLength, NULL, (UINT8) PassNumber);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        goto Cleanup;    }    /* Found OSDT table, enable the namespace override feature */    if (ACPI_COMPARE_NAME(Table->Signature, ACPI_SIG_OSDT) &&        PassNumber == ACPI_IMODE_LOAD_PASS1)    {        WalkState->NamespaceOverride = TRUE;    }    /* StartNode is the default location to load the table  */    if (StartNode && StartNode != AcpiGbl_RootNode)    {        Status = AcpiDsScopeStackPush (            StartNode, ACPI_TYPE_METHOD, WalkState);        if (ACPI_FAILURE (Status))        {            AcpiDsDeleteWalkState (WalkState);            goto Cleanup;        }    }    /* Parse the AML */    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,        "*PARSE* pass %u parse/n", PassNumber));    AcpiExEnterInterpreter ();    Status = AcpiPsParseAml (WalkState);    AcpiExExitInterpreter ();Cleanup:    AcpiPsDeleteParseTree (ParseRoot);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiPsParseAml (    ACPI_PARSE_OBJECT       *StartScope,    UINT8                   *Aml,    UINT32                  AmlSize,    UINT32                  ParseFlags,    ACPI_NAMESPACE_NODE     *MethodNode,    ACPI_OPERAND_OBJECT     **Params,    ACPI_OPERAND_OBJECT     **CallerReturnDesc,    ACPI_PARSE_DOWNWARDS    DescendingCallback,    ACPI_PARSE_UPWARDS      AscendingCallback){    ACPI_STATUS             Status;    ACPI_PARSE_STATE        *ParserState;    ACPI_WALK_STATE         *WalkState;    ACPI_WALK_LIST          WalkList;    ACPI_WALK_LIST          *PrevWalkList = AcpiGbl_CurrentWalkList;    ACPI_OPERAND_OBJECT     *ReturnDesc;    ACPI_OPERAND_OBJECT     *MthDesc = NULL;    FUNCTION_TRACE ("PsParseAml");    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Entered with Scope=%p Aml=%p size=%lX/n",        StartScope, Aml, AmlSize));    /* Create and initialize a new parser state */    ParserState = AcpiPsCreateState (Aml, AmlSize);    if (!ParserState)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    AcpiPsInitScope (ParserState, StartScope);    if (MethodNode)    {        MthDesc = AcpiNsGetAttachedObject (MethodNode);    }    /* Create and initialize a new walk list */    WalkList.WalkState = NULL;    WalkList.AcquiredMutexList.Prev = NULL;    WalkList.AcquiredMutexList.Next = NULL;    WalkState = AcpiDsCreateWalkState (TABLE_ID_DSDT, ParserState->StartOp,                        MthDesc, &WalkList);    if (!WalkState)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    WalkState->MethodNode           = MethodNode;    WalkState->ParserState          = ParserState;    WalkState->ParseFlags           = ParseFlags;    WalkState->DescendingCallback   = DescendingCallback;    WalkState->AscendingCallback    = AscendingCallback;    /* TBD: [Restructure] TEMP until we pass WalkState to the interpreter     */    AcpiGbl_CurrentWalkList = &WalkList;    if (MethodNode)    {        ParserState->StartNode  = MethodNode;        WalkState->WalkType     = WALK_METHOD;        /* Push start scope on scope stack and make it current  */        Status = AcpiDsScopeStackPush (MethodNode, ACPI_TYPE_METHOD, WalkState);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }        /* Init arguments if this is a control method */        /* TBD: [Restructure] add walkstate as a param */        AcpiDsMethodDataInitArgs (Params, MTH_NUM_ARGS, WalkState);    }    else    {        /* Setup the current scope */        ParserState->StartNode = ParserState->StartOp->Node;        if (ParserState->StartNode)        {            /* Push start scope on scope stack and make it current  */            Status = AcpiDsScopeStackPush (ParserState->StartNode,                            ParserState->StartNode->Type, WalkState);            if (ACPI_FAILURE (Status))            {                goto Cleanup;//.........这里部分代码省略.........

ACPI_STATUSAcpiPsExecuteMethod (    ACPI_EVALUATE_INFO      *Info){    ACPI_STATUS             Status;    ACPI_PARSE_OBJECT       *Op;    ACPI_WALK_STATE         *WalkState;    ACPI_FUNCTION_TRACE (PsExecuteMethod);    /* Quick validation of DSDT header */    AcpiTbCheckDsdtHeader ();    /* Validate the Info and method Node */    if (!Info || !Info->Node)    {        return_ACPI_STATUS (AE_NULL_ENTRY);    }    /* Init for new method, wait on concurrency semaphore */    Status = AcpiDsBeginMethodExecution (Info->Node, Info->ObjDesc, NULL);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /*     * The caller "owns" the parameters, so give each one an extra reference     */    AcpiPsUpdateParameterList (Info, REF_INCREMENT);    /*     * Execute the method. Performs parse simultaneously     */    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,        "**** Begin Method Parse/Execute [%4.4s] **** Node=%p Obj=%p/n",        Info->Node->Name.Ascii, Info->Node, Info->ObjDesc));    /* Create and init a Root Node */    Op = AcpiPsCreateScopeOp (Info->ObjDesc->Method.AmlStart);    if (!Op)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    /* Create and initialize a new walk state */    Info->PassNumber = ACPI_IMODE_EXECUTE;    WalkState = AcpiDsCreateWalkState (        Info->ObjDesc->Method.OwnerId, NULL, NULL, NULL);    if (!WalkState)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    Status = AcpiDsInitAmlWalk (WalkState, Op, Info->Node,        Info->ObjDesc->Method.AmlStart,        Info->ObjDesc->Method.AmlLength, Info, Info->PassNumber);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        goto Cleanup;    }    if (Info->ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)    {        WalkState->ParseFlags |= ACPI_PARSE_MODULE_LEVEL;    }    /* Invoke an internal method if necessary */    if (Info->ObjDesc->Method.InfoFlags & ACPI_METHOD_INTERNAL_ONLY)    {        Status = Info->ObjDesc->Method.Dispatch.Implementation (WalkState);        Info->ReturnObject = WalkState->ReturnDesc;        /* Cleanup states */        AcpiDsScopeStackClear (WalkState);        AcpiPsCleanupScope (&WalkState->ParserState);        AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);        AcpiDsDeleteWalkState (WalkState);        goto Cleanup;    }    /*     * Start method evaluation with an implicit return of zero.     * This is done for Windows compatibility.     */    if (AcpiGbl_EnableInterpreterSlack)    {        WalkState->ImplicitReturnObj =//.........这里部分代码省略.........

ACPI_STATUSAcpiPsExecuteTable (    ACPI_EVALUATE_INFO      *Info){    ACPI_STATUS             Status;    ACPI_PARSE_OBJECT       *Op = NULL;    ACPI_WALK_STATE         *WalkState = NULL;    ACPI_FUNCTION_TRACE (PsExecuteTable);    /* Create and init a Root Node */    Op = AcpiPsCreateScopeOp (Info->ObjDesc->Method.AmlStart);    if (!Op)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (        Info->ObjDesc->Method.OwnerId, NULL, NULL, NULL);    if (!WalkState)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    Status = AcpiDsInitAmlWalk (WalkState, Op, Info->Node,        Info->ObjDesc->Method.AmlStart,        Info->ObjDesc->Method.AmlLength, Info, Info->PassNumber);    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }    if (Info->ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)    {        WalkState->ParseFlags |= ACPI_PARSE_MODULE_LEVEL;    }    /* Info->Node is the default location to load the table  */    if (Info->Node && Info->Node != AcpiGbl_RootNode)    {        Status = AcpiDsScopeStackPush (            Info->Node, ACPI_TYPE_METHOD, WalkState);        if (ACPI_FAILURE (Status))        {            goto Cleanup;        }    }    /*     * Parse the AML, WalkState will be deleted by ParseAml     */    AcpiExEnterInterpreter ();    Status = AcpiPsParseAml (WalkState);    AcpiExExitInterpreter ();    WalkState = NULL;Cleanup:    if (WalkState)    {        AcpiDsDeleteWalkState (WalkState);    }    if (Op)    {        AcpiPsDeleteParseTree (Op);    }    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiDbDisassembleMethod (    char                    *Name){    ACPI_STATUS             Status;    ACPI_PARSE_OBJECT       *Op;    ACPI_WALK_STATE         *WalkState;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_NAMESPACE_NODE     *Method;    Method = AcpiDbConvertToNode (Name);    if (!Method)    {        return (AE_BAD_PARAMETER);    }    if (Method->Type != ACPI_TYPE_METHOD)    {        ACPI_ERROR ((AE_INFO, "%s (%s): Object must be a control method",            Name, AcpiUtGetTypeName (Method->Type)));        return (AE_BAD_PARAMETER);    }    ObjDesc = Method->Object;    Op = AcpiPsCreateScopeOp ();    if (!Op)    {        return (AE_NO_MEMORY);    }    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (0, Op, NULL, NULL);    if (!WalkState)    {        return (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, Op, NULL,        ObjDesc->Method.AmlStart,        ObjDesc->Method.AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);    if (ACPI_FAILURE (Status))    {        return (Status);    }    Status = AcpiUtAllocateOwnerId (&ObjDesc->Method.OwnerId);    WalkState->OwnerId = ObjDesc->Method.OwnerId;    /* Push start scope on scope stack and make it current */    Status = AcpiDsScopeStackPush (Method,        Method->Type, WalkState);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Parse the entire method AML including deferred operators */    WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;    WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;    Status = AcpiPsParseAml (WalkState);    (void) AcpiDmParseDeferredOps (Op);    /* Now we can disassemble the method */    AcpiGbl_DbOpt_verbose = FALSE;    AcpiDmDisassemble (NULL, Op, 0);    AcpiGbl_DbOpt_verbose = TRUE;    AcpiPsDeleteParseTree (Op);    /* Method cleanup */    AcpiNsDeleteNamespaceSubtree (Method);    AcpiNsDeleteNamespaceByOwner (ObjDesc->Method.OwnerId);    AcpiUtReleaseOwnerId (&ObjDesc->Method.OwnerId);    return (AE_OK);}

ACPI_STATUSAcpiPsxExecute (    ACPI_NAMESPACE_NODE     *MethodNode,    ACPI_OPERAND_OBJECT     **Params,    ACPI_OPERAND_OBJECT     **ReturnObjDesc){    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     *ObjDesc;    UINT32                  i;    ACPI_PARSE_OBJECT       *Op;    ACPI_WALK_STATE         *WalkState;    ACPI_FUNCTION_TRACE ("PsxExecute");    /* Validate the Node and get the attached object */    if (!MethodNode)    {        return_ACPI_STATUS (AE_NULL_ENTRY);    }    ObjDesc = AcpiNsGetAttachedObject (MethodNode);    if (!ObjDesc)    {        return_ACPI_STATUS (AE_NULL_OBJECT);    }    /* Init for new method, wait on concurrency semaphore */    Status = AcpiDsBeginMethodExecution (MethodNode, ObjDesc, NULL);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    if (Params)    {        /*         * The caller "owns" the parameters, so give each one an extra         * reference         */        for (i = 0; Params[i]; i++)        {            AcpiUtAddReference (Params[i]);        }    }    /*     * 1) Perform the first pass parse of the method to enter any     * named objects that it creates into the namespace     */    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,        "**** Begin Method Parse **** Entry=%p obj=%p/n",        MethodNode, ObjDesc));    /* Create and init a Root Node */    Op = AcpiPsCreateScopeOp ();    if (!Op)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /*     * Get a new OwnerId for objects created by this method.  Namespace     * objects (such as Operation Regions) can be created during the     * first pass parse.     */    ObjDesc->Method.OwningId = AcpiUtAllocateOwnerId (ACPI_OWNER_TYPE_METHOD);    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (ObjDesc->Method.OwningId,                                    NULL, NULL, NULL);    if (!WalkState)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, Op, MethodNode, ObjDesc->Method.AmlStart,                    ObjDesc->Method.AmlLength, NULL, NULL, 1);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        return_ACPI_STATUS (Status);    }    /* Parse the AML */    Status = AcpiPsParseAml (WalkState);    AcpiPsDeleteParseTree (Op);    /*     * 2) Execute the method.  Performs second pass parse simultaneously     */    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,        "**** Begin Method Execution **** Entry=%p obj=%p/n",        MethodNode, ObjDesc));//.........这里部分代码省略.........

ACPI_STATUSAcpiDsExecuteArguments (    ACPI_NAMESPACE_NODE     *Node,    ACPI_NAMESPACE_NODE     *ScopeNode,    UINT32                  AmlLength,    UINT8                   *AmlStart){    ACPI_STATUS             Status;    ACPI_PARSE_OBJECT       *Op;    ACPI_WALK_STATE         *WalkState;    ACPI_PARSE_OBJECT       *Arg;    ACPI_FUNCTION_TRACE ("AcpiDsExecuteArguments");    /*     * Allocate a new parser op to be the root of the parsed tree     */    Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);    if (!Op)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Save the Node for use in AcpiPsParseAml */    Op->Common.Node = ScopeNode;    /* Create and initialize a new parser state */    WalkState = AcpiDsCreateWalkState (TABLE_ID_DSDT, NULL, NULL, NULL);    if (!WalkState)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,                    AmlLength, NULL, NULL, 1);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        return_ACPI_STATUS (Status);    }    WalkState->ParseFlags = ACPI_PARSE_DEFERRED_OP;    /* Pass1: Parse the entire declaration */    Status = AcpiPsParseAml (WalkState);    if (ACPI_FAILURE (Status))    {        AcpiPsDeleteParseTree (Op);        return_ACPI_STATUS (Status);    }    /* Get and init the Op created above */    Arg = Op->Common.Value.Arg;    Op->Common.Node = Node;    Arg->Common.Node = Node;    AcpiPsDeleteParseTree (Op);    /* Evaluate the address and length arguments for the Buffer Field */    Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);    if (!Op)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Op->Common.Node = ScopeNode;    /* Create and initialize a new parser state */    WalkState = AcpiDsCreateWalkState (TABLE_ID_DSDT, NULL, NULL, NULL);    if (!WalkState)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,                    AmlLength, NULL, NULL, 3);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        return_ACPI_STATUS (Status);    }    Status = AcpiPsParseAml (WalkState);    AcpiPsDeleteParseTree (Op);    return_ACPI_STATUS (Status);}