acparser.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	OP_HAS_RETURN_VALUE   1
#define	ACPI_VAR_ARGS   ACPI_UINT32_MAX
#define	ACPI_PARSE_DELETE_TREE   0x0001
#define	ACPI_PARSE_NO_TREE_DELETE   0x0000
#define	ACPI_PARSE_TREE_MASK   0x0001
#define	ACPI_PARSE_LOAD_PASS1   0x0010
#define	ACPI_PARSE_LOAD_PASS2   0x0020
#define	ACPI_PARSE_EXECUTE   0x0030
#define	ACPI_PARSE_MODE_MASK   0x0030
#define	ACPI_PARSE_DEFERRED_OP   0x0100
#define	ACPI_PARSE_DISASSEMBLE   0x0200
#define	ACPI_PARSE_MODULE_LEVEL   0x0400
#define	ACPI_NOT_METHOD_CALL   FALSE
#define	ACPI_POSSIBLE_METHOD_CALL   TRUE

Functions
ACPI_STATUS	AcpiPsExecuteMethod (ACPI_EVALUATE_INFO *Info)
ACPI_STATUS	AcpiPsExecuteTable (ACPI_EVALUATE_INFO *Info)
UINT8 *	AcpiPsGetNextPackageEnd (ACPI_PARSE_STATE *ParserState)
char *	AcpiPsGetNextNamestring (ACPI_PARSE_STATE *ParserState)
void	AcpiPsGetNextSimpleArg (ACPI_PARSE_STATE *ParserState, UINT32 ArgType, ACPI_PARSE_OBJECT *Arg)
ACPI_STATUS	AcpiPsGetNextNamepath (ACPI_WALK_STATE *WalkState, ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Arg, BOOLEAN PossibleMethodCall)
ACPI_STATUS	AcpiPsGetNextArg (ACPI_WALK_STATE *WalkState, ACPI_PARSE_STATE *ParserState, UINT32 ArgType, ACPI_PARSE_OBJECT **ReturnArg)
ACPI_PARSE_OBJECT *	AcpiPsFindName (ACPI_PARSE_OBJECT *Scope, UINT32 Name, UINT32 Opcode)
ACPI_PARSE_OBJECT *	AcpiPsGetParent (ACPI_PARSE_OBJECT *Op)
ACPI_STATUS	AcpiPsBuildNamedOp (ACPI_WALK_STATE *WalkState, UINT8 *AmlOpStart, ACPI_PARSE_OBJECT *UnnamedOp, ACPI_PARSE_OBJECT **Op)
ACPI_STATUS	AcpiPsCreateOp (ACPI_WALK_STATE *WalkState, UINT8 *AmlOpStart, ACPI_PARSE_OBJECT **NewOp)
ACPI_STATUS	AcpiPsCompleteOp (ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **Op, ACPI_STATUS Status)
ACPI_STATUS	AcpiPsCompleteFinalOp (ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_STATUS Status)
const ACPI_OPCODE_INFO *	AcpiPsGetOpcodeInfo (UINT16 Opcode)
const char *	AcpiPsGetOpcodeName (UINT16 Opcode)
UINT8	AcpiPsGetArgumentCount (UINT32 OpType)
ACPI_STATUS	AcpiPsParseAml (ACPI_WALK_STATE *WalkState)
UINT32	AcpiPsGetOpcodeSize (UINT32 Opcode)
UINT16	AcpiPsPeekOpcode (ACPI_PARSE_STATE *state)
ACPI_STATUS	AcpiPsCompleteThisOp (ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op)
ACPI_STATUS	AcpiPsNextParseState (ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_STATUS CallbackStatus)
ACPI_STATUS	AcpiPsParseLoop (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiPsInitScope (ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Root)
ACPI_PARSE_OBJECT *	AcpiPsGetParentScope (ACPI_PARSE_STATE *state)
BOOLEAN	AcpiPsHasCompletedScope (ACPI_PARSE_STATE *ParserState)
void	AcpiPsPopScope (ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT **Op, UINT32 *ArgList, UINT32 *ArgCount)
ACPI_STATUS	AcpiPsPushScope (ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Op, UINT32 RemainingArgs, UINT32 ArgCount)
void	AcpiPsCleanupScope (ACPI_PARSE_STATE *state)
void	AcpiPsAppendArg (ACPI_PARSE_OBJECT *op, ACPI_PARSE_OBJECT *arg)
ACPI_PARSE_OBJECT *	AcpiPsFind (ACPI_PARSE_OBJECT *Scope, char *Path, UINT16 Opcode, UINT32 Create)
ACPI_PARSE_OBJECT *	AcpiPsGetArg (ACPI_PARSE_OBJECT *op, UINT32 argn)
ACPI_PARSE_OBJECT *	AcpiPsGetDepthNext (ACPI_PARSE_OBJECT *Origin, ACPI_PARSE_OBJECT *Op)
ACPI_STATUS	AcpiPsWalkParsedAml (ACPI_PARSE_OBJECT *StartOp, ACPI_PARSE_OBJECT *EndOp, ACPI_OPERAND_OBJECT *MthDesc, ACPI_NAMESPACE_NODE *StartNode, ACPI_OPERAND_OBJECT **Params, ACPI_OPERAND_OBJECT **CallerReturnDesc, ACPI_OWNER_ID OwnerId, ACPI_PARSE_DOWNWARDS DescendingCallback, ACPI_PARSE_UPWARDS AscendingCallback)
ACPI_STATUS	AcpiPsGetNextWalkOp (ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_PARSE_UPWARDS AscendingCallback)
ACPI_STATUS	AcpiPsDeleteCompletedOp (ACPI_WALK_STATE *WalkState)
void	AcpiPsDeleteParseTree (ACPI_PARSE_OBJECT *root)
ACPI_PARSE_OBJECT *	AcpiPsCreateScopeOp (UINT8 *Aml)
void	AcpiPsInitOp (ACPI_PARSE_OBJECT *op, UINT16 opcode)
ACPI_PARSE_OBJECT *	AcpiPsAllocOp (UINT16 Opcode, UINT8 *Aml)
void	AcpiPsFreeOp (ACPI_PARSE_OBJECT *Op)
BOOLEAN	AcpiPsIsLeadingChar (UINT32 c)
UINT32	AcpiPsGetName (ACPI_PARSE_OBJECT *op)
void	AcpiPsSetName (ACPI_PARSE_OBJECT *op, UINT32 name)
UINT32	AcpiPsSprintPath (char *BufferStart, UINT32 BufferSize, ACPI_PARSE_OBJECT *Op)
UINT32	AcpiPsSprintOp (char *BufferStart, UINT32 BufferSize, ACPI_PARSE_OBJECT *Op)
void	AcpiPsShow (ACPI_PARSE_OBJECT *op)

Variables
const UINT8	AcpiGbl_ShortOpIndex []
const UINT8	AcpiGbl_LongOpIndex []

Macro Definition Documentation

ACPI_NOT_METHOD_CALL

#define ACPI_NOT_METHOD_CALL   FALSE

Definition at line 117 of file acparser.h.

ACPI_PARSE_DEFERRED_OP

#define ACPI_PARSE_DEFERRED_OP   0x0100

Definition at line 64 of file acparser.h.

ACPI_PARSE_DELETE_TREE

#define ACPI_PARSE_DELETE_TREE   0x0001

Definition at line 55 of file acparser.h.

ACPI_PARSE_DISASSEMBLE

#define ACPI_PARSE_DISASSEMBLE   0x0200

Definition at line 65 of file acparser.h.

ACPI_PARSE_EXECUTE

#define ACPI_PARSE_EXECUTE   0x0030

Definition at line 61 of file acparser.h.

ACPI_PARSE_LOAD_PASS1

#define ACPI_PARSE_LOAD_PASS1   0x0010

Definition at line 59 of file acparser.h.

ACPI_PARSE_LOAD_PASS2

#define ACPI_PARSE_LOAD_PASS2   0x0020

Definition at line 60 of file acparser.h.

ACPI_PARSE_MODE_MASK

#define ACPI_PARSE_MODE_MASK   0x0030

Definition at line 62 of file acparser.h.

ACPI_PARSE_MODULE_LEVEL

#define ACPI_PARSE_MODULE_LEVEL   0x0400

Definition at line 67 of file acparser.h.

ACPI_PARSE_NO_TREE_DELETE

#define ACPI_PARSE_NO_TREE_DELETE   0x0000

Definition at line 56 of file acparser.h.

ACPI_PARSE_TREE_MASK

#define ACPI_PARSE_TREE_MASK   0x0001

Definition at line 57 of file acparser.h.

ACPI_POSSIBLE_METHOD_CALL

#define ACPI_POSSIBLE_METHOD_CALL   TRUE

Definition at line 118 of file acparser.h.

ACPI_VAR_ARGS

#define ACPI_VAR_ARGS   ACPI_UINT32_MAX

Definition at line 52 of file acparser.h.

OP_HAS_RETURN_VALUE

#define OP_HAS_RETURN_VALUE   1

Definition at line 48 of file acparser.h.

Function Documentation

AcpiPsAllocOp()

ACPI_PARSE_OBJECT * AcpiPsAllocOp	(	UINT16	Opcode,
		UINT8 *	Aml
	)

Definition at line 130 of file psutils.c.

{
    ACPI_PARSE_OBJECT       *Op;
    const ACPI_OPCODE_INFO  *OpInfo;
    UINT8                   Flags = ACPI_PARSEOP_GENERIC;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    OpInfo = AcpiPsGetOpcodeInfo (Opcode);
 
    /* Determine type of ParseOp required */
 
    if (OpInfo->Flags & AML_DEFER)
    {
        Flags = ACPI_PARSEOP_DEFERRED;
    }
    else if (OpInfo->Flags & AML_NAMED)
    {
        Flags = ACPI_PARSEOP_NAMED_OBJECT;
    }
    else if (Opcode == AML_INT_BYTELIST_OP)
    {
        Flags = ACPI_PARSEOP_BYTELIST;
    }
 
    /* Allocate the minimum required size object */
 
    if (Flags == ACPI_PARSEOP_GENERIC)
    {
        /* The generic op (default) is by far the most common (16 to 1) */
 
        Op = AcpiOsAcquireObject (AcpiGbl_PsNodeCache);
    }
    else
    {
        /* Extended parseop */
 
        Op = AcpiOsAcquireObject (AcpiGbl_PsNodeExtCache);
    }
 
    /* Initialize the Op */
 
    if (Op)
    {
        AcpiPsInitOp (Op, Opcode);
        Op->Common.Aml = Aml;
        Op->Common.Flags = Flags;
        ASL_CV_CLEAR_OP_COMMENTS(Op);
 
        if (Opcode == AML_SCOPE_OP)
        {
            AcpiGbl_CurrentScope = Op;
        }
 
        if (AcpiGbl_CaptureComments)
        {
            ASL_CV_TRANSFER_COMMENTS (Op);
        }
    }
 
    return (Op);
}

Referenced by AcpiDsAutoSerializeMethod(), AcpiDsExecuteArguments(), AcpiDsLoad1BeginOp(), AcpiDsLoad2BeginOp(), AcpiPsCompleteThisOp(), AcpiPsCreateOp(), AcpiPsCreateScopeOp(), AcpiPsGetNextArg(), AcpiPsGetNextField(), and AcpiPsGetNextNamepath().

AcpiPsAppendArg()

void AcpiPsAppendArg	(	ACPI_PARSE_OBJECT *	op,
		ACPI_PARSE_OBJECT *	arg
	)

Definition at line 138 of file pstree.c.

{
    ACPI_PARSE_OBJECT       *PrevArg;
    const ACPI_OPCODE_INFO  *OpInfo;
 
 
    ACPI_FUNCTION_TRACE (PsAppendArg);
 
 
    if (!Op)
    {
        return_VOID;
    }
 
    /* Get the info structure for this opcode */
 
    OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
    if (OpInfo->Class == AML_CLASS_UNKNOWN)
    {
        /* Invalid opcode */
 
        ACPI_ERROR ((AE_INFO, "Invalid AML Opcode: 0x%2.2X",
            Op->Common.AmlOpcode));
        return_VOID;
    }
 
    /* Check if this opcode requires argument sub-objects */
 
    if (!(OpInfo->Flags & AML_HAS_ARGS))
    {
        /* Has no linked argument objects */
 
        return_VOID;
    }
 
    /* Append the argument to the linked argument list */
 
    if (Op->Common.Value.Arg)
    {
        /* Append to existing argument list */
 
        PrevArg = Op->Common.Value.Arg;
        while (PrevArg->Common.Next)
        {
            PrevArg = PrevArg->Common.Next;
        }
        PrevArg->Common.Next = Arg;
    }
    else
    {
        /* No argument list, this will be the first argument */
 
        Op->Common.Value.Arg = Arg;
    }
 
    /* Set the parent in this arg and any args linked after it */
 
    while (Arg)
    {
        Arg->Common.Parent = Op;
        Arg = Arg->Common.Next;
 
        Op->Common.ArgListLength++;
    }
 
    return_VOID;
}

Referenced by AcpiDsLoad1BeginOp(), AcpiPsBuildNamedOp(), AcpiPsCreateOp(), AcpiPsGetArguments(), AcpiPsGetNextField(), and AcpiPsGetNextNamepath().

AcpiPsBuildNamedOp()

ACPI_STATUS AcpiPsBuildNamedOp	(	ACPI_WALK_STATE *	WalkState,
		UINT8 *	AmlOpStart,
		ACPI_PARSE_OBJECT *	UnnamedOp,
		ACPI_PARSE_OBJECT **	Op
	)

Definition at line 193 of file psobject.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_PARSE_OBJECT       *Arg = NULL;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsBuildNamedOp, WalkState);
 
 
    UnnamedOp->Common.Value.Arg = NULL;
    UnnamedOp->Common.ArgListLength = 0;
    UnnamedOp->Common.AmlOpcode = WalkState->Opcode;
 
    /*
     * Get and append arguments until we find the node that contains
     * the name (the type ARGP_NAME).
     */
    while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) &&
          (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) != ARGP_NAME))
    {
        ASL_CV_CAPTURE_COMMENTS (WalkState);
        Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
            GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        AcpiPsAppendArg (UnnamedOp, Arg);
        INCREMENT_ARG_LIST (WalkState->ArgTypes);
    }
 
    /* are there any inline comments associated with the NameSeg?? If so, save this. */
 
    ASL_CV_CAPTURE_COMMENTS (WalkState);
 
