1 /******************************************************************************
2  *
3  * Module Name: dswstate - Dispatcher parse tree walk management routines
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2014, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 
45 #define __DSWSTATE_C__
46 
47 #include "acpi.h"
48 #include "accommon.h"
49 #include "acparser.h"
50 #include "acdispat.h"
51 #include "acnamesp.h"
52 
53 #define _COMPONENT          ACPI_DISPATCHER
54         ACPI_MODULE_NAME    ("dswstate")
55 
56 /* Local prototypes */
57 
58 static ACPI_STATUS
59 AcpiDsResultStackPush (
60     ACPI_WALK_STATE         *WalkState);
61 
62 static ACPI_STATUS
63 AcpiDsResultStackPop (
64     ACPI_WALK_STATE         *WalkState);
65 
66 
67 /*******************************************************************************
68  *
69  * FUNCTION:    AcpiDsResultPop
70  *
71  * PARAMETERS:  Object              - Where to return the popped object
72  *              WalkState           - Current Walk state
73  *
74  * RETURN:      Status
75  *
76  * DESCRIPTION: Pop an object off the top of this walk's result stack
77  *
78  ******************************************************************************/
79 
80 ACPI_STATUS
81 AcpiDsResultPop (
82     ACPI_OPERAND_OBJECT     **Object,
83     ACPI_WALK_STATE         *WalkState)
84 {
85     UINT32                  Index;
86     ACPI_GENERIC_STATE      *State;
87     ACPI_STATUS             Status;
88 
89 
90     ACPI_FUNCTION_NAME (DsResultPop);
91 
92 
93     State = WalkState->Results;
94 
95     /* Incorrect state of result stack */
96 
97     if (State && !WalkState->ResultCount)
98     {
99         ACPI_ERROR ((AE_INFO, "No results on result stack"));
100         return (AE_AML_INTERNAL);
101     }
102 
103     if (!State && WalkState->ResultCount)
104     {
105         ACPI_ERROR ((AE_INFO, "No result state for result stack"));
106         return (AE_AML_INTERNAL);
107     }
108 
109     /* Empty result stack */
110 
111     if (!State)
112     {
113         ACPI_ERROR ((AE_INFO, "Result stack is empty! State=%p", WalkState));
114         return (AE_AML_NO_RETURN_VALUE);
115     }
116 
117     /* Return object of the top element and clean that top element result stack */
118 
119     WalkState->ResultCount--;
120     Index = (UINT32) WalkState->ResultCount % ACPI_RESULTS_FRAME_OBJ_NUM;
121 
122     *Object = State->Results.ObjDesc [Index];
123     if (!*Object)
124     {
125         ACPI_ERROR ((AE_INFO, "No result objects on result stack, State=%p",
126             WalkState));
127         return (AE_AML_NO_RETURN_VALUE);
128     }
129 
130     State->Results.ObjDesc [Index] = NULL;
131     if (Index == 0)
132     {
133         Status = AcpiDsResultStackPop (WalkState);
134         if (ACPI_FAILURE (Status))
135         {
136             return (Status);
137         }
138     }
139 
140     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
141         "Obj=%p [%s] Index=%X State=%p Num=%X\n", *Object,
142         AcpiUtGetObjectTypeName (*Object),
143         Index, WalkState, WalkState->ResultCount));
144 
145     return (AE_OK);
146 }
147 
148 
149 /*******************************************************************************
150  *
151  * FUNCTION:    AcpiDsResultPush
152  *
153  * PARAMETERS:  Object              - Where to return the popped object
154  *              WalkState           - Current Walk state
155  *
156  * RETURN:      Status
157  *
158  * DESCRIPTION: Push an object onto the current result stack
159  *
160  ******************************************************************************/
161 
162 ACPI_STATUS
163 AcpiDsResultPush (
164     ACPI_OPERAND_OBJECT     *Object,
165     ACPI_WALK_STATE         *WalkState)
166 {
167     ACPI_GENERIC_STATE      *State;
168     ACPI_STATUS             Status;
169     UINT32                  Index;
170 
171 
172     ACPI_FUNCTION_NAME (DsResultPush);
173 
174 
175     if (WalkState->ResultCount > WalkState->ResultSize)
176     {
177         ACPI_ERROR ((AE_INFO, "Result stack is full"));
178         return (AE_AML_INTERNAL);
179     }
180     else if (WalkState->ResultCount == WalkState->ResultSize)
181     {
182         /* Extend the result stack */
183 
184         Status = AcpiDsResultStackPush (WalkState);
185         if (ACPI_FAILURE (Status))
186         {
187             ACPI_ERROR ((AE_INFO, "Failed to extend the result stack"));
188             return (Status);
189         }
190     }
191 
192     if (!(WalkState->ResultCount < WalkState->ResultSize))
193     {
194         ACPI_ERROR ((AE_INFO, "No free elements in result stack"));
195         return (AE_AML_INTERNAL);
196     }
197 
198     State = WalkState->Results;
199     if (!State)
200     {
201         ACPI_ERROR ((AE_INFO, "No result stack frame during push"));
202         return (AE_AML_INTERNAL);
203     }
204 
205     if (!Object)
206     {
207         ACPI_ERROR ((AE_INFO,
208             "Null Object! Obj=%p State=%p Num=%u",
209             Object, WalkState, WalkState->ResultCount));
210         return (AE_BAD_PARAMETER);
211     }
212 
213     /* Assign the address of object to the top free element of result stack */
214 
215     Index = (UINT32) WalkState->ResultCount % ACPI_RESULTS_FRAME_OBJ_NUM;
216     State->Results.ObjDesc [Index] = Object;
217     WalkState->ResultCount++;
218 
219     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s] State=%p Num=%X Cur=%X\n",
220         Object, AcpiUtGetObjectTypeName ((ACPI_OPERAND_OBJECT *) Object),
221         WalkState, WalkState->ResultCount, WalkState->CurrentResult));
222 
223     return (AE_OK);
224 }
225 
226 
227 /*******************************************************************************
228  *
229  * FUNCTION:    AcpiDsResultStackPush
230  *
231  * PARAMETERS:  WalkState           - Current Walk state
232  *
233  * RETURN:      Status
234  *
235  * DESCRIPTION: Push an object onto the WalkState result stack
236  *
237  ******************************************************************************/
238 
239 static ACPI_STATUS
240 AcpiDsResultStackPush (
241     ACPI_WALK_STATE         *WalkState)
242 {
243     ACPI_GENERIC_STATE      *State;
244 
245 
246     ACPI_FUNCTION_NAME (DsResultStackPush);
247 
248 
249     /* Check for stack overflow */
250 
251     if (((UINT32) WalkState->ResultSize + ACPI_RESULTS_FRAME_OBJ_NUM) >
252         ACPI_RESULTS_OBJ_NUM_MAX)
253     {
254         ACPI_ERROR ((AE_INFO, "Result stack overflow: State=%p Num=%u",
255             WalkState, WalkState->ResultSize));
256         return (AE_STACK_OVERFLOW);
257     }
258 
259     State = AcpiUtCreateGenericState ();
260     if (!State)
261     {
262         return (AE_NO_MEMORY);
263     }
264 
265     State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_RESULT;
266     AcpiUtPushGenericState (&WalkState->Results, State);
267 
268     /* Increase the length of the result stack by the length of frame */
269 
270     WalkState->ResultSize += ACPI_RESULTS_FRAME_OBJ_NUM;
271 
272     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Results=%p State=%p\n",
273         State, WalkState));
274 
275     return (AE_OK);
276 }
277 
278 
279 /*******************************************************************************
280  *
281  * FUNCTION:    AcpiDsResultStackPop
282  *
283  * PARAMETERS:  WalkState           - Current Walk state
284  *
285  * RETURN:      Status
286  *
287  * DESCRIPTION: Pop an object off of the WalkState result stack
288  *
289  ******************************************************************************/
290 
291 static ACPI_STATUS
292 AcpiDsResultStackPop (
293     ACPI_WALK_STATE         *WalkState)
294 {
295     ACPI_GENERIC_STATE      *State;
296 
297 
298     ACPI_FUNCTION_NAME (DsResultStackPop);
299 
300 
301     /* Check for stack underflow */
302 
303     if (WalkState->Results == NULL)
304     {
305         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Result stack underflow - State=%p\n",
306             WalkState));
307         return (AE_AML_NO_OPERAND);
308     }
309 
310     if (WalkState->ResultSize < ACPI_RESULTS_FRAME_OBJ_NUM)
311     {
312         ACPI_ERROR ((AE_INFO, "Insufficient result stack size"));
313         return (AE_AML_INTERNAL);
314     }
315 
316     State = AcpiUtPopGenericState (&WalkState->Results);
317     AcpiUtDeleteGenericState (State);
318 
319     /* Decrease the length of result stack by the length of frame */
320 
321     WalkState->ResultSize -= ACPI_RESULTS_FRAME_OBJ_NUM;
322 
323     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
324         "Result=%p RemainingResults=%X State=%p\n",
325         State, WalkState->ResultCount, WalkState));
326 
327     return (AE_OK);
328 }
329 
330 
331 /*******************************************************************************
332  *
333  * FUNCTION:    AcpiDsObjStackPush
334  *
335  * PARAMETERS:  Object              - Object to push
336  *              WalkState           - Current Walk state
337  *
338  * RETURN:      Status
339  *
340  * DESCRIPTION: Push an object onto this walk's object/operand stack
341  *
342  ******************************************************************************/
343 
344 ACPI_STATUS
345 AcpiDsObjStackPush (
346     void                    *Object,
347     ACPI_WALK_STATE         *WalkState)
348 {
349     ACPI_FUNCTION_NAME (DsObjStackPush);
350 
351 
352     /* Check for stack overflow */
353 
354     if (WalkState->NumOperands >= ACPI_OBJ_NUM_OPERANDS)
355     {
356         ACPI_ERROR ((AE_INFO,
357             "Object stack overflow! Obj=%p State=%p #Ops=%u",
358             Object, WalkState, WalkState->NumOperands));
359         return (AE_STACK_OVERFLOW);
360     }
361 
362     /* Put the object onto the stack */
363 
364     WalkState->Operands [WalkState->OperandIndex] = Object;
365     WalkState->NumOperands++;
366 
367     /* For the usual order of filling the operand stack */
368 
369     WalkState->OperandIndex++;
370 
371     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s] State=%p #Ops=%X\n",
372         Object, AcpiUtGetObjectTypeName ((ACPI_OPERAND_OBJECT *) Object),
373         WalkState, WalkState->NumOperands));
374 
375     return (AE_OK);
376 }
377 
378 
379 /*******************************************************************************
380  *
381  * FUNCTION:    AcpiDsObjStackPop
382  *
383  * PARAMETERS:  PopCount            - Number of objects/entries to pop
384  *              WalkState           - Current Walk state
385  *
386  * RETURN:      Status
387  *
388  * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT
389  *              deleted by this routine.
390  *
391  ******************************************************************************/
392 
393 ACPI_STATUS
394 AcpiDsObjStackPop (
395     UINT32                  PopCount,
396     ACPI_WALK_STATE         *WalkState)
397 {
398     UINT32                  i;
399 
400 
401     ACPI_FUNCTION_NAME (DsObjStackPop);
402 
403 
404     for (i = 0; i < PopCount; i++)
405     {
406         /* Check for stack underflow */
407 
408         if (WalkState->NumOperands == 0)
409         {
410             ACPI_ERROR ((AE_INFO,
411                 "Object stack underflow! Count=%X State=%p #Ops=%u",
412                 PopCount, WalkState, WalkState->NumOperands));
413             return (AE_STACK_UNDERFLOW);
414         }
415 
416         /* Just set the stack entry to null */
417 
418         WalkState->NumOperands--;
419         WalkState->Operands [WalkState->NumOperands] = NULL;
420     }
421 
422     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%u\n",
423         PopCount, WalkState, WalkState->NumOperands));
424 
425     return (AE_OK);
426 }
427 
428 
429 /*******************************************************************************
430  *
431  * FUNCTION:    AcpiDsObjStackPopAndDelete
432  *
433  * PARAMETERS:  PopCount            - Number of objects/entries to pop
434  *              WalkState           - Current Walk state
435  *
436  * RETURN:      Status
437  *
438  * DESCRIPTION: Pop this walk's object stack and delete each object that is
439  *              popped off.
440  *
441  ******************************************************************************/
442 
443 void
444 AcpiDsObjStackPopAndDelete (
445     UINT32                  PopCount,
446     ACPI_WALK_STATE         *WalkState)
447 {
448     INT32                   i;
449     ACPI_OPERAND_OBJECT     *ObjDesc;
450 
451 
452     ACPI_FUNCTION_NAME (DsObjStackPopAndDelete);
453 
454 
455     if (PopCount == 0)
456     {
457         return;
458     }
459 
460     for (i = (INT32) PopCount - 1; i >= 0; i--)
461     {
462         if (WalkState->NumOperands == 0)
463         {
464             return;
465         }
466 
467         /* Pop the stack and delete an object if present in this stack entry */
468 
469         WalkState->NumOperands--;
470         ObjDesc = WalkState->Operands [i];
471         if (ObjDesc)
472         {
473             AcpiUtRemoveReference (WalkState->Operands [i]);
474             WalkState->Operands [i] = NULL;
475         }
476     }
477 
478     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%X\n",
479         PopCount, WalkState, WalkState->NumOperands));
480 }
481 
482 
483 /*******************************************************************************
484  *
485  * FUNCTION:    AcpiDsGetCurrentWalkState
486  *
487  * PARAMETERS:  Thread          - Get current active state for this Thread
488  *
489  * RETURN:      Pointer to the current walk state
490  *
491  * DESCRIPTION: Get the walk state that is at the head of the list (the "current"
492  *              walk state.)
493  *
494  ******************************************************************************/
495 
496 ACPI_WALK_STATE *
497 AcpiDsGetCurrentWalkState (
498     ACPI_THREAD_STATE       *Thread)
499 {
500     ACPI_FUNCTION_NAME (DsGetCurrentWalkState);
501 
502 
503     if (!Thread)
504     {
505         return (NULL);
506     }
507 
508     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Current WalkState %p\n",
509         Thread->WalkStateList));
510 
511     return (Thread->WalkStateList);
512 }
513 
514 
515 /*******************************************************************************
516  *
517  * FUNCTION:    AcpiDsPushWalkState
518  *
519  * PARAMETERS:  WalkState       - State to push
520  *              Thread          - Thread state object
521  *
522  * RETURN:      None
523  *
524  * DESCRIPTION: Place the Thread state at the head of the state list
525  *
526  ******************************************************************************/
527 
528 void
529 AcpiDsPushWalkState (
530     ACPI_WALK_STATE         *WalkState,
531     ACPI_THREAD_STATE       *Thread)
532 {
533     ACPI_FUNCTION_TRACE (DsPushWalkState);
534 
535 
536     WalkState->Next = Thread->WalkStateList;
537     Thread->WalkStateList = WalkState;
538 
539     return_VOID;
540 }
541 
542 
543 /*******************************************************************************
544  *
545  * FUNCTION:    AcpiDsPopWalkState
546  *
547  * PARAMETERS:  Thread      - Current thread state
548  *
549  * RETURN:      A WalkState object popped from the thread's stack
550  *
551  * DESCRIPTION: Remove and return the walkstate object that is at the head of
552  *              the walk stack for the given walk list. NULL indicates that
553  *              the list is empty.
554  *
555  ******************************************************************************/
556 
557 ACPI_WALK_STATE *
558 AcpiDsPopWalkState (
559     ACPI_THREAD_STATE       *Thread)
560 {
561     ACPI_WALK_STATE         *WalkState;
562 
563 
564     ACPI_FUNCTION_TRACE (DsPopWalkState);
565 
566 
567     WalkState = Thread->WalkStateList;
568 
569     if (WalkState)
570     {
571         /* Next walk state becomes the current walk state */
572 
573         Thread->WalkStateList = WalkState->Next;
574 
575         /*
576          * Don't clear the NEXT field, this serves as an indicator
577          * that there is a parent WALK STATE
578          * Do Not: WalkState->Next = NULL;
579          */
580     }
581 
582     return_PTR (WalkState);
583 }
584 
585 
586 /*******************************************************************************
587  *
588  * FUNCTION:    AcpiDsCreateWalkState
589  *
590  * PARAMETERS:  OwnerId         - ID for object creation
591  *              Origin          - Starting point for this walk
592  *              MethodDesc      - Method object
593  *              Thread          - Current thread state
594  *
595  * RETURN:      Pointer to the new walk state.
596  *
597  * DESCRIPTION: Allocate and initialize a new walk state. The current walk
598  *              state is set to this new state.
599  *
600  ******************************************************************************/
601 
602 ACPI_WALK_STATE *
603 AcpiDsCreateWalkState (
604     ACPI_OWNER_ID           OwnerId,
605     ACPI_PARSE_OBJECT       *Origin,
606     ACPI_OPERAND_OBJECT     *MethodDesc,
607     ACPI_THREAD_STATE       *Thread)
608 {
609     ACPI_WALK_STATE         *WalkState;
610 
611 
612     ACPI_FUNCTION_TRACE (DsCreateWalkState);
613 
614 
615     WalkState = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_WALK_STATE));
616     if (!WalkState)
617     {
618         return_PTR (NULL);
619     }
620 
621     WalkState->DescriptorType = ACPI_DESC_TYPE_WALK;
622     WalkState->MethodDesc = MethodDesc;
623     WalkState->OwnerId = OwnerId;
624     WalkState->Origin = Origin;
625     WalkState->Thread = Thread;
626 
627     WalkState->ParserState.StartOp = Origin;
628 
629     /* Init the method args/local */
630 
631 #if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
632     AcpiDsMethodDataInit (WalkState);
633 #endif
634 
635     /* Put the new state at the head of the walk list */
636 
637     if (Thread)
638     {
639         AcpiDsPushWalkState (WalkState, Thread);
640     }
641 
642     return_PTR (WalkState);
643 }
644 
645 
646 /*******************************************************************************
647  *
648  * FUNCTION:    AcpiDsInitAmlWalk
649  *
650  * PARAMETERS:  WalkState       - New state to be initialized
651  *              Op              - Current parse op
652  *              MethodNode      - Control method NS node, if any
653  *              AmlStart        - Start of AML
654  *              AmlLength       - Length of AML
655  *              Info            - Method info block (params, etc.)
656  *              PassNumber      - 1, 2, or 3
657  *
658  * RETURN:      Status
659  *
660  * DESCRIPTION: Initialize a walk state for a pass 1 or 2 parse tree walk
661  *
662  ******************************************************************************/
663 
664 ACPI_STATUS
665 AcpiDsInitAmlWalk (
666     ACPI_WALK_STATE         *WalkState,
667     ACPI_PARSE_OBJECT       *Op,
668     ACPI_NAMESPACE_NODE     *MethodNode,
669     UINT8                   *AmlStart,
670     UINT32                  AmlLength,
671     ACPI_EVALUATE_INFO      *Info,
672     UINT8                   PassNumber)
673 {
674     ACPI_STATUS             Status;
675     ACPI_PARSE_STATE        *ParserState = &WalkState->ParserState;
676     ACPI_PARSE_OBJECT       *ExtraOp;
677 
678 
679     ACPI_FUNCTION_TRACE (DsInitAmlWalk);
680 
681 
682     WalkState->ParserState.Aml =
683     WalkState->ParserState.AmlStart = AmlStart;
684     WalkState->ParserState.AmlEnd =
685     WalkState->ParserState.PkgEnd = AmlStart + AmlLength;
686 
687     /* The NextOp of the NextWalk will be the beginning of the method */
688 
689     WalkState->NextOp = NULL;
690     WalkState->PassNumber = PassNumber;
691 
692     if (Info)
693     {
694         WalkState->Params = Info->Parameters;
695         WalkState->CallerReturnDesc = &Info->ReturnObject;
696     }
697 
698     Status = AcpiPsInitScope (&WalkState->ParserState, Op);
699     if (ACPI_FAILURE (Status))
700     {
701         return_ACPI_STATUS (Status);
702     }
703 
704     if (MethodNode)
705     {
706         WalkState->ParserState.StartNode = MethodNode;
707         WalkState->WalkType = ACPI_WALK_METHOD;
708         WalkState->MethodNode = MethodNode;
709         WalkState->MethodDesc = AcpiNsGetAttachedObject (MethodNode);
710 
711         /* Push start scope on scope stack and make it current  */
712 
713         Status = AcpiDsScopeStackPush (MethodNode, ACPI_TYPE_METHOD, WalkState);
714         if (ACPI_FAILURE (Status))
715         {
716             return_ACPI_STATUS (Status);
717         }
718 
719         /* Init the method arguments */
720 
721         Status = AcpiDsMethodDataInitArgs (WalkState->Params,
722                     ACPI_METHOD_NUM_ARGS, WalkState);
723         if (ACPI_FAILURE (Status))
724         {
725             return_ACPI_STATUS (Status);
726         }
727     }
728     else
729     {
730         /*
731          * Setup the current scope.
732          * Find a Named Op that has a namespace node associated with it.
733          * search upwards from this Op. Current scope is the first
734          * Op with a namespace node.
735          */
736         ExtraOp = ParserState->StartOp;
737         while (ExtraOp && !ExtraOp->Common.Node)
738         {
739             ExtraOp = ExtraOp->Common.Parent;
740         }
741 
742         if (!ExtraOp)
743         {
744             ParserState->StartNode = NULL;
745         }
746         else
747         {
748             ParserState->StartNode = ExtraOp->Common.Node;
749         }
750 
751         if (ParserState->StartNode)
752         {
753             /* Push start scope on scope stack and make it current  */
754 
755             Status = AcpiDsScopeStackPush (ParserState->StartNode,
756                             ParserState->StartNode->Type, WalkState);
757             if (ACPI_FAILURE (Status))
758             {
759                 return_ACPI_STATUS (Status);
760             }
761         }
762     }
763 
764     Status = AcpiDsInitCallbacks (WalkState, PassNumber);
765     return_ACPI_STATUS (Status);
766 }
767 
768 
769 /*******************************************************************************
770  *
771  * FUNCTION:    AcpiDsDeleteWalkState
772  *
773  * PARAMETERS:  WalkState       - State to delete
774  *
775  * RETURN:      Status
776  *
777  * DESCRIPTION: Delete a walk state including all internal data structures
778  *
779  ******************************************************************************/
780 
781 void
782 AcpiDsDeleteWalkState (
783     ACPI_WALK_STATE         *WalkState)
784 {
785     ACPI_GENERIC_STATE      *State;
786 
787 
788     ACPI_FUNCTION_TRACE_PTR (DsDeleteWalkState, WalkState);
789 
790 
791     if (!WalkState)
792     {
793         return_VOID;
794     }
795 
796     if (WalkState->DescriptorType != ACPI_DESC_TYPE_WALK)
797     {
798         ACPI_ERROR ((AE_INFO, "%p is not a valid walk state",
799             WalkState));
800         return_VOID;
801     }
802 
803     /* There should not be any open scopes */
804 
805     if (WalkState->ParserState.Scope)
806     {
807         ACPI_ERROR ((AE_INFO, "%p walk still has a scope list",
808             WalkState));
809         AcpiPsCleanupScope (&WalkState->ParserState);
810     }
811 
812     /* Always must free any linked control states */
813 
814     while (WalkState->ControlState)
815     {
816         State = WalkState->ControlState;
817         WalkState->ControlState = State->Common.Next;
818 
819         AcpiUtDeleteGenericState (State);
820     }
821 
822     /* Always must free any linked parse states */
823 
824     while (WalkState->ScopeInfo)
825     {
826         State = WalkState->ScopeInfo;
827         WalkState->ScopeInfo = State->Common.Next;
828 
829         AcpiUtDeleteGenericState (State);
830     }
831 
832     /* Always must free any stacked result states */
833 
834     while (WalkState->Results)
835     {
836         State = WalkState->Results;
837         WalkState->Results = State->Common.Next;
838 
839         AcpiUtDeleteGenericState (State);
840     }
841 
842     ACPI_FREE (WalkState);
843     return_VOID;
844 }
845