ReactOS 0.4.15-dev-7136-g77ab709
psloop.c
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Module Name: psloop - Main AML parse loop
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2022, 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 MERCHANTABILITY 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 * Parse the AML and build an operation tree as most interpreters, (such as
46 * Perl) do. Parsing is done by hand rather than with a YACC generated parser
47 * to tightly constrain stack and dynamic memory usage. Parsing is kept
48 * flexible and the code fairly compact by parsing based on a list of AML
49 * opcode templates in AmlOpInfo[].
50 */
51
52#include "acpi.h"
53#include "accommon.h"
54#include "acinterp.h"
55#include "acparser.h"
56#include "acdispat.h"
57#include "amlcode.h"
58#include "acconvert.h"
59#include "acnamesp.h"
60
61#define _COMPONENT ACPI_PARSER
62 ACPI_MODULE_NAME ("psloop")
63
64
65/* Local prototypes */
66
67static ACPI_STATUS
69 ACPI_WALK_STATE *WalkState,
70 UINT8 *AmlOpStart,
72
73
74/*******************************************************************************
75 *
76 * FUNCTION: AcpiPsGetArguments
77 *
78 * PARAMETERS: WalkState - Current state
79 * AmlOpStart - Op start in AML
80 * Op - Current Op
81 *
82 * RETURN: Status
83 *
84 * DESCRIPTION: Get arguments for passed Op.
85 *
86 ******************************************************************************/
87
88static ACPI_STATUS
90 ACPI_WALK_STATE *WalkState,
91 UINT8 *AmlOpStart,
93{
96
97
98 ACPI_FUNCTION_TRACE_PTR (PsGetArguments, WalkState);
99
100
102 "Get arguments for opcode [%s]\n", Op->Common.AmlOpName));
103
104 switch (Op->Common.AmlOpcode)
105 {
106 case AML_BYTE_OP: /* AML_BYTEDATA_ARG */
107 case AML_WORD_OP: /* AML_WORDDATA_ARG */
108 case AML_DWORD_OP: /* AML_DWORDATA_ARG */
109 case AML_QWORD_OP: /* AML_QWORDATA_ARG */
110 case AML_STRING_OP: /* AML_ASCIICHARLIST_ARG */
111
112 /* Fill in constant or string argument directly */
113
114 AcpiPsGetNextSimpleArg (&(WalkState->ParserState),
115 GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), Op);
116 break;
117
118 case AML_INT_NAMEPATH_OP: /* AML_NAMESTRING_ARG */
119
120 Status = AcpiPsGetNextNamepath (WalkState,
121 &(WalkState->ParserState), Op, ACPI_POSSIBLE_METHOD_CALL);
122 if (ACPI_FAILURE (Status))
123 {
125 }
126
127 WalkState->ArgTypes = 0;
128 break;
129
130 default:
131 /*
132 * Op is not a constant or string, append each argument to the Op
133 */
134 while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) &&
135 !WalkState->ArgCount)
136 {
137 WalkState->Aml = WalkState->ParserState.Aml;
138
139 switch (Op->Common.AmlOpcode)
140 {
141 case AML_METHOD_OP:
142 case AML_BUFFER_OP:
143 case AML_PACKAGE_OP:
145 case AML_WHILE_OP:
146
147 break;
148
149 default:
150
151 ASL_CV_CAPTURE_COMMENTS (WalkState);
152 break;
153 }
154
155 Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
156 GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
157 if (ACPI_FAILURE (Status))
158 {
160 }
161
162 if (Arg)
163 {
164 AcpiPsAppendArg (Op, Arg);
165 }
166
167 INCREMENT_ARG_LIST (WalkState->ArgTypes);
168 }
169
171 "Final argument count: %8.8X pass %u\n",
172 WalkState->ArgCount, WalkState->PassNumber));
173
174 /* Special processing for certain opcodes */
175
176 switch (Op->Common.AmlOpcode)
177 {
178 case AML_METHOD_OP:
179 /*
180 * Skip parsing of control method because we don't have enough
181 * info in the first pass to parse it correctly.
182 *
183 * Save the length and address of the body
184 */
185 Op->Named.Data = WalkState->ParserState.Aml;
186 Op->Named.Length = (UINT32)
187 (WalkState->ParserState.PkgEnd - WalkState->ParserState.Aml);
188
189 /* Skip body of method */
190
191 WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
192 WalkState->ArgCount = 0;
193 break;
194
195 case AML_BUFFER_OP:
196 case AML_PACKAGE_OP:
198
199 if ((Op->Common.Parent) &&
200 (Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
201 (WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
202 {
204 "Setup Package/Buffer: Pass %u, AML Ptr: %p\n",
205 WalkState->PassNumber, AmlOpStart));
206
207 /*
208 * Skip parsing of Buffers and Packages because we don't have
209 * enough info in the first pass to parse them correctly.
210 */
211 Op->Named.Data = AmlOpStart;
212 Op->Named.Length = (UINT32)
213 (WalkState->ParserState.PkgEnd - AmlOpStart);
214
215 /* Skip body */
216
217 WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
218 WalkState->ArgCount = 0;
219 }
220 break;
221
222 case AML_WHILE_OP:
223
224 if (WalkState->ControlState)
225 {
226 WalkState->ControlState->Control.PackageEnd =
227 WalkState->ParserState.PkgEnd;
228 }
229 break;
230
231 default:
232
233 /* No action for all other opcodes */
234
235 break;
236 }
237
238 break;
239 }
240
242}
243
244
245/*******************************************************************************
246 *
247 * FUNCTION: AcpiPsParseLoop
248 *
249 * PARAMETERS: WalkState - Current state
250 *
251 * RETURN: Status
252 *
253 * DESCRIPTION: Parse AML (pointed to by the current parser state) and return
254 * a tree of ops.
255 *
256 ******************************************************************************/
257
260 ACPI_WALK_STATE *WalkState)
261{
263 ACPI_PARSE_OBJECT *Op = NULL; /* current op */
264 ACPI_PARSE_STATE *ParserState;
265 UINT8 *AmlOpStart = NULL;
266 UINT8 OpcodeLength;
267
268
269 ACPI_FUNCTION_TRACE_PTR (PsParseLoop, WalkState);
270
271
272 if (WalkState->DescendingCallback == NULL)
273 {
275 }
276
277 ParserState = &WalkState->ParserState;
278 WalkState->ArgTypes = 0;
279
280#ifndef ACPI_CONSTANT_EVAL_ONLY
281
282 if (WalkState->WalkType & ACPI_WALK_METHOD_RESTART)
283 {
284 /* We are restarting a preempted control method */
285
286 if (AcpiPsHasCompletedScope (ParserState))
287 {
288 /*
289 * We must check if a predicate to an IF or WHILE statement
290 * was just completed
291 */
292 if ((ParserState->Scope->ParseScope.Op) &&
293 ((ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_IF_OP) ||
294 (ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_WHILE_OP)) &&
295 (WalkState->ControlState) &&
296 (WalkState->ControlState->Common.State ==
298 {
299 /*
300 * A predicate was just completed, get the value of the
301 * predicate and branch based on that value
302 */
303 WalkState->Op = NULL;
306 {
308 {
310 "Invoked method did not return a value"));
311 }
312
313 ACPI_EXCEPTION ((AE_INFO, Status, "GetPredicate Failed"));
315 }
316
317 Status = AcpiPsNextParseState (WalkState, Op, Status);
318 }
319
320 AcpiPsPopScope (ParserState, &Op,
321 &WalkState->ArgTypes, &WalkState->ArgCount);
322 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
323 }
324 else if (WalkState->PrevOp)
325 {
326 /* We were in the middle of an op */
327
328 Op = WalkState->PrevOp;
329 WalkState->ArgTypes = WalkState->PrevArgTypes;
330 }
331 }
332#endif
333
334 /* Iterative parsing loop, while there is more AML to process: */
335
336 while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
337 {
338 ASL_CV_CAPTURE_COMMENTS (WalkState);
339
340 AmlOpStart = ParserState->Aml;
341 if (!Op)
342 {
343 Status = AcpiPsCreateOp (WalkState, AmlOpStart, &Op);
344 if (ACPI_FAILURE (Status))
345 {
346 /*
347 * ACPI_PARSE_MODULE_LEVEL means that we are loading a table by
348 * executing it as a control method. However, if we encounter
349 * an error while loading the table, we need to keep trying to
350 * load the table rather than aborting the table load. Set the
351 * status to AE_OK to proceed with the table load.
352 */
353 if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&
355 {
356 Status = AE_OK;
357 }
359 {
360 continue;
361 }
362
364 {
365 Status = AE_OK;
366 }
367
369 {
371 }
372
373 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
374 if (ACPI_FAILURE (Status))
375 {
377 }
378 if (AcpiNsOpensScope (
380 {
381 /*
382 * If the scope/device op fails to parse, skip the body of
383 * the scope op because the parse failure indicates that
384 * the device may not exist.
385 */
386 ACPI_INFO (("Skipping parse of AML opcode: %s (0x%4.4X)",
387 AcpiPsGetOpcodeName (WalkState->Opcode), WalkState->Opcode));
388
389 /*
390 * Determine the opcode length before skipping the opcode.
391 * An opcode can be 1 byte or 2 bytes in length.
392 */
393 OpcodeLength = 1;
394 if ((WalkState->Opcode & 0xFF00) == AML_EXTENDED_OPCODE)
395 {
396 OpcodeLength = 2;
397 }
398 WalkState->ParserState.Aml = WalkState->Aml + OpcodeLength;
399
400 WalkState->ParserState.Aml =
402 WalkState->Aml = WalkState->ParserState.Aml;
403 }
404
405 continue;
406 }
407
408 AcpiExStartTraceOpcode (Op, WalkState);
409 }
410
411 /*
412 * Start ArgCount at zero because we don't know if there are
413 * any args yet
414 */
415 WalkState->ArgCount = 0;
416
417 switch (Op->Common.AmlOpcode)
418 {
419 case AML_BYTE_OP:
420 case AML_WORD_OP:
421 case AML_DWORD_OP:
422 case AML_QWORD_OP:
423
424 break;
425
426 default:
427
428 ASL_CV_CAPTURE_COMMENTS (WalkState);
429 break;
430 }
431
432 /* Are there any arguments that must be processed? */
433
434 if (WalkState->ArgTypes)
435 {
436 /* Get arguments */
437
438 Status = AcpiPsGetArguments (WalkState, AmlOpStart, Op);
439 if (ACPI_FAILURE (Status))
440 {
441 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
442 if (ACPI_FAILURE (Status))
443 {
445 }
446 if ((WalkState->ControlState) &&
447 ((WalkState->ControlState->Control.Opcode == AML_IF_OP) ||
448 (WalkState->ControlState->Control.Opcode == AML_WHILE_OP)))
449 {
450 /*
451 * If the if/while op fails to parse, we will skip parsing
452 * the body of the op.
453 */
454 ParserState->Aml =
455 WalkState->ControlState->Control.AmlPredicateStart + 1;
456 ParserState->Aml =
457 AcpiPsGetNextPackageEnd (ParserState);
458 WalkState->Aml = ParserState->Aml;
459
460 ACPI_ERROR ((AE_INFO, "Skipping While/If block"));
461 if (*WalkState->Aml == AML_ELSE_OP)
462 {
463 ACPI_ERROR ((AE_INFO, "Skipping Else block"));
464 WalkState->ParserState.Aml = WalkState->Aml + 1;
465 WalkState->ParserState.Aml =
466 AcpiPsGetNextPackageEnd (ParserState);
467 WalkState->Aml = ParserState->Aml;
468 }
470 }
471 Op = NULL;
472 continue;
473 }
474 }
475
476 /* Check for arguments that need to be processed */
477
479 "Parseloop: argument count: %8.8X\n", WalkState->ArgCount));
480
481 if (WalkState->ArgCount)
482 {
483 /*
484 * There are arguments (complex ones), push Op and
485 * prepare for argument
486 */
487 Status = AcpiPsPushScope (ParserState, Op,
488 WalkState->ArgTypes, WalkState->ArgCount);
489 if (ACPI_FAILURE (Status))
490 {
491 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
492 if (ACPI_FAILURE (Status))
493 {
495 }
496
497 continue;
498 }
499
500 Op = NULL;
501 continue;
502 }
503
504 /*
505 * All arguments have been processed -- Op is complete,
506 * prepare for next
507 */
508 WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
509 if (WalkState->OpInfo->Flags & AML_NAMED)
510 {
511 if (Op->Common.AmlOpcode == AML_REGION_OP ||
512 Op->Common.AmlOpcode == AML_DATA_REGION_OP)
513 {
514 /*
515 * Skip parsing of control method or opregion body,
516 * because we don't have enough info in the first pass
517 * to parse them correctly.
518 *
519 * Completed parsing an OpRegion declaration, we now
520 * know the length.
521 */
522 Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
523 }
524 }
525
526 if (WalkState->OpInfo->Flags & AML_CREATE)
527 {
528 /*
529 * Backup to beginning of CreateXXXfield declaration (1 for
530 * Opcode)
531 *
532 * BodyLength is unknown until we parse the body
533 */
534 Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
535 }
536
537 if (Op->Common.AmlOpcode == AML_BANK_FIELD_OP)
538 {
539 /*
540 * Backup to beginning of BankField declaration
541 *
542 * BodyLength is unknown until we parse the body
543 */
544 Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
545 }
546
547 /* This op complete, notify the dispatcher */
548
549 if (WalkState->AscendingCallback != NULL)
550 {
551 WalkState->Op = Op;
552 WalkState->Opcode = Op->Common.AmlOpcode;
553
554 Status = WalkState->AscendingCallback (WalkState);
555 Status = AcpiPsNextParseState (WalkState, Op, Status);
556 if (Status == AE_CTRL_PENDING)
557 {
558 Status = AE_OK;
559 }
560 else if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&
563 {
564 /*
565 * ACPI_PARSE_MODULE_LEVEL flag means that we are currently
566 * loading a table by executing it as a control method.
567 * However, if we encounter an error while loading the table,
568 * we need to keep trying to load the table rather than
569 * aborting the table load (setting the status to AE_OK
570 * continues the table load). If we get a failure at this
571 * point, it means that the dispatcher got an error while
572 * trying to execute the Op.
573 */
574 Status = AE_OK;
575 }
576 }
577
578 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
579 if (ACPI_FAILURE (Status))
580 {
582 }
583
584 } /* while ParserState->Aml */
585
586 Status = AcpiPsCompleteFinalOp (WalkState, Op, Status);
588}
unsigned char UINT8
unsigned int UINT32
#define ACPI_AML_EXCEPTION(Status)
Definition: acexcep.h:100
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
#define AE_ALREADY_EXISTS
Definition: acexcep.h:115
#define AE_CTRL_PENDING
Definition: acexcep.h:225
#define AE_NOT_FOUND
Definition: acexcep.h:113
#define AE_CTRL_TERMINATE
Definition: acexcep.h:226
#define AE_CTRL_PARSE_PENDING
Definition: acexcep.h:235
#define ACPI_CNTL_EXCEPTION(Status)
Definition: acexcep.h:103
#define AE_CTRL_PARSE_CONTINUE
Definition: acexcep.h:234
#define AE_AML_NO_RETURN_VALUE
Definition: acexcep.h:197
#define AE_OK
Definition: acexcep.h:97
@ ACPI_IMODE_LOAD_PASS2
Definition: aclocal.h:168
#define ACPI_CONTROL_PREDICATE_EXECUTING
Definition: aclocal.h:671
#define ASL_CV_CAPTURE_COMMENTS(a)
Definition: acmacros.h:526
#define GET_CURRENT_ARG_TYPE(List)
Definition: acmacros.h:450
#define INCREMENT_ARG_LIST(List)
Definition: acmacros.h:451
UINT32 AcpiNsOpensScope(ACPI_OBJECT_TYPE Type)
Definition: nsutils.c:736
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:239
#define ACPI_DB_PARSE
Definition: acoutput.h:162
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
#define ACPI_FUNCTION_TRACE_PTR(a, b)
Definition: acoutput.h:481
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
#define AE_INFO
Definition: acoutput.h:230
#define ACPI_INFO(plist)
Definition: acoutput.h:237
void AcpiPsGetNextSimpleArg(ACPI_PARSE_STATE *ParserState, UINT32 ArgType, ACPI_PARSE_OBJECT *Arg)
Definition: psargs.c:428
const char * AcpiPsGetOpcodeName(UINT16 Opcode)
Definition: psopinfo.c:169
ACPI_STATUS AcpiPsCompleteOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **Op, ACPI_STATUS Status)
Definition: psobject.c:495
ACPI_STATUS AcpiPsCreateOp(ACPI_WALK_STATE *WalkState, UINT8 *AmlOpStart, ACPI_PARSE_OBJECT **NewOp)
Definition: psobject.c:344
#define ACPI_POSSIBLE_METHOD_CALL
Definition: acparser.h:118
ACPI_STATUS AcpiPsGetNextArg(ACPI_WALK_STATE *WalkState, ACPI_PARSE_STATE *ParserState, UINT32 ArgType, ACPI_PARSE_OBJECT **ReturnArg)
Definition: psargs.c:785
ACPI_STATUS AcpiPsNextParseState(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_STATUS CallbackStatus)
Definition: psparse.c:337
ACPI_STATUS AcpiPsPushScope(ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Op, UINT32 RemainingArgs, UINT32 ArgCount)
Definition: psscope.c:157
void AcpiPsPopScope(ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT **Op, UINT32 *ArgList, UINT32 *ArgCount)
Definition: psscope.c:219
ACPI_STATUS AcpiPsGetNextNamepath(ACPI_WALK_STATE *WalkState, ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Arg, BOOLEAN PossibleMethodCall)
Definition: psargs.c:254
void AcpiPsAppendArg(ACPI_PARSE_OBJECT *op, ACPI_PARSE_OBJECT *arg)
Definition: pstree.c:138
#define ACPI_PARSE_MODULE_LEVEL
Definition: acparser.h:67
const ACPI_OPCODE_INFO * AcpiPsGetOpcodeInfo(UINT16 Opcode)
Definition: psopinfo.c:72
BOOLEAN AcpiPsHasCompletedScope(ACPI_PARSE_STATE *ParserState)
Definition: psscope.c:88
UINT8 * AcpiPsGetNextPackageEnd(ACPI_PARSE_STATE *ParserState)
Definition: psargs.c:138
ACPI_STATUS AcpiPsCompleteFinalOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_STATUS Status)
Definition: psobject.c:705
#define ACPI_WALK_METHOD_RESTART
Definition: acstruct.h:70
#define ACPI_FREE(a)
Definition: actypes.h:386
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_TO_POINTER(i)
Definition: actypes.h:552
ACPI_GENERIC_STATE * AcpiUtPopGenericState(ACPI_GENERIC_STATE **ListHead)
Definition: utstate.c:93
#define AML_VARIABLE_PACKAGE_OP
Definition: amlcode.h:63
#define AML_REGION_OP
Definition: amlcode.h:180
#define AML_DWORD_OP
Definition: amlcode.h:57
#define AML_BYTE_OP
Definition: amlcode.h:55
#define AML_BANK_FIELD_OP
Definition: amlcode.h:187
#define AML_NAME_OP
Definition: amlcode.h:54
#define AML_STRING_OP
Definition: amlcode.h:58
#define AML_DATA_REGION_OP
Definition: amlcode.h:188
#define AML_EXTENDED_OPCODE
Definition: amlcode.h:156
#define AML_BUFFER_OP
Definition: amlcode.h:61
#define AML_METHOD_OP
Definition: amlcode.h:64
#define AML_CREATE
Definition: amlcode.h:320
#define AML_WORD_OP
Definition: amlcode.h:56
#define AML_IF_OP
Definition: amlcode.h:134
#define AML_PACKAGE_OP
Definition: amlcode.h:62
#define AML_ELSE_OP
Definition: amlcode.h:135
#define AML_QWORD_OP
Definition: amlcode.h:59
#define AML_INT_NAMEPATH_OP
Definition: amlcode.h:205
#define AML_NAMED
Definition: amlcode.h:323
#define AML_WHILE_OP
Definition: amlcode.h:136
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
ACPI_STATUS AcpiDsGetPredicateValue(ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT *ResultObj)
Definition: dswexec.c:94
void AcpiExStartTraceOpcode(ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState)
Definition: extrace.c:353
Status
Definition: gdiplustypes.h:25
static ACPI_STATUS AcpiPsGetArguments(ACPI_WALK_STATE *WalkState, UINT8 *AmlOpStart, ACPI_PARSE_OBJECT *Op)
Definition: psloop.c:89
ACPI_STATUS AcpiPsParseLoop(ACPI_WALK_STATE *WalkState)
Definition: psloop.c:259
UINT8 * AmlPredicateStart
Definition: aclocal.h:727
ACPI_STATE_COMMON UINT16 Opcode
Definition: aclocal.h:725
UINT16 Flags
Definition: aclocal.h:873
UINT8 ObjectType
Definition: aclocal.h:874
union acpi_generic_state * Scope
Definition: aclocal.h:1108
UINT8 * AmlEnd
Definition: aclocal.h:1103
union acpi_parse_object * Op
Definition: aclocal.h:749
UINT8 * Aml
Definition: acstruct.h:91
UINT32 ArgTypes
Definition: acstruct.h:92
ACPI_PARSE_OBJECT * Op
Definition: acstruct.h:118
UINT32 PrevArgTypes
Definition: acstruct.h:98
UINT32 ArgCount
Definition: acstruct.h:99
ACPI_PARSE_DOWNWARDS DescendingCallback
Definition: acstruct.h:128
UINT32 ParseFlags
Definition: acstruct.h:95
ACPI_PARSE_OBJECT * PrevOp
Definition: acstruct.h:125
UINT16 Opcode
Definition: acstruct.h:78
const ACPI_OPCODE_INFO * OpInfo
Definition: acstruct.h:119
ACPI_GENERIC_STATE * ControlState
Definition: acstruct.h:110
ACPI_PARSE_UPWARDS AscendingCallback
Definition: acstruct.h:129
ACPI_PARSE_STATE ParserState
Definition: acstruct.h:97
UINT8 WalkType
Definition: acstruct.h:77
ACPI_COMMON_STATE Common
Definition: aclocal.h:822
ACPI_PSCOPE_STATE ParseScope
Definition: aclocal.h:826
ACPI_CONTROL_STATE Control
Definition: aclocal.h:823
ACPI_PARSE_OBJ_NAMED Named
Definition: aclocal.h:1079
ACPI_PARSE_OBJ_COMMON Common
Definition: aclocal.h:1078