#ifdef ACPI_ASL_COMPILER
    if (AcpiGbl_CurrentInlineComment != NULL)
    {
        UnnamedOp->Common.NameComment = AcpiGbl_CurrentInlineComment;
        AcpiGbl_CurrentInlineComment = NULL;
    }
#endif
 
    /*
     * Make sure that we found a NAME and didn't run out of arguments
     */
    if (!GET_CURRENT_ARG_TYPE (WalkState->ArgTypes))
    {
        return_ACPI_STATUS (AE_AML_NO_OPERAND);
    }
 
    /* We know that this arg is a name, move to next arg */
 
    INCREMENT_ARG_LIST (WalkState->ArgTypes);
 
    /*
     * Find the object. This will either insert the object into
     * the namespace or simply look it up
     */
    WalkState->Op = NULL;
 
    Status = WalkState->DescendingCallback (WalkState, Op);
    if (ACPI_FAILURE (Status))
    {
        if (Status != AE_CTRL_TERMINATE)
        {
            ACPI_EXCEPTION ((AE_INFO, Status, "During name lookup/catalog"));
        }
        return_ACPI_STATUS (Status);
    }
 
    if (!*Op)
    {
        return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
    }
 
    Status = AcpiPsNextParseState (WalkState, *Op, Status);
    if (ACPI_FAILURE (Status))
    {
        if (Status == AE_CTRL_PENDING)
        {
            Status = AE_CTRL_PARSE_PENDING;
        }
        return_ACPI_STATUS (Status);
    }
 
    AcpiPsAppendArg (*Op, UnnamedOp->Common.Value.Arg);
 
#ifdef ACPI_ASL_COMPILER
 
    /* save any comments that might be associated with UnnamedOp. */
 
    (*Op)->Common.InlineComment     = UnnamedOp->Common.InlineComment;
    (*Op)->Common.EndNodeComment    = UnnamedOp->Common.EndNodeComment;
    (*Op)->Common.CloseBraceComment = UnnamedOp->Common.CloseBraceComment;
    (*Op)->Common.NameComment       = UnnamedOp->Common.NameComment;
    (*Op)->Common.CommentList       = UnnamedOp->Common.CommentList;
    (*Op)->Common.EndBlkComment     = UnnamedOp->Common.EndBlkComment;
    (*Op)->Common.CvFilename        = UnnamedOp->Common.CvFilename;
    (*Op)->Common.CvParentFilename  = UnnamedOp->Common.CvParentFilename;
    (*Op)->Named.Aml                = UnnamedOp->Common.Aml;
 
    UnnamedOp->Common.InlineComment     = NULL;
    UnnamedOp->Common.EndNodeComment    = NULL;
    UnnamedOp->Common.CloseBraceComment = NULL;
    UnnamedOp->Common.NameComment       = NULL;
    UnnamedOp->Common.CommentList       = NULL;
    UnnamedOp->Common.EndBlkComment     = NULL;
#endif
 
    if ((*Op)->Common.AmlOpcode == AML_REGION_OP ||
        (*Op)->Common.AmlOpcode == AML_DATA_REGION_OP)
    {
        /*
         * Defer final parsing of an OperationRegion body, because we don't
         * have enough info in the first pass to parse it correctly (i.e.,
         * there may be method calls within the TermArg elements of the body.)
         *
         * However, we must continue parsing because the opregion is not a
         * standalone package -- we don't know where the end is at this point.
         *
         * (Length is unknown until parse of the body complete)
         */
        (*Op)->Named.Data = AmlOpStart;
        (*Op)->Named.Length = 0;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiPsCreateOp().

AcpiPsCleanupScope()

void AcpiPsCleanupScope

(

ACPI_PARSE_STATE *

state

)

Definition at line 277 of file psscope.c.

{
    ACPI_GENERIC_STATE      *Scope;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsCleanupScope, ParserState);
 
 
    if (!ParserState)
    {
        return_VOID;
    }
 
    /* Delete anything on the scope stack */
 
    while (ParserState->Scope)
    {
        Scope = AcpiUtPopGenericState (&ParserState->Scope);
        AcpiUtDeleteGenericState (Scope);
    }
 
    return_VOID;
}

Referenced by AcpiDsDeleteWalkState(), AcpiPsExecuteMethod(), and AcpiPsParseAml().

AcpiPsCompleteFinalOp()

ACPI_STATUS AcpiPsCompleteFinalOp	(	ACPI_WALK_STATE *	WalkState,
		ACPI_PARSE_OBJECT *	Op,
		ACPI_STATUS	Status
	)

Definition at line 705 of file psobject.c.

{
    ACPI_STATUS             Status2;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsCompleteFinalOp, WalkState);
 
 
    /*
     * Complete the last Op (if not completed), and clear the scope stack.
     * It is easily possible to end an AML "package" with an unbounded number
     * of open scopes (such as when several ASL blocks are closed with
     * sequential closing braces). We want to terminate each one cleanly.
     */
    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "AML package complete at Op %p\n", Op));
    do
    {
        if (Op)
        {
            if (WalkState->AscendingCallback != NULL)
            {
                WalkState->Op = Op;
                WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
                WalkState->Opcode = Op->Common.AmlOpcode;
 
                Status = WalkState->AscendingCallback (WalkState);
                Status = AcpiPsNextParseState (WalkState, Op, Status);
                if (Status == AE_CTRL_PENDING)
                {
                    Status = AcpiPsCompleteOp (WalkState, &Op, AE_OK);
                    if (ACPI_FAILURE (Status))
                    {
                        return_ACPI_STATUS (Status);
                    }
                }
 
                if (Status == AE_CTRL_TERMINATE)
                {
                    Status = AE_OK;
 
                    /* Clean up */
                    do
                    {
                        if (Op)
                        {
                            Status2 = AcpiPsCompleteThisOp (WalkState, Op);
                            if (ACPI_FAILURE (Status2))
                            {
                                return_ACPI_STATUS (Status2);
                            }
                        }
 
                        AcpiPsPopScope (&(WalkState->ParserState), &Op,
                            &WalkState->ArgTypes, &WalkState->ArgCount);
 
                    } while (Op);
 
                    return_ACPI_STATUS (Status);
                }
 
                else if (ACPI_FAILURE (Status))
                {
                    /* First error is most important */
 
                    (void) AcpiPsCompleteThisOp (WalkState, Op);
                    return_ACPI_STATUS (Status);
                }
            }
 
            Status2 = AcpiPsCompleteThisOp (WalkState, Op);
            if (ACPI_FAILURE (Status2))
            {
                return_ACPI_STATUS (Status2);
            }
        }
 
        AcpiPsPopScope (&(WalkState->ParserState), &Op, &WalkState->ArgTypes,
            &WalkState->ArgCount);
 
    } while (Op);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiPsParseLoop().

AcpiPsCompleteOp()

ACPI_STATUS AcpiPsCompleteOp	(	ACPI_WALK_STATE *	WalkState,
		ACPI_PARSE_OBJECT **	Op,
		ACPI_STATUS	Status
	)

Definition at line 495 of file psobject.c.

