1 /******************************************************************************
2 *
3 * Module Name: psscope - Parser scope stack management routines
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2016, 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 #include "acpi.h"
45 #include "accommon.h"
46 #include "acparser.h"
47
48 #define _COMPONENT ACPI_PARSER
49 ACPI_MODULE_NAME ("psscope")
50
51
52 /*******************************************************************************
53 *
54 * FUNCTION: AcpiPsGetParentScope
55 *
56 * PARAMETERS: ParserState - Current parser state object
57 *
58 * RETURN: Pointer to an Op object
59 *
60 * DESCRIPTION: Get parent of current op being parsed
61 *
62 ******************************************************************************/
63
64 ACPI_PARSE_OBJECT *
AcpiPsGetParentScope(ACPI_PARSE_STATE * ParserState)65 AcpiPsGetParentScope (
66 ACPI_PARSE_STATE *ParserState)
67 {
68
69 return (ParserState->Scope->ParseScope.Op);
70 }
71
72
73 /*******************************************************************************
74 *
75 * FUNCTION: AcpiPsHasCompletedScope
76 *
77 * PARAMETERS: ParserState - Current parser state object
78 *
79 * RETURN: Boolean, TRUE = scope completed.
80 *
81 * DESCRIPTION: Is parsing of current argument complete? Determined by
82 * 1) AML pointer is at or beyond the end of the scope
83 * 2) The scope argument count has reached zero.
84 *
85 ******************************************************************************/
86
87 BOOLEAN
AcpiPsHasCompletedScope(ACPI_PARSE_STATE * ParserState)88 AcpiPsHasCompletedScope (
89 ACPI_PARSE_STATE *ParserState)
90 {
91
92 return ((BOOLEAN)
93 ((ParserState->Aml >= ParserState->Scope->ParseScope.ArgEnd ||
94 !ParserState->Scope->ParseScope.ArgCount)));
95 }
96
97
98 /*******************************************************************************
99 *
100 * FUNCTION: AcpiPsInitScope
101 *
102 * PARAMETERS: ParserState - Current parser state object
103 * Root - the Root Node of this new scope
104 *
105 * RETURN: Status
106 *
107 * DESCRIPTION: Allocate and init a new scope object
108 *
109 ******************************************************************************/
110
111 ACPI_STATUS
AcpiPsInitScope(ACPI_PARSE_STATE * ParserState,ACPI_PARSE_OBJECT * RootOp)112 AcpiPsInitScope (
113 ACPI_PARSE_STATE *ParserState,
114 ACPI_PARSE_OBJECT *RootOp)
115 {
116 ACPI_GENERIC_STATE *Scope;
117
118
119 ACPI_FUNCTION_TRACE_PTR (PsInitScope, RootOp);
120
121
122 Scope = AcpiUtCreateGenericState ();
123 if (!Scope)
124 {
125 return_ACPI_STATUS (AE_NO_MEMORY);
126 }
127
128 Scope->Common.DescriptorType = ACPI_DESC_TYPE_STATE_RPSCOPE;
129 Scope->ParseScope.Op = RootOp;
130 Scope->ParseScope.ArgCount = ACPI_VAR_ARGS;
131 Scope->ParseScope.ArgEnd = ParserState->AmlEnd;
132 Scope->ParseScope.PkgEnd = ParserState->AmlEnd;
133
134 ParserState->Scope = Scope;
135 ParserState->StartOp = RootOp;
136
137 return_ACPI_STATUS (AE_OK);
138 }
139
140
141 /*******************************************************************************
142 *
143 * FUNCTION: AcpiPsPushScope
144 *
145 * PARAMETERS: ParserState - Current parser state object
146 * Op - Current op to be pushed
147 * RemainingArgs - List of args remaining
148 * ArgCount - Fixed or variable number of args
149 *
150 * RETURN: Status
151 *
152 * DESCRIPTION: Push current op to begin parsing its argument
153 *
154 ******************************************************************************/
155
156 ACPI_STATUS
AcpiPsPushScope(ACPI_PARSE_STATE * ParserState,ACPI_PARSE_OBJECT * Op,UINT32 RemainingArgs,UINT32 ArgCount)157 AcpiPsPushScope (
158 ACPI_PARSE_STATE *ParserState,
159 ACPI_PARSE_OBJECT *Op,
160 UINT32 RemainingArgs,
161 UINT32 ArgCount)
162 {
163 ACPI_GENERIC_STATE *Scope;
164
165
166 ACPI_FUNCTION_TRACE_PTR (PsPushScope, Op);
167
168
169 Scope = AcpiUtCreateGenericState ();
170 if (!Scope)
171 {
172 return_ACPI_STATUS (AE_NO_MEMORY);
173 }
174
175 Scope->Common.DescriptorType = ACPI_DESC_TYPE_STATE_PSCOPE;
176 Scope->ParseScope.Op = Op;
177 Scope->ParseScope.ArgList = RemainingArgs;
178 Scope->ParseScope.ArgCount = ArgCount;
179 Scope->ParseScope.PkgEnd = ParserState->PkgEnd;
180
181 /* Push onto scope stack */
182
183 AcpiUtPushGenericState (&ParserState->Scope, Scope);
184
185 if (ArgCount == ACPI_VAR_ARGS)
186 {
187 /* Multiple arguments */
188
189 Scope->ParseScope.ArgEnd = ParserState->PkgEnd;
190 }
191 else
192 {
193 /* Single argument */
194
195 Scope->ParseScope.ArgEnd = ACPI_TO_POINTER (ACPI_MAX_PTR);
196 }
197
198 return_ACPI_STATUS (AE_OK);
199 }
200
201
202 /*******************************************************************************
203 *
204 * FUNCTION: AcpiPsPopScope
205 *
206 * PARAMETERS: ParserState - Current parser state object
207 * Op - Where the popped op is returned
208 * ArgList - Where the popped "next argument" is
209 * returned
210 * ArgCount - Count of objects in ArgList
211 *
212 * RETURN: Status
213 *
214 * DESCRIPTION: Return to parsing a previous op
215 *
216 ******************************************************************************/
217
218 void
AcpiPsPopScope(ACPI_PARSE_STATE * ParserState,ACPI_PARSE_OBJECT ** Op,UINT32 * ArgList,UINT32 * ArgCount)219 AcpiPsPopScope (
220 ACPI_PARSE_STATE *ParserState,
221 ACPI_PARSE_OBJECT **Op,
222 UINT32 *ArgList,
223 UINT32 *ArgCount)
224 {
225 ACPI_GENERIC_STATE *Scope = ParserState->Scope;
226
227
228 ACPI_FUNCTION_TRACE (PsPopScope);
229
230
231 /* Only pop the scope if there is in fact a next scope */
232
233 if (Scope->Common.Next)
234 {
235 Scope = AcpiUtPopGenericState (&ParserState->Scope);
236
237 /* Return to parsing previous op */
238
239 *Op = Scope->ParseScope.Op;
240 *ArgList = Scope->ParseScope.ArgList;
241 *ArgCount = Scope->ParseScope.ArgCount;
242 ParserState->PkgEnd = Scope->ParseScope.PkgEnd;
243
244 /* All done with this scope state structure */
245
246 AcpiUtDeleteGenericState (Scope);
247 }
248 else
249 {
250 /* Empty parse stack, prepare to fetch next opcode */
251
252 *Op = NULL;
253 *ArgList = 0;
254 *ArgCount = 0;
255 }
256
257 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
258 "Popped Op %p Args %X\n", *Op, *ArgCount));
259 return_VOID;
260 }
261
262
263 /*******************************************************************************
264 *
265 * FUNCTION: AcpiPsCleanupScope
266 *
267 * PARAMETERS: ParserState - Current parser state object
268 *
269 * RETURN: None
270 *
271 * DESCRIPTION: Destroy available list, remaining stack levels, and return
272 * root scope
273 *
274 ******************************************************************************/
275
276 void
AcpiPsCleanupScope(ACPI_PARSE_STATE * ParserState)277 AcpiPsCleanupScope (
278 ACPI_PARSE_STATE *ParserState)
279 {
280 ACPI_GENERIC_STATE *Scope;
281
282
283 ACPI_FUNCTION_TRACE_PTR (PsCleanupScope, ParserState);
284
285
286 if (!ParserState)
287 {
288 return_VOID;
289 }
290
291 /* Delete anything on the scope stack */
292
293 while (ParserState->Scope)
294 {
295 Scope = AcpiUtPopGenericState (&ParserState->Scope);
296 AcpiUtDeleteGenericState (Scope);
297 }
298
299 return_VOID;
300 }
301