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

static ACPI_STATUSAcpiNsDumpOneObjectPath (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    UINT32                  MaxLevel = *((UINT32 *) Context);    char                    *Pathname;    ACPI_NAMESPACE_NODE     *Node;    int                     PathIndent;    if (!ObjHandle)    {        return (AE_OK);    }    Node = AcpiNsValidateHandle (ObjHandle);    if (!Node)    {        /* Ignore bad node during namespace walk */        return (AE_OK);    }    Pathname = AcpiNsGetNormalizedPathname (Node, TRUE);    PathIndent = 1;    if (Level <= MaxLevel)    {        PathIndent = MaxLevel - Level + 1;    }    AcpiOsPrintf ("%2d%*s%-12s%*s",        Level, Level, " ", AcpiUtGetTypeName (Node->Type),        PathIndent, " ");    AcpiOsPrintf ("%s/n", &Pathname[1]);    ACPI_FREE (Pathname);    return (AE_OK);}

voidAcpiDsScopeStackClear (    ACPI_WALK_STATE         *WalkState){    ACPI_GENERIC_STATE      *ScopeInfo;    ACPI_FUNCTION_NAME ("DsScopeStackClear");    while (WalkState->ScopeInfo)    {        /* Pop a scope off the stack */        ScopeInfo = WalkState->ScopeInfo;        WalkState->ScopeInfo = ScopeInfo->Scope.Next;        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,            "Popped object type (%s)/n", AcpiUtGetTypeName (ScopeInfo->Common.Value)));        AcpiUtDeleteGenericState (ScopeInfo);    }}

static ACPI_STATUSAcpiDsMethodDataSetValue (    UINT8                   Type,    UINT32                  Index,    ACPI_OPERAND_OBJECT     *Object,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    ACPI_FUNCTION_TRACE (DsMethodDataSetValue);    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,        "NewObj %p Type %2.2X, Refs=%u [%s]/n", Object,        Type, Object->Common.ReferenceCount,        AcpiUtGetTypeName (Object->Common.Type)));    /* Get the namespace node for the arg/local */    Status = AcpiDsMethodDataGetNode (Type, Index, WalkState, &Node);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /*     * Increment ref count so object can't be deleted while installed.     * NOTE: We do not copy the object in order to preserve the call by     * reference semantics of ACPI Control Method invocation.     * (See ACPI Specification 2.0C)     */    AcpiUtAddReference (Object);    /* Install the object */    Node->Object = Object;    return_ACPI_STATUS (Status);}

voidAcpiDbDisplayResources (    char                    *ObjectArg){    ACPI_NAMESPACE_NODE     *Node;    AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);    AcpiDbgLevel |= ACPI_LV_RESOURCES;    /* Asterisk means "display resources for all devices" */    if (!ObjectArg || (!strcmp (ObjectArg, "*")))    {        (void) AcpiWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,            ACPI_UINT32_MAX, AcpiDbDeviceResources, NULL, NULL, NULL);    }    else    {        /* Convert string to object pointer */        Node = AcpiDbConvertToNode (ObjectArg);        if (Node)        {            if (Node->Type != ACPI_TYPE_DEVICE)            {                AcpiOsPrintf (                    "%4.4s: Name is not a device object (%s)/n",                    Node->Name.Ascii, AcpiUtGetTypeName (Node->Type));            }            else            {                (void) AcpiDbDeviceResources (Node, 0, NULL, NULL);            }        }    }    AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);}

//.........这里部分代码省略.........    if (OpInfo->Flags & AML_NAMED)    {        /* For nearly all NAMED operators, the name reference is the first child */        Path = Op->Asl.Child->Asl.Value.String;        if (Op->Asl.AmlOpcode == AML_ALIAS_OP)        {            /*             * ALIAS is the only oddball opcode, the name declaration             * (alias name) is the second operand             */            Path = Op->Asl.Child->Asl.Next->Asl.Value.String;        }    }    else if (OpInfo->Flags & AML_CREATE)    {        /* Name must appear as the last parameter */        NextOp = Op->Asl.Child;        while (!(NextOp->Asl.CompileFlags & OP_IS_NAME_DECLARATION))        {            NextOp = NextOp->Asl.Next;        }        Path = NextOp->Asl.Value.String;    }    else    {        Path = Op->Asl.Value.String;    }    ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);    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.     */    AslGbl_NsLookupCount++;    Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,        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))                {                    /*                     * There exists such a name, but we couldn't get to it                     * from this scope                     */                    AslError (ASL_ERROR, ASL_MSG_NOT_REACHABLE, Op,                        Op->Asl.ExternalName);