{
    ACPI_STATUS             Status2;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsCompleteOp, WalkState);
 
 
    /*
     * Finished one argument of the containing scope
     */
    WalkState->ParserState.Scope->ParseScope.ArgCount--;
 
    /* Close this Op (will result in parse subtree deletion) */
 
    Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
    if (ACPI_FAILURE (Status2))
    {
        return_ACPI_STATUS (Status2);
    }
 
    *Op = NULL;
 
    switch (Status)
    {
    case AE_OK:
 
        break;
 
    case AE_CTRL_TRANSFER:
 
        /* We are about to transfer to a called method */
 
        WalkState->PrevOp = NULL;
        WalkState->PrevArgTypes = WalkState->ArgTypes;
        return_ACPI_STATUS (Status);
 
    case AE_CTRL_END:
 
        AcpiPsPopScope (&(WalkState->ParserState), Op,
            &WalkState->ArgTypes, &WalkState->ArgCount);
 
        if (*Op)
        {
            WalkState->Op = *Op;
            WalkState->OpInfo = AcpiPsGetOpcodeInfo ((*Op)->Common.AmlOpcode);
            WalkState->Opcode = (*Op)->Common.AmlOpcode;
 
            Status = WalkState->AscendingCallback (WalkState);
            (void) AcpiPsNextParseState (WalkState, *Op, Status);
 
            Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
            if (ACPI_FAILURE (Status2))
            {
                return_ACPI_STATUS (Status2);
            }
        }
 
        break;
 
    case AE_CTRL_BREAK:
    case AE_CTRL_CONTINUE:
 
        /* Pop off scopes until we find the While */
 
        while (!(*Op) || ((*Op)->Common.AmlOpcode != AML_WHILE_OP))
        {
            AcpiPsPopScope (&(WalkState->ParserState), Op,
                &WalkState->ArgTypes, &WalkState->ArgCount);
        }
 
        /* Close this iteration of the While loop */
 
        WalkState->Op = *Op;
        WalkState->OpInfo = AcpiPsGetOpcodeInfo ((*Op)->Common.AmlOpcode);
        WalkState->Opcode = (*Op)->Common.AmlOpcode;
 
        Status = WalkState->AscendingCallback (WalkState);
        (void) AcpiPsNextParseState (WalkState, *Op, Status);
 
        Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
        if (ACPI_FAILURE (Status2))
        {
            return_ACPI_STATUS (Status2);
        }
 
        break;
 
    case AE_CTRL_TERMINATE:
 
        /* Clean up */
        do
        {
            if (*Op)
            {
                Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
                if (ACPI_FAILURE (Status2))
                {
                    return_ACPI_STATUS (Status2);
                }
 
                AcpiUtDeleteGenericState (
                    AcpiUtPopGenericState (&WalkState->ControlState));
            }
 
            AcpiPsPopScope (&(WalkState->ParserState), Op,
                &WalkState->ArgTypes, &WalkState->ArgCount);
 
        } while (*Op);
 
        return_ACPI_STATUS (AE_OK);
 
    default:  /* All other non-AE_OK status */
 
        do
        {
            if (*Op)
            {
                /*
                 * These Opcodes need to be removed from the namespace because they
                 * get created even if these opcodes cannot be created due to
                 * errors.
                 */
                if (((*Op)->Common.AmlOpcode == AML_REGION_OP) ||
                    ((*Op)->Common.AmlOpcode == AML_DATA_REGION_OP))
                {
                    AcpiNsDeleteChildren ((*Op)->Common.Node);
                    AcpiNsRemoveNode ((*Op)->Common.Node);
                    (*Op)->Common.Node = NULL;
                    AcpiPsDeleteParseTree (*Op);
                }
 
                Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
                if (ACPI_FAILURE (Status2))
                {
                    return_ACPI_STATUS (Status2);
                }
            }
 
            AcpiPsPopScope (&(WalkState->ParserState), Op,
                &WalkState->ArgTypes, &WalkState->ArgCount);
 
        } while (*Op);
 
 
#if 0
        /*
         * TBD: Cleanup parse ops on error
         */
        if (*Op == NULL)
        {
            AcpiPsPopScope (ParserState, Op,
                &WalkState->ArgTypes, &WalkState->ArgCount);
        }
#endif
        WalkState->PrevOp = NULL;
        WalkState->PrevArgTypes = WalkState->ArgTypes;
 
        if (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)
        {
            /*
             * There was something that went wrong while executing code at the
             * module-level. We need to skip parsing whatever caused the
             * error and keep going. One runtime error during the table load
             * should not cause the entire table to not be loaded. This is
             * because there could be correct AML beyond the parts that caused
             * the runtime error.
             */
            ACPI_INFO (("Ignoring error and continuing table load"));
            return_ACPI_STATUS (AE_OK);
        }
        return_ACPI_STATUS (Status);
    }
 
    /* This scope complete? */
 
    if (AcpiPsHasCompletedScope (&(WalkState->ParserState)))
    {
        AcpiPsPopScope (&(WalkState->ParserState), Op,
            &WalkState->ArgTypes, &WalkState->ArgCount);
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", *Op));
    }
    else
    {
        *Op = NULL;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiPsCompleteFinalOp(), and AcpiPsParseLoop().

AcpiPsCompleteThisOp()

ACPI_STATUS AcpiPsCompleteThisOp	(	ACPI_WALK_STATE *	WalkState,
		ACPI_PARSE_OBJECT *	Op
	)

Definition at line 144 of file psparse.c.

{
    ACPI_PARSE_OBJECT       *Prev;
    ACPI_PARSE_OBJECT       *Next;
    const ACPI_OPCODE_INFO  *ParentInfo;
    ACPI_PARSE_OBJECT       *ReplacementOp = NULL;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsCompleteThisOp, Op);
 
 
    /* Check for null Op, can happen if AML code is corrupt */
 
    if (!Op)
    {
        return_ACPI_STATUS (AE_OK);  /* OK for now */
    }
 
    AcpiExStopTraceOpcode (Op, WalkState);
 
    /* Delete this op and the subtree below it if asked to */
 
    if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) != ACPI_PARSE_DELETE_TREE) ||
         (WalkState->OpInfo->Class == AML_CLASS_ARGUMENT))
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /* Make sure that we only delete this subtree */
 
    if (Op->Common.Parent)
    {
        Prev = Op->Common.Parent->Common.Value.Arg;
        if (!Prev)
        {
            /* Nothing more to do */
 
            goto Cleanup;
        }
 
        /*
         * Check if we need to replace the operator and its subtree
         * with a return value op (placeholder op)
         */
        ParentInfo = AcpiPsGetOpcodeInfo (Op->Common.Parent->Common.AmlOpcode);
 
        switch (ParentInfo->Class)
        {
        case AML_CLASS_CONTROL:
 
            break;
 
        case AML_CLASS_CREATE:
            /*
             * These opcodes contain TermArg operands. The current
             * op must be replaced by a placeholder return op
             */
            ReplacementOp = AcpiPsAllocOp (
                AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
            if (!ReplacementOp)
            {
                Status = AE_NO_MEMORY;
            }
            break;
 
        case AML_CLASS_NAMED_OBJECT:
            /*
             * These opcodes contain TermArg operands. The current
             * op must be replaced by a placeholder return op
             */
            if ((Op->Common.Parent->Common.AmlOpcode == AML_REGION_OP)       ||
                (Op->Common.Parent->Common.AmlOpcode == AML_DATA_REGION_OP)  ||
                (Op->Common.Parent->Common.AmlOpcode == AML_BUFFER_OP)       ||
                (Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP)      ||
                (Op->Common.Parent->Common.AmlOpcode == AML_BANK_FIELD_OP)   ||
                (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
            {
                ReplacementOp = AcpiPsAllocOp (
                    AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
                if (!ReplacementOp)
                {
                    Status = AE_NO_MEMORY;
                }
            }
            else if ((Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
                     (WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
            {
                if ((Op->Common.AmlOpcode == AML_BUFFER_OP) ||
                    (Op->Common.AmlOpcode == AML_PACKAGE_OP) ||
                    (Op->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
                {
                    ReplacementOp = AcpiPsAllocOp (Op->Common.AmlOpcode,
                        Op->Common.Aml);
                    if (!ReplacementOp)
                    {
                        Status = AE_NO_MEMORY;
                    }
                    else
                    {
                        ReplacementOp->Named.Data = Op->Named.Data;
                        ReplacementOp->Named.Length = Op->Named.Length;
                    }
                }
            }
            break;
 
        default:
 
            ReplacementOp = AcpiPsAllocOp (
                AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
            if (!ReplacementOp)
            {
                Status = AE_NO_MEMORY;
            }
        }
 
        /* We must unlink this op from the parent tree */
 
        if (Prev == Op)
        {
            /* This op is the first in the list */
 
            if (ReplacementOp)
            {
                ReplacementOp->Common.Parent = Op->Common.Parent;
                ReplacementOp->Common.Value.Arg = NULL;
                ReplacementOp->Common.Node = Op->Common.Node;
                Op->Common.Parent->Common.Value.Arg = ReplacementOp;
                ReplacementOp->Common.Next = Op->Common.Next;
            }
            else
            {
                Op->Common.Parent->Common.Value.Arg = Op->Common.Next;
            }
        }
 
        /* Search the parent list */
 
        else while (Prev)
        {
            /* Traverse all siblings in the parent's argument list */
 
            Next = Prev->Common.Next;
            if (Next == Op)
            {
                if (ReplacementOp)
                {
                    ReplacementOp->Common.Parent = Op->Common.Parent;
                    ReplacementOp->Common.Value.Arg = NULL;
                    ReplacementOp->Common.Node = Op->Common.Node;
                    Prev->Common.Next = ReplacementOp;
                    ReplacementOp->Common.Next = Op->Common.Next;
                    Next = NULL;
                }
                else
                {
                    Prev->Common.Next = Op->Common.Next;
                    Next = NULL;
                }
            }
            Prev = Next;
        }
    }
 
 
Cleanup:
 
    /* Now we can actually delete the subtree rooted at Op */
 
    AcpiPsDeleteParseTree (Op);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiPsCompleteFinalOp(), and AcpiPsCompleteOp().

AcpiPsCreateOp()

ACPI_STATUS AcpiPsCreateOp	(	ACPI_WALK_STATE *	WalkState,
		UINT8 *	AmlOpStart,
		ACPI_PARSE_OBJECT **	NewOp
	)

Definition at line 344 of file psobject.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_PARSE_OBJECT       *Op;
    ACPI_PARSE_OBJECT       *NamedOp = NULL;
    ACPI_PARSE_OBJECT       *ParentScope;
    UINT8                   ArgumentCount;
    const ACPI_OPCODE_INFO  *OpInfo;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsCreateOp, WalkState);
 
 
    Status = AcpiPsGetAmlOpcode (WalkState);
    if (Status == AE_CTRL_PARSE_CONTINUE)
    {
        return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
    }
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Create Op structure and append to parent's argument list */
 
    WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode);
    Op = AcpiPsAllocOp (WalkState->Opcode, AmlOpStart);
    if (!Op)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    if (WalkState->OpInfo->Flags & AML_NAMED)
    {
        Status = AcpiPsBuildNamedOp (WalkState, AmlOpStart, Op, &NamedOp);
        AcpiPsFreeOp (Op);
 
#ifdef ACPI_ASL_COMPILER
        if (AcpiGbl_DisasmFlag && WalkState->Opcode == AML_EXTERNAL_OP &&
            Status == AE_NOT_FOUND)
        {
            /*
             * If parsing of AML_EXTERNAL_OP's name path fails, then skip
             * past this opcode and keep parsing. This is a much better
             * alternative than to abort the entire disassembler. At this
             * point, the ParserState is at the end of the namepath of the
             * external declaration opcode. Setting WalkState->Aml to
             * WalkState->ParserState.Aml + 2 moves increments the
             * WalkState->Aml past the object type and the paramcount of the
             * external opcode.
             */
            WalkState->Aml = WalkState->ParserState.Aml + 2;
            WalkState->ParserState.Aml = WalkState->Aml;
            return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
        }
#endif
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        *NewOp = NamedOp;
        return_ACPI_STATUS (AE_OK);
    }
 
    /* Not a named opcode, just allocate Op and append to parent */
 
    if (WalkState->OpInfo->Flags & AML_CREATE)
    {
        /*
         * Backup to beginning of CreateXXXfield declaration
         * BodyLength is unknown until we parse the body
         */
        Op->Named.Data = AmlOpStart;
        Op->Named.Length = 0;
    }
 
    if (WalkState->Opcode == AML_BANK_FIELD_OP)
    {
        /*
         * Backup to beginning of BankField declaration
         * BodyLength is unknown until we parse the body
         */
        Op->Named.Data = AmlOpStart;
        Op->Named.Length = 0;
    }
 
    ParentScope = AcpiPsGetParentScope (&(WalkState->ParserState));
    AcpiPsAppendArg (ParentScope, Op);
 
    if (ParentScope)
    {
        OpInfo = AcpiPsGetOpcodeInfo (ParentScope->Common.AmlOpcode);
        if (OpInfo->Flags & AML_HAS_TARGET)
        {
            ArgumentCount = AcpiPsGetArgumentCount (OpInfo->Type);
            if (ParentScope->Common.ArgListLength > ArgumentCount)
            {
                Op->Common.Flags |= ACPI_PARSEOP_TARGET;
            }
        }
 
        /*
         * Special case for both Increment() and Decrement(), where
         * the lone argument is both a source and a target.
         */
        else if ((ParentScope->Common.AmlOpcode == AML_INCREMENT_OP) ||
                (ParentScope->Common.AmlOpcode == AML_DECREMENT_OP))
        {
            Op->Common.Flags |= ACPI_PARSEOP_TARGET;
        }
    }
 
    if (WalkState->DescendingCallback != NULL)
    {
        /*
         * Find the object. This will either insert the object into
         * the namespace or simply look it up
         */
        WalkState->Op = *NewOp = Op;
 
        Status = WalkState->DescendingCallback (WalkState, &Op);
        Status = AcpiPsNextParseState (WalkState, Op, Status);
        if (Status == AE_CTRL_PENDING)
        {
            Status = AE_CTRL_PARSE_PENDING;
        }
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiPsParseLoop().

AcpiPsCreateScopeOp()

ACPI_PARSE_OBJECT * AcpiPsCreateScopeOp

(

UINT8 *

Aml

)

Definition at line 67 of file psutils.c.

{
    ACPI_PARSE_OBJECT       *ScopeOp;
 
 
    ScopeOp = AcpiPsAllocOp (AML_SCOPE_OP, Aml);
    if (!ScopeOp)
    {
        return (NULL);
    }
 
    ScopeOp->Named.Name = ACPI_ROOT_NAME;
    return (ScopeOp);
}

Referenced by AcpiNsOneCompleteParse(), AcpiPsExecuteMethod(), and AcpiPsExecuteTable().

AcpiPsDeleteCompletedOp()

ACPI_STATUS AcpiPsDeleteCompletedOp

(

ACPI_WALK_STATE *

WalkState

)

AcpiPsDeleteParseTree()

void AcpiPsDeleteParseTree

(

ACPI_PARSE_OBJECT *

root

)

Definition at line 67 of file pswalk.c.

{
    ACPI_PARSE_OBJECT       *Op = SubtreeRoot;
    ACPI_PARSE_OBJECT       *Next = NULL;
    ACPI_PARSE_OBJECT       *Parent = NULL;
    UINT32                  Level = 0;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsDeleteParseTree, SubtreeRoot);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE_TREES,
        " root %p\n", SubtreeRoot));
 
    /* Visit all nodes in the subtree */
 
    while (Op)
    {
        if (Op != Parent)
        {
            /* This is the descending case */
 
            if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_PARSE_TREES, _COMPONENT))
            {
                /* This debug option will print the entire parse tree */
 
                AcpiOsPrintf ("        %*.s%s %p", (Level * 4), " ",
                    AcpiPsGetOpcodeName (Op->Common.AmlOpcode), Op);
 
                if (Op->Named.AmlOpcode == AML_INT_NAMEPATH_OP)
                {
                    AcpiOsPrintf ("    %4.4s", Op->Common.Value.String);
                }
                if (Op->Named.AmlOpcode == AML_STRING_OP)
                {
                    AcpiOsPrintf ("    %s", Op->Common.Value.String);
                }
                AcpiOsPrintf ("\n");
            }
 
            /* Look for an argument or child of the current op */
 
            Next = AcpiPsGetArg (Op, 0);
            if (Next)
            {
                /* Still going downward in tree (Op is not completed yet) */
 
                Op = Next;
                Level++;
                continue;
            }
        }
 
        /* No more children, this Op is complete. */
 
        Next = Op->Common.Next;
        Parent = Op->Common.Parent;
 
        AcpiPsFreeOp (Op);
 
        /* If we are back to the starting point, the walk is complete. */
 
        if (Op == SubtreeRoot)
        {
            return_VOID;
        }
 
        if (Next)
        {
            Op = Next;
        }
        else
        {
            Level--;
            Op = Parent;
        }
    }
 
    return_VOID;
}

Referenced by AcpiDsAutoSerializeMethod(), AcpiDsExecuteArguments(), AcpiNsOneCompleteParse(), AcpiPsCompleteOp(), AcpiPsCompleteThisOp(), AcpiPsExecuteMethod(), and AcpiPsExecuteTable().

AcpiPsExecuteMethod()

ACPI_STATUS AcpiPsExecuteMethod

(

ACPI_EVALUATE_INFO *

Info

)

Definition at line 131 of file psxface.c.

{
    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;
    }
 
    WalkState->MethodPathname = Info->FullPathname;
    WalkState->MethodIsNested = FALSE;
 
    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 =
            AcpiUtCreateIntegerObject ((UINT64) 0);
        if (!WalkState->ImplicitReturnObj)
        {
            Status = AE_NO_MEMORY;
            AcpiDsDeleteWalkState (WalkState);
            goto Cleanup;
        }
    }
 
    /* Parse the AML */
 
    Status = AcpiPsParseAml (WalkState);
 
    /* WalkState was deleted by ParseAml */
 
Cleanup:
    AcpiPsDeleteParseTree (Op);
 
    /* Take away the extra reference that we gave the parameters above */
 
    AcpiPsUpdateParameterList (Info, REF_DECREMENT);
 
    /* Exit now if error above */
 
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * If the method has returned an object, signal this to the caller with
     * a control exception code
     */
    if (Info->ReturnObject)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Method returned ObjDesc=%p\n",
            Info->ReturnObject));
        ACPI_DUMP_STACK_ENTRY (Info->ReturnObject);
 
        Status = AE_CTRL_RETURN_VALUE;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiNsEvaluate().

AcpiPsExecuteTable()

ACPI_STATUS AcpiPsExecuteTable

(

ACPI_EVALUATE_INFO *

Info

)

Definition at line 297 of file psxface.c.

{
    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;
    }
 
    WalkState->MethodPathname = Info->FullPathname;
    WalkState->MethodIsNested = FALSE;
 
    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);
}

