1 /******************************************************************************
2 *
3 * Module Name: pstree - Parser op tree manipulation/traversal/search
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 __PSTREE_C__
46
47 #include "acpi.h"
48 #include "accommon.h"
49 #include "acparser.h"
50 #include "amlcode.h"
51
52 #define _COMPONENT ACPI_PARSER
53 ACPI_MODULE_NAME ("pstree")
54
55 /* Local prototypes */
56
57 #ifdef ACPI_OBSOLETE_FUNCTIONS
58 ACPI_PARSE_OBJECT *
59 AcpiPsGetChild (
60 ACPI_PARSE_OBJECT *op);
61 #endif
62
63
64 /*******************************************************************************
65 *
66 * FUNCTION: AcpiPsGetArg
67 *
68 * PARAMETERS: Op - Get an argument for this op
69 * Argn - Nth argument to get
70 *
71 * RETURN: The argument (as an Op object). NULL if argument does not exist
72 *
73 * DESCRIPTION: Get the specified op's argument.
74 *
75 ******************************************************************************/
76
77 ACPI_PARSE_OBJECT *
78 AcpiPsGetArg (
79 ACPI_PARSE_OBJECT *Op,
80 UINT32 Argn)
81 {
82 ACPI_PARSE_OBJECT *Arg = NULL;
83 const ACPI_OPCODE_INFO *OpInfo;
84
85
86 ACPI_FUNCTION_ENTRY ();
87
88 /*
89 if (Op->Common.AmlOpcode == AML_INT_CONNECTION_OP)
90 {
91 return (Op->Common.Value.Arg);
92 }
93 */
94 /* Get the info structure for this opcode */
95
96 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
97 if (OpInfo->Class == AML_CLASS_UNKNOWN)
98 {
99 /* Invalid opcode or ASCII character */
100
101 return (NULL);
102 }
103
104 /* Check if this opcode requires argument sub-objects */
105
106 if (!(OpInfo->Flags & AML_HAS_ARGS))
107 {
108 /* Has no linked argument objects */
109
110 return (NULL);
111 }
112
113 /* Get the requested argument object */
114
115 Arg = Op->Common.Value.Arg;
116 while (Arg && Argn)
117 {
118 Argn--;
119 Arg = Arg->Common.Next;
120 }
121
122 return (Arg);
123 }
124
125
126 /*******************************************************************************
127 *
128 * FUNCTION: AcpiPsAppendArg
129 *
130 * PARAMETERS: Op - Append an argument to this Op.
131 * Arg - Argument Op to append
132 *
133 * RETURN: None.
134 *
135 * DESCRIPTION: Append an argument to an op's argument list (a NULL arg is OK)
136 *
137 ******************************************************************************/
138
139 void
140 AcpiPsAppendArg (
141 ACPI_PARSE_OBJECT *Op,
142 ACPI_PARSE_OBJECT *Arg)
143 {
144 ACPI_PARSE_OBJECT *PrevArg;
145 const ACPI_OPCODE_INFO *OpInfo;
146
147
148 ACPI_FUNCTION_ENTRY ();
149
150
151 if (!Op)
152 {
153 return;
154 }
155
156 /* Get the info structure for this opcode */
157
158 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
159 if (OpInfo->Class == AML_CLASS_UNKNOWN)
160 {
161 /* Invalid opcode */
162
163 ACPI_ERROR ((AE_INFO, "Invalid AML Opcode: 0x%2.2X",
164 Op->Common.AmlOpcode));
165 return;
166 }
167
168 /* Check if this opcode requires argument sub-objects */
169
170 if (!(OpInfo->Flags & AML_HAS_ARGS))
171 {
172 /* Has no linked argument objects */
173
174 return;
175 }
176
177 /* Append the argument to the linked argument list */
178
179 if (Op->Common.Value.Arg)
180 {
181 /* Append to existing argument list */
182
183 PrevArg = Op->Common.Value.Arg;
184 while (PrevArg->Common.Next)
185 {
186 PrevArg = PrevArg->Common.Next;
187 }
188 PrevArg->Common.Next = Arg;
189 }
190 else
191 {
192 /* No argument list, this will be the first argument */
193
194 Op->Common.Value.Arg = Arg;
195 }
196
197 /* Set the parent in this arg and any args linked after it */
198
199 while (Arg)
200 {
201 Arg->Common.Parent = Op;
202 Arg = Arg->Common.Next;
203
204 Op->Common.ArgListLength++;
205 }
206 }
207
208
209 /*******************************************************************************
210 *
211 * FUNCTION: AcpiPsGetDepthNext
212 *
213 * PARAMETERS: Origin - Root of subtree to search
214 * Op - Last (previous) Op that was found
215 *
216 * RETURN: Next Op found in the search.
217 *
218 * DESCRIPTION: Get next op in tree (walking the tree in depth-first order)
219 * Return NULL when reaching "origin" or when walking up from root
220 *
221 ******************************************************************************/
222
223 ACPI_PARSE_OBJECT *
224 AcpiPsGetDepthNext (
225 ACPI_PARSE_OBJECT *Origin,
226 ACPI_PARSE_OBJECT *Op)
227 {
228 ACPI_PARSE_OBJECT *Next = NULL;
229 ACPI_PARSE_OBJECT *Parent;
230 ACPI_PARSE_OBJECT *Arg;
231
232
233 ACPI_FUNCTION_ENTRY ();
234
235
236 if (!Op)
237 {
238 return (NULL);
239 }
240
241 /* Look for an argument or child */
242
243 Next = AcpiPsGetArg (Op, 0);
244 if (Next)
245 {
246 return (Next);
247 }
248
249 /* Look for a sibling */
250
251 Next = Op->Common.Next;
252 if (Next)
253 {
254 return (Next);
255 }
256
257 /* Look for a sibling of parent */
258
259 Parent = Op->Common.Parent;
260
261 while (Parent)
262 {
263 Arg = AcpiPsGetArg (Parent, 0);
264 while (Arg && (Arg != Origin) && (Arg != Op))
265 {
266 Arg = Arg->Common.Next;
267 }
268
269 if (Arg == Origin)
270 {
271 /* Reached parent of origin, end search */
272
273 return (NULL);
274 }
275
276 if (Parent->Common.Next)
277 {
278 /* Found sibling of parent */
279
280 return (Parent->Common.Next);
281 }
282
283 Op = Parent;
284 Parent = Parent->Common.Parent;
285 }
286
287 return (Next);
288 }
289
290
291 #ifdef ACPI_OBSOLETE_FUNCTIONS
292 /*******************************************************************************
293 *
294 * FUNCTION: AcpiPsGetChild
295 *
296 * PARAMETERS: Op - Get the child of this Op
297 *
298 * RETURN: Child Op, Null if none is found.
299 *
300 * DESCRIPTION: Get op's children or NULL if none
301 *
302 ******************************************************************************/
303
304 ACPI_PARSE_OBJECT *
305 AcpiPsGetChild (
306 ACPI_PARSE_OBJECT *Op)
307 {
308 ACPI_PARSE_OBJECT *Child = NULL;
309
310
311 ACPI_FUNCTION_ENTRY ();
312
313
314 switch (Op->Common.AmlOpcode)
315 {
316 case AML_SCOPE_OP:
317 case AML_ELSE_OP:
318 case AML_DEVICE_OP:
319 case AML_THERMAL_ZONE_OP:
320 case AML_INT_METHODCALL_OP:
321
322 Child = AcpiPsGetArg (Op, 0);
323 break;
324
325 case AML_BUFFER_OP:
326 case AML_PACKAGE_OP:
327 case AML_METHOD_OP:
328 case AML_IF_OP:
329 case AML_WHILE_OP:
330 case AML_FIELD_OP:
331
332 Child = AcpiPsGetArg (Op, 1);
333 break;
334
335 case AML_POWER_RES_OP:
336 case AML_INDEX_FIELD_OP:
337
338 Child = AcpiPsGetArg (Op, 2);
339 break;
340
341 case AML_PROCESSOR_OP:
342 case AML_BANK_FIELD_OP:
343
344 Child = AcpiPsGetArg (Op, 3);
345 break;
346
347 default:
348
349 /* All others have no children */
350
351 break;
352 }
353
354 return (Child);
355 }
356 #endif