ACPI_STATUSAcpiExResolveObject (    ACPI_OPERAND_OBJECT     **SourceDescPtr,    ACPI_OBJECT_TYPE        TargetType,    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     *SourceDesc = *SourceDescPtr;    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_TRACE (ExResolveObject);    /* Ensure we have a Target that can be stored to */    switch (TargetType)    {    case ACPI_TYPE_BUFFER_FIELD:    case ACPI_TYPE_LOCAL_REGION_FIELD:    case ACPI_TYPE_LOCAL_BANK_FIELD:    case ACPI_TYPE_LOCAL_INDEX_FIELD:        /*         * These cases all require only Integers or values that         * can be converted to Integers (Strings or Buffers)         */    case ACPI_TYPE_INTEGER:    case ACPI_TYPE_STRING:    case ACPI_TYPE_BUFFER:        /*         * Stores into a Field/Region or into a Integer/Buffer/String         * are all essentially the same.  This case handles the         * "interchangeable" types Integer, String, and Buffer.         */        if (SourceDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)        {            /* Resolve a reference object first */            Status = AcpiExResolveToValue (SourceDescPtr, WalkState);            if (ACPI_FAILURE (Status))            {                break;            }        }        /* For CopyObject, no further validation necessary */        if (WalkState->Opcode == AML_COPY_OP)        {            break;        }        /* Must have a Integer, Buffer, or String */        if ((SourceDesc->Common.Type != ACPI_TYPE_INTEGER)    &&            (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)     &&            (SourceDesc->Common.Type != ACPI_TYPE_STRING)     &&            !((SourceDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&                    (SourceDesc->Reference.Class== ACPI_REFCLASS_TABLE)))        {            /* Conversion successful but still not a valid type */            ACPI_ERROR ((AE_INFO,                "Cannot assign type %s to %s (must be type Int/Str/Buf)",                AcpiUtGetObjectTypeName (SourceDesc),                AcpiUtGetTypeName (TargetType)));            Status = AE_AML_OPERAND_TYPE;        }        break;    case ACPI_TYPE_LOCAL_ALIAS:    case ACPI_TYPE_LOCAL_METHOD_ALIAS:        /*         * All aliases should have been resolved earlier, during the         * operand resolution phase.         */        ACPI_ERROR ((AE_INFO, "Store into an unresolved Alias object"));        Status = AE_AML_INTERNAL;        break;    case ACPI_TYPE_PACKAGE:    default:        /*         * All other types than Alias and the various Fields come here,         * including the untyped case - ACPI_TYPE_ANY.         */        break;    }    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiEvQueueNotifyRequest (    ACPI_NAMESPACE_NODE     *Node,    UINT32                  NotifyValue){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_OPERAND_OBJECT     *HandlerListHead = NULL;    ACPI_GENERIC_STATE      *Info;    UINT8                   HandlerListId = 0;    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_NAME (EvQueueNotifyRequest);    /* Are Notifies allowed on this object? */    if (!AcpiEvIsNotifyObject (Node))    {        return (AE_TYPE);    }    /* Get the correct notify list type (System or Device) */    if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)    {        HandlerListId = ACPI_SYSTEM_HANDLER_LIST;    }    else    {        HandlerListId = ACPI_DEVICE_HANDLER_LIST;    }    /* Get the notify object attached to the namespace Node */    ObjDesc = AcpiNsGetAttachedObject (Node);    if (ObjDesc)    {        /* We have an attached object, Get the correct handler list */        HandlerListHead = ObjDesc->CommonNotify.NotifyList[HandlerListId];    }    /*     * If there is no notify handler (Global or Local)     * for this object, just ignore the notify     */    if (!AcpiGbl_GlobalNotify[HandlerListId].Handler && !HandlerListHead)    {        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,            "No notify handler for Notify, ignoring (%4.4s, %X) node %p/n",            AcpiUtGetNodeName (Node), NotifyValue, Node));        return (AE_OK);    }    /* Setup notify info and schedule the notify dispatcher */    Info = AcpiUtCreateGenericState ();    if (!Info)    {        return (AE_NO_MEMORY);    }    Info->Common.DescriptorType = ACPI_DESC_TYPE_STATE_NOTIFY;    Info->Notify.Node = Node;    Info->Notify.Value = (UINT16) NotifyValue;    Info->Notify.HandlerListId = HandlerListId;    Info->Notify.HandlerListHead = HandlerListHead;    Info->Notify.Global = &AcpiGbl_GlobalNotify[HandlerListId];    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,        "Dispatching Notify on [%4.4s] (%s) Value 0x%2.2X (%s) Node %p/n",        AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type),        NotifyValue, AcpiUtGetNotifyName (NotifyValue, ACPI_TYPE_ANY), Node));    Status = AcpiOsExecute (OSL_NOTIFY_HANDLER, AcpiEvNotifyDispatch,        Info);    if (ACPI_FAILURE (Status))    {        AcpiUtDeleteGenericState (Info);    }    return (Status);}

ACPI_OPERAND_OBJECT  *AcpiUtCreateInternalObjectDbg (    const char              *ModuleName,    UINT32                  LineNumber,    UINT32                  ComponentId,    ACPI_OBJECT_TYPE        Type){    ACPI_OPERAND_OBJECT     *Object;    ACPI_OPERAND_OBJECT     *SecondObject;    ACPI_FUNCTION_TRACE_STR (UtCreateInternalObjectDbg,        AcpiUtGetTypeName (Type));    /* Allocate the raw object descriptor */    Object = AcpiUtAllocateObjectDescDbg (        ModuleName, LineNumber, ComponentId);    if (!Object)    {        return_PTR (NULL);    }    switch (Type)    {    case ACPI_TYPE_REGION:    case ACPI_TYPE_BUFFER_FIELD:    case ACPI_TYPE_LOCAL_BANK_FIELD:        /* These types require a secondary object */        SecondObject = AcpiUtAllocateObjectDescDbg (            ModuleName, LineNumber, ComponentId);        if (!SecondObject)        {            AcpiUtDeleteObjectDesc (Object);            return_PTR (NULL);        }        SecondObject->Common.Type = ACPI_TYPE_LOCAL_EXTRA;        SecondObject->Common.ReferenceCount = 1;        /* Link the second object to the first */        Object->Common.NextObject = SecondObject;        break;    default:        /* All others have no secondary object */        break;    }    /* Save the object type in the object descriptor */    Object->Common.Type = (UINT8) Type;    /* Init the reference count */    Object->Common.ReferenceCount = 1;    /* Any per-type initialization should go here */    return_PTR (Object);}

//.........这里部分代码省略.........    case ACPI_TYPE_REGION:        Info->OpRegionCount++;        break;    case ACPI_TYPE_BUFFER_FIELD:        Info->FieldCount++;        break;    case ACPI_TYPE_LOCAL_BANK_FIELD:        Info->FieldCount++;        break;    case ACPI_TYPE_BUFFER:        Info->BufferCount++;        break;    case ACPI_TYPE_PACKAGE:        Info->PackageCount++;        break;    default:        /* No init required, just exit now */        return (AE_OK);    }    /* If the object is already initialized, nothing else to do */    if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)    {        return (AE_OK);    }    /* Must lock the interpreter before executing AML code */    AcpiExEnterInterpreter ();    /*     * Each of these types can contain executable AML code within the     * declaration.     */    switch (Type)    {    case ACPI_TYPE_REGION:        Info->OpRegionInit++;        Status = AcpiDsGetRegionArguments (ObjDesc);        break;    case ACPI_TYPE_BUFFER_FIELD:        Info->FieldInit++;        Status = AcpiDsGetBufferFieldArguments (ObjDesc);        break;    case ACPI_TYPE_LOCAL_BANK_FIELD:        Info->FieldInit++;        Status = AcpiDsGetBankFieldArguments (ObjDesc);        break;    case ACPI_TYPE_BUFFER:        Info->BufferInit++;        Status = AcpiDsGetBufferArguments (ObjDesc);        break;    case ACPI_TYPE_PACKAGE:        Info->PackageInit++;        Status = AcpiDsGetPackageArguments (ObjDesc);        break;    default:        /* No other types can get here */        break;    }    if (ACPI_FAILURE (Status))    {        ACPI_EXCEPTION ((AE_INFO, Status,            "Could not execute arguments for [%4.4s] (%s)",            AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Type)));    }    /*     * We ignore errors from above, and always return OK, since we don't want     * to abort the walk on any single error.     */    AcpiExExitInterpreter ();    return (AE_OK);}