Referenced by AcpiNsExecuteTable().

AcpiPsFind()

ACPI_PARSE_OBJECT * AcpiPsFind	(	ACPI_PARSE_OBJECT *	Scope,
		char *	Path,
		UINT16	Opcode,
		UINT32	Create
	)

AcpiPsFindName()

ACPI_PARSE_OBJECT * AcpiPsFindName	(	ACPI_PARSE_OBJECT *	Scope,
		UINT32	Name,
		UINT32	Opcode
	)

AcpiPsFreeOp()

void AcpiPsFreeOp

(

ACPI_PARSE_OBJECT *

Op

)

Definition at line 212 of file psutils.c.

{
    ACPI_FUNCTION_NAME (PsFreeOp);
 
 
    ASL_CV_CLEAR_OP_COMMENTS(Op);
    if (Op->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
            "Free retval op: %p\n", Op));
    }
 
    if (Op->Common.Flags & ACPI_PARSEOP_GENERIC)
    {
        (void) AcpiOsReleaseObject (AcpiGbl_PsNodeCache, Op);
    }
    else
    {
        (void) AcpiOsReleaseObject (AcpiGbl_PsNodeExtCache, Op);
    }
}

Referenced by AcpiDsAutoSerializeMethod(), AcpiNsOneCompleteParse(), AcpiPsCreateOp(), AcpiPsDeleteParseTree(), AcpiPsGetNextArg(), and AcpiPsGetNextField().

AcpiPsGetArg()

ACPI_PARSE_OBJECT * AcpiPsGetArg	(	ACPI_PARSE_OBJECT *	op,
		UINT32	argn
	)

Definition at line 76 of file pstree.c.

{
    ACPI_PARSE_OBJECT       *Arg = NULL;
    const ACPI_OPCODE_INFO  *OpInfo;
 
 
    ACPI_FUNCTION_ENTRY ();
 
/*
    if (Op->Common.AmlOpcode == AML_INT_CONNECTION_OP)
    {
        return (Op->Common.Value.Arg);
    }
*/
    /* Get the info structure for this opcode */
 
    OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
    if (OpInfo->Class == AML_CLASS_UNKNOWN)
    {
        /* Invalid opcode or ASCII character */
 
        return (NULL);
    }
 
    /* Check if this opcode requires argument sub-objects */
 
    if (!(OpInfo->Flags & AML_HAS_ARGS))
    {
        /* Has no linked argument objects */
 
        return (NULL);
    }
 
    /* Get the requested argument object */
 
    Arg = Op->Common.Value.Arg;
    while (Arg && Argn)
    {
        Argn--;
        Arg = Arg->Common.Next;
    }
 
    return (Arg);
}

Referenced by AcpiDsCreateBufferField(), AcpiDsEvalBankFieldOperands(), AcpiDsInitFieldObjects(), AcpiPsDeleteParseTree(), and AcpiPsGetDepthNext().

AcpiPsGetArgumentCount()

UINT8 AcpiPsGetArgumentCount

(

UINT32

OpType

)

Definition at line 203 of file psopinfo.c.

{
 
    if (OpType <= AML_TYPE_EXEC_6A_0T_1R)
    {
        return (AcpiGbl_ArgumentCount[OpType]);
    }
 
    return (0);
}

Referenced by AcpiPsCreateOp().

AcpiPsGetDepthNext()

ACPI_PARSE_OBJECT * AcpiPsGetDepthNext	(	ACPI_PARSE_OBJECT *	Origin,
		ACPI_PARSE_OBJECT *	Op
	)

Definition at line 224 of file pstree.c.

{
    ACPI_PARSE_OBJECT       *Next = NULL;
    ACPI_PARSE_OBJECT       *Parent;
    ACPI_PARSE_OBJECT       *Arg;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    if (!Op)
    {
        return (NULL);
    }
 
    /* Look for an argument or child */
 
    Next = AcpiPsGetArg (Op, 0);
    if (Next)
    {
        ASL_CV_LABEL_FILENODE (Next);
        return (Next);
    }
 
    /* Look for a sibling */
 
    Next = Op->Common.Next;
    if (Next)
    {
        ASL_CV_LABEL_FILENODE (Next);
        return (Next);
    }
 
    /* Look for a sibling of parent */
 
    Parent = Op->Common.Parent;
 
    while (Parent)
    {
        Arg = AcpiPsGetArg (Parent, 0);
        while (Arg && (Arg != Origin) && (Arg != Op))
        {
 
            ASL_CV_LABEL_FILENODE (Arg);
            Arg = Arg->Common.Next;
        }
 
        if (Arg == Origin)
        {
            /* Reached parent of origin, end search */
 
            return (NULL);
        }
 
        if (Parent->Common.Next)
        {
            /* Found sibling of parent */
 
            ASL_CV_LABEL_FILENODE (Parent->Common.Next);
            return (Parent->Common.Next);
        }
 
        Op = Parent;
        Parent = Parent->Common.Parent;
    }
 
    ASL_CV_LABEL_FILENODE (Next);
    return (Next);
}

AcpiPsGetName()

UINT32 AcpiPsGetName

(

ACPI_PARSE_OBJECT *

op

)

Definition at line 260 of file psutils.c.

{
 
    /* The "generic" object has no name associated with it */
 
    if (Op->Common.Flags & ACPI_PARSEOP_GENERIC)
    {
        return (0);
    }
 
    /* Only the "Extended" parse objects have a name */
 
    return (Op->Named.Name);
}

AcpiPsGetNextArg()

ACPI_STATUS AcpiPsGetNextArg	(	ACPI_WALK_STATE *	WalkState,
		ACPI_PARSE_STATE *	ParserState,
		UINT32	ArgType,
		ACPI_PARSE_OBJECT **	ReturnArg
	)

Definition at line 785 of file psargs.c.

