aslrules.y revision 306536 
1NoEcho('
2/******************************************************************************
3 *
4 * Module Name: aslrules.y - Main Bison/Yacc production rules
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2016, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions, and the following disclaimer,
17 *    without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 *    substantially similar to the "NO WARRANTY" disclaimer below
20 *    ("Disclaimer") and any redistribution must be conditioned upon
21 *    including a substantially similar Disclaimer requirement for further
22 *    binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 *    of any contributors may be used to endorse or promote products derived
25 *    from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45')
46
47/*******************************************************************************
48 *
49 * ASL Root and Secondary Terms
50 *
51 ******************************************************************************/
52
53/*
54 * Root term. Allow multiple #line directives before the definition block
55 * to handle output from preprocessors
56 */
57AslCode
58    : DefinitionBlockList           {$<n>$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_ASL_CODE),1, $1);}
59    | error                         {YYABORT; $$ = NULL;}
60    ;
61
62
63/*
64 * Note concerning support for "module-level code".
65 *
66 * ACPI 1.0 allowed Type1 and Type2 executable opcodes outside of control
67 * methods (the so-called module-level code.) This support was explicitly
68 * removed in ACPI 2.0, but this type of code continues to be created by
69 * BIOS vendors. In order to support the disassembly and recompilation of
70 * such code (and the porting of ASL code to iASL), iASL supports this
71 * code in violation of the current ACPI specification.
72 *
73 * The grammar change to support module-level code is to revert the
74 * {ObjectList} portion of the DefinitionBlockTerm in ACPI 2.0 to the
75 * original use of {TermList} instead (see below.) This allows the use
76 * of Type1 and Type2 opcodes at module level.
77 *
78 * 04/2016: The module-level code is now allowed in the following terms:
79 * DeviceTerm, PowerResTerm, ProcessorTerm, ScopeTerm, ThermalZoneTerm.
80 * The ObjectList term is obsolete and has been removed.
81 */
82DefinitionBlockTerm
83    : PARSEOP_DEFINITION_BLOCK '('  {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITION_BLOCK);}
84        String ','
85        String ','
86        ByteConst ','
87        String ','
88        String ','
89        DWordConst
90        ')'                         {TrSetEndLineNumber ($<n>3);}
91            '{' TermList '}'        {$$ = TrLinkChildren ($<n>3,7,$4,$6,$8,$10,$12,$14,$18);}
92    ;
93
94DefinitionBlockList
95    : DefinitionBlockTerm
96    | DefinitionBlockTerm
97        DefinitionBlockList         {$$ = TrLinkPeerNodes (2, $1,$2);}
98    ;
99
100SuperName
101    : NameString                    {}
102    | ArgTerm                       {}
103    | LocalTerm                     {}
104    | DebugTerm                     {}
105    | Type6Opcode                   {}
106
107Target
108    :                               {$$ = TrCreateNullTarget ();} /* Placeholder is a ZeroOp object */
109    | ','                           {$$ = TrCreateNullTarget ();} /* Placeholder is a ZeroOp object */
110    | ',' SuperName                 {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
111    ;
112
113TermArg
114    : Type2Opcode                   {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
115    | DataObject                    {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
116    | NameString                    {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
117    | ArgTerm                       {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
118    | LocalTerm                     {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
119    ;
120
121/*
122 NOTE: Removed from TermArg due to reduce/reduce conflicts:
123    | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
124    | Type2StringOpcode             {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
125    | Type2BufferOpcode             {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
126    | Type2BufferOrStringOpcode     {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
127
128*/
129
130MethodInvocationTerm
131    : NameString '('                {TrUpdateNode (PARSEOP_METHODCALL, $1);}
132        ArgList ')'                 {$$ = TrLinkChildNode ($1,$4);}
133    ;
134
135/* OptionalCount must appear before ByteList or an incorrect reduction will result */
136
137OptionalCount
138    :                               {$$ = TrCreateLeafNode (PARSEOP_ONES);}       /* Placeholder is a OnesOp object */
139    | ','                           {$$ = TrCreateLeafNode (PARSEOP_ONES);}       /* Placeholder is a OnesOp object */
140    | ',' TermArg                   {$$ = $2;}
141    ;
142
143VarPackageLengthTerm
144    :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
145    | TermArg                       {$$ = $1;}
146    ;
147
148
149/******* List Terms **************************************************/
150
151ArgList
152    :                               {$$ = NULL;}
153    | TermArg
154    | ArgList ','                   /* Allows a trailing comma at list end */
155    | ArgList ','
156        TermArg                     {$$ = TrLinkPeerNode ($1,$3);}
157    ;
158
159ByteList
160    :                               {$$ = NULL;}
161    | ByteConstExpr
162    | ByteList ','                  /* Allows a trailing comma at list end */
163    | ByteList ','
164        ByteConstExpr               {$$ = TrLinkPeerNode ($1,$3);}
165    ;
166
167DWordList
168    :                               {$$ = NULL;}
169    | DWordConstExpr
170    | DWordList ','                 /* Allows a trailing comma at list end */
171    | DWordList ','
172        DWordConstExpr              {$$ = TrLinkPeerNode ($1,$3);}
173    ;
174
175FieldUnitList
176    :                               {$$ = NULL;}
177    | FieldUnit
178    | FieldUnitList ','             /* Allows a trailing comma at list end */
179    | FieldUnitList ','
180        FieldUnit                   {$$ = TrLinkPeerNode ($1,$3);}
181    ;
182
183FieldUnit
184    : FieldUnitEntry                {}
185    | OffsetTerm                    {}
186    | AccessAsTerm                  {}
187    | ConnectionTerm                {}
188    ;
189
190FieldUnitEntry
191    : ',' AmlPackageLengthTerm      {$$ = TrCreateNode (PARSEOP_RESERVED_BYTES,1,$2);}
192    | NameSeg ','
193        AmlPackageLengthTerm        {$$ = TrLinkChildNode ($1,$3);}
194    ;
195
196Object
197    : CompilerDirective             {}
198    | NamedObject                   {}
199    | NameSpaceModifier             {}
200    ;
201
202PackageList
203    :                               {$$ = NULL;}
204    | PackageElement
205    | PackageList ','               /* Allows a trailing comma at list end */
206    | PackageList ','
207        PackageElement              {$$ = TrLinkPeerNode ($1,$3);}
208    ;
209
210PackageElement
211    : DataObject                    {}
212    | NameString                    {}
213    ;
214
215    /* Rules for specifying the type of one method argument or return value */
216
217ParameterTypePackage
218    :                               {$$ = NULL;}
219    | ObjectTypeKeyword             {$$ = $1;}
220    | ParameterTypePackage ','
221        ObjectTypeKeyword           {$$ = TrLinkPeerNodes (2,$1,$3);}
222    ;
223
224ParameterTypePackageList
225    :                               {$$ = NULL;}
226    | ObjectTypeKeyword             {$$ = $1;}
227    | '{' ParameterTypePackage '}'  {$$ = $2;}
228    ;
229
230OptionalParameterTypePackage
231    :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
232    | ',' ParameterTypePackageList  {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
233    ;
234
235    /* Rules for specifying the types for method arguments */
236
237ParameterTypesPackage
238    : ParameterTypePackageList      {$$ = $1;}
239    | ParameterTypesPackage ','
240        ParameterTypePackageList    {$$ = TrLinkPeerNodes (2,$1,$3);}
241    ;
242
243ParameterTypesPackageList
244    :                               {$$ = NULL;}
245    | ObjectTypeKeyword             {$$ = $1;}
246    | '{' ParameterTypesPackage '}' {$$ = $2;}
247    ;
248
249OptionalParameterTypesPackage
250    :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
251    | ',' ParameterTypesPackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
252    ;
253
254    /* ACPI 3.0 -- allow semicolons between terms */
255
256TermList
257    :                               {$$ = NULL;}
258    | TermList Term                 {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
259    | TermList Term ';'             {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
260    | TermList ';' Term             {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
261    | TermList ';' Term ';'         {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
262    ;
263
264Term
265    : Object                        {}
266    | Type1Opcode                   {}
267    | Type2Opcode                   {}
268    | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
269    | Type2StringOpcode             {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
270    | Type2BufferOpcode             {}
271    | Type2BufferOrStringOpcode     {}
272    | error                         {$$ = AslDoError(); yyclearin;}
273    ;
274
275/*
276 * Case-Default list; allow only one Default term and unlimited Case terms
277 */
278CaseDefaultTermList
279    :                               {$$ = NULL;}
280    | CaseTerm  {}
281    | DefaultTerm   {}
282    | CaseDefaultTermList
283        CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
284    | CaseDefaultTermList
285        DefaultTerm                 {$$ = TrLinkPeerNode ($1,$2);}
286
287/* Original - attempts to force zero or one default term within the switch */
288
289/*
290CaseDefaultTermList
291    :                               {$$ = NULL;}
292    | CaseTermList
293        DefaultTerm
294        CaseTermList                {$$ = TrLinkPeerNode ($1,TrLinkPeerNode ($2, $3));}
295    | CaseTermList
296        CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
297    ;
298
299CaseTermList
300    :                               {$$ = NULL;}
301    | CaseTerm                      {}
302    | CaseTermList
303        CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
304    ;
305*/
306
307
308/*******************************************************************************
309 *
310 * ASL Data and Constant Terms
311 *
312 ******************************************************************************/
313
314DataObject
315    : BufferData                    {}
316    | PackageData                   {}
317    | IntegerData                   {}
318    | StringData                    {}
319    ;
320
321BufferData
322    : Type5Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
323    | Type2BufferOrStringOpcode     {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
324    | Type2BufferOpcode             {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
325    | BufferTerm                    {}
326    ;
327
328PackageData
329    : PackageTerm                   {}
330    ;
331
332IntegerData
333    : Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
334    | Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
335    | Integer                       {}
336    | ConstTerm                     {}
337    ;
338
339StringData
340    : Type2StringOpcode             {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
341    | String                        {}
342    ;
343
344ByteConst
345    : Integer                       {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
346    ;
347
348WordConst
349    : Integer                       {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
350    ;
351
352DWordConst
353    : Integer                       {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
354    ;
355
356QWordConst
357    : Integer                       {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
358    ;
359
360/*
361 * The NODE_COMPILE_TIME_CONST flag in the following constant expressions
362 * enables compile-time constant folding to reduce the Type3Opcodes/Type2IntegerOpcodes
363 * to simple integers. It is an error if these types of expressions cannot be
364 * reduced, since the AML grammar for ****ConstExpr requires a simple constant.
365 * Note: The required byte length of the constant is passed through to the
366 * constant folding code in the node AmlLength field.
367 */
368ByteConstExpr
369    : Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 1);}
370    | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 1);}
371    | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
372    | ByteConst                     {}
373    ;
374
375WordConstExpr
376    : Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 2);}
377    | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 2);}
378    | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
379    | WordConst                     {}
380    ;
381
382DWordConstExpr
383    : Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 4);}
384    | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 4);}
385    | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
386    | DWordConst                    {}
387    ;
388
389QWordConstExpr
390    : Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 8);}
391    | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 8);}
392    | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
393    | QWordConst                    {}
394    ;
395
396ConstTerm
397    : ConstExprTerm                 {}
398    | PARSEOP_REVISION              {$$ = TrCreateLeafNode (PARSEOP_REVISION);}
399    ;
400
401ConstExprTerm
402    : PARSEOP_ZERO                  {$$ = TrCreateValuedLeafNode (PARSEOP_ZERO, 0);}
403    | PARSEOP_ONE                   {$$ = TrCreateValuedLeafNode (PARSEOP_ONE, 1);}
404    | PARSEOP_ONES                  {$$ = TrCreateValuedLeafNode (PARSEOP_ONES, ACPI_UINT64_MAX);}
405    | PARSEOP___DATE__              {$$ = TrCreateConstantLeafNode (PARSEOP___DATE__);}
406    | PARSEOP___FILE__              {$$ = TrCreateConstantLeafNode (PARSEOP___FILE__);}
407    | PARSEOP___LINE__              {$$ = TrCreateConstantLeafNode (PARSEOP___LINE__);}
408    | PARSEOP___PATH__              {$$ = TrCreateConstantLeafNode (PARSEOP___PATH__);}
409    ;
410
411Integer
412    : PARSEOP_INTEGER               {$$ = TrCreateValuedLeafNode (PARSEOP_INTEGER, AslCompilerlval.i);}
413    ;
414
415String
416    : PARSEOP_STRING_LITERAL        {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, (ACPI_NATIVE_INT) AslCompilerlval.s);}
417    ;
418
419
420/*******************************************************************************
421 *
422 * ASL Opcode Terms
423 *
424 ******************************************************************************/
425
426CompilerDirective
427    : IncludeTerm                   {}
428    | IncludeEndTerm                {}
429    | ExternalTerm                  {}
430    ;
431
432NamedObject
433    : BankFieldTerm                 {}
434    | CreateBitFieldTerm            {}
435    | CreateByteFieldTerm           {}
436    | CreateDWordFieldTerm          {}
437    | CreateFieldTerm               {}
438    | CreateQWordFieldTerm          {}
439    | CreateWordFieldTerm           {}
440    | DataRegionTerm                {}
441    | DeviceTerm                    {}
442    | EventTerm                     {}
443    | FieldTerm                     {}
444    | FunctionTerm                  {}
445    | IndexFieldTerm                {}
446    | MethodTerm                    {}
447    | MutexTerm                     {}
448    | OpRegionTerm                  {}
449    | PowerResTerm                  {}
450    | ProcessorTerm                 {}
451    | ThermalZoneTerm               {}
452    ;
453
454NameSpaceModifier
455    : AliasTerm                     {}
456    | NameTerm                      {}
457    | ScopeTerm                     {}
458    ;
459
460/* For ObjectType: SuperName except for MethodInvocationTerm */
461
462ObjectTypeName
463    : NameString                    {}
464    | ArgTerm                       {}
465    | LocalTerm                     {}
466    | DebugTerm                     {}
467    | RefOfTerm                     {}
468    | DerefOfTerm                   {}
469    | IndexTerm                     {}
470/*    | MethodInvocationTerm          {} */  /* Caused reduce/reduce with Type6Opcode->MethodInvocationTerm */
471    ;
472
473RequiredTarget
474    : ',' SuperName                 {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
475    ;
476
477SimpleTarget
478    : NameString                    {}
479    | LocalTerm                     {}
480    | ArgTerm                       {}
481    ;
482
483/* Opcode types */
484
485Type1Opcode
486    : BreakTerm                     {}
487    | BreakPointTerm                {}
488    | ContinueTerm                  {}
489    | FatalTerm                     {}
490    | ForTerm                       {}
491    | ElseIfTerm                    {}
492    | LoadTerm                      {}
493    | NoOpTerm                      {}
494    | NotifyTerm                    {}
495    | ReleaseTerm                   {}
496    | ResetTerm                     {}
497    | ReturnTerm                    {}
498    | SignalTerm                    {}
499    | SleepTerm                     {}
500    | StallTerm                     {}
501    | SwitchTerm                    {}
502    | UnloadTerm                    {}
503    | WhileTerm                     {}
504    ;
505
506Type2Opcode
507    : AcquireTerm                   {}
508    | CondRefOfTerm                 {}
509    | CopyObjectTerm                {}
510    | DerefOfTerm                   {}
511    | ObjectTypeTerm                {}
512    | RefOfTerm                     {}
513    | SizeOfTerm                    {}
514    | StoreTerm                     {}
515    | EqualsTerm                    {}
516    | TimerTerm                     {}
517    | WaitTerm                      {}
518    | MethodInvocationTerm          {}
519    ;
520
521/*
522 * Type 3/4/5 opcodes
523 */
524Type2IntegerOpcode                  /* "Type3" opcodes */
525    : Expression                    {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
526    | AddTerm                       {}
527    | AndTerm                       {}
528    | DecTerm                       {}
529    | DivideTerm                    {}
530    | FindSetLeftBitTerm            {}
531    | FindSetRightBitTerm           {}
532    | FromBCDTerm                   {}
533    | IncTerm                       {}
534    | IndexTerm                     {}
535    | LAndTerm                      {}
536    | LEqualTerm                    {}
537    | LGreaterTerm                  {}
538    | LGreaterEqualTerm             {}
539    | LLessTerm                     {}
540    | LLessEqualTerm                {}
541    | LNotTerm                      {}
542    | LNotEqualTerm                 {}
543    | LoadTableTerm                 {}
544    | LOrTerm                       {}
545    | MatchTerm                     {}
546    | ModTerm                       {}
547    | MultiplyTerm                  {}
548    | NAndTerm                      {}
549    | NOrTerm                       {}
550    | NotTerm                       {}
551    | OrTerm                        {}
552    | ShiftLeftTerm                 {}
553    | ShiftRightTerm                {}
554    | SubtractTerm                  {}
555    | ToBCDTerm                     {}
556    | ToIntegerTerm                 {}
557    | XOrTerm                       {}
558    ;
559
560Type2StringOpcode                   /* "Type4" Opcodes */
561    : ToDecimalStringTerm           {}
562    | ToHexStringTerm               {}
563    | ToStringTerm                  {}
564    ;
565
566Type2BufferOpcode                   /* "Type5" Opcodes */
567    : ToBufferTerm                  {}
568    | ConcatResTerm                 {}
569    ;
570
571Type2BufferOrStringOpcode
572    : ConcatTerm                    {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
573    | PrintfTerm                    {}
574    | FprintfTerm                   {}
575    | MidTerm                       {}
576    ;
577
578/*
579 * A type 3 opcode evaluates to an Integer and cannot have a destination operand
580 */
581Type3Opcode
582    : EISAIDTerm                    {}
583    ;
584
585/* Obsolete
586Type4Opcode
587    : ConcatTerm                    {}
588    | ToDecimalStringTerm           {}
589    | ToHexStringTerm               {}
590    | MidTerm                       {}
591    | ToStringTerm                  {}
592    ;
593*/
594
595Type5Opcode
596    : ResourceTemplateTerm          {}
597    | UnicodeTerm                   {}
598    | ToPLDTerm                     {}
599    | ToUUIDTerm                    {}
600    ;
601
602Type6Opcode
603    : RefOfTerm                     {}
604    | DerefOfTerm                   {}
605    | IndexTerm                     {}
606    | IndexExpTerm                  {}
607    | MethodInvocationTerm          {}
608    ;
609
610
611/*******************************************************************************
612 *
613 * ASL Primary Terms
614 *
615 ******************************************************************************/
616
617AccessAsTerm
618    : PARSEOP_ACCESSAS '('
619        AccessTypeKeyword
620        OptionalAccessAttribTerm
621        ')'                         {$$ = TrCreateNode (PARSEOP_ACCESSAS,2,$3,$4);}
622    | PARSEOP_ACCESSAS '('
623        error ')'                   {$$ = AslDoError(); yyclearin;}
624    ;
625
626AcquireTerm
627    : PARSEOP_ACQUIRE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_ACQUIRE);}
628        SuperName
629        ',' WordConstExpr
630        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$6);}
631    | PARSEOP_ACQUIRE '('
632        error ')'                   {$$ = AslDoError(); yyclearin;}
633    ;
634
635AddTerm
636    : PARSEOP_ADD '('               {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);}
637        TermArg
638        TermArgItem
639        Target
640        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
641    | PARSEOP_ADD '('
642        error ')'                   {$$ = AslDoError(); yyclearin;}
643    ;
644
645AliasTerm
646    : PARSEOP_ALIAS '('             {$<n>$ = TrCreateLeafNode (PARSEOP_ALIAS);}
647        NameString
648        NameStringItem
649        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,
650                                        TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));}
651    | PARSEOP_ALIAS '('
652        error ')'                   {$$ = AslDoError(); yyclearin;}
653    ;
654
655AndTerm
656    : PARSEOP_AND '('               {$<n>$ = TrCreateLeafNode (PARSEOP_AND);}
657        TermArg
658        TermArgItem
659        Target
660        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
661    | PARSEOP_AND '('
662        error ')'                   {$$ = AslDoError(); yyclearin;}
663    ;
664
665ArgTerm
666    : PARSEOP_ARG0                  {$$ = TrCreateLeafNode (PARSEOP_ARG0);}
667    | PARSEOP_ARG1                  {$$ = TrCreateLeafNode (PARSEOP_ARG1);}
668    | PARSEOP_ARG2                  {$$ = TrCreateLeafNode (PARSEOP_ARG2);}
669    | PARSEOP_ARG3                  {$$ = TrCreateLeafNode (PARSEOP_ARG3);}
670    | PARSEOP_ARG4                  {$$ = TrCreateLeafNode (PARSEOP_ARG4);}
671    | PARSEOP_ARG5                  {$$ = TrCreateLeafNode (PARSEOP_ARG5);}
672    | PARSEOP_ARG6                  {$$ = TrCreateLeafNode (PARSEOP_ARG6);}
673    ;
674
675BankFieldTerm
676    : PARSEOP_BANKFIELD '('         {$<n>$ = TrCreateLeafNode (PARSEOP_BANKFIELD);}
677        NameString
678        NameStringItem
679        TermArgItem
680        ',' AccessTypeKeyword
681        ',' LockRuleKeyword
682        ',' UpdateRuleKeyword
683        ')' '{'
684            FieldUnitList '}'       {$$ = TrLinkChildren ($<n>3,7,$4,$5,$6,$8,$10,$12,$15);}
685    | PARSEOP_BANKFIELD '('
686        error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
687    ;
688
689BreakTerm
690    : PARSEOP_BREAK                 {$$ = TrCreateNode (PARSEOP_BREAK, 0);}
691    ;
692
693BreakPointTerm
694    : PARSEOP_BREAKPOINT            {$$ = TrCreateNode (PARSEOP_BREAKPOINT, 0);}
695    ;
696
697BufferTerm
698    : PARSEOP_BUFFER '('            {$<n>$ = TrCreateLeafNode (PARSEOP_BUFFER);}
699        OptionalBufferLength
700        ')' '{'
701            BufferTermData '}'      {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
702    | PARSEOP_BUFFER '('
703        error ')'                   {$$ = AslDoError(); yyclearin;}
704    ;
705
706BufferTermData
707    : ByteList                      {}
708    | StringData                    {}
709    ;
710
711CaseTerm
712    : PARSEOP_CASE '('              {$<n>$ = TrCreateLeafNode (PARSEOP_CASE);}
713        DataObject
714        ')' '{'
715            TermList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
716    | PARSEOP_CASE '('
717        error ')'                   {$$ = AslDoError(); yyclearin;}
718    ;
719
720ConcatTerm
721    : PARSEOP_CONCATENATE '('       {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATE);}
722        TermArg
723        TermArgItem
724        Target
725        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
726    | PARSEOP_CONCATENATE '('
727        error ')'                   {$$ = AslDoError(); yyclearin;}
728    ;
729
730ConcatResTerm
731    : PARSEOP_CONCATENATERESTEMPLATE '('    {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATERESTEMPLATE);}
732        TermArg
733        TermArgItem
734        Target
735        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
736    | PARSEOP_CONCATENATERESTEMPLATE '('
737        error ')'                   {$$ = AslDoError(); yyclearin;}
738    ;
739
740ConnectionTerm
741    : PARSEOP_CONNECTION '('
742        NameString
743        ')'                         {$$ = TrCreateNode (PARSEOP_CONNECTION,1,$3);}
744    | PARSEOP_CONNECTION '('        {$<n>$ = TrCreateLeafNode (PARSEOP_CONNECTION);}
745        ResourceMacroTerm
746        ')'                         {$$ = TrLinkChildren ($<n>3, 1,
747                                            TrLinkChildren (TrCreateLeafNode (PARSEOP_RESOURCETEMPLATE), 3,
748                                                TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
749                                                TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
750                                                $4));}
751    | PARSEOP_CONNECTION '('
752        error ')'                   {$$ = AslDoError(); yyclearin;}
753    ;
754
755CondRefOfTerm
756    : PARSEOP_CONDREFOF '('         {$<n>$ = TrCreateLeafNode (PARSEOP_CONDREFOF);}
757        SuperName
758        Target
759        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
760    | PARSEOP_CONDREFOF '('
761        error ')'                   {$$ = AslDoError(); yyclearin;}
762    ;
763
764ContinueTerm
765    : PARSEOP_CONTINUE              {$$ = TrCreateNode (PARSEOP_CONTINUE, 0);}
766    ;
767
768CopyObjectTerm
769    : PARSEOP_COPYOBJECT '('        {$<n>$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);}
770        TermArg
771        ',' SimpleTarget
772        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
773    | PARSEOP_COPYOBJECT '('
774        error ')'                   {$$ = AslDoError(); yyclearin;}
775    ;
776
777CreateBitFieldTerm
778    : PARSEOP_CREATEBITFIELD '('    {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);}
779        TermArg
780        TermArgItem
781        NameStringItem
782        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
783    | PARSEOP_CREATEBITFIELD '('
784        error ')'                   {$$ = AslDoError(); yyclearin;}
785    ;
786
787CreateByteFieldTerm
788    : PARSEOP_CREATEBYTEFIELD '('   {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);}
789        TermArg
790        TermArgItem
791        NameStringItem
792        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
793    | PARSEOP_CREATEBYTEFIELD '('
794        error ')'                   {$$ = AslDoError(); yyclearin;}
795    ;
796
797CreateDWordFieldTerm
798    : PARSEOP_CREATEDWORDFIELD '('  {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);}
799        TermArg
800        TermArgItem
801        NameStringItem
802        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
803    | PARSEOP_CREATEDWORDFIELD '('
804        error ')'                   {$$ = AslDoError(); yyclearin;}
805    ;
806
807CreateFieldTerm
808    : PARSEOP_CREATEFIELD '('       {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);}
809        TermArg
810        TermArgItem
811        TermArgItem
812        NameStringItem
813        ')'                         {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,TrSetNodeFlags ($7, NODE_IS_NAME_DECLARATION));}
814    | PARSEOP_CREATEFIELD '('
815        error ')'                   {$$ = AslDoError(); yyclearin;}
816    ;
817
818CreateQWordFieldTerm
819    : PARSEOP_CREATEQWORDFIELD '('  {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);}
820        TermArg
821        TermArgItem
822        NameStringItem
823        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
824    | PARSEOP_CREATEQWORDFIELD '('
825        error ')'                   {$$ = AslDoError(); yyclearin;}
826    ;
827
828CreateWordFieldTerm
829    : PARSEOP_CREATEWORDFIELD '('   {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);}
830        TermArg
831        TermArgItem
832        NameStringItem
833        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
834    | PARSEOP_CREATEWORDFIELD '('
835        error ')'                   {$$ = AslDoError(); yyclearin;}
836    ;
837
838DataRegionTerm
839    : PARSEOP_DATATABLEREGION '('   {$<n>$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);}
840        NameString
841        TermArgItem
842        TermArgItem
843        TermArgItem
844        ')'                         {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$6,$7);}
845    | PARSEOP_DATATABLEREGION '('
846        error ')'                   {$$ = AslDoError(); yyclearin;}
847    ;
848
849DebugTerm
850    : PARSEOP_DEBUG                 {$$ = TrCreateLeafNode (PARSEOP_DEBUG);}
851    ;
852
853DecTerm
854    : PARSEOP_DECREMENT '('         {$<n>$ = TrCreateLeafNode (PARSEOP_DECREMENT);}
855        SuperName
856        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
857    | PARSEOP_DECREMENT '('
858        error ')'                   {$$ = AslDoError(); yyclearin;}
859    ;
860
861DefaultTerm
862    : PARSEOP_DEFAULT '{'           {$<n>$ = TrCreateLeafNode (PARSEOP_DEFAULT);}
863        TermList '}'                {$$ = TrLinkChildren ($<n>3,1,$4);}
864    | PARSEOP_DEFAULT '{'
865        error '}'                   {$$ = AslDoError(); yyclearin;}
866    ;
867
868DerefOfTerm
869    : PARSEOP_DEREFOF '('           {$<n>$ = TrCreateLeafNode (PARSEOP_DEREFOF);}
870        TermArg
871        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
872    | PARSEOP_DEREFOF '('
873        error ')'                   {$$ = AslDoError(); yyclearin;}
874    ;
875
876DeviceTerm
877    : PARSEOP_DEVICE '('            {$<n>$ = TrCreateLeafNode (PARSEOP_DEVICE);}
878        NameString
879        ')' '{'
880            TermList '}'            {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
881    | PARSEOP_DEVICE '('
882        error ')'                   {$$ = AslDoError(); yyclearin;}
883    ;
884
885DivideTerm
886    : PARSEOP_DIVIDE '('            {$<n>$ = TrCreateLeafNode (PARSEOP_DIVIDE);}
887        TermArg
888        TermArgItem
889        Target
890        Target
891        ')'                         {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);}
892    | PARSEOP_DIVIDE '('
893        error ')'                   {$$ = AslDoError(); yyclearin;}
894    ;
895
896EISAIDTerm
897    : PARSEOP_EISAID '('
898        StringData ')'              {$$ = TrUpdateNode (PARSEOP_EISAID, $3);}
899    | PARSEOP_EISAID '('
900        error ')'                   {$$ = AslDoError(); yyclearin;}
901    ;
902
903ElseIfTerm
904    : IfTerm ElseTerm               {$$ = TrLinkPeerNode ($1,$2);}
905    ;
906
907ElseTerm
908    :                               {$$ = NULL;}
909    | PARSEOP_ELSE '{'              {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
910        TermList '}'                {$$ = TrLinkChildren ($<n>3,1,$4);}
911
912    | PARSEOP_ELSE '{'
913        error '}'                   {$$ = AslDoError(); yyclearin;}
914
915    | PARSEOP_ELSE
916        error                       {$$ = AslDoError(); yyclearin;}
917
918    | PARSEOP_ELSEIF '('            {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
919        TermArg                     {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
920        ')' '{'
921            TermList '}'            {TrLinkChildren ($<n>5,2,$4,$8);}
922        ElseTerm                    {TrLinkPeerNode ($<n>5,$11);}
923                                    {$$ = TrLinkChildren ($<n>3,1,$<n>5);}
924
925    | PARSEOP_ELSEIF '('
926        error ')'                   {$$ = AslDoError(); yyclearin;}
927
928    | PARSEOP_ELSEIF
929        error                       {$$ = AslDoError(); yyclearin;}
930    ;
931
932EventTerm
933    : PARSEOP_EVENT '('             {$<n>$ = TrCreateLeafNode (PARSEOP_EVENT);}
934        NameString
935        ')'                         {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));}
936    | PARSEOP_EVENT '('
937        error ')'                   {$$ = AslDoError(); yyclearin;}
938    ;
939
940ExternalTerm
941    : PARSEOP_EXTERNAL '('
942        NameString
943        OptionalObjectTypeKeyword
944        OptionalParameterTypePackage
945        OptionalParameterTypesPackage
946        ')'                         {$$ = TrCreateNode (PARSEOP_EXTERNAL,4,$3,$4,$5,$6);}
947    | PARSEOP_EXTERNAL '('
948        error ')'                   {$$ = AslDoError(); yyclearin;}
949    ;
950
951FatalTerm
952    : PARSEOP_FATAL '('             {$<n>$ = TrCreateLeafNode (PARSEOP_FATAL);}
953        ByteConstExpr
954        ',' DWordConstExpr
955        TermArgItem
956        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
957    | PARSEOP_FATAL '('
958        error ')'                   {$$ = AslDoError(); yyclearin;}
959    ;
960
961FieldTerm
962    : PARSEOP_FIELD '('             {$<n>$ = TrCreateLeafNode (PARSEOP_FIELD);}
963        NameString
964        ',' AccessTypeKeyword
965        ',' LockRuleKeyword
966        ',' UpdateRuleKeyword
967        ')' '{'
968            FieldUnitList '}'       {$$ = TrLinkChildren ($<n>3,5,$4,$6,$8,$10,$13);}
969    | PARSEOP_FIELD '('
970        error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
971    ;
972
973FindSetLeftBitTerm
974    : PARSEOP_FINDSETLEFTBIT '('    {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);}
975        TermArg
976        Target
977        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
978    | PARSEOP_FINDSETLEFTBIT '('
979        error ')'                   {$$ = AslDoError(); yyclearin;}
980    ;
981
982FindSetRightBitTerm
983    : PARSEOP_FINDSETRIGHTBIT '('   {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);}
984        TermArg
985        Target
986        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
987    | PARSEOP_FINDSETRIGHTBIT '('
988        error ')'                   {$$ = AslDoError(); yyclearin;}
989    ;
990
991    /* Convert a For() loop to a While() loop */
992ForTerm
993    : PARSEOP_FOR '('               {$<n>$ = TrCreateLeafNode (PARSEOP_WHILE);}
994        OptionalTermArg ','         {}
995        OptionalPredicate ','
996        OptionalTermArg             {$<n>$ = TrLinkPeerNode ($4,$<n>3);
997                                        TrSetParent ($9,$<n>3);}                /* New parent is WHILE */
998        ')' '{' TermList '}'        {$<n>$ = TrLinkChildren ($<n>3,2,$7,$13);}
999                                    {$<n>$ = TrLinkPeerNode ($13,$9);
1000                                        $$ = $<n>10;}
1001    ;
1002
1003OptionalPredicate
1004    :                               {$$ = TrCreateValuedLeafNode (PARSEOP_INTEGER, 1);}
1005    | TermArg                       {$$ = $1;}
1006    ;
1007
1008FprintfTerm
1009    : PARSEOP_FPRINTF '('            {$<n>$ = TrCreateLeafNode (PARSEOP_FPRINTF);}
1010        TermArg ','
1011        StringData
1012        PrintfArgList
1013        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
1014    | PARSEOP_FPRINTF '('
1015        error ')'                   {$$ = AslDoError(); yyclearin;}
1016    ;
1017
1018FromBCDTerm
1019    : PARSEOP_FROMBCD '('           {$<n>$ = TrCreateLeafNode (PARSEOP_FROMBCD);}
1020        TermArg
1021        Target
1022        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1023    | PARSEOP_FROMBCD '('
1024        error ')'                   {$$ = AslDoError(); yyclearin;}
1025    ;
1026
1027FunctionTerm
1028    : PARSEOP_FUNCTION '('          {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
1029        NameString
1030        OptionalParameterTypePackage
1031        OptionalParameterTypesPackage
1032        ')' '{'
1033            TermList '}'            {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),
1034                                        TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),
1035                                        TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL),
1036                                        TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),$5,$6,$9);}
1037    | PARSEOP_FUNCTION '('
1038        error ')'                   {$$ = AslDoError(); yyclearin;}
1039    ;
1040
1041IfTerm
1042    : PARSEOP_IF '('                {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
1043        TermArg
1044        ')' '{'
1045            TermList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1046
1047    | PARSEOP_IF '('
1048        error ')'                   {$$ = AslDoError(); yyclearin;}
1049    ;
1050
1051IncludeTerm
1052    : PARSEOP_INCLUDE '('
1053        String  ')'                 {$$ = TrUpdateNode (PARSEOP_INCLUDE, $3);
1054                                        FlOpenIncludeFile ($3);}
1055    ;
1056
1057IncludeEndTerm
1058    : PARSEOP_INCLUDE_END           {$<n>$ = TrCreateLeafNode (PARSEOP_INCLUDE_END); TrSetCurrentFilename ($$);}
1059    ;
1060
1061IncTerm
1062    : PARSEOP_INCREMENT '('         {$<n>$ = TrCreateLeafNode (PARSEOP_INCREMENT);}
1063        SuperName
1064        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1065    | PARSEOP_INCREMENT '('
1066        error ')'                   {$$ = AslDoError(); yyclearin;}
1067    ;
1068
1069IndexFieldTerm
1070    : PARSEOP_INDEXFIELD '('        {$<n>$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);}
1071        NameString
1072        NameStringItem
1073        ',' AccessTypeKeyword
1074        ',' LockRuleKeyword
1075        ',' UpdateRuleKeyword
1076        ')' '{'
1077            FieldUnitList '}'       {$$ = TrLinkChildren ($<n>3,6,$4,$5,$7,$9,$11,$14);}
1078    | PARSEOP_INDEXFIELD '('
1079        error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
1080    ;
1081
1082IndexTerm
1083    : PARSEOP_INDEX '('             {$<n>$ = TrCreateLeafNode (PARSEOP_INDEX);}
1084        TermArg
1085        TermArgItem
1086        Target
1087        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1088    | PARSEOP_INDEX '('
1089        error ')'                   {$$ = AslDoError(); yyclearin;}
1090    ;
1091
1092LAndTerm
1093    : PARSEOP_LAND '('              {$<n>$ = TrCreateLeafNode (PARSEOP_LAND);}
1094        TermArg
1095        TermArgItem
1096        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1097    | PARSEOP_LAND '('
1098        error ')'                   {$$ = AslDoError(); yyclearin;}
1099    ;
1100
1101LEqualTerm
1102    : PARSEOP_LEQUAL '('            {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
1103        TermArg
1104        TermArgItem
1105        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1106    | PARSEOP_LEQUAL '('
1107        error ')'                   {$$ = AslDoError(); yyclearin;}
1108    ;
1109
1110LGreaterEqualTerm
1111    : PARSEOP_LGREATEREQUAL '('     {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
1112        TermArg
1113        TermArgItem
1114        ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1115    | PARSEOP_LGREATEREQUAL '('
1116        error ')'                   {$$ = AslDoError(); yyclearin;}
1117    ;
1118
1119LGreaterTerm
1120    : PARSEOP_LGREATER '('          {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
1121        TermArg
1122        TermArgItem
1123        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1124    | PARSEOP_LGREATER '('
1125        error ')'                   {$$ = AslDoError(); yyclearin;}
1126    ;
1127
1128LLessEqualTerm
1129    : PARSEOP_LLESSEQUAL '('        {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
1130        TermArg
1131        TermArgItem
1132        ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1133    | PARSEOP_LLESSEQUAL '('
1134        error ')'                   {$$ = AslDoError(); yyclearin;}
1135    ;
1136
1137LLessTerm
1138    : PARSEOP_LLESS '('             {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
1139        TermArg
1140        TermArgItem
1141        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1142    | PARSEOP_LLESS '('
1143        error ')'                   {$$ = AslDoError(); yyclearin;}
1144    ;
1145
1146LNotEqualTerm
1147    : PARSEOP_LNOTEQUAL '('         {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
1148        TermArg
1149        TermArgItem
1150        ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1151    | PARSEOP_LNOTEQUAL '('
1152        error ')'                   {$$ = AslDoError(); yyclearin;}
1153    ;
1154
1155LNotTerm
1156    : PARSEOP_LNOT '('              {$<n>$ = TrCreateLeafNode (PARSEOP_LNOT);}
1157        TermArg
1158        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1159    | PARSEOP_LNOT '('
1160        error ')'                   {$$ = AslDoError(); yyclearin;}
1161    ;
1162
1163LoadTableTerm
1164    : PARSEOP_LOADTABLE '('         {$<n>$ = TrCreateLeafNode (PARSEOP_LOADTABLE);}
1165        TermArg
1166        TermArgItem
1167        TermArgItem
1168        OptionalListString
1169        OptionalListString
1170        OptionalReference
1171        ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$5,$6,$7,$8,$9);}
1172    | PARSEOP_LOADTABLE '('
1173        error ')'                   {$$ = AslDoError(); yyclearin;}
1174    ;
1175
1176LoadTerm
1177    : PARSEOP_LOAD '('              {$<n>$ = TrCreateLeafNode (PARSEOP_LOAD);}
1178        NameString
1179        RequiredTarget
1180        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1181    | PARSEOP_LOAD '('
1182        error ')'                   {$$ = AslDoError(); yyclearin;}
1183    ;
1184
1185LocalTerm
1186    : PARSEOP_LOCAL0                {$$ = TrCreateLeafNode (PARSEOP_LOCAL0);}
1187    | PARSEOP_LOCAL1                {$$ = TrCreateLeafNode (PARSEOP_LOCAL1);}
1188    | PARSEOP_LOCAL2                {$$ = TrCreateLeafNode (PARSEOP_LOCAL2);}
1189    | PARSEOP_LOCAL3                {$$ = TrCreateLeafNode (PARSEOP_LOCAL3);}
1190    | PARSEOP_LOCAL4                {$$ = TrCreateLeafNode (PARSEOP_LOCAL4);}
1191    | PARSEOP_LOCAL5                {$$ = TrCreateLeafNode (PARSEOP_LOCAL5);}
1192    | PARSEOP_LOCAL6                {$$ = TrCreateLeafNode (PARSEOP_LOCAL6);}
1193    | PARSEOP_LOCAL7                {$$ = TrCreateLeafNode (PARSEOP_LOCAL7);}
1194    ;
1195
1196LOrTerm
1197    : PARSEOP_LOR '('               {$<n>$ = TrCreateLeafNode (PARSEOP_LOR);}
1198        TermArg
1199        TermArgItem
1200        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1201    | PARSEOP_LOR '('
1202        error ')'                   {$$ = AslDoError(); yyclearin;}
1203    ;
1204
1205MatchTerm
1206    : PARSEOP_MATCH '('             {$<n>$ = TrCreateLeafNode (PARSEOP_MATCH);}
1207        TermArg
1208        ',' MatchOpKeyword
1209        TermArgItem
1210        ',' MatchOpKeyword
1211        TermArgItem
1212        TermArgItem
1213        ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$6,$7,$9,$10,$11);}
1214    | PARSEOP_MATCH '('
1215        error ')'                   {$$ = AslDoError(); yyclearin;}
1216    ;
1217
1218MethodTerm
1219    : PARSEOP_METHOD  '('           {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
1220        NameString
1221        OptionalByteConstExpr       {UtCheckIntegerRange ($5, 0, 7);}
1222        OptionalSerializeRuleKeyword
1223        OptionalByteConstExpr
1224        OptionalParameterTypePackage
1225        OptionalParameterTypesPackage
1226        ')' '{'
1227            TermList '}'            {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$7,$8,$9,$10,$13);}
1228    | PARSEOP_METHOD '('
1229        error ')'                   {$$ = AslDoError(); yyclearin;}
1230    ;
1231
1232MidTerm
1233    : PARSEOP_MID '('               {$<n>$ = TrCreateLeafNode (PARSEOP_MID);}
1234        TermArg
1235        TermArgItem
1236        TermArgItem
1237        Target
1238        ')'                         {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);}
1239    | PARSEOP_MID '('
1240        error ')'                   {$$ = AslDoError(); yyclearin;}
1241    ;
1242
1243ModTerm
1244    : PARSEOP_MOD '('               {$<n>$ = TrCreateLeafNode (PARSEOP_MOD);}
1245        TermArg
1246        TermArgItem
1247        Target
1248        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1249    | PARSEOP_MOD '('
1250        error ')'                   {$$ = AslDoError(); yyclearin;}
1251    ;
1252
1253MultiplyTerm
1254    : PARSEOP_MULTIPLY '('          {$<n>$ = TrCreateLeafNode (PARSEOP_MULTIPLY);}
1255        TermArg
1256        TermArgItem
1257        Target
1258        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1259    | PARSEOP_MULTIPLY '('
1260        error ')'                   {$$ = AslDoError(); yyclearin;}
1261    ;
1262
1263MutexTerm
1264    : PARSEOP_MUTEX '('             {$<n>$ = TrCreateLeafNode (PARSEOP_MUTEX);}
1265        NameString
1266        ',' ByteConstExpr
1267        ')'                         {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
1268    | PARSEOP_MUTEX '('
1269        error ')'                   {$$ = AslDoError(); yyclearin;}
1270    ;
1271
1272NameTerm
1273    : PARSEOP_NAME '('              {$<n>$ = TrCreateLeafNode (PARSEOP_NAME);}
1274        NameString
1275        ',' DataObject
1276        ')'                         {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
1277    | PARSEOP_NAME '('
1278        error ')'                   {$$ = AslDoError(); yyclearin;}
1279    ;
1280
1281NAndTerm
1282    : PARSEOP_NAND '('              {$<n>$ = TrCreateLeafNode (PARSEOP_NAND);}
1283        TermArg
1284        TermArgItem
1285        Target
1286        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1287    | PARSEOP_NAND '('
1288        error ')'                   {$$ = AslDoError(); yyclearin;}
1289    ;
1290
1291NoOpTerm
1292    : PARSEOP_NOOP                  {$$ = TrCreateNode (PARSEOP_NOOP, 0);}
1293    ;
1294
1295NOrTerm
1296    : PARSEOP_NOR '('               {$<n>$ = TrCreateLeafNode (PARSEOP_NOR);}
1297        TermArg
1298        TermArgItem
1299        Target
1300        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1301    | PARSEOP_NOR '('
1302        error ')'                   {$$ = AslDoError(); yyclearin;}
1303    ;
1304
1305NotifyTerm
1306    : PARSEOP_NOTIFY '('            {$<n>$ = TrCreateLeafNode (PARSEOP_NOTIFY);}
1307        SuperName
1308        TermArgItem
1309        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1310    | PARSEOP_NOTIFY '('
1311        error ')'                   {$$ = AslDoError(); yyclearin;}
1312    ;
1313
1314NotTerm
1315    : PARSEOP_NOT '('               {$<n>$ = TrCreateLeafNode (PARSEOP_NOT);}
1316        TermArg
1317        Target
1318        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1319    | PARSEOP_NOT '('
1320        error ')'                   {$$ = AslDoError(); yyclearin;}
1321    ;
1322
1323ObjectTypeTerm
1324    : PARSEOP_OBJECTTYPE '('        {$<n>$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);}
1325        ObjectTypeName
1326        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1327    | PARSEOP_OBJECTTYPE '('
1328        error ')'                   {$$ = AslDoError(); yyclearin;}
1329    ;
1330
1331OffsetTerm
1332    : PARSEOP_OFFSET '('
1333        AmlPackageLengthTerm
1334        ')'                         {$$ = TrCreateNode (PARSEOP_OFFSET,1,$3);}
1335    | PARSEOP_OFFSET '('
1336        error ')'                   {$$ = AslDoError(); yyclearin;}
1337    ;
1338
1339OpRegionTerm
1340    : PARSEOP_OPERATIONREGION '('   {$<n>$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);}
1341        NameString
1342        ',' OpRegionSpaceIdTerm
1343        TermArgItem
1344        TermArgItem
1345        ')'                         {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8);}
1346    | PARSEOP_OPERATIONREGION '('
1347        error ')'                   {$$ = AslDoError(); yyclearin;}
1348    ;
1349
1350OpRegionSpaceIdTerm
1351    : RegionSpaceKeyword            {}
1352    | ByteConst                     {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
1353    ;
1354
1355OrTerm
1356    : PARSEOP_OR '('                {$<n>$ = TrCreateLeafNode (PARSEOP_OR);}
1357        TermArg
1358        TermArgItem
1359        Target
1360        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1361    | PARSEOP_OR '('
1362        error ')'                   {$$ = AslDoError(); yyclearin;}
1363    ;
1364
1365PackageTerm
1366    : PARSEOP_PACKAGE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_VAR_PACKAGE);}
1367        VarPackageLengthTerm
1368        ')' '{'
1369            PackageList '}'         {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1370    | PARSEOP_PACKAGE '('
1371        error ')'                   {$$ = AslDoError(); yyclearin;}
1372    ;
1373
1374PowerResTerm
1375    : PARSEOP_POWERRESOURCE '('     {$<n>$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);}
1376        NameString
1377        ',' ByteConstExpr
1378        ',' WordConstExpr
1379        ')' '{'
1380            TermList '}'            {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$8,$11);}
1381    | PARSEOP_POWERRESOURCE '('
1382        error ')'                   {$$ = AslDoError(); yyclearin;}
1383    ;
1384
1385PrintfTerm
1386    : PARSEOP_PRINTF '('            {$<n>$ = TrCreateLeafNode (PARSEOP_PRINTF);}
1387        StringData
1388        PrintfArgList
1389        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1390    | PARSEOP_PRINTF '('
1391        error ')'                   {$$ = AslDoError(); yyclearin;}
1392    ;
1393
1394PrintfArgList
1395    :                               {$$ = NULL;}
1396    | TermArg                       {$$ = $1;}
1397    | PrintfArgList ','
1398       TermArg                      {$$ = TrLinkPeerNode ($1, $3);}
1399    ;
1400
1401ProcessorTerm
1402    : PARSEOP_PROCESSOR '('         {$<n>$ = TrCreateLeafNode (PARSEOP_PROCESSOR);}
1403        NameString
1404        ',' ByteConstExpr
1405        OptionalDWordConstExpr
1406        OptionalByteConstExpr
1407        ')' '{'
1408            TermList '}'            {$$ = TrLinkChildren ($<n>3,5,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8,$11);}
1409    | PARSEOP_PROCESSOR '('
1410        error ')'                   {$$ = AslDoError(); yyclearin;}
1411    ;
1412
1413RawDataBufferTerm
1414    : PARSEOP_DATABUFFER  '('       {$<n>$ = TrCreateLeafNode (PARSEOP_DATABUFFER);}
1415        OptionalWordConst
1416        ')' '{'
1417            ByteList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1418    | PARSEOP_DATABUFFER '('
1419        error ')'                   {$$ = AslDoError(); yyclearin;}
1420    ;
1421
1422/*
1423 * In RefOf, the node isn't really a target, but we can't keep track of it after
1424 * we've taken a pointer to it. (hard to tell if a local becomes initialized this way.)
1425 */
1426RefOfTerm
1427    : PARSEOP_REFOF '('             {$<n>$ = TrCreateLeafNode (PARSEOP_REFOF);}
1428        SuperName
1429        ')'                         {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));}
1430    | PARSEOP_REFOF '('
1431        error ')'                   {$$ = AslDoError(); yyclearin;}
1432    ;
1433
1434ReleaseTerm
1435    : PARSEOP_RELEASE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_RELEASE);}
1436        SuperName
1437        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1438    | PARSEOP_RELEASE '('
1439        error ')'                   {$$ = AslDoError(); yyclearin;}
1440    ;
1441
1442ResetTerm
1443    : PARSEOP_RESET '('             {$<n>$ = TrCreateLeafNode (PARSEOP_RESET);}
1444        SuperName
1445        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1446    | PARSEOP_RESET '('
1447        error ')'                   {$$ = AslDoError(); yyclearin;}
1448    ;
1449
1450ReturnTerm
1451    : PARSEOP_RETURN '('            {$<n>$ = TrCreateLeafNode (PARSEOP_RETURN);}
1452        OptionalReturnArg
1453        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1454    | PARSEOP_RETURN                {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_RETURN),1,TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN));}
1455    | PARSEOP_RETURN '('
1456        error ')'                   {$$ = AslDoError(); yyclearin;}
1457    ;
1458
1459ScopeTerm
1460    : PARSEOP_SCOPE '('             {$<n>$ = TrCreateLeafNode (PARSEOP_SCOPE);}
1461        NameString
1462        ')' '{'
1463            TermList '}'            {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
1464    | PARSEOP_SCOPE '('
1465        error ')'                   {$$ = AslDoError(); yyclearin;}
1466    ;
1467
1468ShiftLeftTerm
1469    : PARSEOP_SHIFTLEFT '('         {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);}
1470        TermArg
1471        TermArgItem
1472        Target
1473        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1474    | PARSEOP_SHIFTLEFT '('
1475        error ')'                   {$$ = AslDoError(); yyclearin;}
1476    ;
1477
1478ShiftRightTerm
1479    : PARSEOP_SHIFTRIGHT '('        {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);}
1480        TermArg
1481        TermArgItem
1482        Target
1483        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1484    | PARSEOP_SHIFTRIGHT '('
1485        error ')'                   {$$ = AslDoError(); yyclearin;}
1486    ;
1487
1488SignalTerm
1489    : PARSEOP_SIGNAL '('            {$<n>$ = TrCreateLeafNode (PARSEOP_SIGNAL);}
1490        SuperName
1491        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1492    | PARSEOP_SIGNAL '('
1493        error ')'                   {$$ = AslDoError(); yyclearin;}
1494    ;
1495
1496SizeOfTerm
1497    : PARSEOP_SIZEOF '('            {$<n>$ = TrCreateLeafNode (PARSEOP_SIZEOF);}
1498        SuperName
1499        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1500    | PARSEOP_SIZEOF '('
1501        error ')'                   {$$ = AslDoError(); yyclearin;}
1502    ;
1503
1504SleepTerm
1505    : PARSEOP_SLEEP '('             {$<n>$ = TrCreateLeafNode (PARSEOP_SLEEP);}
1506        TermArg
1507        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1508    | PARSEOP_SLEEP '('
1509        error ')'                   {$$ = AslDoError(); yyclearin;}
1510    ;
1511
1512StallTerm
1513    : PARSEOP_STALL '('             {$<n>$ = TrCreateLeafNode (PARSEOP_STALL);}
1514        TermArg
1515        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1516    | PARSEOP_STALL '('
1517        error ')'                   {$$ = AslDoError(); yyclearin;}
1518    ;
1519
1520StoreTerm
1521    : PARSEOP_STORE '('             {$<n>$ = TrCreateLeafNode (PARSEOP_STORE);}
1522        TermArg
1523        ',' SuperName
1524        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
1525    | PARSEOP_STORE '('
1526        error ')'                   {$$ = AslDoError(); yyclearin;}
1527    ;
1528
1529SubtractTerm
1530    : PARSEOP_SUBTRACT '('          {$<n>$ = TrCreateLeafNode (PARSEOP_SUBTRACT);}
1531        TermArg
1532        TermArgItem
1533        Target
1534        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1535    | PARSEOP_SUBTRACT '('
1536        error ')'                   {$$ = AslDoError(); yyclearin;}
1537    ;
1538SwitchTerm
1539    : PARSEOP_SWITCH '('            {$<n>$ = TrCreateLeafNode (PARSEOP_SWITCH);}
1540        TermArg
1541        ')' '{'
1542            CaseDefaultTermList '}'
1543                                    {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1544    | PARSEOP_SWITCH '('
1545        error ')'                   {$$ = AslDoError(); yyclearin;}
1546    ;
1547
1548ThermalZoneTerm
1549    : PARSEOP_THERMALZONE '('       {$<n>$ = TrCreateLeafNode (PARSEOP_THERMALZONE);}
1550        NameString
1551        ')' '{'
1552            TermList '}'            {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
1553    | PARSEOP_THERMALZONE '('
1554        error ')'                   {$$ = AslDoError(); yyclearin;}
1555    ;
1556
1557TimerTerm
1558    : PARSEOP_TIMER '('             {$<n>$ = TrCreateLeafNode (PARSEOP_TIMER);}
1559        ')'                         {$$ = TrLinkChildren ($<n>3,0);}
1560    | PARSEOP_TIMER                 {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_TIMER),0);}
1561    | PARSEOP_TIMER '('
1562        error ')'                   {$$ = AslDoError(); yyclearin;}
1563    ;
1564
1565ToBCDTerm
1566    : PARSEOP_TOBCD '('             {$<n>$ = TrCreateLeafNode (PARSEOP_TOBCD);}
1567        TermArg
1568        Target
1569        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1570    | PARSEOP_TOBCD '('
1571        error ')'                   {$$ = AslDoError(); yyclearin;}
1572    ;
1573
1574ToBufferTerm
1575    : PARSEOP_TOBUFFER '('          {$<n>$ = TrCreateLeafNode (PARSEOP_TOBUFFER);}
1576        TermArg
1577        Target
1578        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1579    | PARSEOP_TOBUFFER '('
1580        error ')'                   {$$ = AslDoError(); yyclearin;}
1581    ;
1582
1583ToDecimalStringTerm
1584    : PARSEOP_TODECIMALSTRING '('   {$<n>$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);}
1585        TermArg
1586        Target
1587        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1588    | PARSEOP_TODECIMALSTRING '('
1589        error ')'                   {$$ = AslDoError(); yyclearin;}
1590    ;
1591
1592ToHexStringTerm
1593    : PARSEOP_TOHEXSTRING '('       {$<n>$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);}
1594        TermArg
1595        Target
1596        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1597    | PARSEOP_TOHEXSTRING '('
1598        error ')'                   {$$ = AslDoError(); yyclearin;}
1599    ;
1600
1601ToIntegerTerm
1602    : PARSEOP_TOINTEGER '('         {$<n>$ = TrCreateLeafNode (PARSEOP_TOINTEGER);}
1603        TermArg
1604        Target
1605        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1606    | PARSEOP_TOINTEGER '('
1607        error ')'                   {$$ = AslDoError(); yyclearin;}
1608    ;
1609
1610ToPLDTerm
1611    : PARSEOP_TOPLD '('             {$<n>$ = TrCreateLeafNode (PARSEOP_TOPLD);}
1612        PldKeywordList
1613        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1614    | PARSEOP_TOPLD '('
1615        error ')'                   {$$ = AslDoError(); yyclearin;}
1616    ;
1617
1618PldKeywordList
1619    :                               {$$ = NULL;}
1620    | PldKeyword
1621        PARSEOP_EXP_EQUALS Integer  {$$ = TrLinkChildren ($1,1,$3);}
1622    | PldKeyword
1623        PARSEOP_EXP_EQUALS String   {$$ = TrLinkChildren ($1,1,$3);}
1624    | PldKeywordList ','            /* Allows a trailing comma at list end */
1625    | PldKeywordList ','
1626        PldKeyword
1627        PARSEOP_EXP_EQUALS Integer  {$$ = TrLinkPeerNode ($1,TrLinkChildren ($3,1,$5));}
1628    | PldKeywordList ','
1629        PldKeyword
1630        PARSEOP_EXP_EQUALS String   {$$ = TrLinkPeerNode ($1,TrLinkChildren ($3,1,$5));}
1631    ;
1632
1633
1634ToStringTerm
1635    : PARSEOP_TOSTRING '('          {$<n>$ = TrCreateLeafNode (PARSEOP_TOSTRING);}
1636        TermArg
1637        OptionalCount
1638        Target
1639        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1640    | PARSEOP_TOSTRING '('
1641        error ')'                   {$$ = AslDoError(); yyclearin;}
1642    ;
1643
1644ToUUIDTerm
1645    : PARSEOP_TOUUID '('
1646        StringData ')'              {$$ = TrUpdateNode (PARSEOP_TOUUID, $3);}
1647    | PARSEOP_TOUUID '('
1648        error ')'                   {$$ = AslDoError(); yyclearin;}
1649    ;
1650
1651UnicodeTerm
1652    : PARSEOP_UNICODE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_UNICODE);}
1653        StringData
1654        ')'                         {$$ = TrLinkChildren ($<n>3,2,0,$4);}
1655    | PARSEOP_UNICODE '('
1656        error ')'                   {$$ = AslDoError(); yyclearin;}
1657    ;
1658
1659UnloadTerm
1660    : PARSEOP_UNLOAD '('            {$<n>$ = TrCreateLeafNode (PARSEOP_UNLOAD);}
1661        SuperName
1662        ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1663    | PARSEOP_UNLOAD '('
1664        error ')'                   {$$ = AslDoError(); yyclearin;}
1665    ;
1666
1667WaitTerm
1668    : PARSEOP_WAIT '('              {$<n>$ = TrCreateLeafNode (PARSEOP_WAIT);}
1669        SuperName
1670        TermArgItem
1671        ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1672    | PARSEOP_WAIT '('
1673        error ')'                   {$$ = AslDoError(); yyclearin;}
1674    ;
1675
1676XOrTerm
1677    : PARSEOP_XOR '('               {$<n>$ = TrCreateLeafNode (PARSEOP_XOR);}
1678        TermArg
1679        TermArgItem
1680        Target
1681        ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1682    | PARSEOP_XOR '('
1683        error ')'                   {$$ = AslDoError(); yyclearin;}
1684    ;
1685
1686WhileTerm
1687    : PARSEOP_WHILE '('             {$<n>$ = TrCreateLeafNode (PARSEOP_WHILE);}
1688        TermArg
1689        ')' '{' TermList '}'
1690                                    {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1691    | PARSEOP_WHILE '('
1692        error ')'                   {$$ = AslDoError(); yyclearin;}
1693    ;
1694
1695
1696/*******************************************************************************
1697 *
1698 * ASL Helper Terms
1699 *
1700 ******************************************************************************/
1701
1702AmlPackageLengthTerm
1703    : Integer                       {$$ = TrUpdateNode (PARSEOP_PACKAGE_LENGTH,(ACPI_PARSE_OBJECT *) $1);}
1704    ;
1705
1706NameStringItem
1707    : ',' NameString                {$$ = $2;}
1708    | ',' error                     {$$ = AslDoError (); yyclearin;}
1709    ;
1710
1711TermArgItem
1712    : ',' TermArg                   {$$ = $2;}
1713    | ',' error                     {$$ = AslDoError (); yyclearin;}
1714    ;
1715
1716OptionalReference
1717    :                               {$$ = TrCreateLeafNode (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
1718    | ','                           {$$ = TrCreateLeafNode (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
1719    | ',' TermArg                   {$$ = $2;}
1720    ;
1721
1722OptionalReturnArg
1723    :                               {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN);}       /* Placeholder is a ZeroOp object */
1724    | TermArg                       {$$ = $1;}
1725    ;
1726
1727OptionalSerializeRuleKeyword
1728    :                               {$$ = NULL;}
1729    | ','                           {$$ = NULL;}
1730    | ',' SerializeRuleKeyword      {$$ = $2;}
1731    ;
1732
1733OptionalTermArg
1734    :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
1735    | TermArg                       {$$ = $1;}
1736    ;
1737
1738OptionalBufferLength
1739    :                               {$$ = NULL;}
1740    | TermArg                       {$$ = $1;}
1741    ;
1742
1743OptionalWordConst
1744    :                               {$$ = NULL;}
1745    | WordConst                     {$$ = $1;}
1746    ;
1747