ACPI_STATUSAcpiDsScopeStackPush (    ACPI_NAMESPACE_NODE     *Node,    ACPI_OBJECT_TYPE        Type,    ACPI_WALK_STATE         *WalkState){    ACPI_GENERIC_STATE      *ScopeInfo;    ACPI_GENERIC_STATE      *OldScopeInfo;    ACPI_FUNCTION_TRACE (DsScopeStackPush);    if (!Node)    {        /* Invalid scope   */        ACPI_ERROR ((AE_INFO, "Null scope parameter"));        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Make sure object type is valid */    if (!AcpiUtValidObjectType (Type))    {        ACPI_WARNING ((AE_INFO,            "Invalid object type: 0x%X", Type));    }    /* Allocate a new scope object */    ScopeInfo = AcpiUtCreateGenericState ();    if (!ScopeInfo)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Init new scope object */    ScopeInfo->Common.DescriptorType = ACPI_DESC_TYPE_STATE_WSCOPE;    ScopeInfo->Scope.Node = Node;    ScopeInfo->Common.Value = (UINT16) Type;    WalkState->ScopeDepth++;    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,        "[%.2d] Pushed scope ", (UINT32) WalkState->ScopeDepth));    OldScopeInfo = WalkState->ScopeInfo;    if (OldScopeInfo)    {        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,            "[%4.4s] (%s)",            AcpiUtGetNodeName (OldScopeInfo->Scope.Node),            AcpiUtGetTypeName (OldScopeInfo->Common.Value)));    }    else    {        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC, ACPI_NAMESPACE_ROOT));    }    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,        ", New scope -> [%4.4s] (%s)/n",        AcpiUtGetNodeName (ScopeInfo->Scope.Node),        AcpiUtGetTypeName (ScopeInfo->Common.Value)));    /* Push new scope object onto stack */    AcpiUtPushGenericState (&WalkState->ScopeInfo, ScopeInfo);    return_ACPI_STATUS (AE_OK);}

//.........这里部分代码省略.........            if (ThisNode->Child == NULL)            {                ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "-"));            }            else if (AcpiNsExistDownstreamSibling (ThisNode->Child))            {                ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "+"));            }            else            {                ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "-"));            }        }    }    /* Check the integrity of our data */    if (Type > INTERNAL_TYPE_MAX)    {        Type = INTERNAL_TYPE_DEF_ANY;                                /* prints as *ERROR* */    }    if (!AcpiUtValidAcpiName (ThisNode->Name))    {        REPORT_WARNING (("Invalid ACPI Name %08X/n", ThisNode->Name));    }    /*     * Now we can print out the pertinent information     */    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " %4.4s %-9s ", &ThisNode->Name, AcpiUtGetTypeName (Type)));    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "%p S:%p O:%p",  ThisNode, ThisNode->Child, ThisNode->Object));    if (!ThisNode->Object)    {        /* No attached object, we are done */        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, "/n"));        return (AE_OK);    }    switch (Type)    {    case ACPI_TYPE_METHOD:        /* Name is a Method and its AML offset/length are set */        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " M:%p-%X/n",                    ((ACPI_OPERAND_OBJECT  *) ThisNode->Object)->Method.Pcode,                    ((ACPI_OPERAND_OBJECT  *) ThisNode->Object)->Method.PcodeLength));        break;    case ACPI_TYPE_INTEGER:        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " N:%X/n",                    ((ACPI_OPERAND_OBJECT  *) ThisNode->Object)->Integer.Value));        break;

voidAcpiNsInstallNode (    ACPI_WALK_STATE         *WalkState,    ACPI_NAMESPACE_NODE     *ParentNode,    /* Parent */    ACPI_NAMESPACE_NODE     *Node,          /* New Child*/    ACPI_OBJECT_TYPE        Type){    ACPI_OWNER_ID           OwnerId = 0;    ACPI_NAMESPACE_NODE     *ChildNode;    ACPI_FUNCTION_TRACE (NsInstallNode);    /*     * Get the owner ID from the Walk state     * The owner ID is used to track table deletion and     * deletion of objects created by methods     */    if (WalkState)    {        OwnerId = WalkState->OwnerId;    }    /* Link the new entry into the parent and existing children */    ChildNode = ParentNode->Child;    if (!ChildNode)    {        ParentNode->Child = Node;        Node->Flags |= ANOBJ_END_OF_PEER_LIST;        Node->Peer = ParentNode;    }    else    {        while (!(ChildNode->Flags & ANOBJ_END_OF_PEER_LIST))        {            ChildNode = ChildNode->Peer;        }        ChildNode->Peer = Node;        /* Clear end-of-list flag */        ChildNode->Flags &= ~ANOBJ_END_OF_PEER_LIST;        Node->Flags |= ANOBJ_END_OF_PEER_LIST;        Node->Peer = ParentNode;    }    /* Init the new entry */    Node->OwnerId = OwnerId;    Node->Type = (UINT8) Type;    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,        "%4.4s (%s) [Node %p Owner %X] added to %4.4s (%s) [Node %p]/n",        AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type), Node, OwnerId,        AcpiUtGetNodeName (ParentNode), AcpiUtGetTypeName (ParentNode->Type),        ParentNode));    return_VOID;}

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//.........这里部分代码省略.........

ACPI_STATUSAcpiEvaluateObjectTyped (    ACPI_HANDLE             Handle,    ACPI_STRING             Pathname,    ACPI_OBJECT_LIST        *ExternalParams,    ACPI_BUFFER             *ReturnBuffer,    ACPI_OBJECT_TYPE        ReturnType){    ACPI_STATUS             Status;    BOOLEAN                 MustFree = FALSE;    ACPI_FUNCTION_TRACE (AcpiEvaluateObjectTyped);    /* Return buffer must be valid */    if (!ReturnBuffer)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    if (ReturnBuffer->Length == ACPI_ALLOCATE_BUFFER)    {        MustFree = TRUE;    }    /* Evaluate the object */    Status = AcpiEvaluateObject (Handle, Pathname, ExternalParams, ReturnBuffer);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Type ANY means "don't care" */    if (ReturnType == ACPI_TYPE_ANY)    {        return_ACPI_STATUS (AE_OK);    }    if (ReturnBuffer->Length == 0)    {        /* Error because caller specifically asked for a return value */        ACPI_ERROR ((AE_INFO, "No return value"));        return_ACPI_STATUS (AE_NULL_OBJECT);    }    /* Examine the object type returned from EvaluateObject */    if (((ACPI_OBJECT *) ReturnBuffer->Pointer)->Type == ReturnType)    {        return_ACPI_STATUS (AE_OK);    }    /* Return object type does not match requested type */    ACPI_ERROR ((AE_INFO,        "Incorrect return type [%s] requested [%s]",        AcpiUtGetTypeName (((ACPI_OBJECT *) ReturnBuffer->Pointer)->Type),        AcpiUtGetTypeName (ReturnType)));    if (MustFree)    {        /* Caller used ACPI_ALLOCATE_BUFFER, free the return buffer */        AcpiOsFree (ReturnBuffer->Pointer);        ReturnBuffer->Pointer = NULL;    }    ReturnBuffer->Length = 0;    return_ACPI_STATUS (AE_TYPE);}