{
    ACPI_PARSE_OBJECT       *Arg = NULL;
    ACPI_PARSE_OBJECT       *Prev = NULL;
    ACPI_PARSE_OBJECT       *Field;
    UINT32                  Subop;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsGetNextArg, ParserState);
 
 
    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
        "Expected argument type ARGP: %s (%2.2X)\n",
        AcpiUtGetArgumentTypeName (ArgType), ArgType));
 
    switch (ArgType)
    {
    case ARGP_BYTEDATA:
    case ARGP_WORDDATA:
    case ARGP_DWORDDATA:
    case ARGP_CHARLIST:
    case ARGP_NAME:
    case ARGP_NAMESTRING:
 
        /* Constants, strings, and namestrings are all the same size */
 
        Arg = AcpiPsAllocOp (AML_BYTE_OP, ParserState->Aml);
        if (!Arg)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        AcpiPsGetNextSimpleArg (ParserState, ArgType, Arg);
        break;
 
    case ARGP_PKGLENGTH:
 
        /* Package length, nothing returned */
 
        ParserState->PkgEnd = AcpiPsGetNextPackageEnd (ParserState);
        break;
 
    case ARGP_FIELDLIST:
 
        if (ParserState->Aml < ParserState->PkgEnd)
        {
            /* Non-empty list */
 
            while (ParserState->Aml < ParserState->PkgEnd)
            {
                Field = AcpiPsGetNextField (ParserState);
                if (!Field)
                {
                    return_ACPI_STATUS (AE_NO_MEMORY);
                }
 
                if (Prev)
                {
                    Prev->Common.Next = Field;
                }
                else
                {
                    Arg = Field;
                }
                Prev = Field;
            }
 
            /* Skip to End of byte data */
 
            ParserState->Aml = ParserState->PkgEnd;
        }
        break;
 
    case ARGP_BYTELIST:
 
        if (ParserState->Aml < ParserState->PkgEnd)
        {
            /* Non-empty list */
 
            Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP,
                ParserState->Aml);
            if (!Arg)
            {
                return_ACPI_STATUS (AE_NO_MEMORY);
            }
 
            /* Fill in bytelist data */
 
            Arg->Common.Value.Size = (UINT32)
                ACPI_PTR_DIFF (ParserState->PkgEnd, ParserState->Aml);
            Arg->Named.Data = ParserState->Aml;
 
            /* Skip to End of byte data */
 
            ParserState->Aml = ParserState->PkgEnd;
        }
        break;
 
    case ARGP_SIMPLENAME:
    case ARGP_NAME_OR_REF:
 
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
            "**** SimpleName/NameOrRef: %s (%2.2X)\n",
            AcpiUtGetArgumentTypeName (ArgType), ArgType));
 
        Subop = AcpiPsPeekOpcode (ParserState);
        if (Subop == 0                  ||
            AcpiPsIsLeadingChar (Subop) ||
            ACPI_IS_ROOT_PREFIX (Subop) ||
            ACPI_IS_PARENT_PREFIX (Subop))
        {
            /* NullName or NameString */
 
            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
            if (!Arg)
            {
                return_ACPI_STATUS (AE_NO_MEMORY);
            }
 
            Status = AcpiPsGetNextNamepath (WalkState, ParserState,
                Arg, ACPI_NOT_METHOD_CALL);
        }
        else
        {
            /* Single complex argument, nothing returned */
 
            WalkState->ArgCount = 1;
        }
        break;
 
    case ARGP_TARGET:
    case ARGP_SUPERNAME:
 
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
            "**** Target/Supername: %s (%2.2X)\n",
            AcpiUtGetArgumentTypeName (ArgType), ArgType));
 
        Subop = AcpiPsPeekOpcode (ParserState);
        if (Subop == 0                  ||
            AcpiPsIsLeadingChar (Subop) ||
            ACPI_IS_ROOT_PREFIX (Subop) ||
            ACPI_IS_PARENT_PREFIX (Subop))
        {
            /* NULL target (zero). Convert to a NULL namepath */
 
            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
            if (!Arg)
            {
                return_ACPI_STATUS (AE_NO_MEMORY);
            }
 
            Status = AcpiPsGetNextNamepath (WalkState, ParserState,
                Arg, ACPI_POSSIBLE_METHOD_CALL);
 
            if (Arg->Common.AmlOpcode == AML_INT_METHODCALL_OP)
            {
                /* Free method call op and corresponding namestring sub-ob */
 
                AcpiPsFreeOp (Arg->Common.Value.Arg);
                AcpiPsFreeOp (Arg);
                Arg = NULL;
                WalkState->ArgCount = 1;
            }
        }
        else
        {
            /* Single complex argument, nothing returned */
 
            WalkState->ArgCount = 1;
        }
        break;
 
    case ARGP_DATAOBJ:
    case ARGP_TERMARG:
 
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
            "**** TermArg/DataObj: %s (%2.2X)\n",
            AcpiUtGetArgumentTypeName (ArgType), ArgType));
 
        /* Single complex argument, nothing returned */
 
        WalkState->ArgCount = 1;
        break;
 
    case ARGP_DATAOBJLIST:
    case ARGP_TERMLIST:
    case ARGP_OBJLIST:
 
        if (ParserState->Aml < ParserState->PkgEnd)
        {
            /* Non-empty list of variable arguments, nothing returned */
 
            WalkState->ArgCount = ACPI_VAR_ARGS;
        }
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Invalid ArgType: 0x%X", ArgType));
        Status = AE_AML_OPERAND_TYPE;
        break;
    }
 
    *ReturnArg = Arg;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiPsBuildNamedOp(), and AcpiPsGetArguments().

AcpiPsGetNextNamepath()

ACPI_STATUS AcpiPsGetNextNamepath	(	ACPI_WALK_STATE *	WalkState,
		ACPI_PARSE_STATE *	ParserState,
		ACPI_PARSE_OBJECT *	Arg,
		BOOLEAN	PossibleMethodCall
	)

Definition at line 254 of file psargs.c.

{
    ACPI_STATUS             Status;
    char                    *Path;
    ACPI_PARSE_OBJECT       *NameOp;
    ACPI_OPERAND_OBJECT     *MethodDesc;
    ACPI_NAMESPACE_NODE     *Node;
    UINT8                   *Start = ParserState->Aml;
 
 
    ACPI_FUNCTION_TRACE (PsGetNextNamepath);
 
 
    Path = AcpiPsGetNextNamestring (ParserState);
    AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
 
    /* Null path case is allowed, just exit */
 
    if (!Path)
    {
        Arg->Common.Value.Name = Path;
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * Lookup the name in the internal namespace, starting with the current
     * scope. We don't want to add anything new to the namespace here,
     * however, so we use MODE_EXECUTE.
     * Allow searching of the parent tree, but don't open a new scope -
     * we just want to lookup the object (must be mode EXECUTE to perform
     * the upsearch)
     */
    Status = AcpiNsLookup (WalkState->ScopeInfo, Path,
        ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
        ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, &Node);
 
    /*
     * If this name is a control method invocation, we must
     * setup the method call
     */
    if (ACPI_SUCCESS (Status) &&
        PossibleMethodCall &&
        (Node->Type == ACPI_TYPE_METHOD))
    {
        if ((GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) == ARGP_SUPERNAME) ||
            (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) == ARGP_TARGET))
        {
            /*
             * AcpiPsGetNextNamestring has increased the AML pointer past
             * the method invocation namestring, so we need to restore the
             * saved AML pointer back to the original method invocation
             * namestring.
             */
            WalkState->ParserState.Aml = Start;
            WalkState->ArgCount = 1;
            AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
        }
 
        /* This name is actually a control method invocation */
 
        MethodDesc = AcpiNsGetAttachedObject (Node);
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
            "Control Method invocation %4.4s - %p Desc %p Path=%p\n",
            Node->Name.Ascii, Node, MethodDesc, Path));
 
        NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Start);
        if (!NameOp)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        /* Change Arg into a METHOD CALL and attach name to it */
 
        AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
        NameOp->Common.Value.Name = Path;
 
        /* Point METHODCALL/NAME to the METHOD Node */
 
        NameOp->Common.Node = Node;
        AcpiPsAppendArg (Arg, NameOp);
 
        if (!MethodDesc)
        {
            ACPI_ERROR ((AE_INFO,
                "Control Method %p has no attached object",
                Node));
            return_ACPI_STATUS (AE_AML_INTERNAL);
        }
 
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
            "Control Method - %p Args %X\n",
            Node, MethodDesc->Method.ParamCount));
 
        /* Get the number of arguments to expect */
 
        WalkState->ArgCount = MethodDesc->Method.ParamCount;
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * Special handling if the name was not found during the lookup -
     * some NotFound cases are allowed
     */
    if (Status == AE_NOT_FOUND)
    {
        /* 1) NotFound is ok during load pass 1/2 (allow forward references) */
 
        if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) !=
            ACPI_PARSE_EXECUTE)
        {
            Status = AE_OK;
        }
 
        /* 2) NotFound during a CondRefOf(x) is ok by definition */
 
        else if (WalkState->Op->Common.AmlOpcode == AML_CONDITIONAL_REF_OF_OP)
        {
            Status = AE_OK;
        }
 
        /*
         * 3) NotFound while building a Package is ok at this point, we
         * may flag as an error later if slack mode is not enabled.
         * (Some ASL code depends on allowing this behavior)
         */
        else if ((Arg->Common.Parent) &&
            ((Arg->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
             (Arg->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP)))
        {
            Status = AE_OK;
        }
    }
 
    /* Final exception check (may have been changed from code above) */
 
    if (ACPI_FAILURE (Status))
    {
        ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, Path, Status);
 
        if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) ==
            ACPI_PARSE_EXECUTE)
        {
            /* Report a control method execution error */
 
            Status = AcpiDsMethodError (Status, WalkState);
        }
    }
 
    /* Save the namepath */
 
    Arg->Common.Value.Name = Path;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiPsGetArguments(), and AcpiPsGetNextArg().

AcpiPsGetNextNamestring()

char * AcpiPsGetNextNamestring

(

ACPI_PARSE_STATE *

ParserState

)

Definition at line 172 of file psargs.c.

{
    UINT8                   *Start = ParserState->Aml;
    UINT8                   *End = ParserState->Aml;
 
 
    ACPI_FUNCTION_TRACE (PsGetNextNamestring);
 
 
    /* Point past any namestring prefix characters (backslash or carat) */
 
    while (ACPI_IS_ROOT_PREFIX (*End) ||
           ACPI_IS_PARENT_PREFIX (*End))
    {
        End++;
    }
 
    /* Decode the path prefix character */
 
    switch (*End)
    {
    case 0:
 
        /* NullName */
 
        if (End == Start)
        {
            Start = NULL;
        }
        End++;
        break;
 
    case AML_DUAL_NAME_PREFIX:
 
        /* Two name segments */
 
        End += 1 + (2 * ACPI_NAMESEG_SIZE);
        break;
 
    case AML_MULTI_NAME_PREFIX:
 
        /* Multiple name segments, 4 chars each, count in next byte */
 
        End += 2 + (*(End + 1) * ACPI_NAMESEG_SIZE);
        break;
 
    default:
 
        /* Single name segment */
 
        End += ACPI_NAMESEG_SIZE;
        break;
    }
 
    ParserState->Aml = End;
    return_PTR ((char *) Start);
}

Referenced by AcpiDsLoad1BeginOp(), AcpiDsLoad2BeginOp(), AcpiInstallMethod(), AcpiPsGetNextField(), AcpiPsGetNextNamepath(), and AcpiPsGetNextSimpleArg().

AcpiPsGetNextPackageEnd()

UINT8 * AcpiPsGetNextPackageEnd

(

ACPI_PARSE_STATE *

ParserState

)

Definition at line 138 of file psargs.c.

{
    UINT8                   *Start = ParserState->Aml;
    UINT32                  PackageLength;
 
 
    ACPI_FUNCTION_TRACE (PsGetNextPackageEnd);
 
 
    /* Function below updates ParserState->Aml */
 
    PackageLength = AcpiPsGetNextPackageLength (ParserState);
 
    return_PTR (Start + PackageLength); /* end of package */
}

Referenced by AcpiInstallMethod(), AcpiPsGetNextArg(), AcpiPsNextParseState(), and AcpiPsParseLoop().

AcpiPsGetNextSimpleArg()

void AcpiPsGetNextSimpleArg	(	ACPI_PARSE_STATE *	ParserState,
		UINT32	ArgType,
		ACPI_PARSE_OBJECT *	Arg
	)

Definition at line 428 of file psargs.c.

{
    UINT32                  Length;
    UINT16                  Opcode;
    UINT8                   *Aml = ParserState->Aml;
 
 
    ACPI_FUNCTION_TRACE_U32 (PsGetNextSimpleArg, ArgType);
 
 
    switch (ArgType)
    {
    case ARGP_BYTEDATA:
 
        /* Get 1 byte from the AML stream */
 
        Opcode = AML_BYTE_OP;
        Arg->Common.Value.Integer = (UINT64) *Aml;
        Length = 1;
        break;
 
    case ARGP_WORDDATA:
 
        /* Get 2 bytes from the AML stream */
 
        Opcode = AML_WORD_OP;
        ACPI_MOVE_16_TO_64 (&Arg->Common.Value.Integer, Aml);
        Length = 2;
        break;
 
    case ARGP_DWORDDATA:
 
        /* Get 4 bytes from the AML stream */
 
        Opcode = AML_DWORD_OP;
        ACPI_MOVE_32_TO_64 (&Arg->Common.Value.Integer, Aml);
        Length = 4;
        break;
 
    case ARGP_QWORDDATA:
 
        /* Get 8 bytes from the AML stream */
 
        Opcode = AML_QWORD_OP;
        ACPI_MOVE_64_TO_64 (&Arg->Common.Value.Integer, Aml);
        Length = 8;
        break;
 
    case ARGP_CHARLIST:
 
        /* Get a pointer to the string, point past the string */
 
        Opcode = AML_STRING_OP;
        Arg->Common.Value.String = ACPI_CAST_PTR (char, Aml);
 
        /* Find the null terminator */
 
        Length = 0;
        while (Aml[Length])
        {
            Length++;
        }
        Length++;
        break;
 
    case ARGP_NAME:
    case ARGP_NAMESTRING:
 
        AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
        Arg->Common.Value.Name = AcpiPsGetNextNamestring (ParserState);
        return_VOID;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Invalid ArgType 0x%X", ArgType));
        return_VOID;
    }
 
    AcpiPsInitOp (Arg, Opcode);
    ParserState->Aml += Length;
    return_VOID;
}