ACPI_STATUSAcpiExResolveNodeToValue (    ACPI_NAMESPACE_NODE     **ObjectPtr,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status = AE_OK;    ACPI_OPERAND_OBJECT     *SourceDesc;    ACPI_OPERAND_OBJECT     *ObjDesc = NULL;    ACPI_NAMESPACE_NODE     *Node;    ACPI_OBJECT_TYPE        EntryType;    ACPI_FUNCTION_TRACE (ExResolveNodeToValue);    /*     * The stack pointer points to a ACPI_NAMESPACE_NODE (Node). Get the     * object that is attached to the Node.     */    Node       = *ObjectPtr;    SourceDesc = AcpiNsGetAttachedObject (Node);    EntryType  = AcpiNsGetType ((ACPI_HANDLE) Node);    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Entry=%p SourceDesc=%p [%s]/n",         Node, SourceDesc, AcpiUtGetTypeName (EntryType)));    if ((EntryType == ACPI_TYPE_LOCAL_ALIAS) ||        (EntryType == ACPI_TYPE_LOCAL_METHOD_ALIAS))    {        /* There is always exactly one level of indirection */        Node       = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Node->Object);        SourceDesc = AcpiNsGetAttachedObject (Node);        EntryType  = AcpiNsGetType ((ACPI_HANDLE) Node);        *ObjectPtr = Node;    }    /*     * Several object types require no further processing:     * 1) Device/Thermal objects don't have a "real" subobject, return the Node     * 2) Method locals and arguments have a pseudo-Node     * 3) 10/2007: Added method type to assist with Package construction.     */    if ((EntryType == ACPI_TYPE_DEVICE)  ||        (EntryType == ACPI_TYPE_THERMAL) ||        (EntryType == ACPI_TYPE_METHOD)  ||        (Node->Flags & (ANOBJ_METHOD_ARG | ANOBJ_METHOD_LOCAL)))    {        return_ACPI_STATUS (AE_OK);    }    if (!SourceDesc)    {        ACPI_ERROR ((AE_INFO, "No object attached to node %p",            Node));        return_ACPI_STATUS (AE_AML_NO_OPERAND);    }    /*     * Action is based on the type of the Node, which indicates the type     * of the attached object or pointer     */    switch (EntryType)    {    case ACPI_TYPE_PACKAGE:        if (SourceDesc->Common.Type != ACPI_TYPE_PACKAGE)        {            ACPI_ERROR ((AE_INFO, "Object not a Package, type %s",                AcpiUtGetObjectTypeName (SourceDesc)));            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);        }        Status = AcpiDsGetPackageArguments (SourceDesc);        if (ACPI_SUCCESS (Status))        {            /* Return an additional reference to the object */            ObjDesc = SourceDesc;            AcpiUtAddReference (ObjDesc);        }        break;    case ACPI_TYPE_BUFFER:        if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)        {            ACPI_ERROR ((AE_INFO, "Object not a Buffer, type %s",                AcpiUtGetObjectTypeName (SourceDesc)));            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);        }        Status = AcpiDsGetBufferArguments (SourceDesc);        if (ACPI_SUCCESS (Status))        {            /* Return an additional reference to the object */            ObjDesc = SourceDesc;//.........这里部分代码省略.........

ACPI_STATUSAcpiExStoreObjectToNode (    ACPI_OPERAND_OBJECT     *SourceDesc,    ACPI_NAMESPACE_NODE     *Node,    ACPI_WALK_STATE         *WalkState,    UINT8                   ImplicitConversion){    ACPI_STATUS             Status = AE_OK;    ACPI_OPERAND_OBJECT     *TargetDesc;    ACPI_OPERAND_OBJECT     *NewDesc;    ACPI_OBJECT_TYPE        TargetType;    ACPI_FUNCTION_TRACE_PTR (ExStoreObjectToNode, SourceDesc);    /* Get current type of the node, and object attached to Node */    TargetType = AcpiNsGetType (Node);    TargetDesc = AcpiNsGetAttachedObject (Node);    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Storing %p (%s) to node %p (%s)/n",        SourceDesc, AcpiUtGetObjectTypeName (SourceDesc),              Node, AcpiUtGetTypeName (TargetType)));    /*     * Resolve the source object to an actual value     * (If it is a reference object)     */    Status = AcpiExResolveObject (&SourceDesc, TargetType, WalkState);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Do the actual store operation */    switch (TargetType)    {    case ACPI_TYPE_INTEGER:    case ACPI_TYPE_STRING:    case ACPI_TYPE_BUFFER:        /*         * The simple data types all support implicit source operand         * conversion before the store.         */        if ((WalkState->Opcode == AML_COPY_OP) ||            !ImplicitConversion)        {            /*             * However, CopyObject and Stores to ArgX do not perform             * an implicit conversion, as per the ACPI specification.             * A direct store is performed instead.             */            Status = AcpiExStoreDirectToNode (SourceDesc, Node,                WalkState);            break;        }        /* Store with implicit source operand conversion support */        Status = AcpiExStoreObjectToObject (SourceDesc, TargetDesc,            &NewDesc, WalkState);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }        if (NewDesc != TargetDesc)        {            /*             * Store the new NewDesc as the new value of the Name, and set             * the Name's type to that of the value being stored in it.             * SourceDesc reference count is incremented by AttachObject.             *             * Note: This may change the type of the node if an explicit             * store has been performed such that the node/object type             * has been changed.             */            Status = AcpiNsAttachObject (Node, NewDesc,                NewDesc->Common.Type);            ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,                "Store %s into %s via Convert/Attach/n",                AcpiUtGetObjectTypeName (SourceDesc),                AcpiUtGetObjectTypeName (NewDesc)));        }        break;    case ACPI_TYPE_BUFFER_FIELD:    case ACPI_TYPE_LOCAL_REGION_FIELD:    case ACPI_TYPE_LOCAL_BANK_FIELD:    case ACPI_TYPE_LOCAL_INDEX_FIELD:        /*         * For all fields, always write the source data to the target         * field. Any required implicit source operand conversion is         * performed in the function below as necessary. Note, field         * objects must retain their original type permanently.         *///.........这里部分代码省略.........

//.........这里部分代码省略.........    /*     * For all names: Check that the incoming argument count for     * this method/object matches the actual ASL/AML definition.     */    AcpiNsCheckArgumentCount (Info->FullPathname, Info->Node,        Info->ParamCount, Info->Predefined);    /* For predefined names: Typecheck all incoming arguments */    AcpiNsCheckArgumentTypes (Info);    /*     * Three major evaluation cases:     *     * 1) Object types that cannot be evaluated by definition     * 2) The object is a control method -- execute it     * 3) The object is not a method -- just return it's current value     */    switch (AcpiNsGetType (Info->Node))    {    case ACPI_TYPE_DEVICE:    case ACPI_TYPE_EVENT:    case ACPI_TYPE_MUTEX:    case ACPI_TYPE_REGION:    case ACPI_TYPE_THERMAL:    case ACPI_TYPE_LOCAL_SCOPE:        /*         * 1) Disallow evaluation of certain object types. For these,         *    object evaluation is undefined and not supported.         */        ACPI_ERROR ((AE_INFO,            "%s: Evaluation of object type [%s] is not supported",            Info->FullPathname,            AcpiUtGetTypeName (Info->Node->Type)));        Status = AE_TYPE;        goto Cleanup;    case ACPI_TYPE_METHOD:        /*         * 2) Object is a control method - execute it         */        /* Verify that there is a method object associated with this node */        if (!Info->ObjDesc)        {            ACPI_ERROR ((AE_INFO, "%s: Method has no attached sub-object",                Info->FullPathname));            Status = AE_NULL_OBJECT;            goto Cleanup;        }        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,            "**** Execute method [%s] at AML address %p length %X/n",            Info->FullPathname,            Info->ObjDesc->Method.AmlStart + 1,            Info->ObjDesc->Method.AmlLength - 1));        /*         * Any namespace deletion must acquire both the namespace and         * interpreter locks to ensure that no thread is using the portion of         * the namespace that is being deleted.         *         * Execute the method via the interpreter. The interpreter is locked         * here before calling into the AML parser

voidAcpiNsInstallNode (    ACPI_WALK_STATE         *WalkState,    ACPI_NAMESPACE_NODE     *ParentNode,    /* Parent */    ACPI_NAMESPACE_NODE     *Node,          /* New Child*/    ACPI_OBJECT_TYPE        Type){    ACPI_OWNER_ID           OwnerId = 0;    ACPI_NAMESPACE_NODE     *ChildNode;    ACPI_FUNCTION_TRACE (NsInstallNode);    if (WalkState)    {        /*         * Get the owner ID from the Walk state. The owner ID is used to         * track table deletion and deletion of objects created by methods.         */        OwnerId = WalkState->OwnerId;        if ((WalkState->MethodDesc) &&            (ParentNode != WalkState->MethodNode))        {            /*             * A method is creating a new node that is not a child of the             * method (it is non-local). Mark the executing method as having             * modified the namespace. This is used for cleanup when the             * method exits.             */            WalkState->MethodDesc->Method.InfoFlags |=                ACPI_METHOD_MODIFIED_NAMESPACE;        }    }    /* Link the new entry into the parent and existing children */    Node->Peer = NULL;    Node->Parent = ParentNode;    ChildNode = ParentNode->Child;    if (!ChildNode)    {        ParentNode->Child = Node;    }    else    {        /* Add node to the end of the peer list */        while (ChildNode->Peer)        {            ChildNode = ChildNode->Peer;        }        ChildNode->Peer = Node;    }    /* Init the new entry */    Node->OwnerId = OwnerId;    Node->Type = (UINT8) Type;    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,        "%4.4s (%s) [Node %p Owner %X] added to %4.4s (%s) [Node %p]/n",        AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type), Node, OwnerId,        AcpiUtGetNodeName (ParentNode), AcpiUtGetTypeName (ParentNode->Type),        ParentNode));    return_VOID;}

ACPI_STATUSAcpiDsLoad1BeginOp (    ACPI_WALK_STATE         *WalkState,    ACPI_PARSE_OBJECT       **OutOp){    ACPI_PARSE_OBJECT       *Op;    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    ACPI_OBJECT_TYPE        ObjectType;    char                    *Path;    UINT32                  Flags;    ACPI_FUNCTION_TRACE (DsLoad1BeginOp);    Op = WalkState->Op;    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p/n", Op, WalkState));    /* We are only interested in opcodes that have an associated name */    if (Op)    {        if (!(WalkState->OpInfo->Flags & AML_NAMED))        {            *OutOp = Op;            return_ACPI_STATUS (AE_OK);        }        /* Check if this object has already been installed in the namespace */        if (Op->Common.Node)        {            *OutOp = Op;            return_ACPI_STATUS (AE_OK);        }    }    Path = AcpiPsGetNextNamestring (&WalkState->ParserState);    /* Map the raw opcode into an internal object type */    ObjectType = WalkState->OpInfo->ObjectType;    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,        "State=%p Op=%p [%s]/n", WalkState, Op, AcpiUtGetTypeName (ObjectType)));    switch (WalkState->Opcode)    {    case AML_SCOPE_OP:        /*         * The target name of the Scope() operator must exist at this point so         * that we can actually open the scope to enter new names underneath it.         * Allow search-to-root for single namesegs.         */        Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,                        ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState, &(Node));#ifdef ACPI_ASL_COMPILER        if (Status == AE_NOT_FOUND)        {            /*             * Table disassembly:             * Target of Scope() not found. Generate an External for it, and             * insert the name into the namespace.             */            AcpiDmAddOpToExternalList (Op, Path, ACPI_TYPE_DEVICE, 0, 0);            Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,                       ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT,                       WalkState, &Node);        }#endif        if (ACPI_FAILURE (Status))        {            ACPI_ERROR_NAMESPACE (Path, Status);            return_ACPI_STATUS (Status);        }        /*         * Check to make sure that the target is         * one of the opcodes that actually opens a scope         */        switch (Node->Type)        {        case ACPI_TYPE_ANY:        case ACPI_TYPE_LOCAL_SCOPE:         /* Scope  */        case ACPI_TYPE_DEVICE:        case ACPI_TYPE_POWER:        case ACPI_TYPE_PROCESSOR:        case ACPI_TYPE_THERMAL:            /* These are acceptable types */            break;        case ACPI_TYPE_INTEGER:        case ACPI_TYPE_STRING:        case ACPI_TYPE_BUFFER:            /*             * These types we will allow, but we will change the type.             * This enables some existing code of the form:             *//.........这里部分代码省略.........

//.........这里部分代码省略.........        switch (Type)        {        case ACPI_TYPE_INTEGER:            Value = AcpiGbl_IntegerByteWidth;            break;        case ACPI_TYPE_STRING:            Value = TempDesc->String.Length;            break;        case ACPI_TYPE_BUFFER:            /* Buffer arguments may not be evaluated at this point */            Status = AcpiDsGetBufferArguments (TempDesc);            Value = TempDesc->Buffer.Length;            break;        case ACPI_TYPE_PACKAGE:            /* Package arguments may not be evaluated at this point */            Status = AcpiDsGetPackageArguments (TempDesc);            Value = TempDesc->Package.Count;            break;        default:            ACPI_ERROR ((AE_INFO,                "Operand must be Buffer/Integer/String/Package"                " - found type %s",                AcpiUtGetTypeName (Type)));            Status = AE_AML_OPERAND_TYPE;            goto Cleanup;        }        if (ACPI_FAILURE (Status))        {            goto Cleanup;        }        /*         * Now that we have the size of the object, create a result         * object to hold the value         */        ReturnDesc = AcpiUtCreateIntegerObject (Value);        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        break;    case AML_REF_OF_OP:             /* RefOf (SourceObject) */        Status = AcpiExGetObjectReference (            Operand[0], &ReturnDesc, WalkState);        if (ACPI_FAILURE (Status))        {            goto Cleanup;        }        break;

ACPI_STATUSAcpiExConvertToTargetType (    ACPI_OBJECT_TYPE        DestinationType,    ACPI_OPERAND_OBJECT     *SourceDesc,    ACPI_OPERAND_OBJECT     **ResultDesc,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_TRACE (ExConvertToTargetType);    /* Default behavior */    *ResultDesc = SourceDesc;    /*     * If required by the target,     * perform implicit conversion on the source before we store it.     */    switch (GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs))    {    case ARGI_SIMPLE_TARGET:    case ARGI_FIXED_TARGET:    case ARGI_INTEGER_REF:      /* Handles Increment, Decrement cases */        switch (DestinationType)        {        case ACPI_TYPE_LOCAL_REGION_FIELD:            /*             * Named field can always handle conversions             */            break;        default:            /* No conversion allowed for these types */            if (DestinationType != SourceDesc->Common.Type)            {                ACPI_DEBUG_PRINT ((ACPI_DB_INFO,                    "Explicit operator, will store (%s) over existing type (%s)/n",                    AcpiUtGetObjectTypeName (SourceDesc),                    AcpiUtGetTypeName (DestinationType)));                Status = AE_TYPE;            }        }        break;    case ARGI_TARGETREF:        switch (DestinationType)        {        case ACPI_TYPE_INTEGER:        case ACPI_TYPE_BUFFER_FIELD:        case ACPI_TYPE_LOCAL_BANK_FIELD:        case ACPI_TYPE_LOCAL_INDEX_FIELD:            /*             * These types require an Integer operand. We can convert             * a Buffer or a String to an Integer if necessary.             */            Status = AcpiExConvertToInteger (SourceDesc, ResultDesc,                        16);            break;        case ACPI_TYPE_STRING:            /*             * The operand must be a String. We can convert an             * Integer or Buffer if necessary             */            Status = AcpiExConvertToString (SourceDesc, ResultDesc,                        ACPI_IMPLICIT_CONVERT_HEX);            break;        case ACPI_TYPE_BUFFER:            /*             * The operand must be a Buffer. We can convert an             * Integer or String if necessary             */            Status = AcpiExConvertToBuffer (SourceDesc, ResultDesc);            break;        default:            ACPI_ERROR ((AE_INFO, "Bad destination type during conversion: 0x%X",                DestinationType));            Status = AE_AML_INTERNAL;            break;        }        break;    case ARGI_REFERENCE:        /*         * CreateXxxxField cases - we are storing the field object into the name         */        break;    default://.........这里部分代码省略.........

voidAcpiUtDumpAllocations (    UINT32                  Component,    const char              *Module){    ACPI_DEBUG_MEM_BLOCK    *Element;    ACPI_DESCRIPTOR         *Descriptor;    UINT32                  NumOutstanding = 0;    UINT8                   DescriptorType;    ACPI_FUNCTION_TRACE (UtDumpAllocations);    /*     * Walk the allocation list.     */    if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_MEMORY)))    {        return;    }    Element = AcpiGbl_GlobalList->ListHead;    while (Element)    {        if ((Element->Component & Component) &&            ((Module == NULL) || (0 == ACPI_STRCMP (Module, Element->Module))))        {            Descriptor = ACPI_CAST_PTR (ACPI_DESCRIPTOR, &Element->UserSpace);            if (Element->Size < sizeof (ACPI_COMMON_DESCRIPTOR))            {                AcpiOsPrintf ("%p Length 0x%04X %9.9s-%d "                    "[Not a Descriptor - too small]/n",                    Descriptor, Element->Size, Element->Module,                    Element->Line);            }            else            {                /* Ignore allocated objects that are in a cache */                if (ACPI_GET_DESCRIPTOR_TYPE (Descriptor) != ACPI_DESC_TYPE_CACHED)                {                    AcpiOsPrintf ("%p Length 0x%04X %9.9s-%d [%s] ",                        Descriptor, Element->Size, Element->Module,                        Element->Line, AcpiUtGetDescriptorName (Descriptor));                    /* Validate the descriptor type using Type field and length */                    DescriptorType = 0; /* Not a valid descriptor type */                    switch (ACPI_GET_DESCRIPTOR_TYPE (Descriptor))                    {                    case ACPI_DESC_TYPE_OPERAND:                        if (Element->Size == sizeof (ACPI_DESC_TYPE_OPERAND))                        {                            DescriptorType = ACPI_DESC_TYPE_OPERAND;                        }                        break;                    case ACPI_DESC_TYPE_PARSER:                        if (Element->Size == sizeof (ACPI_DESC_TYPE_PARSER))                        {                            DescriptorType = ACPI_DESC_TYPE_PARSER;                        }                        break;                    case ACPI_DESC_TYPE_NAMED:                        if (Element->Size == sizeof (ACPI_DESC_TYPE_NAMED))                        {                            DescriptorType = ACPI_DESC_TYPE_NAMED;                        }                        break;                    default:                        break;                    }                    /* Display additional info for the major descriptor types */                    switch (DescriptorType)                    {                    case ACPI_DESC_TYPE_OPERAND:                        AcpiOsPrintf ("%12.12s  RefCount 0x%04X/n",                            AcpiUtGetTypeName (Descriptor->Object.Common.Type),                            Descriptor->Object.Common.ReferenceCount);                        break;                    case ACPI_DESC_TYPE_PARSER:                        AcpiOsPrintf ("AmlOpcode 0x%04hX/n",                            Descriptor->Op.Asl.AmlOpcode);                        break;                    case ACPI_DESC_TYPE_NAMED:                        AcpiOsPrintf ("%4.4s/n",                            AcpiUtGetNodeName (&Descriptor->Node));                        break;                    default:                        AcpiOsPrintf ( "/n");//.........这里部分代码省略.........

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_STATUSAcpiNsDumpOneObject (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    ACPI_WALK_INFO          *Info = (ACPI_WALK_INFO *) Context;    ACPI_NAMESPACE_NODE     *ThisNode;    ACPI_OPERAND_OBJECT     *ObjDesc = NULL;    ACPI_OBJECT_TYPE        ObjType;    ACPI_OBJECT_TYPE        Type;    UINT32                  BytesToDump;    UINT32                  DbgLevel;    UINT32                  i;    ACPI_FUNCTION_NAME (NsDumpOneObject);    /* Is output enabled? */    if (!(AcpiDbgLevel & Info->DebugLevel))    {        return (AE_OK);    }    if (!ObjHandle)    {        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Null object handle/n"));        return (AE_OK);    }    ThisNode = AcpiNsValidateHandle (ObjHandle);    if (!ThisNode)    {        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Invalid object handle %p/n",            ObjHandle));        return (AE_OK);    }    Type = ThisNode->Type;    /* Check if the owner matches */    if ((Info->OwnerId != ACPI_OWNER_ID_MAX) &&        (Info->OwnerId != ThisNode->OwnerId))    {        return (AE_OK);    }    if (!(Info->DisplayType & ACPI_DISPLAY_SHORT))    {        /* Indent the object according to the level */        AcpiOsPrintf ("%2d%*s", (UINT32) Level - 1, (int) Level * 2, " ");        /* Check the node type and name */        if (Type > ACPI_TYPE_LOCAL_MAX)        {            ACPI_WARNING ((AE_INFO,                "Invalid ACPI Object Type 0x%08X", Type));        }        AcpiOsPrintf ("%4.4s", AcpiUtGetNodeName (ThisNode));    }    /* Now we can print out the pertinent information */    AcpiOsPrintf (" %-12s %p %2.2X ",        AcpiUtGetTypeName (Type), ThisNode, ThisNode->OwnerId);    DbgLevel = AcpiDbgLevel;    AcpiDbgLevel = 0;    ObjDesc = AcpiNsGetAttachedObject (ThisNode);    AcpiDbgLevel = DbgLevel;    /* Temp nodes are those nodes created by a control method */    if (ThisNode->Flags & ANOBJ_TEMPORARY)    {        AcpiOsPrintf ("(T) ");    }    switch (Info->DisplayType & ACPI_DISPLAY_MASK)    {    case ACPI_DISPLAY_SUMMARY:        if (!ObjDesc)        {            /* No attached object. Some types should always have an object */            switch (Type)            {            case ACPI_TYPE_INTEGER:            case ACPI_TYPE_PACKAGE:            case ACPI_TYPE_BUFFER:            case ACPI_TYPE_STRING:            case ACPI_TYPE_METHOD://.........这里部分代码省略.........

ACPI_STATUSAcpiDbDisplayStatistics (    char                    *TypeArg){    UINT32                  i;    UINT32                  Temp;    if (!TypeArg)    {        AcpiOsPrintf ("The following subcommands are available:/n    ALLOCATIONS, OBJECTS, MEMORY, MISC, SIZES, TABLES/n");        return (AE_OK);    }    AcpiUtStrupr (TypeArg);    Temp = AcpiDbMatchArgument (TypeArg, AcpiDbStatTypes);    if (Temp == (UINT32) -1)    {        AcpiOsPrintf ("Invalid or unsupported argument/n");        return (AE_OK);    }    switch (Temp)    {    case CMD_STAT_ALLOCATIONS:#ifdef ACPI_DBG_TRACK_ALLOCATIONS        AcpiUtDumpAllocationInfo ();#endif        break;    case CMD_STAT_TABLES:        AcpiOsPrintf ("ACPI Table Information (not implemented):/n/n");        break;    case CMD_STAT_OBJECTS:        AcpiDbCountNamespaceObjects ();        AcpiOsPrintf ("/nObjects defined in the current namespace:/n/n");        AcpiOsPrintf ("%16.16s %10.10s %10.10s/n",            "ACPI_TYPE", "NODES", "OBJECTS");        for (i = 0; i < ACPI_TYPE_NS_NODE_MAX; i++)        {            AcpiOsPrintf ("%16.16s % 10ld% 10ld/n", AcpiUtGetTypeName (i),                AcpiGbl_NodeTypeCount [i], AcpiGbl_ObjTypeCount [i]);        }        AcpiOsPrintf ("%16.16s % 10ld% 10ld/n", "Misc/Unknown",            AcpiGbl_NodeTypeCountMisc, AcpiGbl_ObjTypeCountMisc);        AcpiOsPrintf ("%16.16s % 10ld% 10ld/n", "TOTALS:",            AcpiGbl_NumNodes, AcpiGbl_NumObjects);        break;    case CMD_STAT_MEMORY:#ifdef ACPI_DBG_TRACK_ALLOCATIONS        AcpiOsPrintf ("/n----Object Statistics (all in hex)---------/n");        AcpiDbListInfo (AcpiGbl_GlobalList);        AcpiDbListInfo (AcpiGbl_NsNodeList);#endif#ifdef ACPI_USE_LOCAL_CACHE        AcpiOsPrintf ("/n----Cache Statistics (all in hex)---------/n");        AcpiDbListInfo (AcpiGbl_OperandCache);        AcpiDbListInfo (AcpiGbl_PsNodeCache);        AcpiDbListInfo (AcpiGbl_PsNodeExtCache);        AcpiDbListInfo (AcpiGbl_StateCache);#endif        break;    case CMD_STAT_MISC:        AcpiOsPrintf ("/nMiscellaneous Statistics:/n/n");        AcpiOsPrintf ("Calls to AcpiPsFind:..  ........% 7ld/n",            AcpiGbl_PsFindCount);        AcpiOsPrintf ("Calls to AcpiNsLookup:..........% 7ld/n",            AcpiGbl_NsLookupCount);        AcpiOsPrintf ("/n");        AcpiOsPrintf ("Mutex usage:/n/n");        for (i = 0; i < ACPI_NUM_MUTEX; i++)        {            AcpiOsPrintf ("%-28s:       % 7ld/n",                AcpiUtGetMutexName (i), AcpiGbl_MutexInfo[i].UseCount);        }        break;    case CMD_STAT_SIZES:        AcpiOsPrintf ("/nInternal object sizes:/n/n");//.........这里部分代码省略.........

ACPI_STATUSAcpiEvaluateObjectTyped (    ACPI_HANDLE             Handle,    ACPI_STRING             Pathname,    ACPI_OBJECT_LIST        *ExternalParams,    ACPI_BUFFER             *ReturnBuffer,    ACPI_OBJECT_TYPE        ReturnType){    ACPI_STATUS             Status;    BOOLEAN                 FreeBufferOnError = FALSE;    ACPI_FUNCTION_TRACE (AcpiEvaluateObjectTyped);    /* Return buffer must be valid */    if (!ReturnBuffer)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    if (ReturnBuffer->Length == ACPI_ALLOCATE_BUFFER)    {        FreeBufferOnError = TRUE;    }    /* Evaluate the object */    Status = AcpiEvaluateObject (Handle, Pathname,        ExternalParams, ReturnBuffer);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Type ANY means "don't care" */    if (ReturnType == ACPI_TYPE_ANY)    {        return_ACPI_STATUS (AE_OK);    }    if (ReturnBuffer->Length == 0)    {        /* Error because caller specifically asked for a return value */        ACPI_ERROR ((AE_INFO, "No return value"));        return_ACPI_STATUS (AE_NULL_OBJECT);    }    /* Examine the object type returned from EvaluateObject */    if (((ACPI_OBJECT *) ReturnBuffer->Pointer)->Type == ReturnType)    {        return_ACPI_STATUS (AE_OK);    }    /* Return object type does not match requested type */    ACPI_ERROR ((AE_INFO,        "Incorrect return type [%s] requested [%s]",        AcpiUtGetTypeName (((ACPI_OBJECT *) ReturnBuffer->Pointer)->Type),        AcpiUtGetTypeName (ReturnType)));    if (FreeBufferOnError)    {        /*         * Free a buffer created via ACPI_ALLOCATE_BUFFER.         * Note: We use AcpiOsFree here because AcpiOsAllocate was used         * to allocate the buffer. This purposefully bypasses the         * (optionally enabled) allocation tracking mechanism since we         * only want to track internal allocations.         */        AcpiOsFree (ReturnBuffer->Pointer);        ReturnBuffer->Pointer = NULL;    }    ReturnBuffer->Length = 0;    return_ACPI_STATUS (AE_TYPE);}

//.........这里部分代码省略.........            AslCoreSubsystemError (Op, Status,                "Failure from namespace lookup", FALSE);            return_ACPI_STATUS (Status);        }        /* We found a node with this name, now check the type */        switch (Node->Type)        {        case ACPI_TYPE_LOCAL_SCOPE:        case ACPI_TYPE_DEVICE:        case ACPI_TYPE_POWER:        case ACPI_TYPE_PROCESSOR:        case ACPI_TYPE_THERMAL:            /* These are acceptable types - they all open a new scope */            break;        case ACPI_TYPE_INTEGER:        case ACPI_TYPE_STRING:        case ACPI_TYPE_BUFFER:            /*             * These types we will allow, but we will change the type.             * This enables some existing code of the form:             *             *  Name (DEB, 0)             *  Scope (DEB) { ... }             *             * Which is used to workaround the fact that the MS interpreter             * does not allow Scope() forward references.             */            sprintf (MsgBuffer, "%s [%s], changing type to [Scope]",                Op->Asl.ExternalName, AcpiUtGetTypeName (Node->Type));            AslError (ASL_REMARK, ASL_MSG_SCOPE_TYPE, Op, MsgBuffer);            /* Switch the type to scope, open the new scope */            Node->Type = ACPI_TYPE_LOCAL_SCOPE;            Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE,                        WalkState);            if (ACPI_FAILURE (Status))            {                return_ACPI_STATUS (Status);            }            break;        default:            /* All other types are an error */            sprintf (MsgBuffer, "%s [%s]", Op->Asl.ExternalName,                AcpiUtGetTypeName (Node->Type));            AslError (ASL_ERROR, ASL_MSG_SCOPE_TYPE, Op, MsgBuffer);            /*             * However, switch the type to be an actual scope so             * that compilation can continue without generating a whole             * cascade of additional errors. Open the new scope.             */            Node->Type = ACPI_TYPE_LOCAL_SCOPE;            Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE,                        WalkState);            if (ACPI_FAILURE (Status))            {                return_ACPI_STATUS (Status);

ACPI_STATUSAcpiNsCheckObjectType (    ACPI_PREDEFINED_DATA        *Data,    ACPI_OPERAND_OBJECT         **ReturnObjectPtr,    UINT32                      ExpectedBtypes,    UINT32                      PackageIndex){    ACPI_OPERAND_OBJECT         *ReturnObject = *ReturnObjectPtr;    ACPI_STATUS                 Status = AE_OK;    char                        TypeBuffer[48]; /* Room for 5 types */    /* A Namespace node should not get here, but make sure */    if (ReturnObject &&        ACPI_GET_DESCRIPTOR_TYPE (ReturnObject) == ACPI_DESC_TYPE_NAMED)    {        ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,            "Invalid return type - Found a Namespace node [%4.4s] type %s",            ReturnObject->Node.Name.Ascii,            AcpiUtGetTypeName (ReturnObject->Node.Type)));        return (AE_AML_OPERAND_TYPE);    }    /*     * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type.     * The bitmapped type allows multiple possible return types.     *     * Note, the cases below must handle all of the possible types returned     * from all of the predefined names (including elements of returned     * packages)     */    Data->ReturnBtype = AcpiNsGetBitmappedType (ReturnObject);    if (Data->ReturnBtype == ACPI_RTYPE_ANY)    {        /* Not one of the supported objects, must be incorrect */        goto TypeErrorExit;    }    /* For reference objects, check that the reference type is correct */    if ((Data->ReturnBtype & ExpectedBtypes) == ACPI_RTYPE_REFERENCE)    {        Status = AcpiNsCheckReference (Data, ReturnObject);        return (Status);    }    /* Attempt simple repair of the returned object if necessary */    Status = AcpiNsSimpleRepair (Data, ExpectedBtypes,                PackageIndex, ReturnObjectPtr);    return (Status);TypeErrorExit:    /* Create a string with all expected types for this predefined object */    AcpiUtGetExpectedReturnTypes (TypeBuffer, ExpectedBtypes);    if (PackageIndex == ACPI_NOT_PACKAGE_ELEMENT)    {        ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,            "Return type mismatch - found %s, expected %s",            AcpiUtGetObjectTypeName (ReturnObject), TypeBuffer));    }    else    {        ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,            "Return Package type mismatch at index %u - "            "found %s, expected %s", PackageIndex,            AcpiUtGetObjectTypeName (ReturnObject), TypeBuffer));    }    return (AE_AML_OPERAND_TYPE);}