Referenced by AcpiPsGetArguments(), and AcpiPsGetNextArg().

AcpiPsGetNextWalkOp()

ACPI_STATUS AcpiPsGetNextWalkOp	(	ACPI_WALK_STATE *	WalkState,
		ACPI_PARSE_OBJECT *	Op,
		ACPI_PARSE_UPWARDS	AscendingCallback
	)

AcpiPsGetOpcodeInfo()

const ACPI_OPCODE_INFO * AcpiPsGetOpcodeInfo

(

UINT16

Opcode

)

Definition at line 72 of file psopinfo.c.

{
#ifdef ACPI_DEBUG_OUTPUT
    const char              *OpcodeName = "Unknown AML opcode";
#endif
 
    ACPI_FUNCTION_NAME (PsGetOpcodeInfo);
 
 
    /*
     * Detect normal 8-bit opcode or extended 16-bit opcode
     */
    if (!(Opcode & 0xFF00))
    {
        /* Simple (8-bit) opcode: 0-255, can't index beyond table  */
 
        return (&AcpiGbl_AmlOpInfo [AcpiGbl_ShortOpIndex [(UINT8) Opcode]]);
    }
 
    if (((Opcode & 0xFF00) == AML_EXTENDED_OPCODE) &&
        (((UINT8) Opcode) <= MAX_EXTENDED_OPCODE))
    {
        /* Valid extended (16-bit) opcode */
 
        return (&AcpiGbl_AmlOpInfo [AcpiGbl_LongOpIndex [(UINT8) Opcode]]);
    }
 
#if defined ACPI_ASL_COMPILER && defined ACPI_DEBUG_OUTPUT
#include "asldefine.h"
 
    switch (Opcode)
    {
    case AML_RAW_DATA_BYTE:
        OpcodeName = "-Raw Data Byte-";
        break;
 
    case AML_RAW_DATA_WORD:
        OpcodeName = "-Raw Data Word-";
        break;
 
    case AML_RAW_DATA_DWORD:
        OpcodeName = "-Raw Data Dword-";
        break;
 
    case AML_RAW_DATA_QWORD:
        OpcodeName = "-Raw Data Qword-";
        break;
 
    case AML_RAW_DATA_BUFFER:
        OpcodeName = "-Raw Data Buffer-";
        break;
 
    case AML_RAW_DATA_CHAIN:
        OpcodeName = "-Raw Data Buffer Chain-";
        break;
 
    case AML_PACKAGE_LENGTH:
        OpcodeName = "-Package Length-";
        break;
 
    case AML_UNASSIGNED_OPCODE:
        OpcodeName = "-Unassigned Opcode-";
        break;
 
    case AML_DEFAULT_ARG_OP:
        OpcodeName = "-Default Arg-";
        break;
 
    default:
        break;
    }
#endif
 
    /* Unknown AML opcode */
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
        "%s [%4.4X]\n", OpcodeName, Opcode));
 
    return (&AcpiGbl_AmlOpInfo [_UNK]);
}

Referenced by AcpiDsBuildInternalObject(), AcpiDsCreateOperand(), AcpiDsExecBeginOp(), AcpiDsInitObjectFromOp(), AcpiDsIsResultUsed(), AcpiDsLoad1EndOp(), AcpiExResolveOperands(), AcpiPsAllocOp(), AcpiPsAppendArg(), AcpiPsCompleteFinalOp(), AcpiPsCompleteOp(), AcpiPsCompleteThisOp(), AcpiPsCreateOp(), AcpiPsGetAmlOpcode(), AcpiPsGetArg(), AcpiPsGetOpcodeName(), AcpiPsInitOp(), and AcpiPsParseLoop().

AcpiPsGetOpcodeName()

const char * AcpiPsGetOpcodeName

(

UINT16

Opcode

)

Definition at line 169 of file psopinfo.c.

{
#if defined(ACPI_DISASSEMBLER) || defined (ACPI_DEBUG_OUTPUT)
 
    const ACPI_OPCODE_INFO  *Op;
 
 
    Op = AcpiPsGetOpcodeInfo (Opcode);
 
    /* Always guaranteed to return a valid pointer */
 
    return (Op->Name);
 
#else
    return ("OpcodeName unavailable");
 
#endif
}

Referenced by AcpiDsEvalBankFieldOperands(), AcpiDsEvalBufferFieldOperands(), AcpiDsExecEndOp(), AcpiDsInitBufferField(), AcpiDsIsResultUsed(), AcpiDsLoad2EndOp(), AcpiExOpcode_0A_0T_1R(), AcpiExOpcode_1A_0T_0R(), AcpiExOpcode_1A_0T_1R(), AcpiExOpcode_1A_1T_1R(), AcpiExOpcode_2A_0T_0R(), AcpiExOpcode_2A_0T_1R(), AcpiExOpcode_2A_1T_1R(), AcpiExOpcode_2A_2T_1R(), AcpiExOpcode_3A_0T_0R(), AcpiExOpcode_3A_1T_1R(), AcpiExOpcode_6A_0T_1R(), AcpiExResolveOperands(), AcpiPsDeleteParseTree(), and AcpiPsParseLoop().

AcpiPsGetOpcodeSize()

UINT32 AcpiPsGetOpcodeSize

(

UINT32

Opcode

)

Definition at line 78 of file psparse.c.

{
 
    /* Extended (2-byte) opcode if > 255 */
 
    if (Opcode > 0x00FF)
    {
        return (2);
    }
 
    /* Otherwise, just a single byte opcode */
 
    return (1);
}

Referenced by AcpiInstallMethod(), and AcpiPsGetAmlOpcode().

AcpiPsGetParent()

ACPI_PARSE_OBJECT * AcpiPsGetParent

(

ACPI_PARSE_OBJECT *

Op

)

AcpiPsGetParentScope()

ACPI_PARSE_OBJECT * AcpiPsGetParentScope

(

ACPI_PARSE_STATE *

state

)

Definition at line 65 of file psscope.c.

{
 
    return (ParserState->Scope->ParseScope.Op);
}

Referenced by AcpiDsLoad1BeginOp(), and AcpiPsCreateOp().

AcpiPsHasCompletedScope()

BOOLEAN AcpiPsHasCompletedScope

(

ACPI_PARSE_STATE *

ParserState

)

Definition at line 88 of file psscope.c.

{
 
    return ((BOOLEAN)
            ((ParserState->Aml >= ParserState->Scope->ParseScope.ArgEnd ||
             !ParserState->Scope->ParseScope.ArgCount)));
}

Referenced by AcpiPsCompleteOp(), and AcpiPsParseLoop().

AcpiPsInitOp()

void AcpiPsInitOp	(	ACPI_PARSE_OBJECT *	op,
		UINT16	opcode
	)

Definition at line 98 of file psutils.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    Op->Common.DescriptorType = ACPI_DESC_TYPE_PARSER;
    Op->Common.AmlOpcode = Opcode;
 
    ACPI_DISASM_ONLY_MEMBERS (AcpiUtSafeStrncpy (Op->Common.AmlOpName,
        (AcpiPsGetOpcodeInfo (Opcode))->Name,
        sizeof (Op->Common.AmlOpName)));
}

Referenced by AcpiPsAllocOp(), AcpiPsGetNextNamepath(), and AcpiPsGetNextSimpleArg().

AcpiPsInitScope()

ACPI_STATUS AcpiPsInitScope	(	ACPI_PARSE_STATE *	ParserState,
		ACPI_PARSE_OBJECT *	Root
	)

Definition at line 112 of file psscope.c.

{
    ACPI_GENERIC_STATE      *Scope;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsInitScope, RootOp);
 
 
    Scope = AcpiUtCreateGenericState ();
    if (!Scope)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    Scope->Common.DescriptorType = ACPI_DESC_TYPE_STATE_RPSCOPE;
    Scope->ParseScope.Op = RootOp;
    Scope->ParseScope.ArgCount = ACPI_VAR_ARGS;
    Scope->ParseScope.ArgEnd = ParserState->AmlEnd;
    Scope->ParseScope.PkgEnd = ParserState->AmlEnd;
 
    ParserState->Scope = Scope;
    ParserState->StartOp = RootOp;
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsInitAmlWalk().

AcpiPsIsLeadingChar()

BOOLEAN AcpiPsIsLeadingChar

(

UINT32

c

)

Definition at line 249 of file psutils.c.

{
    return ((BOOLEAN) (c == '_' || (c >= 'A' && c <= 'Z')));
}

Referenced by AcpiPsGetNextArg().

AcpiPsNextParseState()

ACPI_STATUS AcpiPsNextParseState	(	ACPI_WALK_STATE *	WalkState,
		ACPI_PARSE_OBJECT *	Op,
		ACPI_STATUS	CallbackStatus
	)

Definition at line 337 of file psparse.c.

{
    ACPI_PARSE_STATE        *ParserState = &WalkState->ParserState;
    ACPI_STATUS             Status = AE_CTRL_PENDING;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsNextParseState, Op);
 
 
    switch (CallbackStatus)
    {
    case AE_CTRL_TERMINATE:
        /*
         * A control method was terminated via a RETURN statement.
         * The walk of this method is complete.
         */
        ParserState->Aml = ParserState->AmlEnd;
        Status = AE_CTRL_TERMINATE;
        break;
 
    case AE_CTRL_BREAK:
 
        ParserState->Aml = WalkState->AmlLastWhile;
        WalkState->ControlState->Common.Value = FALSE;
        Status = AE_CTRL_BREAK;
        break;
 
    case AE_CTRL_CONTINUE:
 
        ParserState->Aml = WalkState->AmlLastWhile;
        Status = AE_CTRL_CONTINUE;
        break;
 
    case AE_CTRL_PENDING:
 
        ParserState->Aml = WalkState->AmlLastWhile;
        break;
 
#if 0
    case AE_CTRL_SKIP:
 
        ParserState->Aml = ParserState->Scope->ParseScope.PkgEnd;
        Status = AE_OK;
        break;
#endif
 
    case AE_CTRL_TRUE:
        /*
         * Predicate of an IF was true, and we are at the matching ELSE.
         * Just close out this package
         */
        ParserState->Aml = AcpiPsGetNextPackageEnd (ParserState);
        Status = AE_CTRL_PENDING;
        break;
 
    case AE_CTRL_FALSE:
        /*
         * Either an IF/WHILE Predicate was false or we encountered a BREAK
         * opcode. In both cases, we do not execute the rest of the
         * package;  We simply close out the parent (finishing the walk of
         * this branch of the tree) and continue execution at the parent
         * level.
         */
        ParserState->Aml = ParserState->Scope->ParseScope.PkgEnd;
 
        /* In the case of a BREAK, just force a predicate (if any) to FALSE */
 
        WalkState->ControlState->Common.Value = FALSE;
        Status = AE_CTRL_END;
        break;
 
    case AE_CTRL_TRANSFER:
 
        /* A method call (invocation) -- transfer control */
 
        Status = AE_CTRL_TRANSFER;
        WalkState->PrevOp = Op;
        WalkState->MethodCallOp = Op;
        WalkState->MethodCallNode = (Op->Common.Value.Arg)->Common.Node;
 
        /* Will return value (if any) be used by the caller? */
 
        WalkState->ReturnUsed = AcpiDsIsResultUsed (Op, WalkState);
        break;
 
    default:
 
        Status = CallbackStatus;
        if (ACPI_CNTL_EXCEPTION (CallbackStatus))
        {
            Status = AE_OK;
        }
        break;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiPsBuildNamedOp(), AcpiPsCompleteFinalOp(), AcpiPsCompleteOp(), AcpiPsCreateOp(), and AcpiPsParseLoop().

AcpiPsParseAml()

ACPI_STATUS AcpiPsParseAml

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 453 of file psparse.c.

{
    ACPI_STATUS             Status;
    ACPI_THREAD_STATE       *Thread;
    ACPI_THREAD_STATE       *PrevWalkList = AcpiGbl_CurrentWalkList;
    ACPI_WALK_STATE         *PreviousWalkState;
 
 
    ACPI_FUNCTION_TRACE (PsParseAml);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
        "Entered with WalkState=%p Aml=%p size=%X\n",
        WalkState, WalkState->ParserState.Aml,
        WalkState->ParserState.AmlSize));
 
    if (!WalkState->ParserState.Aml)
    {
        return_ACPI_STATUS (AE_BAD_ADDRESS);
    }
 
    /* Create and initialize a new thread state */
 
    Thread = AcpiUtCreateThreadState ();
    if (!Thread)
    {
        if (WalkState->MethodDesc)
        {
            /* Executing a control method - additional cleanup */
 
            AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
        }
 
        AcpiDsDeleteWalkState (WalkState);
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    WalkState->Thread = Thread;
 
    /*
     * If executing a method, the starting SyncLevel is this method's
     * SyncLevel
     */
    if (WalkState->MethodDesc)
    {
        WalkState->Thread->CurrentSyncLevel =
            WalkState->MethodDesc->Method.SyncLevel;
    }
 
    AcpiDsPushWalkState (WalkState, Thread);
 
    /*
     * This global allows the AML debugger to get a handle to the currently
     * executing control method.
     */
    AcpiGbl_CurrentWalkList = Thread;
 
    /*
     * Execute the walk loop as long as there is a valid Walk State. This
     * handles nested control method invocations without recursion.
     */
    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "State=%p\n", WalkState));
 
    Status = AE_OK;
    while (WalkState)
    {
        if (ACPI_SUCCESS (Status))
        {
            /*
             * The ParseLoop executes AML until the method terminates
             * or calls another method.
             */
            Status = AcpiPsParseLoop (WalkState);
        }
 
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
            "Completed one call to walk loop, %s State=%p\n",
            AcpiFormatException (Status), WalkState));
 
        if (WalkState->MethodPathname && WalkState->MethodIsNested)
        {
            /* Optional object evaluation log */
 
            ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EVALUATION, "%-26s:  %*s%s\n",
                "   Exit nested method",
                (WalkState->MethodNestingDepth + 1) * 3, " ",
                &WalkState->MethodPathname[1]));
 
            ACPI_FREE (WalkState->MethodPathname);
            WalkState->MethodIsNested = FALSE;
        }
        if (Status == AE_CTRL_TRANSFER)
        {
            /*
             * A method call was detected.
             * Transfer control to the called control method
             */
            Status = AcpiDsCallControlMethod (Thread, WalkState, NULL);
            if (ACPI_FAILURE (Status))
            {
                Status = AcpiDsMethodError (Status, WalkState);
            }
 
            /*
             * If the transfer to the new method method call worked,
             * a new walk state was created -- get it
             */
            WalkState = AcpiDsGetCurrentWalkState (Thread);
            continue;
        }
        else if (Status == AE_CTRL_TERMINATE)
        {
            Status = AE_OK;
        }
        else if ((Status != AE_OK) && (WalkState->MethodDesc))
        {
            /* Either the method parse or actual execution failed */
 
            AcpiExExitInterpreter ();
            if (Status == AE_ABORT_METHOD)
            {
                AcpiNsPrintNodePathname (
                    WalkState->MethodNode, "Aborting method");
                AcpiOsPrintf ("\n");
            }
            else
            {
                ACPI_ERROR_METHOD ("Aborting method",
                    WalkState->MethodNode, NULL, Status);
            }
            AcpiExEnterInterpreter ();
 
            /* Check for possible multi-thread reentrancy problem */
 
            if ((Status == AE_ALREADY_EXISTS) &&
                (!(WalkState->MethodDesc->Method.InfoFlags &
                    ACPI_METHOD_SERIALIZED)))
            {
                /*
                 * Method is not serialized and tried to create an object
                 * twice. The probable cause is that the method cannot
                 * handle reentrancy. Mark as "pending serialized" now, and
                 * then mark "serialized" when the last thread exits.
                 */
                WalkState->MethodDesc->Method.InfoFlags |=
                    ACPI_METHOD_SERIALIZED_PENDING;
            }
        }
 
        /* We are done with this walk, move on to the parent if any */
 
        WalkState = AcpiDsPopWalkState (Thread);
 
        /* Reset the current scope to the beginning of scope stack */
 
        AcpiDsScopeStackClear (WalkState);
 
        /*
         * If we just returned from the execution of a control method or if we
         * encountered an error during the method parse phase, there's lots of
         * cleanup to do
         */
        if (((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) ==
            ACPI_PARSE_EXECUTE &&
            !(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) ||
            (ACPI_FAILURE (Status)))
        {
            AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
        }
 
        /* Delete this walk state and all linked control states */
 
        AcpiPsCleanupScope (&WalkState->ParserState);
        PreviousWalkState = WalkState;
 
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
            "ReturnValue=%p, ImplicitValue=%p State=%p\n",
            WalkState->ReturnDesc, WalkState->ImplicitReturnObj, WalkState));
 
        /* Check if we have restarted a preempted walk */
 
        WalkState = AcpiDsGetCurrentWalkState (Thread);
        if (WalkState)
        {
            if (ACPI_SUCCESS (Status))
            {
                /*
                 * There is another walk state, restart it.
                 * If the method return value is not used by the parent,
                 * The object is deleted
                 */
                if (!PreviousWalkState->ReturnDesc)
                {
                    /*
                     * In slack mode execution, if there is no return value
                     * we should implicitly return zero (0) as a default value.
                     */
                    if (AcpiGbl_EnableInterpreterSlack &&
                        !PreviousWalkState->ImplicitReturnObj)
                    {
                        PreviousWalkState->ImplicitReturnObj =
                            AcpiUtCreateIntegerObject ((UINT64) 0);
                        if (!PreviousWalkState->ImplicitReturnObj)
                        {
                            return_ACPI_STATUS (AE_NO_MEMORY);
                        }
                    }
 
                    /* Restart the calling control method */
 
                    Status = AcpiDsRestartControlMethod (WalkState,
                        PreviousWalkState->ImplicitReturnObj);
                }
                else
                {
                    /*
                     * We have a valid return value, delete any implicit
                     * return value.
                     */
                    AcpiDsClearImplicitReturn (PreviousWalkState);
 
                    Status = AcpiDsRestartControlMethod (WalkState,
                        PreviousWalkState->ReturnDesc);
                }
                if (ACPI_SUCCESS (Status))
                {
                    WalkState->WalkType |= ACPI_WALK_METHOD_RESTART;
                }
            }
            else
            {
                /* On error, delete any return object or implicit return */
 
                AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
                AcpiDsClearImplicitReturn (PreviousWalkState);
            }
        }
 
        /*
         * Just completed a 1st-level method, save the final internal return
         * value (if any)
         */
        else if (PreviousWalkState->CallerReturnDesc)
        {
            if (PreviousWalkState->ImplicitReturnObj)
            {
                *(PreviousWalkState->CallerReturnDesc) =
                    PreviousWalkState->ImplicitReturnObj;
            }
            else
            {
                 /* NULL if no return value */
 
                *(PreviousWalkState->CallerReturnDesc) =
                    PreviousWalkState->ReturnDesc;
            }
        }
        else
        {
            if (PreviousWalkState->ReturnDesc)
            {
                /* Caller doesn't want it, must delete it */
 
                AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
            }
            if (PreviousWalkState->ImplicitReturnObj)
            {
                /* Caller doesn't want it, must delete it */
 
                AcpiUtRemoveReference (PreviousWalkState->ImplicitReturnObj);
            }
        }
 
        AcpiDsDeleteWalkState (PreviousWalkState);
    }
 
    /* Normal exit */
 
    AcpiExReleaseAllMutexes (Thread);
    AcpiUtDeleteGenericState (ACPI_CAST_PTR (ACPI_GENERIC_STATE, Thread));
    AcpiGbl_CurrentWalkList = PrevWalkList;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsAutoSerializeMethod(), AcpiDsExecuteArguments(), AcpiNsOneCompleteParse(), AcpiPsExecuteMethod(), and AcpiPsExecuteTable().

AcpiPsParseLoop()

ACPI_STATUS AcpiPsParseLoop

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 259 of file psloop.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_PARSE_OBJECT       *Op = NULL;     /* current op */
    ACPI_PARSE_STATE        *ParserState;
    UINT8                   *AmlOpStart = NULL;
    UINT8                   OpcodeLength;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsParseLoop, WalkState);
 
 
    if (WalkState->DescendingCallback == NULL)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    ParserState = &WalkState->ParserState;
    WalkState->ArgTypes = 0;
 
#ifndef ACPI_CONSTANT_EVAL_ONLY
 
    if (WalkState->WalkType & ACPI_WALK_METHOD_RESTART)
    {
        /* We are restarting a preempted control method */
 
        if (AcpiPsHasCompletedScope (ParserState))
        {
            /*
             * We must check if a predicate to an IF or WHILE statement
             * was just completed
             */
            if ((ParserState->Scope->ParseScope.Op) &&
               ((ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_IF_OP) ||
                (ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_WHILE_OP)) &&
                (WalkState->ControlState) &&
                (WalkState->ControlState->Common.State ==
                    ACPI_CONTROL_PREDICATE_EXECUTING))
            {
                /*
                 * A predicate was just completed, get the value of the
                 * predicate and branch based on that value
                 */
                WalkState->Op = NULL;
                Status = AcpiDsGetPredicateValue (WalkState, ACPI_TO_POINTER (TRUE));
                if (ACPI_FAILURE (Status) && !ACPI_CNTL_EXCEPTION (Status))
                {
                    if (Status == AE_AML_NO_RETURN_VALUE)
                    {
                        ACPI_EXCEPTION ((AE_INFO, Status,
                            "Invoked method did not return a value"));
                    }
 
                    ACPI_EXCEPTION ((AE_INFO, Status, "GetPredicate Failed"));
                    return_ACPI_STATUS (Status);
                }
 
                Status = AcpiPsNextParseState (WalkState, Op, Status);
            }
 
            AcpiPsPopScope (ParserState, &Op,
                &WalkState->ArgTypes, &WalkState->ArgCount);
            ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
        }
        else if (WalkState->PrevOp)
        {
            /* We were in the middle of an op */
 
            Op = WalkState->PrevOp;
            WalkState->ArgTypes = WalkState->PrevArgTypes;
        }
    }
#endif
 
    /* Iterative parsing loop, while there is more AML to process: */
 
    while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
    {
        ASL_CV_CAPTURE_COMMENTS (WalkState);
 
        AmlOpStart = ParserState->Aml;
        if (!Op)
        {
            Status = AcpiPsCreateOp (WalkState, AmlOpStart, &Op);
            if (ACPI_FAILURE (Status))
            {
                /*
                 * ACPI_PARSE_MODULE_LEVEL means that we are loading a table by
                 * executing it as a control method. However, if we encounter
                 * an error while loading the table, we need to keep trying to
                 * load the table rather than aborting the table load. Set the
                 * status to AE_OK to proceed with the table load.
                 */
                if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&
                    ((Status == AE_ALREADY_EXISTS) || (Status == AE_NOT_FOUND)))
                {
                    Status = AE_OK;
                }
                if (Status == AE_CTRL_PARSE_CONTINUE)
                {
                    continue;
                }
 
                if (Status == AE_CTRL_PARSE_PENDING)
                {
                    Status = AE_OK;
                }
 
                if (Status == AE_CTRL_TERMINATE)
                {
                    return_ACPI_STATUS (Status);
                }
 
                Status = AcpiPsCompleteOp (WalkState, &Op, Status);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
                if (AcpiNsOpensScope (
                    AcpiPsGetOpcodeInfo (WalkState->Opcode)->ObjectType))
                {
                    /*
                     * If the scope/device op fails to parse, skip the body of
                     * the scope op because the parse failure indicates that
                     * the device may not exist.
                     */
                    ACPI_INFO (("Skipping parse of AML opcode: %s (0x%4.4X)",
                        AcpiPsGetOpcodeName (WalkState->Opcode), WalkState->Opcode));
 
                    /*
                     * Determine the opcode length before skipping the opcode.
                     * An opcode can be 1 byte or 2 bytes in length.
                     */
                    OpcodeLength = 1;
                    if ((WalkState->Opcode & 0xFF00) == AML_EXTENDED_OPCODE)
                    {
                        OpcodeLength = 2;
                    }
                    WalkState->ParserState.Aml = WalkState->Aml + OpcodeLength;
 
                    WalkState->ParserState.Aml =
                        AcpiPsGetNextPackageEnd(&WalkState->ParserState);
                    WalkState->Aml = WalkState->ParserState.Aml;
                }
 
                continue;
            }
 
            AcpiExStartTraceOpcode (Op, WalkState);
        }
 
        /*
         * Start ArgCount at zero because we don't know if there are
         * any args yet
         */
        WalkState->ArgCount = 0;
 
        switch (Op->Common.AmlOpcode)
        {
        case AML_BYTE_OP:
        case AML_WORD_OP:
        case AML_DWORD_OP:
        case AML_QWORD_OP:
 
            break;
 
        default:
 
            ASL_CV_CAPTURE_COMMENTS (WalkState);
            break;
        }
 
        /* Are there any arguments that must be processed? */
 
        if (WalkState->ArgTypes)
        {
            /* Get arguments */
 
            Status = AcpiPsGetArguments (WalkState, AmlOpStart, Op);
            if (ACPI_FAILURE (Status))
            {
                Status = AcpiPsCompleteOp (WalkState, &Op, Status);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
                if ((WalkState->ControlState) &&
                    ((WalkState->ControlState->Control.Opcode == AML_IF_OP) ||
                    (WalkState->ControlState->Control.Opcode == AML_WHILE_OP)))
                {
                    /*
                     * If the if/while op fails to parse, we will skip parsing
                     * the body of the op.
                     */
                    ParserState->Aml =
                        WalkState->ControlState->Control.AmlPredicateStart + 1;
                    ParserState->Aml =
                        AcpiPsGetNextPackageEnd (ParserState);
                    WalkState->Aml = ParserState->Aml;
 
                    ACPI_ERROR ((AE_INFO, "Skipping While/If block"));
                    if (*WalkState->Aml == AML_ELSE_OP)
                    {
                        ACPI_ERROR ((AE_INFO, "Skipping Else block"));
                        WalkState->ParserState.Aml = WalkState->Aml + 1;
                        WalkState->ParserState.Aml =
                            AcpiPsGetNextPackageEnd (ParserState);
                        WalkState->Aml = ParserState->Aml;
                    }
                    ACPI_FREE(AcpiUtPopGenericState (&WalkState->ControlState));
                }
                Op = NULL;
                continue;
            }
        }
 
        /* Check for arguments that need to be processed */
 
        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
            "Parseloop: argument count: %8.8X\n", WalkState->ArgCount));
 
        if (WalkState->ArgCount)
        {
            /*
             * There are arguments (complex ones), push Op and
             * prepare for argument
             */
            Status = AcpiPsPushScope (ParserState, Op,
                WalkState->ArgTypes, WalkState->ArgCount);
            if (ACPI_FAILURE (Status))
            {
                Status = AcpiPsCompleteOp (WalkState, &Op, Status);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
 
                continue;
            }
 
            Op = NULL;
            continue;
        }
 
        /*
         * All arguments have been processed -- Op is complete,
         * prepare for next
         */
        WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
        if (WalkState->OpInfo->Flags & AML_NAMED)
        {
            if (Op->Common.AmlOpcode == AML_REGION_OP ||
                Op->Common.AmlOpcode == AML_DATA_REGION_OP)
            {
                /*
                 * Skip parsing of control method or opregion body,
                 * because we don't have enough info in the first pass
                 * to parse them correctly.
                 *
                 * Completed parsing an OpRegion declaration, we now
                 * know the length.
                 */
                Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
            }
        }
 
        if (WalkState->OpInfo->Flags & AML_CREATE)
        {
            /*
             * Backup to beginning of CreateXXXfield declaration (1 for
             * Opcode)
             *
             * BodyLength is unknown until we parse the body
             */
            Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
        }
 
        if (Op->Common.AmlOpcode == AML_BANK_FIELD_OP)
        {
            /*
             * Backup to beginning of BankField declaration
             *
             * BodyLength is unknown until we parse the body
             */
            Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
        }
 
        /* This op complete, notify the dispatcher */
 
        if (WalkState->AscendingCallback != NULL)
        {
            WalkState->Op = Op;
            WalkState->Opcode = Op->Common.AmlOpcode;
 
            Status = WalkState->AscendingCallback (WalkState);
            Status = AcpiPsNextParseState (WalkState, Op, Status);
            if (Status == AE_CTRL_PENDING)
            {
                Status = AE_OK;
            }
            else if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&
                (ACPI_AML_EXCEPTION(Status) || Status == AE_ALREADY_EXISTS ||
                Status == AE_NOT_FOUND))
            {
                /*
                 * ACPI_PARSE_MODULE_LEVEL flag means that we are currently
                 * loading a table by executing it as a control method.
                 * However, if we encounter an error while loading the table,
                 * we need to keep trying to load the table rather than
                 * aborting the table load (setting the status to AE_OK
                 * continues the table load). If we get a failure at this
                 * point, it means that the dispatcher got an error while
                 * trying to execute the Op.
                 */
                Status = AE_OK;
            }
        }
 
        Status = AcpiPsCompleteOp (WalkState, &Op, Status);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
    } /* while ParserState->Aml */
 
    Status = AcpiPsCompleteFinalOp (WalkState, Op, Status);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiPsParseAml().

AcpiPsPeekOpcode()

UINT16 AcpiPsPeekOpcode

(

ACPI_PARSE_STATE *

state

)

Definition at line 108 of file psparse.c.

{
    UINT8                   *Aml;
    UINT16                  Opcode;
 
 
    Aml = ParserState->Aml;
    Opcode = (UINT16) ACPI_GET8 (Aml);
 
    if (Opcode == AML_EXTENDED_PREFIX)
    {
        /* Extended opcode, get the second opcode byte */
 
        Aml++;
        Opcode = (UINT16) ((Opcode << 8) | ACPI_GET8 (Aml));
    }
 
    return (Opcode);
}

Referenced by AcpiInstallMethod(), AcpiPsGetAmlOpcode(), and AcpiPsGetNextArg().

AcpiPsPopScope()

void AcpiPsPopScope	(	ACPI_PARSE_STATE *	ParserState,
		ACPI_PARSE_OBJECT **	Op,
		UINT32 *	ArgList,
		UINT32 *	ArgCount
	)

Definition at line 219 of file psscope.c.

{
    ACPI_GENERIC_STATE      *Scope = ParserState->Scope;
 
 
    ACPI_FUNCTION_TRACE (PsPopScope);
 
 
    /* Only pop the scope if there is in fact a next scope */
 
    if (Scope->Common.Next)
    {
        Scope = AcpiUtPopGenericState (&ParserState->Scope);
 
        /* Return to parsing previous op */
 
        *Op = Scope->ParseScope.Op;
        *ArgList = Scope->ParseScope.ArgList;
        *ArgCount = Scope->ParseScope.ArgCount;
        ParserState->PkgEnd = Scope->ParseScope.PkgEnd;
 
        /* All done with this scope state structure */
 
        AcpiUtDeleteGenericState (Scope);
    }
    else
    {
        /* Empty parse stack, prepare to fetch next opcode */
 
        *Op = NULL;
        *ArgList = 0;
        *ArgCount = 0;
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
        "Popped Op %p Args %X\n", *Op, *ArgCount));
    return_VOID;
}

Referenced by AcpiPsCompleteFinalOp(), AcpiPsCompleteOp(), and AcpiPsParseLoop().

AcpiPsPushScope()

ACPI_STATUS AcpiPsPushScope	(	ACPI_PARSE_STATE *	ParserState,
		ACPI_PARSE_OBJECT *	Op,
		UINT32	RemainingArgs,
		UINT32	ArgCount
	)

Definition at line 157 of file psscope.c.

{
    ACPI_GENERIC_STATE      *Scope;
 
 
    ACPI_FUNCTION_TRACE_PTR (PsPushScope, Op);
 
 
    Scope = AcpiUtCreateGenericState ();
    if (!Scope)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    Scope->Common.DescriptorType = ACPI_DESC_TYPE_STATE_PSCOPE;
    Scope->ParseScope.Op = Op;
    Scope->ParseScope.ArgList = RemainingArgs;
    Scope->ParseScope.ArgCount = ArgCount;
    Scope->ParseScope.PkgEnd = ParserState->PkgEnd;
 
    /* Push onto scope stack */
 
    AcpiUtPushGenericState (&ParserState->Scope, Scope);
 
    if (ArgCount == ACPI_VAR_ARGS)
    {
        /* Multiple arguments */
 
        Scope->ParseScope.ArgEnd = ParserState->PkgEnd;
    }
    else
    {
        /* Single argument */
 
        Scope->ParseScope.ArgEnd = ACPI_TO_POINTER (ACPI_MAX_PTR);
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiPsParseLoop().

AcpiPsSetName()

void AcpiPsSetName	(	ACPI_PARSE_OBJECT *	op,
		UINT32	name
	)

Definition at line 281 of file psutils.c.

{
 
    /* The "generic" object has no name associated with it */
 
    if (Op->Common.Flags & ACPI_PARSEOP_GENERIC)
    {
        return;
    }
 
    Op->Named.Name = name;
}

Referenced by AcpiDsAutoSerializeMethod(), and AcpiPsGetNextField().

AcpiPsShow()

void AcpiPsShow

(

ACPI_PARSE_OBJECT *

op

)

AcpiPsSprintOp()

UINT32 AcpiPsSprintOp	(	char *	BufferStart,
		UINT32	BufferSize,
		ACPI_PARSE_OBJECT *	Op
	)

AcpiPsSprintPath()

UINT32 AcpiPsSprintPath	(	char *	BufferStart,
		UINT32	BufferSize,
		ACPI_PARSE_OBJECT *	Op
	)

AcpiPsWalkParsedAml()

ACPI_STATUS AcpiPsWalkParsedAml	(	ACPI_PARSE_OBJECT *	StartOp,
		ACPI_PARSE_OBJECT *	EndOp,
		ACPI_OPERAND_OBJECT *	MthDesc,
		ACPI_NAMESPACE_NODE *	StartNode,
		ACPI_OPERAND_OBJECT **	Params,
		ACPI_OPERAND_OBJECT **	CallerReturnDesc,
		ACPI_OWNER_ID	OwnerId,
		ACPI_PARSE_DOWNWARDS	DescendingCallback,
		ACPI_PARSE_UPWARDS	AscendingCallback
	)

Variable Documentation

AcpiGbl_LongOpIndex

const UINT8 AcpiGbl_LongOpIndex[]

extern

Definition at line 262 of file psopinfo.c.

Referenced by AcpiPsGetOpcodeInfo().

AcpiGbl_ShortOpIndex

const UINT8 AcpiGbl_ShortOpIndex[]

extern

Definition at line 220 of file psopinfo.c.

Referenced by AcpiPsGetOpcodeInfo().