1 NoEcho('
2 /******************************************************************************
3  *
4  * Module Name: aslrules.y - Bison/Yacc production rules
5  *
6  *****************************************************************************/
7 
8 /*
9  * Copyright (C) 2000 - 2014, 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  * Production rules start here
50  *
51  ******************************************************************************/
52 
53 /*
54  * ASL Names
55  *
56  * Root rule. Allow multiple #line directives before the definition block
57  * to handle output from preprocessors
58  */
59 ASLCode
60     : DefinitionBlockTerm
61     | error                         {YYABORT; $$ = NULL;}
62     ;
63 
64 /*
65  * Blocks, Data, and Opcodes
66  */
67 
68 /*
69  * Note concerning support for "module-level code".
70  *
71  * ACPI 1.0 allowed Type1 and Type2 executable opcodes outside of control
72  * methods (the so-called module-level code.) This support was explicitly
73  * removed in ACPI 2.0, but this type of code continues to be created by
74  * BIOS vendors. In order to support the disassembly and recompilation of
75  * such code (and the porting of ASL code to iASL), iASL supports this
76  * code in violation of the current ACPI specification.
77  *
78  * The grammar change to support module-level code is to revert the
79  * {ObjectList} portion of the DefinitionBlockTerm in ACPI 2.0 to the
80  * original use of {TermList} instead (see below.) This allows the use
81  * of Type1 and Type2 opcodes at module level.
82  */
83 DefinitionBlockTerm
84     : PARSEOP_DEFINITIONBLOCK '('   {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITIONBLOCK);}
85         String ','
86         String ','
87         ByteConst ','
88         String ','
89         String ','
90         DWordConst
91         ')'                         {TrSetEndLineNumber ($<n>3);}
92             '{' TermList '}'        {$$ = TrLinkChildren ($<n>3,7,$4,$6,$8,$10,$12,$14,$18);}
93     ;
94 
95 /* ACPI 3.0 -- allow semicolons between terms */
96 
97 TermList
98     :                               {$$ = NULL;}
99     | TermList Term                 {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
100     | TermList Term ';'             {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
101     | TermList ';' Term             {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
102     | TermList ';' Term ';'         {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
103     ;
104 
105 Term
106     : Object                        {}
107     | Type1Opcode                   {}
108     | Type2Opcode                   {}
109     | Type2IntegerOpcode            {}
110     | Type2StringOpcode             {}
111     | Type2BufferOpcode             {}
112     | Type2BufferOrStringOpcode     {}
113     | error                         {$$ = AslDoError(); yyclearin;}
114     ;
115 
116 CompilerDirective
117     : IncludeTerm                   {}
118     | ExternalTerm                  {}
119     ;
120 
121 ObjectList
122     :                               {$$ = NULL;}
123     | ObjectList Object             {$$ = TrLinkPeerNode ($1,$2);}
124     | error                         {$$ = AslDoError(); yyclearin;}
125     ;
126 
127 Object
128     : CompilerDirective             {}
129     | NamedObject                   {}
130     | NameSpaceModifier             {}
131     ;
132 
133 DataObject
134     : BufferData                    {}
135     | PackageData                   {}
136     | IntegerData                   {}
137     | StringData                    {}
138     ;
139 
140 BufferData
141     : Type5Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
142     | Type2BufferOrStringOpcode     {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
143     | Type2BufferOpcode             {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
144     | BufferTerm                    {}
145     ;
146 
147 PackageData
148     : PackageTerm                   {}
149     ;
150 
151 IntegerData
152     : Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
153     | Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
154     | Integer                       {}
155     | ConstTerm                     {}
156     ;
157 
158 StringData
159     : Type2StringOpcode             {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
160     | String                        {}
161     ;
162 
163 NamedObject
164     : BankFieldTerm                 {}
165     | CreateBitFieldTerm            {}
166     | CreateByteFieldTerm           {}
167     | CreateDWordFieldTerm          {}
168     | CreateFieldTerm               {}
169     | CreateQWordFieldTerm          {}
170     | CreateWordFieldTerm           {}
171     | DataRegionTerm                {}
172     | DeviceTerm                    {}
173     | EventTerm                     {}
174     | FieldTerm                     {}
175     | FunctionTerm                  {}
176     | IndexFieldTerm                {}
177     | MethodTerm                    {}
178     | MutexTerm                     {}
179     | OpRegionTerm                  {}
180     | PowerResTerm                  {}
181     | ProcessorTerm                 {}
182     | ThermalZoneTerm               {}
183     ;
184 
185 NameSpaceModifier
186     : AliasTerm                     {}
187     | NameTerm                      {}
188     | ScopeTerm                     {}
189     ;
190 
191 UserTerm
192     : NameString '('                {TrUpdateNode (PARSEOP_METHODCALL, $1);}
193         ArgList ')'                 {$$ = TrLinkChildNode ($1,$4);}
194     ;
195 
196 ArgList
197     :                               {$$ = NULL;}
198     | TermArg
199     | ArgList ','                   /* Allows a trailing comma at list end */
200     | ArgList ','
201         TermArg                     {$$ = TrLinkPeerNode ($1,$3);}
202     ;
203 
204 /*
205 Removed from TermArg due to reduce/reduce conflicts
206     | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
207     | Type2StringOpcode             {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
208     | Type2BufferOpcode             {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
209     | Type2BufferOrStringOpcode     {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
210 
211 */
212 
213 TermArg
214     : Type2Opcode                   {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
215     | DataObject                    {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
216     | NameString                    {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
217     | ArgTerm                       {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
218     | LocalTerm                     {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
219     ;
220 
221 Target
222     :                               {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_TARGET | NODE_COMPILE_TIME_CONST);} /* Placeholder is a ZeroOp object */
223     | ','                           {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_TARGET | NODE_COMPILE_TIME_CONST);} /* Placeholder is a ZeroOp object */
224     | ',' SuperName                 {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
225     ;
226 
227 RequiredTarget
228     : ',' SuperName                 {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
229     ;
230 
231 SimpleTarget
232     : NameString                    {}
233     | LocalTerm                     {}
234     | ArgTerm                       {}
235     ;
236 
237 /* Rules for specifying the type of one method argument or return value */
238 
239 ParameterTypePackage
240     :                               {$$ = NULL;}
241     | ObjectTypeKeyword             {$$ = $1;}
242     | ParameterTypePackage ','
243         ObjectTypeKeyword           {$$ = TrLinkPeerNodes (2,$1,$3);}
244     ;
245 
246 ParameterTypePackageList
247     :                               {$$ = NULL;}
248     | ObjectTypeKeyword             {$$ = $1;}
249     | '{' ParameterTypePackage '}'  {$$ = $2;}
250     ;
251 
252 OptionalParameterTypePackage
253     :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
254     | ',' ParameterTypePackageList  {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
255     ;
256 
257 /* Rules for specifying the types for method arguments */
258 
259 ParameterTypesPackage
260     : ParameterTypePackageList      {$$ = $1;}
261     | ParameterTypesPackage ','
262         ParameterTypePackageList    {$$ = TrLinkPeerNodes (2,$1,$3);}
263     ;
264 
265 ParameterTypesPackageList
266     :                               {$$ = NULL;}
267     | ObjectTypeKeyword             {$$ = $1;}
268     | '{' ParameterTypesPackage '}' {$$ = $2;}
269     ;
270 
271 OptionalParameterTypesPackage
272     :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
273     | ',' ParameterTypesPackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
274     ;
275 
276 
277 /* Opcode types */
278 
279 Type1Opcode
280     : BreakTerm                     {}
281     | BreakPointTerm                {}
282     | ContinueTerm                  {}
283     | FatalTerm                     {}
284     | IfElseTerm                    {}
285     | LoadTerm                      {}
286     | NoOpTerm                      {}
287     | NotifyTerm                    {}
288     | ReleaseTerm                   {}
289     | ResetTerm                     {}
290     | ReturnTerm                    {}
291     | SignalTerm                    {}
292     | SleepTerm                     {}
293     | StallTerm                     {}
294     | SwitchTerm                    {}
295     | UnloadTerm                    {}
296     | WhileTerm                     {}
297     ;
298 
299 Type2Opcode
300     : AcquireTerm                   {}
301     | CondRefOfTerm                 {}
302     | CopyObjectTerm                {}
303     | DerefOfTerm                   {}
304     | ObjectTypeTerm                {}
305     | RefOfTerm                     {}
306     | SizeOfTerm                    {}
307     | StoreTerm                     {}
308     | TimerTerm                     {}
309     | WaitTerm                      {}
310     | UserTerm                      {}
311     ;
312 
313 /*
314  * Type 3/4/5 opcodes
315  */
316 
317 Type2IntegerOpcode                  /* "Type3" opcodes */
318     : AddTerm                       {}
319     | AndTerm                       {}
320     | DecTerm                       {}
321     | DivideTerm                    {}
322     | FindSetLeftBitTerm            {}
323     | FindSetRightBitTerm           {}
324     | FromBCDTerm                   {}
325     | IncTerm                       {}
326     | IndexTerm                     {}
327     | LAndTerm                      {}
328     | LEqualTerm                    {}
329     | LGreaterTerm                  {}
330     | LGreaterEqualTerm             {}
331     | LLessTerm                     {}
332     | LLessEqualTerm                {}
333     | LNotTerm                      {}
334     | LNotEqualTerm                 {}
335     | LoadTableTerm                 {}
336     | LOrTerm                       {}
337     | MatchTerm                     {}
338     | ModTerm                       {}
339     | MultiplyTerm                  {}
340     | NAndTerm                      {}
341     | NOrTerm                       {}
342     | NotTerm                       {}
343     | OrTerm                        {}
344     | ShiftLeftTerm                 {}
345     | ShiftRightTerm                {}
346     | SubtractTerm                  {}
347     | ToBCDTerm                     {}
348     | ToIntegerTerm                 {}
349     | XOrTerm                       {}
350     ;
351 
352 Type2StringOpcode                   /* "Type4" Opcodes */
353     : ToDecimalStringTerm           {}
354     | ToHexStringTerm               {}
355     | ToStringTerm                  {}
356     ;
357 
358 Type2BufferOpcode                   /* "Type5" Opcodes */
359     : ToBufferTerm                  {}
360     | ConcatResTerm                 {}
361     ;
362 
363 Type2BufferOrStringOpcode
364     : ConcatTerm                    {}
365     | MidTerm                       {}
366     ;
367 
368 /*
369  * A type 3 opcode evaluates to an Integer and cannot have a destination operand
370  */
371 
372 Type3Opcode
373     : EISAIDTerm                    {}
374     ;
375 
376 /* Obsolete
377 Type4Opcode
378     : ConcatTerm                    {}
379     | ToDecimalStringTerm           {}
380     | ToHexStringTerm               {}
381     | MidTerm                       {}
382     | ToStringTerm                  {}
383     ;
384 */
385 
386 
387 Type5Opcode
388     : ResourceTemplateTerm          {}
389     | UnicodeTerm                   {}
390     | ToUUIDTerm                    {}
391     ;
392 
393 Type6Opcode
394     : RefOfTerm                     {}
395     | DerefOfTerm                   {}
396     | IndexTerm                     {}
397     | UserTerm                      {}
398     ;
399 
400 IncludeTerm
401     : PARSEOP_INCLUDE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_INCLUDE);}
402         String  ')'                 {TrLinkChildren ($<n>3,1,$4);FlOpenIncludeFile ($4);}
403         TermList
404         IncludeEndTerm              {$$ = TrLinkPeerNodes (3,$<n>3,$7,$8);}
405     ;
406 
407 IncludeEndTerm
408     : PARSEOP_INCLUDE_END           {$$ = TrCreateLeafNode (PARSEOP_INCLUDE_END);}
409     ;
410 
411 ExternalTerm
412     : PARSEOP_EXTERNAL '('
413         NameString
414         OptionalObjectTypeKeyword
415         OptionalParameterTypePackage
416         OptionalParameterTypesPackage
417         ')'                         {$$ = TrCreateNode (PARSEOP_EXTERNAL,4,$3,$4,$5,$6);}
418     | PARSEOP_EXTERNAL '('
419         error ')'                   {$$ = AslDoError(); yyclearin;}
420     ;
421 
422 
423 /******* Named Objects *******************************************************/
424 
425 
426 BankFieldTerm
427     : PARSEOP_BANKFIELD '('         {$<n>$ = TrCreateLeafNode (PARSEOP_BANKFIELD);}
428         NameString
429         NameStringItem
430         TermArgItem
431         ',' AccessTypeKeyword
432         ',' LockRuleKeyword
433         ',' UpdateRuleKeyword
434         ')' '{'
435             FieldUnitList '}'       {$$ = TrLinkChildren ($<n>3,7,$4,$5,$6,$8,$10,$12,$15);}
436     | PARSEOP_BANKFIELD '('
437         error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
438     ;
439 
440 FieldUnitList
441     :                               {$$ = NULL;}
442     | FieldUnit
443     | FieldUnitList ','             /* Allows a trailing comma at list end */
444     | FieldUnitList ','
445         FieldUnit                   {$$ = TrLinkPeerNode ($1,$3);}
446     ;
447 
448 FieldUnit
449     : FieldUnitEntry                {}
450     | OffsetTerm                    {}
451     | AccessAsTerm                  {}
452     | ConnectionTerm                {}
453     ;
454 
455 FieldUnitEntry
456     : ',' AmlPackageLengthTerm      {$$ = TrCreateNode (PARSEOP_RESERVED_BYTES,1,$2);}
457     | NameSeg ','
458         AmlPackageLengthTerm        {$$ = TrLinkChildNode ($1,$3);}
459     ;
460 
461 OffsetTerm
462     : PARSEOP_OFFSET '('
463         AmlPackageLengthTerm
464         ')'                         {$$ = TrCreateNode (PARSEOP_OFFSET,1,$3);}
465     | PARSEOP_OFFSET '('
466         error ')'                   {$$ = AslDoError(); yyclearin;}
467     ;
468 
469 AccessAsTerm
470     : PARSEOP_ACCESSAS '('
471         AccessTypeKeyword
472         OptionalAccessAttribTerm
473         ')'                         {$$ = TrCreateNode (PARSEOP_ACCESSAS,2,$3,$4);}
474     | PARSEOP_ACCESSAS '('
475         error ')'                   {$$ = AslDoError(); yyclearin;}
476     ;
477 
478 ConnectionTerm
479     : PARSEOP_CONNECTION '('
480         NameString
481         ')'                         {$$ = TrCreateNode (PARSEOP_CONNECTION,1,$3);}
482     | PARSEOP_CONNECTION '('        {$<n>$ = TrCreateLeafNode (PARSEOP_CONNECTION);}
483         ResourceMacroTerm
484         ')'                         {$$ = TrLinkChildren ($<n>3, 1,
485                                             TrLinkChildren (TrCreateLeafNode (PARSEOP_RESOURCETEMPLATE), 3,
486                                                 TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
487                                                 TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
488                                                 $4));}
489     | PARSEOP_CONNECTION '('
490         error ')'                   {$$ = AslDoError(); yyclearin;}
491     ;
492 
493 CreateBitFieldTerm
494     : PARSEOP_CREATEBITFIELD '('    {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);}
495         TermArg
496         TermArgItem
497         NameStringItem
498         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
499     | PARSEOP_CREATEBITFIELD '('
500         error ')'                   {$$ = AslDoError(); yyclearin;}
501     ;
502 
503 CreateByteFieldTerm
504     : PARSEOP_CREATEBYTEFIELD '('   {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);}
505         TermArg
506         TermArgItem
507         NameStringItem
508         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
509     | PARSEOP_CREATEBYTEFIELD '('
510         error ')'                   {$$ = AslDoError(); yyclearin;}
511     ;
512 
513 CreateDWordFieldTerm
514     : PARSEOP_CREATEDWORDFIELD '('  {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);}
515         TermArg
516         TermArgItem
517         NameStringItem
518         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
519     | PARSEOP_CREATEDWORDFIELD '('
520         error ')'                   {$$ = AslDoError(); yyclearin;}
521     ;
522 
523 CreateFieldTerm
524     : PARSEOP_CREATEFIELD '('       {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);}
525         TermArg
526         TermArgItem
527         TermArgItem
528         NameStringItem
529         ')'                         {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,TrSetNodeFlags ($7, NODE_IS_NAME_DECLARATION));}
530     | PARSEOP_CREATEFIELD '('
531         error ')'                   {$$ = AslDoError(); yyclearin;}
532     ;
533 
534 CreateQWordFieldTerm
535     : PARSEOP_CREATEQWORDFIELD '('  {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);}
536         TermArg
537         TermArgItem
538         NameStringItem
539         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
540     | PARSEOP_CREATEQWORDFIELD '('
541         error ')'                   {$$ = AslDoError(); yyclearin;}
542     ;
543 
544 CreateWordFieldTerm
545     : PARSEOP_CREATEWORDFIELD '('   {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);}
546         TermArg
547         TermArgItem
548         NameStringItem
549         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
550     | PARSEOP_CREATEWORDFIELD '('
551         error ')'                   {$$ = AslDoError(); yyclearin;}
552     ;
553 
554 DataRegionTerm
555     : PARSEOP_DATATABLEREGION '('   {$<n>$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);}
556         NameString
557         TermArgItem
558         TermArgItem
559         TermArgItem
560         ')'                         {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$6,$7);}
561     | PARSEOP_DATATABLEREGION '('
562         error ')'                   {$$ = AslDoError(); yyclearin;}
563     ;
564 
565 DeviceTerm
566     : PARSEOP_DEVICE '('            {$<n>$ = TrCreateLeafNode (PARSEOP_DEVICE);}
567         NameString
568         ')' '{'
569             ObjectList '}'          {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
570     | PARSEOP_DEVICE '('
571         error ')'                   {$$ = AslDoError(); yyclearin;}
572     ;
573 
574 EventTerm
575     : PARSEOP_EVENT '('             {$<n>$ = TrCreateLeafNode (PARSEOP_EVENT);}
576         NameString
577         ')'                         {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));}
578     | PARSEOP_EVENT '('
579         error ')'                   {$$ = AslDoError(); yyclearin;}
580     ;
581 
582 FieldTerm
583     : PARSEOP_FIELD '('             {$<n>$ = TrCreateLeafNode (PARSEOP_FIELD);}
584         NameString
585         ',' AccessTypeKeyword
586         ',' LockRuleKeyword
587         ',' UpdateRuleKeyword
588         ')' '{'
589             FieldUnitList '}'       {$$ = TrLinkChildren ($<n>3,5,$4,$6,$8,$10,$13);}
590     | PARSEOP_FIELD '('
591         error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
592     ;
593 
594 FunctionTerm
595     : PARSEOP_FUNCTION '('          {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
596         NameString
597         OptionalParameterTypePackage
598         OptionalParameterTypesPackage
599         ')' '{'
600             TermList '}'            {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),
601                                         TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),
602                                         TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL),
603                                         TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),$5,$6,$9);}
604     | PARSEOP_FUNCTION '('
605         error ')'                   {$$ = AslDoError(); yyclearin;}
606     ;
607 
608 IndexFieldTerm
609     : PARSEOP_INDEXFIELD '('        {$<n>$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);}
610         NameString
611         NameStringItem
612         ',' AccessTypeKeyword
613         ',' LockRuleKeyword
614         ',' UpdateRuleKeyword
615         ')' '{'
616             FieldUnitList '}'       {$$ = TrLinkChildren ($<n>3,6,$4,$5,$7,$9,$11,$14);}
617     | PARSEOP_INDEXFIELD '('
618         error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
619     ;
620 
621 MethodTerm
622     : PARSEOP_METHOD  '('           {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
623         NameString
624         OptionalByteConstExpr       {UtCheckIntegerRange ($5, 0, 7);}
625         OptionalSerializeRuleKeyword
626         OptionalByteConstExpr
627         OptionalParameterTypePackage
628         OptionalParameterTypesPackage
629         ')' '{'
630             TermList '}'            {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$7,$8,$9,$10,$13);}
631     | PARSEOP_METHOD '('
632         error ')'                   {$$ = AslDoError(); yyclearin;}
633     ;
634 
635 MutexTerm
636     : PARSEOP_MUTEX '('             {$<n>$ = TrCreateLeafNode (PARSEOP_MUTEX);}
637         NameString
638         ',' ByteConstExpr
639         ')'                         {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
640     | PARSEOP_MUTEX '('
641         error ')'                   {$$ = AslDoError(); yyclearin;}
642     ;
643 
644 OpRegionTerm
645     : PARSEOP_OPERATIONREGION '('   {$<n>$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);}
646         NameString
647         ',' OpRegionSpaceIdTerm
648         TermArgItem
649         TermArgItem
650         ')'                         {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8);}
651     | PARSEOP_OPERATIONREGION '('
652         error ')'                   {$$ = AslDoError(); yyclearin;}
653     ;
654 
655 OpRegionSpaceIdTerm
656     : RegionSpaceKeyword            {}
657     | ByteConst                     {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
658     ;
659 
660 PowerResTerm
661     : PARSEOP_POWERRESOURCE '('     {$<n>$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);}
662         NameString
663         ',' ByteConstExpr
664         ',' WordConstExpr
665         ')' '{'
666             ObjectList '}'          {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$8,$11);}
667     | PARSEOP_POWERRESOURCE '('
668         error ')'                   {$$ = AslDoError(); yyclearin;}
669     ;
670 
671 ProcessorTerm
672     : PARSEOP_PROCESSOR '('         {$<n>$ = TrCreateLeafNode (PARSEOP_PROCESSOR);}
673         NameString
674         ',' ByteConstExpr
675         OptionalDWordConstExpr
676         OptionalByteConstExpr
677         ')' '{'
678             ObjectList '}'          {$$ = TrLinkChildren ($<n>3,5,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8,$11);}
679     | PARSEOP_PROCESSOR '('
680         error ')'                   {$$ = AslDoError(); yyclearin;}
681     ;
682 
683 ThermalZoneTerm
684     : PARSEOP_THERMALZONE '('       {$<n>$ = TrCreateLeafNode (PARSEOP_THERMALZONE);}
685         NameString
686         ')' '{'
687             ObjectList '}'          {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
688     | PARSEOP_THERMALZONE '('
689         error ')'                   {$$ = AslDoError(); yyclearin;}
690     ;
691 
692 
693 /******* Namespace modifiers *************************************************/
694 
695 
696 AliasTerm
697     : PARSEOP_ALIAS '('             {$<n>$ = TrCreateLeafNode (PARSEOP_ALIAS);}
698         NameString
699         NameStringItem
700         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));}
701     | PARSEOP_ALIAS '('
702         error ')'                   {$$ = AslDoError(); yyclearin;}
703     ;
704 
705 NameTerm
706     : PARSEOP_NAME '('              {$<n>$ = TrCreateLeafNode (PARSEOP_NAME);}
707         NameString
708         ',' DataObject
709         ')'                         {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
710     | PARSEOP_NAME '('
711         error ')'                   {$$ = AslDoError(); yyclearin;}
712     ;
713 
714 ScopeTerm
715     : PARSEOP_SCOPE '('             {$<n>$ = TrCreateLeafNode (PARSEOP_SCOPE);}
716         NameString
717         ')' '{'
718             ObjectList '}'          {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
719     | PARSEOP_SCOPE '('
720         error ')'                   {$$ = AslDoError(); yyclearin;}
721     ;
722 
723 
724 /******* Type 1 opcodes *******************************************************/
725 
726 
727 BreakTerm
728     : PARSEOP_BREAK                 {$$ = TrCreateNode (PARSEOP_BREAK, 0);}
729     ;
730 
731 BreakPointTerm
732     : PARSEOP_BREAKPOINT            {$$ = TrCreateNode (PARSEOP_BREAKPOINT, 0);}
733     ;
734 
735 ContinueTerm
736     : PARSEOP_CONTINUE              {$$ = TrCreateNode (PARSEOP_CONTINUE, 0);}
737     ;
738 
739 FatalTerm
740     : PARSEOP_FATAL '('             {$<n>$ = TrCreateLeafNode (PARSEOP_FATAL);}
741         ByteConstExpr
742         ',' DWordConstExpr
743         TermArgItem
744         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
745     | PARSEOP_FATAL '('
746         error ')'                   {$$ = AslDoError(); yyclearin;}
747     ;
748 
749 IfElseTerm
750     : IfTerm ElseTerm               {$$ = TrLinkPeerNode ($1,$2);}
751     ;
752 
753 IfTerm
754     : PARSEOP_IF '('                {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
755         TermArg
756         ')' '{'
757             TermList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
758 
759     | PARSEOP_IF '('
760         error ')'                   {$$ = AslDoError(); yyclearin;}
761     ;
762 
763 ElseTerm
764     :                               {$$ = NULL;}
765     | PARSEOP_ELSE '{'              {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
766         TermList '}'                {$$ = TrLinkChildren ($<n>3,1,$4);}
767 
768     | PARSEOP_ELSE '{'
769         error '}'                   {$$ = AslDoError(); yyclearin;}
770 
771     | PARSEOP_ELSE
772         error                       {$$ = AslDoError(); yyclearin;}
773 
774     | PARSEOP_ELSEIF '('            {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
775         TermArg                     {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
776         ')' '{'
777             TermList '}'            {TrLinkChildren ($<n>5,2,$4,$8);}
778         ElseTerm                    {TrLinkPeerNode ($<n>5,$11);}
779                                     {$$ = TrLinkChildren ($<n>3,1,$<n>5);}
780 
781     | PARSEOP_ELSEIF '('
782         error ')'                   {$$ = AslDoError(); yyclearin;}
783 
784     | PARSEOP_ELSEIF
785         error                       {$$ = AslDoError(); yyclearin;}
786     ;
787 
788 LoadTerm
789     : PARSEOP_LOAD '('              {$<n>$ = TrCreateLeafNode (PARSEOP_LOAD);}
790         NameString
791         RequiredTarget
792         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
793     | PARSEOP_LOAD '('
794         error ')'                   {$$ = AslDoError(); yyclearin;}
795     ;
796 
797 NoOpTerm
798     : PARSEOP_NOOP                  {$$ = TrCreateNode (PARSEOP_NOOP, 0);}
799     ;
800 
801 NotifyTerm
802     : PARSEOP_NOTIFY '('            {$<n>$ = TrCreateLeafNode (PARSEOP_NOTIFY);}
803         SuperName
804         TermArgItem
805         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
806     | PARSEOP_NOTIFY '('
807         error ')'                   {$$ = AslDoError(); yyclearin;}
808     ;
809 
810 ReleaseTerm
811     : PARSEOP_RELEASE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_RELEASE);}
812         SuperName
813         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
814     | PARSEOP_RELEASE '('
815         error ')'                   {$$ = AslDoError(); yyclearin;}
816     ;
817 
818 ResetTerm
819     : PARSEOP_RESET '('             {$<n>$ = TrCreateLeafNode (PARSEOP_RESET);}
820         SuperName
821         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
822     | PARSEOP_RESET '('
823         error ')'                   {$$ = AslDoError(); yyclearin;}
824     ;
825 
826 ReturnTerm
827     : PARSEOP_RETURN '('            {$<n>$ = TrCreateLeafNode (PARSEOP_RETURN);}
828         OptionalReturnArg
829         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
830     | PARSEOP_RETURN                {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_RETURN),1,TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN));}
831     | PARSEOP_RETURN '('
832         error ')'                   {$$ = AslDoError(); yyclearin;}
833     ;
834 
835 SignalTerm
836     : PARSEOP_SIGNAL '('            {$<n>$ = TrCreateLeafNode (PARSEOP_SIGNAL);}
837         SuperName
838         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
839     | PARSEOP_SIGNAL '('
840         error ')'                   {$$ = AslDoError(); yyclearin;}
841     ;
842 
843 SleepTerm
844     : PARSEOP_SLEEP '('             {$<n>$ = TrCreateLeafNode (PARSEOP_SLEEP);}
845         TermArg
846         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
847     | PARSEOP_SLEEP '('
848         error ')'                   {$$ = AslDoError(); yyclearin;}
849     ;
850 
851 StallTerm
852     : PARSEOP_STALL '('             {$<n>$ = TrCreateLeafNode (PARSEOP_STALL);}
853         TermArg
854         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
855     | PARSEOP_STALL '('
856         error ')'                   {$$ = AslDoError(); yyclearin;}
857     ;
858 
859 SwitchTerm
860     : PARSEOP_SWITCH '('            {$<n>$ = TrCreateLeafNode (PARSEOP_SWITCH);}
861         TermArg
862         ')' '{'
863             CaseDefaultTermList '}'
864                                     {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
865     | PARSEOP_SWITCH '('
866         error ')'                   {$$ = AslDoError(); yyclearin;}
867     ;
868 
869 /*
870  * Case-Default list; allow only one Default term and unlimited Case terms
871  */
872 
873 CaseDefaultTermList
874     :                               {$$ = NULL;}
875     | CaseTerm  {}
876     | DefaultTerm   {}
877     | CaseDefaultTermList
878         CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
879     | CaseDefaultTermList
880         DefaultTerm                 {$$ = TrLinkPeerNode ($1,$2);}
881 
882 /* Original - attempts to force zero or one default term within the switch */
883 
884 /*
885 CaseDefaultTermList
886     :                               {$$ = NULL;}
887     | CaseTermList
888         DefaultTerm
889         CaseTermList                {$$ = TrLinkPeerNode ($1,TrLinkPeerNode ($2, $3));}
890     | CaseTermList
891         CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
892     ;
893 
894 CaseTermList
895     :                               {$$ = NULL;}
896     | CaseTerm                      {}
897     | CaseTermList
898         CaseTerm                    {$$ = TrLinkPeerNode ($1,$2);}
899     ;
900 */
901 
902 CaseTerm
903     : PARSEOP_CASE '('              {$<n>$ = TrCreateLeafNode (PARSEOP_CASE);}
904         DataObject
905         ')' '{'
906             TermList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
907     | PARSEOP_CASE '('
908         error ')'                   {$$ = AslDoError(); yyclearin;}
909     ;
910 
911 DefaultTerm
912     : PARSEOP_DEFAULT '{'           {$<n>$ = TrCreateLeafNode (PARSEOP_DEFAULT);}
913         TermList '}'                {$$ = TrLinkChildren ($<n>3,1,$4);}
914     | PARSEOP_DEFAULT '{'
915         error '}'                   {$$ = AslDoError(); yyclearin;}
916     ;
917 
918 UnloadTerm
919     : PARSEOP_UNLOAD '('            {$<n>$ = TrCreateLeafNode (PARSEOP_UNLOAD);}
920         SuperName
921         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
922     | PARSEOP_UNLOAD '('
923         error ')'                   {$$ = AslDoError(); yyclearin;}
924     ;
925 
926 WhileTerm
927     : PARSEOP_WHILE '('             {$<n>$ = TrCreateLeafNode (PARSEOP_WHILE);}
928         TermArg
929         ')' '{' TermList '}'
930                                     {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
931     | PARSEOP_WHILE '('
932         error ')'                   {$$ = AslDoError(); yyclearin;}
933     ;
934 
935 
936 /******* Type 2 opcodes *******************************************************/
937 
938 AcquireTerm
939     : PARSEOP_ACQUIRE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_ACQUIRE);}
940         SuperName
941         ',' WordConstExpr
942         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$6);}
943     | PARSEOP_ACQUIRE '('
944         error ')'                   {$$ = AslDoError(); yyclearin;}
945     ;
946 
947 AddTerm
948     : PARSEOP_ADD '('               {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);}
949         TermArg
950         TermArgItem
951         Target
952         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
953     | PARSEOP_ADD '('
954         error ')'                   {$$ = AslDoError(); yyclearin;}
955     ;
956 
957 AndTerm
958     : PARSEOP_AND '('               {$<n>$ = TrCreateLeafNode (PARSEOP_AND);}
959         TermArg
960         TermArgItem
961         Target
962         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
963     | PARSEOP_AND '('
964         error ')'                   {$$ = AslDoError(); yyclearin;}
965     ;
966 
967 ConcatTerm
968     : PARSEOP_CONCATENATE '('       {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATE);}
969         TermArg
970         TermArgItem
971         Target
972         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
973     | PARSEOP_CONCATENATE '('
974         error ')'                   {$$ = AslDoError(); yyclearin;}
975     ;
976 
977 ConcatResTerm
978     : PARSEOP_CONCATENATERESTEMPLATE '('    {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATERESTEMPLATE);}
979         TermArg
980         TermArgItem
981         Target
982         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
983     | PARSEOP_CONCATENATERESTEMPLATE '('
984         error ')'                   {$$ = AslDoError(); yyclearin;}
985     ;
986 
987 CondRefOfTerm
988     : PARSEOP_CONDREFOF '('         {$<n>$ = TrCreateLeafNode (PARSEOP_CONDREFOF);}
989         SuperName
990         Target
991         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
992     | PARSEOP_CONDREFOF '('
993         error ')'                   {$$ = AslDoError(); yyclearin;}
994     ;
995 
996 CopyObjectTerm
997     : PARSEOP_COPYOBJECT '('        {$<n>$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);}
998         TermArg
999         ',' SimpleTarget
1000         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
1001     | PARSEOP_COPYOBJECT '('
1002         error ')'                   {$$ = AslDoError(); yyclearin;}
1003     ;
1004 
1005 DecTerm
1006     : PARSEOP_DECREMENT '('         {$<n>$ = TrCreateLeafNode (PARSEOP_DECREMENT);}
1007         SuperName
1008         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1009     | PARSEOP_DECREMENT '('
1010         error ')'                   {$$ = AslDoError(); yyclearin;}
1011     ;
1012 
1013 DerefOfTerm
1014     : PARSEOP_DEREFOF '('           {$<n>$ = TrCreateLeafNode (PARSEOP_DEREFOF);}
1015         TermArg
1016         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1017     | PARSEOP_DEREFOF '('
1018         error ')'                   {$$ = AslDoError(); yyclearin;}
1019     ;
1020 
1021 DivideTerm
1022     : PARSEOP_DIVIDE '('            {$<n>$ = TrCreateLeafNode (PARSEOP_DIVIDE);}
1023         TermArg
1024         TermArgItem
1025         Target
1026         Target
1027         ')'                         {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);}
1028     | PARSEOP_DIVIDE '('
1029         error ')'                   {$$ = AslDoError(); yyclearin;}
1030     ;
1031 
1032 FindSetLeftBitTerm
1033     : PARSEOP_FINDSETLEFTBIT '('    {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);}
1034         TermArg
1035         Target
1036         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1037     | PARSEOP_FINDSETLEFTBIT '('
1038         error ')'                   {$$ = AslDoError(); yyclearin;}
1039     ;
1040 
1041 FindSetRightBitTerm
1042     : PARSEOP_FINDSETRIGHTBIT '('   {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);}
1043         TermArg
1044         Target
1045         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1046     | PARSEOP_FINDSETRIGHTBIT '('
1047         error ')'                   {$$ = AslDoError(); yyclearin;}
1048     ;
1049 
1050 FromBCDTerm
1051     : PARSEOP_FROMBCD '('           {$<n>$ = TrCreateLeafNode (PARSEOP_FROMBCD);}
1052         TermArg
1053         Target
1054         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1055     | PARSEOP_FROMBCD '('
1056         error ')'                   {$$ = AslDoError(); yyclearin;}
1057     ;
1058 
1059 IncTerm
1060     : PARSEOP_INCREMENT '('         {$<n>$ = TrCreateLeafNode (PARSEOP_INCREMENT);}
1061         SuperName
1062         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1063     | PARSEOP_INCREMENT '('
1064         error ')'                   {$$ = AslDoError(); yyclearin;}
1065     ;
1066 
1067 IndexTerm
1068     : PARSEOP_INDEX '('             {$<n>$ = TrCreateLeafNode (PARSEOP_INDEX);}
1069         TermArg
1070         TermArgItem
1071         Target
1072         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1073     | PARSEOP_INDEX '('
1074         error ')'                   {$$ = AslDoError(); yyclearin;}
1075     ;
1076 
1077 LAndTerm
1078     : PARSEOP_LAND '('              {$<n>$ = TrCreateLeafNode (PARSEOP_LAND);}
1079         TermArg
1080         TermArgItem
1081         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1082     | PARSEOP_LAND '('
1083         error ')'                   {$$ = AslDoError(); yyclearin;}
1084     ;
1085 
1086 LEqualTerm
1087     : PARSEOP_LEQUAL '('            {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
1088         TermArg
1089         TermArgItem
1090         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1091     | PARSEOP_LEQUAL '('
1092         error ')'                   {$$ = AslDoError(); yyclearin;}
1093     ;
1094 
1095 LGreaterTerm
1096     : PARSEOP_LGREATER '('          {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
1097         TermArg
1098         TermArgItem
1099         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1100     | PARSEOP_LGREATER '('
1101         error ')'                   {$$ = AslDoError(); yyclearin;}
1102     ;
1103 
1104 LGreaterEqualTerm
1105     : PARSEOP_LGREATEREQUAL '('     {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
1106         TermArg
1107         TermArgItem
1108         ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1109     | PARSEOP_LGREATEREQUAL '('
1110         error ')'                   {$$ = AslDoError(); yyclearin;}
1111     ;
1112 
1113 LLessTerm
1114     : PARSEOP_LLESS '('             {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
1115         TermArg
1116         TermArgItem
1117         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1118     | PARSEOP_LLESS '('
1119         error ')'                   {$$ = AslDoError(); yyclearin;}
1120     ;
1121 
1122 LLessEqualTerm
1123     : PARSEOP_LLESSEQUAL '('        {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
1124         TermArg
1125         TermArgItem
1126         ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1127     | PARSEOP_LLESSEQUAL '('
1128         error ')'                   {$$ = AslDoError(); yyclearin;}
1129     ;
1130 
1131 LNotTerm
1132     : PARSEOP_LNOT '('              {$<n>$ = TrCreateLeafNode (PARSEOP_LNOT);}
1133         TermArg
1134         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1135     | PARSEOP_LNOT '('
1136         error ')'                   {$$ = AslDoError(); yyclearin;}
1137     ;
1138 
1139 LNotEqualTerm
1140     : PARSEOP_LNOTEQUAL '('         {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
1141         TermArg
1142         TermArgItem
1143         ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1144     | PARSEOP_LNOTEQUAL '('
1145         error ')'                   {$$ = AslDoError(); yyclearin;}
1146     ;
1147 
1148 LoadTableTerm
1149     : PARSEOP_LOADTABLE '('         {$<n>$ = TrCreateLeafNode (PARSEOP_LOADTABLE);}
1150         TermArg
1151         TermArgItem
1152         TermArgItem
1153         OptionalListString
1154         OptionalListString
1155         OptionalReference
1156         ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$5,$6,$7,$8,$9);}
1157     | PARSEOP_LOADTABLE '('
1158         error ')'                   {$$ = AslDoError(); yyclearin;}
1159     ;
1160 
1161 LOrTerm
1162     : PARSEOP_LOR '('               {$<n>$ = TrCreateLeafNode (PARSEOP_LOR);}
1163         TermArg
1164         TermArgItem
1165         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1166     | PARSEOP_LOR '('
1167         error ')'                   {$$ = AslDoError(); yyclearin;}
1168     ;
1169 
1170 MatchTerm
1171     : PARSEOP_MATCH '('             {$<n>$ = TrCreateLeafNode (PARSEOP_MATCH);}
1172         TermArg
1173         ',' MatchOpKeyword
1174         TermArgItem
1175         ',' MatchOpKeyword
1176         TermArgItem
1177         TermArgItem
1178         ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$6,$7,$9,$10,$11);}
1179     | PARSEOP_MATCH '('
1180         error ')'                   {$$ = AslDoError(); yyclearin;}
1181     ;
1182 
1183 MidTerm
1184     : PARSEOP_MID '('               {$<n>$ = TrCreateLeafNode (PARSEOP_MID);}
1185         TermArg
1186         TermArgItem
1187         TermArgItem
1188         Target
1189         ')'                         {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);}
1190     | PARSEOP_MID '('
1191         error ')'                   {$$ = AslDoError(); yyclearin;}
1192     ;
1193 
1194 ModTerm
1195     : PARSEOP_MOD '('               {$<n>$ = TrCreateLeafNode (PARSEOP_MOD);}
1196         TermArg
1197         TermArgItem
1198         Target
1199         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1200     | PARSEOP_MOD '('
1201         error ')'                   {$$ = AslDoError(); yyclearin;}
1202     ;
1203 
1204 MultiplyTerm
1205     : PARSEOP_MULTIPLY '('          {$<n>$ = TrCreateLeafNode (PARSEOP_MULTIPLY);}
1206         TermArg
1207         TermArgItem
1208         Target
1209         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1210     | PARSEOP_MULTIPLY '('
1211         error ')'                   {$$ = AslDoError(); yyclearin;}
1212     ;
1213 
1214 NAndTerm
1215     : PARSEOP_NAND '('              {$<n>$ = TrCreateLeafNode (PARSEOP_NAND);}
1216         TermArg
1217         TermArgItem
1218         Target
1219         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1220     | PARSEOP_NAND '('
1221         error ')'                   {$$ = AslDoError(); yyclearin;}
1222     ;
1223 
1224 NOrTerm
1225     : PARSEOP_NOR '('               {$<n>$ = TrCreateLeafNode (PARSEOP_NOR);}
1226         TermArg
1227         TermArgItem
1228         Target
1229         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1230     | PARSEOP_NOR '('
1231         error ')'                   {$$ = AslDoError(); yyclearin;}
1232     ;
1233 
1234 NotTerm
1235     : PARSEOP_NOT '('               {$<n>$ = TrCreateLeafNode (PARSEOP_NOT);}
1236         TermArg
1237         Target
1238         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1239     | PARSEOP_NOT '('
1240         error ')'                   {$$ = AslDoError(); yyclearin;}
1241     ;
1242 
1243 ObjectTypeTerm
1244     : PARSEOP_OBJECTTYPE '('        {$<n>$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);}
1245         ObjectTypeName
1246         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1247     | PARSEOP_OBJECTTYPE '('
1248         error ')'                   {$$ = AslDoError(); yyclearin;}
1249     ;
1250 
1251 OrTerm
1252     : PARSEOP_OR '('                {$<n>$ = TrCreateLeafNode (PARSEOP_OR);}
1253         TermArg
1254         TermArgItem
1255         Target
1256         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1257     | PARSEOP_OR '('
1258         error ')'                   {$$ = AslDoError(); yyclearin;}
1259     ;
1260 
1261 /*
1262  * In RefOf, the node isn't really a target, but we can't keep track of it after
1263  * we've taken a pointer to it. (hard to tell if a local becomes initialized this way.)
1264  */
1265 RefOfTerm
1266     : PARSEOP_REFOF '('             {$<n>$ = TrCreateLeafNode (PARSEOP_REFOF);}
1267         SuperName
1268         ')'                         {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));}
1269     | PARSEOP_REFOF '('
1270         error ')'                   {$$ = AslDoError(); yyclearin;}
1271     ;
1272 
1273 ShiftLeftTerm
1274     : PARSEOP_SHIFTLEFT '('         {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);}
1275         TermArg
1276         TermArgItem
1277         Target
1278         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1279     | PARSEOP_SHIFTLEFT '('
1280         error ')'                   {$$ = AslDoError(); yyclearin;}
1281     ;
1282 
1283 ShiftRightTerm
1284     : PARSEOP_SHIFTRIGHT '('        {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);}
1285         TermArg
1286         TermArgItem
1287         Target
1288         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1289     | PARSEOP_SHIFTRIGHT '('
1290         error ')'                   {$$ = AslDoError(); yyclearin;}
1291     ;
1292 
1293 SizeOfTerm
1294     : PARSEOP_SIZEOF '('            {$<n>$ = TrCreateLeafNode (PARSEOP_SIZEOF);}
1295         SuperName
1296         ')'                         {$$ = TrLinkChildren ($<n>3,1,$4);}
1297     | PARSEOP_SIZEOF '('
1298         error ')'                   {$$ = AslDoError(); yyclearin;}
1299     ;
1300 
1301 StoreTerm
1302     : PARSEOP_STORE '('             {$<n>$ = TrCreateLeafNode (PARSEOP_STORE);}
1303         TermArg
1304         ',' SuperName
1305         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
1306     | PARSEOP_STORE '('
1307         error ')'                   {$$ = AslDoError(); yyclearin;}
1308     ;
1309 
1310 SubtractTerm
1311     : PARSEOP_SUBTRACT '('          {$<n>$ = TrCreateLeafNode (PARSEOP_SUBTRACT);}
1312         TermArg
1313         TermArgItem
1314         Target
1315         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1316     | PARSEOP_SUBTRACT '('
1317         error ')'                   {$$ = AslDoError(); yyclearin;}
1318     ;
1319 
1320 TimerTerm
1321     : PARSEOP_TIMER '('             {$<n>$ = TrCreateLeafNode (PARSEOP_TIMER);}
1322         ')'                         {$$ = TrLinkChildren ($<n>3,0);}
1323     | PARSEOP_TIMER                 {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_TIMER),0);}
1324     | PARSEOP_TIMER '('
1325         error ')'                   {$$ = AslDoError(); yyclearin;}
1326     ;
1327 
1328 ToBCDTerm
1329     : PARSEOP_TOBCD '('             {$<n>$ = TrCreateLeafNode (PARSEOP_TOBCD);}
1330         TermArg
1331         Target
1332         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1333     | PARSEOP_TOBCD '('
1334         error ')'                   {$$ = AslDoError(); yyclearin;}
1335     ;
1336 
1337 ToBufferTerm
1338     : PARSEOP_TOBUFFER '('          {$<n>$ = TrCreateLeafNode (PARSEOP_TOBUFFER);}
1339         TermArg
1340         Target
1341         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1342     | PARSEOP_TOBUFFER '('
1343         error ')'                   {$$ = AslDoError(); yyclearin;}
1344     ;
1345 
1346 ToDecimalStringTerm
1347     : PARSEOP_TODECIMALSTRING '('   {$<n>$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);}
1348         TermArg
1349         Target
1350         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1351     | PARSEOP_TODECIMALSTRING '('
1352         error ')'                   {$$ = AslDoError(); yyclearin;}
1353     ;
1354 
1355 ToHexStringTerm
1356     : PARSEOP_TOHEXSTRING '('       {$<n>$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);}
1357         TermArg
1358         Target
1359         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1360     | PARSEOP_TOHEXSTRING '('
1361         error ')'                   {$$ = AslDoError(); yyclearin;}
1362     ;
1363 
1364 ToIntegerTerm
1365     : PARSEOP_TOINTEGER '('         {$<n>$ = TrCreateLeafNode (PARSEOP_TOINTEGER);}
1366         TermArg
1367         Target
1368         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1369     | PARSEOP_TOINTEGER '('
1370         error ')'                   {$$ = AslDoError(); yyclearin;}
1371     ;
1372 
1373 ToStringTerm
1374     : PARSEOP_TOSTRING '('          {$<n>$ = TrCreateLeafNode (PARSEOP_TOSTRING);}
1375         TermArg
1376         OptionalCount
1377         Target
1378         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1379     | PARSEOP_TOSTRING '('
1380         error ')'                   {$$ = AslDoError(); yyclearin;}
1381     ;
1382 
1383 ToUUIDTerm
1384     : PARSEOP_TOUUID '('
1385         StringData ')'              {$$ = TrUpdateNode (PARSEOP_TOUUID, $3);}
1386     | PARSEOP_TOUUID '('
1387         error ')'                   {$$ = AslDoError(); yyclearin;}
1388     ;
1389 
1390 WaitTerm
1391     : PARSEOP_WAIT '('              {$<n>$ = TrCreateLeafNode (PARSEOP_WAIT);}
1392         SuperName
1393         TermArgItem
1394         ')'                         {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1395     | PARSEOP_WAIT '('
1396         error ')'                   {$$ = AslDoError(); yyclearin;}
1397     ;
1398 
1399 XOrTerm
1400     : PARSEOP_XOR '('               {$<n>$ = TrCreateLeafNode (PARSEOP_XOR);}
1401         TermArg
1402         TermArgItem
1403         Target
1404         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1405     | PARSEOP_XOR '('
1406         error ')'                   {$$ = AslDoError(); yyclearin;}
1407     ;
1408 
1409 
1410 /******* Keywords *************************************************************/
1411 
1412 
1413 AccessAttribKeyword
1414     : PARSEOP_ACCESSATTRIB_BLOCK            {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK);}
1415     | PARSEOP_ACCESSATTRIB_BLOCK_CALL       {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK_CALL);}
1416     | PARSEOP_ACCESSATTRIB_BYTE             {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BYTE);}
1417     | PARSEOP_ACCESSATTRIB_QUICK            {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_QUICK );}
1418     | PARSEOP_ACCESSATTRIB_SND_RCV          {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_SND_RCV);}
1419     | PARSEOP_ACCESSATTRIB_WORD             {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD);}
1420     | PARSEOP_ACCESSATTRIB_WORD_CALL        {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD_CALL);}
1421     | PARSEOP_ACCESSATTRIB_MULTIBYTE '('    {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_MULTIBYTE);}
1422         ByteConst
1423         ')'                                 {$$ = TrLinkChildren ($<n>3,1,$4);}
1424     | PARSEOP_ACCESSATTRIB_RAW_BYTES '('    {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_BYTES);}
1425         ByteConst
1426         ')'                                 {$$ = TrLinkChildren ($<n>3,1,$4);}
1427     | PARSEOP_ACCESSATTRIB_RAW_PROCESS '('  {$<n>$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_RAW_PROCESS);}
1428         ByteConst
1429         ')'                                 {$$ = TrLinkChildren ($<n>3,1,$4);}
1430     ;
1431 
1432 AccessTypeKeyword
1433     : PARSEOP_ACCESSTYPE_ANY                {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_ANY);}
1434     | PARSEOP_ACCESSTYPE_BYTE               {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BYTE);}
1435     | PARSEOP_ACCESSTYPE_WORD               {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_WORD);}
1436     | PARSEOP_ACCESSTYPE_DWORD              {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_DWORD);}
1437     | PARSEOP_ACCESSTYPE_QWORD              {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_QWORD);}
1438     | PARSEOP_ACCESSTYPE_BUF                {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BUF);}
1439     ;
1440 
1441 AddressingModeKeyword
1442     : PARSEOP_ADDRESSINGMODE_7BIT           {$$ = TrCreateLeafNode (PARSEOP_ADDRESSINGMODE_7BIT);}
1443     | PARSEOP_ADDRESSINGMODE_10BIT          {$$ = TrCreateLeafNode (PARSEOP_ADDRESSINGMODE_10BIT);}
1444     ;
1445 
1446 AddressKeyword
1447     : PARSEOP_ADDRESSTYPE_MEMORY            {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_MEMORY);}
1448     | PARSEOP_ADDRESSTYPE_RESERVED          {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_RESERVED);}
1449     | PARSEOP_ADDRESSTYPE_NVS               {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_NVS);}
1450     | PARSEOP_ADDRESSTYPE_ACPI              {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_ACPI);}
1451     ;
1452 
1453 AddressSpaceKeyword
1454     : ByteConst                             {$$ = UtCheckIntegerRange ($1, 0x0A, 0xFF);}
1455     | RegionSpaceKeyword                    {}
1456     ;
1457 
1458 BitsPerByteKeyword
1459     : PARSEOP_BITSPERBYTE_FIVE              {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_FIVE);}
1460     | PARSEOP_BITSPERBYTE_SIX               {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_SIX);}
1461     | PARSEOP_BITSPERBYTE_SEVEN             {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_SEVEN);}
1462     | PARSEOP_BITSPERBYTE_EIGHT             {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_EIGHT);}
1463     | PARSEOP_BITSPERBYTE_NINE              {$$ = TrCreateLeafNode (PARSEOP_BITSPERBYTE_NINE);}
1464     ;
1465 
1466 ClockPhaseKeyword
1467     : PARSEOP_CLOCKPHASE_FIRST              {$$ = TrCreateLeafNode (PARSEOP_CLOCKPHASE_FIRST);}
1468     | PARSEOP_CLOCKPHASE_SECOND             {$$ = TrCreateLeafNode (PARSEOP_CLOCKPHASE_SECOND);}
1469     ;
1470 
1471 ClockPolarityKeyword
1472     : PARSEOP_CLOCKPOLARITY_LOW             {$$ = TrCreateLeafNode (PARSEOP_CLOCKPOLARITY_LOW);}
1473     | PARSEOP_CLOCKPOLARITY_HIGH            {$$ = TrCreateLeafNode (PARSEOP_CLOCKPOLARITY_HIGH);}
1474     ;
1475 
1476 DecodeKeyword
1477     : PARSEOP_DECODETYPE_POS                {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_POS);}
1478     | PARSEOP_DECODETYPE_SUB                {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_SUB);}
1479     ;
1480 
1481 DevicePolarityKeyword
1482     : PARSEOP_DEVICEPOLARITY_LOW            {$$ = TrCreateLeafNode (PARSEOP_DEVICEPOLARITY_LOW);}
1483     | PARSEOP_DEVICEPOLARITY_HIGH           {$$ = TrCreateLeafNode (PARSEOP_DEVICEPOLARITY_HIGH);}
1484     ;
1485 
1486 DMATypeKeyword
1487     : PARSEOP_DMATYPE_A                     {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_A);}
1488     | PARSEOP_DMATYPE_COMPATIBILITY         {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_COMPATIBILITY);}
1489     | PARSEOP_DMATYPE_B                     {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_B);}
1490     | PARSEOP_DMATYPE_F                     {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_F);}
1491     ;
1492 
1493 EndianKeyword
1494     : PARSEOP_ENDIAN_LITTLE                 {$$ = TrCreateLeafNode (PARSEOP_ENDIAN_LITTLE);}
1495     | PARSEOP_ENDIAN_BIG                    {$$ = TrCreateLeafNode (PARSEOP_ENDIAN_BIG);}
1496     ;
1497 
1498 FlowControlKeyword
1499     : PARSEOP_FLOWCONTROL_HW                {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_HW);}
1500     | PARSEOP_FLOWCONTROL_NONE              {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_NONE);}
1501     | PARSEOP_FLOWCONTROL_SW                {$$ = TrCreateLeafNode (PARSEOP_FLOWCONTROL_SW);}
1502     ;
1503 
1504 InterruptLevel
1505     : PARSEOP_INTLEVEL_ACTIVEBOTH           {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEBOTH);}
1506     | PARSEOP_INTLEVEL_ACTIVEHIGH           {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEHIGH);}
1507     | PARSEOP_INTLEVEL_ACTIVELOW            {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVELOW);}
1508     ;
1509 
1510 InterruptTypeKeyword
1511     : PARSEOP_INTTYPE_EDGE                  {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_EDGE);}
1512     | PARSEOP_INTTYPE_LEVEL                 {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_LEVEL);}
1513     ;
1514 
1515 IODecodeKeyword
1516     : PARSEOP_IODECODETYPE_16               {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_16);}
1517     | PARSEOP_IODECODETYPE_10               {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_10);}
1518     ;
1519 
1520 IoRestrictionKeyword
1521     : PARSEOP_IORESTRICT_IN                 {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_IN);}
1522     | PARSEOP_IORESTRICT_OUT                {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_OUT);}
1523     | PARSEOP_IORESTRICT_NONE               {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_NONE);}
1524     | PARSEOP_IORESTRICT_PRESERVE           {$$ = TrCreateLeafNode (PARSEOP_IORESTRICT_PRESERVE);}
1525     ;
1526 
1527 LockRuleKeyword
1528     : PARSEOP_LOCKRULE_LOCK                 {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_LOCK);}
1529     | PARSEOP_LOCKRULE_NOLOCK               {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_NOLOCK);}
1530     ;
1531 
1532 MatchOpKeyword
1533     : PARSEOP_MATCHTYPE_MTR                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MTR);}
1534     | PARSEOP_MATCHTYPE_MEQ                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MEQ);}
1535     | PARSEOP_MATCHTYPE_MLE                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLE);}
1536     | PARSEOP_MATCHTYPE_MLT                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLT);}
1537     | PARSEOP_MATCHTYPE_MGE                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGE);}
1538     | PARSEOP_MATCHTYPE_MGT                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGT);}
1539     ;
1540 
1541 MaxKeyword
1542     : PARSEOP_MAXTYPE_FIXED                 {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_FIXED);}
1543     | PARSEOP_MAXTYPE_NOTFIXED              {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_NOTFIXED);}
1544     ;
1545 
1546 MemTypeKeyword
1547     : PARSEOP_MEMTYPE_CACHEABLE             {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_CACHEABLE);}
1548     | PARSEOP_MEMTYPE_WRITECOMBINING        {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_WRITECOMBINING);}
1549     | PARSEOP_MEMTYPE_PREFETCHABLE          {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_PREFETCHABLE);}
1550     | PARSEOP_MEMTYPE_NONCACHEABLE          {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_NONCACHEABLE);}
1551     ;
1552 
1553 MinKeyword
1554     : PARSEOP_MINTYPE_FIXED                 {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_FIXED);}
1555     | PARSEOP_MINTYPE_NOTFIXED              {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_NOTFIXED);}
1556     ;
1557 
1558 ObjectTypeKeyword
1559     : PARSEOP_OBJECTTYPE_UNK                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
1560     | PARSEOP_OBJECTTYPE_INT                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_INT);}
1561     | PARSEOP_OBJECTTYPE_STR                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_STR);}
1562     | PARSEOP_OBJECTTYPE_BUF                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BUF);}
1563     | PARSEOP_OBJECTTYPE_PKG                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PKG);}
1564     | PARSEOP_OBJECTTYPE_FLD                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_FLD);}
1565     | PARSEOP_OBJECTTYPE_DEV                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DEV);}
1566     | PARSEOP_OBJECTTYPE_EVT                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_EVT);}
1567     | PARSEOP_OBJECTTYPE_MTH                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTH);}
1568     | PARSEOP_OBJECTTYPE_MTX                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTX);}
1569     | PARSEOP_OBJECTTYPE_OPR                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_OPR);}
1570     | PARSEOP_OBJECTTYPE_POW                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_POW);}
1571     | PARSEOP_OBJECTTYPE_PRO                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PRO);}
1572     | PARSEOP_OBJECTTYPE_THZ                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_THZ);}
1573     | PARSEOP_OBJECTTYPE_BFF                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BFF);}
1574     | PARSEOP_OBJECTTYPE_DDB                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DDB);}
1575     ;
1576 
1577 ParityTypeKeyword
1578     : PARSEOP_PARITYTYPE_SPACE              {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_SPACE);}
1579     | PARSEOP_PARITYTYPE_MARK               {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_MARK);}
1580     | PARSEOP_PARITYTYPE_ODD                {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_ODD);}
1581     | PARSEOP_PARITYTYPE_EVEN               {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_EVEN);}
1582     | PARSEOP_PARITYTYPE_NONE               {$$ = TrCreateLeafNode (PARSEOP_PARITYTYPE_NONE);}
1583     ;
1584 
1585 PinConfigByte
1586     : PinConfigKeyword                      {$$ = $1;}
1587     | ByteConstExpr                         {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
1588     ;
1589 
1590 PinConfigKeyword
1591     : PARSEOP_PIN_NOPULL                    {$$ = TrCreateLeafNode (PARSEOP_PIN_NOPULL);}
1592     | PARSEOP_PIN_PULLDOWN                  {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLDOWN);}
1593     | PARSEOP_PIN_PULLUP                    {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLUP);}
1594     | PARSEOP_PIN_PULLDEFAULT               {$$ = TrCreateLeafNode (PARSEOP_PIN_PULLDEFAULT);}
1595     ;
1596 
1597 RangeTypeKeyword
1598     : PARSEOP_RANGETYPE_ISAONLY             {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ISAONLY);}
1599     | PARSEOP_RANGETYPE_NONISAONLY          {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_NONISAONLY);}
1600     | PARSEOP_RANGETYPE_ENTIRE              {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ENTIRE);}
1601     ;
1602 
1603 RegionSpaceKeyword
1604     : PARSEOP_REGIONSPACE_IO                {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IO);}
1605     | PARSEOP_REGIONSPACE_MEM               {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_MEM);}
1606     | PARSEOP_REGIONSPACE_PCI               {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCI);}
1607     | PARSEOP_REGIONSPACE_EC                {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_EC);}
1608     | PARSEOP_REGIONSPACE_SMBUS             {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_SMBUS);}
1609     | PARSEOP_REGIONSPACE_CMOS              {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_CMOS);}
1610     | PARSEOP_REGIONSPACE_PCIBAR            {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCIBAR);}
1611     | PARSEOP_REGIONSPACE_IPMI              {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IPMI);}
1612     | PARSEOP_REGIONSPACE_GPIO              {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_GPIO);}
1613     | PARSEOP_REGIONSPACE_GSBUS             {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_GSBUS);}
1614     | PARSEOP_REGIONSPACE_PCC               {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCC);}
1615     | PARSEOP_REGIONSPACE_FFIXEDHW          {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_FFIXEDHW);}
1616     ;
1617 
1618 ResourceTypeKeyword
1619     : PARSEOP_RESOURCETYPE_CONSUMER         {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
1620     | PARSEOP_RESOURCETYPE_PRODUCER         {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_PRODUCER);}
1621     ;
1622 
1623 SerializeRuleKeyword
1624     : PARSEOP_SERIALIZERULE_SERIAL          {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_SERIAL);}
1625     | PARSEOP_SERIALIZERULE_NOTSERIAL       {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL);}
1626     ;
1627 
1628 ShareTypeKeyword
1629     : PARSEOP_SHARETYPE_SHARED              {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHARED);}
1630     | PARSEOP_SHARETYPE_EXCLUSIVE           {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVE);}
1631     | PARSEOP_SHARETYPE_SHAREDWAKE          {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHAREDWAKE);}
1632     | PARSEOP_SHARETYPE_EXCLUSIVEWAKE       {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVEWAKE);}
1633    ;
1634 
1635 SlaveModeKeyword
1636     : PARSEOP_SLAVEMODE_CONTROLLERINIT      {$$ = TrCreateLeafNode (PARSEOP_SLAVEMODE_CONTROLLERINIT);}
1637     | PARSEOP_SLAVEMODE_DEVICEINIT          {$$ = TrCreateLeafNode (PARSEOP_SLAVEMODE_DEVICEINIT);}
1638     ;
1639 
1640 StopBitsKeyword
1641     : PARSEOP_STOPBITS_TWO                  {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_TWO);}
1642     | PARSEOP_STOPBITS_ONEPLUSHALF          {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ONEPLUSHALF);}
1643     | PARSEOP_STOPBITS_ONE                  {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ONE);}
1644     | PARSEOP_STOPBITS_ZERO                 {$$ = TrCreateLeafNode (PARSEOP_STOPBITS_ZERO);}
1645     ;
1646 
1647 TranslationKeyword
1648     : PARSEOP_TRANSLATIONTYPE_SPARSE        {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_SPARSE);}
1649     | PARSEOP_TRANSLATIONTYPE_DENSE         {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_DENSE);}
1650     ;
1651 
1652 TypeKeyword
1653     : PARSEOP_TYPE_TRANSLATION              {$$ = TrCreateLeafNode (PARSEOP_TYPE_TRANSLATION);}
1654     | PARSEOP_TYPE_STATIC                   {$$ = TrCreateLeafNode (PARSEOP_TYPE_STATIC);}
1655     ;
1656 
1657 UpdateRuleKeyword
1658     : PARSEOP_UPDATERULE_PRESERVE           {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_PRESERVE);}
1659     | PARSEOP_UPDATERULE_ONES               {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ONES);}
1660     | PARSEOP_UPDATERULE_ZEROS              {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ZEROS);}
1661     ;
1662 
1663 WireModeKeyword
1664     : PARSEOP_WIREMODE_FOUR                 {$$ = TrCreateLeafNode (PARSEOP_WIREMODE_FOUR);}
1665     | PARSEOP_WIREMODE_THREE                {$$ = TrCreateLeafNode (PARSEOP_WIREMODE_THREE);}
1666     ;
1667 
1668 XferSizeKeyword
1669     : PARSEOP_XFERSIZE_8                    {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_8,   0);}
1670     | PARSEOP_XFERSIZE_16                   {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_16,  1);}
1671     | PARSEOP_XFERSIZE_32                   {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32,  2);}
1672     | PARSEOP_XFERSIZE_64                   {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_64,  3);}
1673     | PARSEOP_XFERSIZE_128                  {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_128, 4);}
1674     | PARSEOP_XFERSIZE_256                  {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_256, 5);}
1675     ;
1676 
1677 XferTypeKeyword
1678     : PARSEOP_XFERTYPE_8                    {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8);}
1679     | PARSEOP_XFERTYPE_8_16                 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8_16);}
1680     | PARSEOP_XFERTYPE_16                   {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_16);}
1681     ;
1682 
1683 
1684 /******* Miscellaneous Types **************************************************/
1685 
1686 
1687 SuperName
1688     : NameString                    {}
1689     | ArgTerm                       {}
1690     | LocalTerm                     {}
1691     | DebugTerm                     {}
1692     | Type6Opcode                   {}
1693 
1694 /* For ObjectType: SuperName except for UserTerm (method invocation) */
1695 
1696 ObjectTypeName
1697     : NameString                    {}
1698     | ArgTerm                       {}
1699     | LocalTerm                     {}
1700     | DebugTerm                     {}
1701     | RefOfTerm                     {}
1702     | DerefOfTerm                   {}
1703     | IndexTerm                     {}
1704 
1705 /*    | UserTerm                      {} */  /* Caused reduce/reduce with Type6Opcode->UserTerm */
1706     ;
1707 
1708 ArgTerm
1709     : PARSEOP_ARG0                  {$$ = TrCreateLeafNode (PARSEOP_ARG0);}
1710     | PARSEOP_ARG1                  {$$ = TrCreateLeafNode (PARSEOP_ARG1);}
1711     | PARSEOP_ARG2                  {$$ = TrCreateLeafNode (PARSEOP_ARG2);}
1712     | PARSEOP_ARG3                  {$$ = TrCreateLeafNode (PARSEOP_ARG3);}
1713     | PARSEOP_ARG4                  {$$ = TrCreateLeafNode (PARSEOP_ARG4);}
1714     | PARSEOP_ARG5                  {$$ = TrCreateLeafNode (PARSEOP_ARG5);}
1715     | PARSEOP_ARG6                  {$$ = TrCreateLeafNode (PARSEOP_ARG6);}
1716     ;
1717 
1718 LocalTerm
1719     : PARSEOP_LOCAL0                {$$ = TrCreateLeafNode (PARSEOP_LOCAL0);}
1720     | PARSEOP_LOCAL1                {$$ = TrCreateLeafNode (PARSEOP_LOCAL1);}
1721     | PARSEOP_LOCAL2                {$$ = TrCreateLeafNode (PARSEOP_LOCAL2);}
1722     | PARSEOP_LOCAL3                {$$ = TrCreateLeafNode (PARSEOP_LOCAL3);}
1723     | PARSEOP_LOCAL4                {$$ = TrCreateLeafNode (PARSEOP_LOCAL4);}
1724     | PARSEOP_LOCAL5                {$$ = TrCreateLeafNode (PARSEOP_LOCAL5);}
1725     | PARSEOP_LOCAL6                {$$ = TrCreateLeafNode (PARSEOP_LOCAL6);}
1726     | PARSEOP_LOCAL7                {$$ = TrCreateLeafNode (PARSEOP_LOCAL7);}
1727     ;
1728 
1729 DebugTerm
1730     : PARSEOP_DEBUG                 {$$ = TrCreateLeafNode (PARSEOP_DEBUG);}
1731     ;
1732 
1733 
1734 ByteConst
1735     : Integer                       {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
1736     ;
1737 
1738 WordConst
1739     : Integer                       {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
1740     ;
1741 
1742 DWordConst
1743     : Integer                       {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
1744     ;
1745 
1746 QWordConst
1747     : Integer                       {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
1748     ;
1749 
1750 Integer
1751     : PARSEOP_INTEGER               {$$ = TrCreateValuedLeafNode (PARSEOP_INTEGER, AslCompilerlval.i);}
1752     ;
1753 
1754 String
1755     : PARSEOP_STRING_LITERAL        {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, (ACPI_NATIVE_INT) AslCompilerlval.s);}
1756     ;
1757 
1758 ConstTerm
1759     : ConstExprTerm                 {}
1760     | PARSEOP_REVISION              {$$ = TrCreateLeafNode (PARSEOP_REVISION);}
1761     ;
1762 
1763 ConstExprTerm
1764     : PARSEOP_ZERO                  {$$ = TrCreateValuedLeafNode (PARSEOP_ZERO, 0);}
1765     | PARSEOP_ONE                   {$$ = TrCreateValuedLeafNode (PARSEOP_ONE, 1);}
1766     | PARSEOP_ONES                  {$$ = TrCreateValuedLeafNode (PARSEOP_ONES, ACPI_UINT64_MAX);}
1767     | PARSEOP___DATE__              {$$ = TrCreateConstantLeafNode (PARSEOP___DATE__);}
1768     | PARSEOP___FILE__              {$$ = TrCreateConstantLeafNode (PARSEOP___FILE__);}
1769     | PARSEOP___LINE__              {$$ = TrCreateConstantLeafNode (PARSEOP___LINE__);}
1770     | PARSEOP___PATH__              {$$ = TrCreateConstantLeafNode (PARSEOP___PATH__);}
1771     ;
1772 
1773 /*
1774  * The NODE_COMPILE_TIME_CONST flag in the following constant expressions
1775  * enables compile-time constant folding to reduce the Type3Opcodes/Type2IntegerOpcodes
1776  * to simple integers. It is an error if these types of expressions cannot be
1777  * reduced, since the AML grammar for ****ConstExpr requires a simple constant.
1778  * Note: The required byte length of the constant is passed through to the
1779  * constant folding code in the node AmlLength field.
1780  */
1781 ByteConstExpr
1782     : Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 1);}
1783     | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 1);}
1784     | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
1785     | ByteConst                     {}
1786     ;
1787 
1788 WordConstExpr
1789     : Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 2);}
1790     | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 2);}
1791     | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
1792     | WordConst                     {}
1793     ;
1794 
1795 DWordConstExpr
1796     : Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 4);}
1797     | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 4);}
1798     | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
1799     | DWordConst                    {}
1800     ;
1801 
1802 QWordConstExpr
1803     : Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 8);}
1804     | Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 8);}
1805     | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
1806     | QWordConst                    {}
1807     ;
1808 
1809 /* OptionalCount must appear before ByteList or an incorrect reduction will result */
1810 
1811 OptionalCount
1812     :                               {$$ = TrCreateLeafNode (PARSEOP_ONES);}       /* Placeholder is a OnesOp object */
1813     | ','                           {$$ = TrCreateLeafNode (PARSEOP_ONES);}       /* Placeholder is a OnesOp object */
1814     | ',' TermArg                   {$$ = $2;}
1815     ;
1816 
1817 BufferTerm
1818     : PARSEOP_BUFFER '('            {$<n>$ = TrCreateLeafNode (PARSEOP_BUFFER);}
1819         OptionalTermArg
1820         ')' '{'
1821             BufferTermData '}'      {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1822     | PARSEOP_BUFFER '('
1823         error ')'                   {$$ = AslDoError(); yyclearin;}
1824     ;
1825 
1826 BufferTermData
1827     : ByteList                      {}
1828     | StringData                    {}
1829     ;
1830 
1831 ByteList
1832     :                               {$$ = NULL;}
1833     | ByteConstExpr
1834     | ByteList ','                  /* Allows a trailing comma at list end */
1835     | ByteList ','
1836         ByteConstExpr               {$$ = TrLinkPeerNode ($1,$3);}
1837     ;
1838 
1839 DataBufferTerm
1840     : PARSEOP_DATABUFFER  '('       {$<n>$ = TrCreateLeafNode (PARSEOP_DATABUFFER);}
1841         OptionalWordConst
1842         ')' '{'
1843             ByteList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1844     | PARSEOP_DATABUFFER '('
1845         error ')'                   {$$ = AslDoError(); yyclearin;}
1846     ;
1847 
1848 DWordList
1849     :                               {$$ = NULL;}
1850     | DWordConstExpr
1851     | DWordList ','                 /* Allows a trailing comma at list end */
1852     | DWordList ','
1853         DWordConstExpr              {$$ = TrLinkPeerNode ($1,$3);}
1854     ;
1855 
1856 PackageTerm
1857     : PARSEOP_PACKAGE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_VAR_PACKAGE);}
1858         VarPackageLengthTerm
1859         ')' '{'
1860             PackageList '}'         {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1861     | PARSEOP_PACKAGE '('
1862         error ')'                   {$$ = AslDoError(); yyclearin;}
1863     ;
1864 
1865 PackageList
1866     :                               {$$ = NULL;}
1867     | PackageElement
1868     | PackageList ','               /* Allows a trailing comma at list end */
1869     | PackageList ','
1870         PackageElement              {$$ = TrLinkPeerNode ($1,$3);}
1871     ;
1872 
1873 PackageElement
1874     : DataObject                    {}
1875     | NameString                    {}
1876     ;
1877 
1878 VarPackageLengthTerm
1879     :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
1880     | TermArg                       {$$ = $1;}
1881     ;
1882 
1883 
1884 /******* Macros ***********************************************/
1885 
1886 
1887 EISAIDTerm
1888     : PARSEOP_EISAID '('
1889         StringData ')'              {$$ = TrUpdateNode (PARSEOP_EISAID, $3);}
1890     | PARSEOP_EISAID '('
1891         error ')'                   {$$ = AslDoError(); yyclearin;}
1892     ;
1893 
1894 UnicodeTerm
1895     : PARSEOP_UNICODE '('           {$<n>$ = TrCreateLeafNode (PARSEOP_UNICODE);}
1896         StringData
1897         ')'                         {$$ = TrLinkChildren ($<n>3,2,0,$4);}
1898     | PARSEOP_UNICODE '('
1899         error ')'                   {$$ = AslDoError(); yyclearin;}
1900     ;
1901 
1902 
1903 /******* Resources and Memory ***********************************************/
1904 
1905 
1906 /*
1907  * Note: Create two default nodes to allow conversion to a Buffer AML opcode
1908  * Also, insert the EndTag at the end of the template.
1909  */
1910 ResourceTemplateTerm
1911     : PARSEOP_RESOURCETEMPLATE '(' ')'
1912         '{'
1913         ResourceMacroList '}'       {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,4,
1914                                           TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
1915                                           TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
1916                                           $5,
1917                                           TrCreateLeafNode (PARSEOP_ENDTAG));}
1918     ;
1919 
1920 ResourceMacroList
1921     :                               {$$ = NULL;}
1922     | ResourceMacroList
1923         ResourceMacroTerm           {$$ = TrLinkPeerNode ($1,$2);}
1924     ;
1925 
1926 ResourceMacroTerm
1927     : DMATerm                       {}
1928     | DWordIOTerm                   {}
1929     | DWordMemoryTerm               {}
1930     | DWordSpaceTerm                {}
1931     | EndDependentFnTerm            {}
1932     | ExtendedIOTerm                {}
1933     | ExtendedMemoryTerm            {}
1934     | ExtendedSpaceTerm             {}
1935     | FixedDmaTerm                  {}
1936     | FixedIOTerm                   {}
1937     | GpioIntTerm                   {}
1938     | GpioIoTerm                    {}
1939     | I2cSerialBusTerm              {}
1940     | InterruptTerm                 {}
1941     | IOTerm                        {}
1942     | IRQNoFlagsTerm                {}
1943     | IRQTerm                       {}
1944     | Memory24Term                  {}
1945     | Memory32FixedTerm             {}
1946     | Memory32Term                  {}
1947     | QWordIOTerm                   {}
1948     | QWordMemoryTerm               {}
1949     | QWordSpaceTerm                {}
1950     | RegisterTerm                  {}
1951     | SpiSerialBusTerm              {}
1952     | StartDependentFnNoPriTerm     {}
1953     | StartDependentFnTerm          {}
1954     | UartSerialBusTerm             {}
1955     | VendorLongTerm                {}
1956     | VendorShortTerm               {}
1957     | WordBusNumberTerm             {}
1958     | WordIOTerm                    {}
1959     | WordSpaceTerm                 {}
1960     ;
1961 
1962 DMATerm
1963     : PARSEOP_DMA '('               {$<n>$ = TrCreateLeafNode (PARSEOP_DMA);}
1964         DMATypeKeyword
1965         OptionalBusMasterKeyword
1966         ',' XferTypeKeyword
1967         OptionalNameString_Last
1968         ')' '{'
1969             ByteList '}'            {$$ = TrLinkChildren ($<n>3,5,$4,$5,$7,$8,$11);}
1970     | PARSEOP_DMA '('
1971         error ')'                   {$$ = AslDoError(); yyclearin;}
1972     ;
1973 
1974 DWordIOTerm
1975     : PARSEOP_DWORDIO '('           {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDIO);}
1976         OptionalResourceType_First
1977         OptionalMinType
1978         OptionalMaxType
1979         OptionalDecodeType
1980         OptionalRangeType
1981         ',' DWordConstExpr
1982         ',' DWordConstExpr
1983         ',' DWordConstExpr
1984         ',' DWordConstExpr
1985         ',' DWordConstExpr
1986         OptionalByteConstExpr
1987         OptionalStringData
1988         OptionalNameString
1989         OptionalType
1990         OptionalTranslationType_Last
1991         ')'                         {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
1992     | PARSEOP_DWORDIO '('
1993         error ')'                   {$$ = AslDoError(); yyclearin;}
1994     ;
1995 
1996 DWordMemoryTerm
1997     : PARSEOP_DWORDMEMORY '('       {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDMEMORY);}
1998         OptionalResourceType_First
1999         OptionalDecodeType
2000         OptionalMinType
2001         OptionalMaxType
2002         OptionalMemType
2003         ',' OptionalReadWriteKeyword
2004         ',' DWordConstExpr
2005         ',' DWordConstExpr
2006         ',' DWordConstExpr
2007         ',' DWordConstExpr
2008         ',' DWordConstExpr
2009         OptionalByteConstExpr
2010         OptionalStringData
2011         OptionalNameString
2012         OptionalAddressRange
2013         OptionalType_Last
2014         ')'                         {$$ = TrLinkChildren ($<n>3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
2015     | PARSEOP_DWORDMEMORY '('
2016         error ')'                   {$$ = AslDoError(); yyclearin;}
2017     ;
2018 
2019 DWordSpaceTerm
2020     : PARSEOP_DWORDSPACE '('        {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDSPACE);}
2021         ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
2022         OptionalResourceType
2023         OptionalDecodeType
2024         OptionalMinType
2025         OptionalMaxType
2026         ',' ByteConstExpr
2027         ',' DWordConstExpr
2028         ',' DWordConstExpr
2029         ',' DWordConstExpr
2030         ',' DWordConstExpr
2031         ',' DWordConstExpr
2032         OptionalByteConstExpr
2033         OptionalStringData
2034         OptionalNameString_Last
2035         ')'                         {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
2036     | PARSEOP_DWORDSPACE '('
2037         error ')'                   {$$ = AslDoError(); yyclearin;}
2038     ;
2039 
2040 
2041 EndDependentFnTerm
2042     : PARSEOP_ENDDEPENDENTFN '('
2043         ')'                         {$$ = TrCreateLeafNode (PARSEOP_ENDDEPENDENTFN);}
2044     | PARSEOP_ENDDEPENDENTFN '('
2045         error ')'                   {$$ = AslDoError(); yyclearin;}
2046     ;
2047 
2048 ExtendedIOTerm
2049     : PARSEOP_EXTENDEDIO '('        {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDIO);}
2050         OptionalResourceType_First
2051         OptionalMinType
2052         OptionalMaxType
2053         OptionalDecodeType
2054         OptionalRangeType
2055         ',' QWordConstExpr
2056         ',' QWordConstExpr
2057         ',' QWordConstExpr
2058         ',' QWordConstExpr
2059         ',' QWordConstExpr
2060         OptionalQWordConstExpr
2061         OptionalNameString
2062         OptionalType
2063         OptionalTranslationType_Last
2064         ')'                         {$$ = TrLinkChildren ($<n>3,14,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22);}
2065     | PARSEOP_EXTENDEDIO '('
2066         error ')'                   {$$ = AslDoError(); yyclearin;}
2067     ;
2068 
2069 ExtendedMemoryTerm
2070     : PARSEOP_EXTENDEDMEMORY '('    {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDMEMORY);}
2071         OptionalResourceType_First
2072         OptionalDecodeType
2073         OptionalMinType
2074         OptionalMaxType
2075         OptionalMemType
2076         ',' OptionalReadWriteKeyword
2077         ',' QWordConstExpr
2078         ',' QWordConstExpr
2079         ',' QWordConstExpr
2080         ',' QWordConstExpr
2081         ',' QWordConstExpr
2082         OptionalQWordConstExpr
2083         OptionalNameString
2084         OptionalAddressRange
2085         OptionalType_Last
2086         ')'                         {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24);}
2087     | PARSEOP_EXTENDEDMEMORY '('
2088         error ')'                   {$$ = AslDoError(); yyclearin;}
2089     ;
2090 
2091 ExtendedSpaceTerm
2092     : PARSEOP_EXTENDEDSPACE '('     {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDSPACE);}
2093         ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
2094         OptionalResourceType
2095         OptionalDecodeType
2096         OptionalMinType
2097         OptionalMaxType
2098         ',' ByteConstExpr
2099         ',' QWordConstExpr
2100         ',' QWordConstExpr
2101         ',' QWordConstExpr
2102         ',' QWordConstExpr
2103         ',' QWordConstExpr
2104         OptionalQWordConstExpr
2105         OptionalNameString_Last
2106         ')'                         {$$ = TrLinkChildren ($<n>3,13,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23);}
2107     | PARSEOP_EXTENDEDSPACE '('
2108         error ')'                   {$$ = AslDoError(); yyclearin;}
2109     ;
2110 
2111 FixedDmaTerm
2112     : PARSEOP_FIXEDDMA '('          {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDDMA);}
2113         WordConstExpr               /* 04: DMA RequestLines */
2114         ',' WordConstExpr           /* 06: DMA Channels */
2115         OptionalXferSize            /* 07: DMA TransferSize */
2116         OptionalNameString          /* 08: DescriptorName */
2117         ')'                         {$$ = TrLinkChildren ($<n>3,4,$4,$6,$7,$8);}
2118     | PARSEOP_FIXEDDMA '('
2119         error ')'                   {$$ = AslDoError(); yyclearin;}
2120     ;
2121 
2122 FixedIOTerm
2123     : PARSEOP_FIXEDIO '('           {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDIO);}
2124         WordConstExpr
2125         ',' ByteConstExpr
2126         OptionalNameString_Last
2127         ')'                         {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
2128     | PARSEOP_FIXEDIO '('
2129         error ')'                   {$$ = AslDoError(); yyclearin;}
2130     ;
2131 
2132 GpioIntTerm
2133     : PARSEOP_GPIO_INT '('          {$<n>$ = TrCreateLeafNode (PARSEOP_GPIO_INT);}
2134         InterruptTypeKeyword        /* 04: InterruptType */
2135         ',' InterruptLevel          /* 06: InterruptLevel */
2136         OptionalShareType           /* 07: SharedType */
2137         ',' PinConfigByte           /* 09: PinConfig */
2138         OptionalWordConstExpr       /* 10: DebounceTimeout */
2139         ',' StringData              /* 12: ResourceSource */
2140         OptionalByteConstExpr       /* 13: ResourceSourceIndex */
2141         OptionalResourceType        /* 14: ResourceType */
2142         OptionalNameString          /* 15: DescriptorName */
2143         OptionalBuffer_Last         /* 16: VendorData */
2144         ')' '{'
2145             DWordConstExpr '}'      {$$ = TrLinkChildren ($<n>3,11,$4,$6,$7,$9,$10,$12,$13,$14,$15,$16,$19);}
2146     | PARSEOP_GPIO_INT '('
2147         error ')'                   {$$ = AslDoError(); yyclearin;}
2148     ;
2149 
2150 GpioIoTerm
2151     : PARSEOP_GPIO_IO '('           {$<n>$ = TrCreateLeafNode (PARSEOP_GPIO_IO);}
2152         OptionalShareType_First     /* 04: SharedType */
2153         ',' PinConfigByte           /* 06: PinConfig */
2154         OptionalWordConstExpr       /* 07: DebounceTimeout */
2155         OptionalWordConstExpr       /* 08: DriveStrength */
2156         OptionalIoRestriction       /* 09: IoRestriction */
2157         ',' StringData              /* 11: ResourceSource */
2158         OptionalByteConstExpr       /* 12: ResourceSourceIndex */
2159         OptionalResourceType        /* 13: ResourceType */
2160         OptionalNameString          /* 14: DescriptorName */
2161         OptionalBuffer_Last         /* 15: VendorData */
2162         ')' '{'
2163             DWordList '}'           {$$ = TrLinkChildren ($<n>3,11,$4,$6,$7,$8,$9,$11,$12,$13,$14,$15,$18);}
2164     | PARSEOP_GPIO_IO '('
2165         error ')'                   {$$ = AslDoError(); yyclearin;}
2166     ;
2167 
2168 I2cSerialBusTerm
2169     : PARSEOP_I2C_SERIALBUS '('     {$<n>$ = TrCreateLeafNode (PARSEOP_I2C_SERIALBUS);}
2170         WordConstExpr               /* 04: SlaveAddress */
2171         OptionalSlaveMode           /* 05: SlaveMode */
2172         ',' DWordConstExpr          /* 07: ConnectionSpeed */
2173         OptionalAddressingMode      /* 08: AddressingMode */
2174         ',' StringData              /* 10: ResourceSource */
2175         OptionalByteConstExpr       /* 11: ResourceSourceIndex */
2176         OptionalResourceType        /* 12: ResourceType */
2177         OptionalNameString          /* 13: DescriptorName */
2178         OptionalBuffer_Last         /* 14: VendorData */
2179         ')'                         {$$ = TrLinkChildren ($<n>3,9,$4,$5,$7,$8,$10,$11,$12,$13,$14);}
2180     | PARSEOP_I2C_SERIALBUS '('
2181         error ')'                   {$$ = AslDoError(); yyclearin;}
2182     ;
2183 
2184 InterruptTerm
2185     : PARSEOP_INTERRUPT '('         {$<n>$ = TrCreateLeafNode (PARSEOP_INTERRUPT);}
2186         OptionalResourceType_First
2187         ',' InterruptTypeKeyword
2188         ',' InterruptLevel
2189         OptionalShareType
2190         OptionalByteConstExpr
2191         OptionalStringData
2192         OptionalNameString_Last
2193         ')' '{'
2194             DWordList '}'           {$$ = TrLinkChildren ($<n>3,8,$4,$6,$8,$9,$10,$11,$12,$15);}
2195     | PARSEOP_INTERRUPT '('
2196         error ')'                   {$$ = AslDoError(); yyclearin;}
2197     ;
2198 
2199 IOTerm
2200     : PARSEOP_IO '('                {$<n>$ = TrCreateLeafNode (PARSEOP_IO);}
2201         IODecodeKeyword
2202         ',' WordConstExpr
2203         ',' WordConstExpr
2204         ',' ByteConstExpr
2205         ',' ByteConstExpr
2206         OptionalNameString_Last
2207         ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
2208     | PARSEOP_IO '('
2209         error ')'                   {$$ = AslDoError(); yyclearin;}
2210     ;
2211 
2212 IRQNoFlagsTerm
2213     : PARSEOP_IRQNOFLAGS '('        {$<n>$ = TrCreateLeafNode (PARSEOP_IRQNOFLAGS);}
2214         OptionalNameString_First
2215         ')' '{'
2216             ByteList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
2217     | PARSEOP_IRQNOFLAGS '('
2218         error ')'                   {$$ = AslDoError(); yyclearin;}
2219     ;
2220 
2221 IRQTerm
2222     : PARSEOP_IRQ '('               {$<n>$ = TrCreateLeafNode (PARSEOP_IRQ);}
2223         InterruptTypeKeyword
2224         ',' InterruptLevel
2225         OptionalShareType
2226         OptionalNameString_Last
2227         ')' '{'
2228             ByteList '}'            {$$ = TrLinkChildren ($<n>3,5,$4,$6,$7,$8,$11);}
2229     | PARSEOP_IRQ '('
2230         error ')'                   {$$ = AslDoError(); yyclearin;}
2231     ;
2232 
2233 Memory24Term
2234     : PARSEOP_MEMORY24 '('          {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY24);}
2235         OptionalReadWriteKeyword
2236         ',' WordConstExpr
2237         ',' WordConstExpr
2238         ',' WordConstExpr
2239         ',' WordConstExpr
2240         OptionalNameString_Last
2241         ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
2242     | PARSEOP_MEMORY24 '('
2243         error ')'                   {$$ = AslDoError(); yyclearin;}
2244     ;
2245 
2246 Memory32FixedTerm
2247     : PARSEOP_MEMORY32FIXED '('     {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32FIXED);}
2248         OptionalReadWriteKeyword
2249         ',' DWordConstExpr
2250         ',' DWordConstExpr
2251         OptionalNameString_Last
2252         ')'                         {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$9);}
2253     | PARSEOP_MEMORY32FIXED '('
2254         error ')'                   {$$ = AslDoError(); yyclearin;}
2255     ;
2256 
2257 Memory32Term
2258     : PARSEOP_MEMORY32 '('          {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32);}
2259         OptionalReadWriteKeyword
2260         ',' DWordConstExpr
2261         ',' DWordConstExpr
2262         ',' DWordConstExpr
2263         ',' DWordConstExpr
2264         OptionalNameString_Last
2265         ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
2266     | PARSEOP_MEMORY32 '('
2267         error ')'                   {$$ = AslDoError(); yyclearin;}
2268     ;
2269 
2270 QWordIOTerm
2271     : PARSEOP_QWORDIO '('           {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDIO);}
2272         OptionalResourceType_First
2273         OptionalMinType
2274         OptionalMaxType
2275         OptionalDecodeType
2276         OptionalRangeType
2277         ',' QWordConstExpr
2278         ',' QWordConstExpr
2279         ',' QWordConstExpr
2280         ',' QWordConstExpr
2281         ',' QWordConstExpr
2282         OptionalByteConstExpr
2283         OptionalStringData
2284         OptionalNameString
2285         OptionalType
2286         OptionalTranslationType_Last
2287         ')'                         {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
2288     | PARSEOP_QWORDIO '('
2289         error ')'                   {$$ = AslDoError(); yyclearin;}
2290     ;
2291 
2292 QWordMemoryTerm
2293     : PARSEOP_QWORDMEMORY '('       {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDMEMORY);}
2294         OptionalResourceType_First
2295         OptionalDecodeType
2296         OptionalMinType
2297         OptionalMaxType
2298         OptionalMemType
2299         ',' OptionalReadWriteKeyword
2300         ',' QWordConstExpr
2301         ',' QWordConstExpr
2302         ',' QWordConstExpr
2303         ',' QWordConstExpr
2304         ',' QWordConstExpr
2305         OptionalByteConstExpr
2306         OptionalStringData
2307         OptionalNameString
2308         OptionalAddressRange
2309         OptionalType_Last
2310         ')'                         {$$ = TrLinkChildren ($<n>3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
2311     | PARSEOP_QWORDMEMORY '('
2312         error ')'                   {$$ = AslDoError(); yyclearin;}
2313     ;
2314 
2315 QWordSpaceTerm
2316     : PARSEOP_QWORDSPACE '('        {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDSPACE);}
2317         ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
2318         OptionalResourceType
2319         OptionalDecodeType
2320         OptionalMinType
2321         OptionalMaxType
2322         ',' ByteConstExpr
2323         ',' QWordConstExpr
2324         ',' QWordConstExpr
2325         ',' QWordConstExpr
2326         ',' QWordConstExpr
2327         ',' QWordConstExpr
2328         OptionalByteConstExpr
2329         OptionalStringData
2330         OptionalNameString_Last
2331         ')'                         {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
2332     | PARSEOP_QWORDSPACE '('
2333         error ')'                   {$$ = AslDoError(); yyclearin;}
2334     ;
2335 
2336 RegisterTerm
2337     : PARSEOP_REGISTER '('          {$<n>$ = TrCreateLeafNode (PARSEOP_REGISTER);}
2338         AddressSpaceKeyword
2339         ',' ByteConstExpr
2340         ',' ByteConstExpr
2341         ',' QWordConstExpr
2342         OptionalAccessSize
2343         OptionalNameString_Last
2344         ')'                         {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$11,$12);}
2345     | PARSEOP_REGISTER '('
2346         error ')'                   {$$ = AslDoError(); yyclearin;}
2347     ;
2348 
2349 SpiSerialBusTerm
2350     : PARSEOP_SPI_SERIALBUS '('     {$<n>$ = TrCreateLeafNode (PARSEOP_SPI_SERIALBUS);}
2351         WordConstExpr               /* 04: DeviceSelection */
2352         OptionalDevicePolarity      /* 05: DevicePolarity */
2353         OptionalWireMode            /* 06: WireMode */
2354         ',' ByteConstExpr           /* 08: DataBitLength */
2355         OptionalSlaveMode           /* 09: SlaveMode */
2356         ',' DWordConstExpr          /* 11: ConnectionSpeed */
2357         ',' ClockPolarityKeyword    /* 13: ClockPolarity */
2358         ',' ClockPhaseKeyword       /* 15: ClockPhase */
2359         ',' StringData              /* 17: ResourceSource */
2360         OptionalByteConstExpr       /* 18: ResourceSourceIndex */
2361         OptionalResourceType        /* 19: ResourceType */
2362         OptionalNameString          /* 20: DescriptorName */
2363         OptionalBuffer_Last         /* 21: VendorData */
2364         ')'                         {$$ = TrLinkChildren ($<n>3,13,$4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,$21);}
2365     | PARSEOP_SPI_SERIALBUS '('
2366         error ')'                   {$$ = AslDoError(); yyclearin;}
2367     ;
2368 
2369 StartDependentFnNoPriTerm
2370     : PARSEOP_STARTDEPENDENTFN_NOPRI '('    {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);}
2371         ')' '{'
2372         ResourceMacroList '}'       {$$ = TrLinkChildren ($<n>3,1,$6);}
2373     | PARSEOP_STARTDEPENDENTFN_NOPRI '('
2374         error ')'                   {$$ = AslDoError(); yyclearin;}
2375     ;
2376 
2377 StartDependentFnTerm
2378     : PARSEOP_STARTDEPENDENTFN '('  {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN);}
2379         ByteConstExpr
2380         ',' ByteConstExpr
2381         ')' '{'
2382         ResourceMacroList '}'       {$$ = TrLinkChildren ($<n>3,3,$4,$6,$9);}
2383     | PARSEOP_STARTDEPENDENTFN '('
2384         error ')'                   {$$ = AslDoError(); yyclearin;}
2385     ;
2386 
2387 UartSerialBusTerm
2388     : PARSEOP_UART_SERIALBUS '('    {$<n>$ = TrCreateLeafNode (PARSEOP_UART_SERIALBUS);}
2389         DWordConstExpr              /* 04: ConnectionSpeed */
2390         OptionalBitsPerByte         /* 05: BitsPerByte */
2391         OptionalStopBits            /* 06: StopBits */
2392         ',' ByteConstExpr           /* 08: LinesInUse */
2393         OptionalEndian              /* 09: Endianess */
2394         OptionalParityType          /* 10: Parity */
2395         OptionalFlowControl         /* 11: FlowControl */
2396         ',' WordConstExpr           /* 13: Rx BufferSize */
2397         ',' WordConstExpr           /* 15: Tx BufferSize */
2398         ',' StringData              /* 17: ResourceSource */
2399         OptionalByteConstExpr       /* 18: ResourceSourceIndex */
2400         OptionalResourceType        /* 19: ResourceType */
2401         OptionalNameString          /* 20: DescriptorName */
2402         OptionalBuffer_Last         /* 21: VendorData */
2403         ')'                         {$$ = TrLinkChildren ($<n>3,14,$4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,$21);}
2404     | PARSEOP_UART_SERIALBUS '('
2405         error ')'                   {$$ = AslDoError(); yyclearin;}
2406     ;
2407 
2408 VendorLongTerm
2409     : PARSEOP_VENDORLONG '('        {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORLONG);}
2410         OptionalNameString_First
2411         ')' '{'
2412             ByteList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
2413     | PARSEOP_VENDORLONG '('
2414         error ')'                   {$$ = AslDoError(); yyclearin;}
2415     ;
2416 
2417 VendorShortTerm
2418     : PARSEOP_VENDORSHORT '('       {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORSHORT);}
2419         OptionalNameString_First
2420         ')' '{'
2421             ByteList '}'            {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
2422     | PARSEOP_VENDORSHORT '('
2423         error ')'                   {$$ = AslDoError(); yyclearin;}
2424     ;
2425 
2426 WordBusNumberTerm
2427     : PARSEOP_WORDBUSNUMBER '('     {$<n>$ = TrCreateLeafNode (PARSEOP_WORDBUSNUMBER);}
2428         OptionalResourceType_First
2429         OptionalMinType
2430         OptionalMaxType
2431         OptionalDecodeType
2432         ',' WordConstExpr
2433         ',' WordConstExpr
2434         ',' WordConstExpr
2435         ',' WordConstExpr
2436         ',' WordConstExpr
2437         OptionalByteConstExpr
2438         OptionalStringData
2439         OptionalNameString_Last
2440         ')'                         {$$ = TrLinkChildren ($<n>3,12,$4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);}
2441     | PARSEOP_WORDBUSNUMBER '('
2442         error ')'                   {$$ = AslDoError(); yyclearin;}
2443     ;
2444 
2445 WordIOTerm
2446     : PARSEOP_WORDIO '('            {$<n>$ = TrCreateLeafNode (PARSEOP_WORDIO);}
2447         OptionalResourceType_First
2448         OptionalMinType
2449         OptionalMaxType
2450         OptionalDecodeType
2451         OptionalRangeType
2452         ',' WordConstExpr
2453         ',' WordConstExpr
2454         ',' WordConstExpr
2455         ',' WordConstExpr
2456         ',' WordConstExpr
2457         OptionalByteConstExpr
2458         OptionalStringData
2459         OptionalNameString
2460         OptionalType
2461         OptionalTranslationType_Last
2462         ')'                         {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
2463     | PARSEOP_WORDIO '('
2464         error ')'                   {$$ = AslDoError(); yyclearin;}
2465     ;
2466 
2467 WordSpaceTerm
2468     : PARSEOP_WORDSPACE '('         {$<n>$ = TrCreateLeafNode (PARSEOP_WORDSPACE);}
2469         ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
2470         OptionalResourceType
2471         OptionalDecodeType
2472         OptionalMinType
2473         OptionalMaxType
2474         ',' ByteConstExpr
2475         ',' WordConstExpr
2476         ',' WordConstExpr
2477         ',' WordConstExpr
2478         ',' WordConstExpr
2479         ',' WordConstExpr
2480         OptionalByteConstExpr
2481         OptionalStringData
2482         OptionalNameString_Last
2483         ')'                         {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
2484     | PARSEOP_WORDSPACE '('
2485         error ')'                   {$$ = AslDoError(); yyclearin;}
2486     ;
2487 
2488 
2489 /******* Object References ***********************************************/
2490 
2491 /* Allow IO, DMA, IRQ Resource macro names to also be used as identifiers */
2492 
2493 NameString
2494     : NameSeg                       {}
2495     | PARSEOP_NAMESTRING            {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) AslCompilerlval.s);}
2496     | PARSEOP_IO                    {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IO");}
2497     | PARSEOP_DMA                   {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "DMA");}
2498     | PARSEOP_IRQ                   {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IRQ");}
2499     ;
2500 
2501 NameSeg
2502     : PARSEOP_NAMESEG               {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESEG, (ACPI_NATIVE_INT) AslCompilerlval.s);}
2503     ;
2504 
2505 
2506 /******* Helper rules ****************************************************/
2507 
2508 
2509 AmlPackageLengthTerm
2510     : Integer                       {$$ = TrUpdateNode (PARSEOP_PACKAGE_LENGTH,(ACPI_PARSE_OBJECT *) $1);}
2511     ;
2512 
2513 NameStringItem
2514     : ',' NameString                {$$ = $2;}
2515     | ',' error                     {$$ = AslDoError (); yyclearin;}
2516     ;
2517 
2518 TermArgItem
2519     : ',' TermArg                   {$$ = $2;}
2520     | ',' error                     {$$ = AslDoError (); yyclearin;}
2521     ;
2522 
2523 OptionalBusMasterKeyword
2524     : ','                                       {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
2525     | ',' PARSEOP_BUSMASTERTYPE_MASTER          {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
2526     | ',' PARSEOP_BUSMASTERTYPE_NOTMASTER       {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_NOTMASTER);}
2527     ;
2528 
2529 OptionalAccessAttribTerm
2530     :                               {$$ = NULL;}
2531     | ','                           {$$ = NULL;}
2532     | ',' ByteConstExpr             {$$ = $2;}
2533     | ',' AccessAttribKeyword       {$$ = $2;}
2534     ;
2535 
2536 OptionalAccessSize
2537     :                               {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);}
2538     | ','                           {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);}
2539     | ',' ByteConstExpr             {$$ = $2;}
2540     ;
2541 
2542 OptionalAddressingMode
2543     : ','                           {$$ = NULL;}
2544     | ',' AddressingModeKeyword     {$$ = $2;}
2545     ;
2546 
2547 OptionalAddressRange
2548     :                               {$$ = NULL;}
2549     | ','                           {$$ = NULL;}
2550     | ',' AddressKeyword            {$$ = $2;}
2551     ;
2552 
2553 OptionalBitsPerByte
2554     : ','                           {$$ = NULL;}
2555     | ',' BitsPerByteKeyword        {$$ = $2;}
2556     ;
2557 
2558 OptionalBuffer_Last
2559     :                               {$$ = NULL;}
2560     | ','                           {$$ = NULL;}
2561     | ',' DataBufferTerm            {$$ = $2;}
2562     ;
2563 
2564 OptionalByteConstExpr
2565     :                               {$$ = NULL;}
2566     | ','                           {$$ = NULL;}
2567     | ',' ByteConstExpr             {$$ = $2;}
2568     ;
2569 
2570 OptionalDecodeType
2571     : ','                           {$$ = NULL;}
2572     | ',' DecodeKeyword             {$$ = $2;}
2573     ;
2574 
2575 OptionalDevicePolarity
2576     : ','                           {$$ = NULL;}
2577     | ',' DevicePolarityKeyword     {$$ = $2;}
2578     ;
2579 
2580 OptionalDWordConstExpr
2581     :                               {$$ = NULL;}
2582     | ','                           {$$ = NULL;}
2583     | ',' DWordConstExpr            {$$ = $2;}
2584     ;
2585 
2586 OptionalEndian
2587     : ','                           {$$ = NULL;}
2588     | ',' EndianKeyword             {$$ = $2;}
2589     ;
2590 
2591 OptionalFlowControl
2592     : ','                           {$$ = NULL;}
2593     | ',' FlowControlKeyword        {$$ = $2;}
2594     ;
2595 
2596 OptionalIoRestriction
2597     : ','                           {$$ = NULL;}
2598     | ',' IoRestrictionKeyword      {$$ = $2;}
2599     ;
2600 
2601 OptionalListString
2602     :                               {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));}   /* Placeholder is a NULL string */
2603     | ','                           {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));}   /* Placeholder is a NULL string */
2604     | ',' TermArg                   {$$ = $2;}
2605     ;
2606 
2607 OptionalMaxType
2608     : ','                           {$$ = NULL;}
2609     | ',' MaxKeyword                {$$ = $2;}
2610     ;
2611 
2612 OptionalMemType
2613     : ','                           {$$ = NULL;}
2614     | ',' MemTypeKeyword            {$$ = $2;}
2615     ;
2616 
2617 OptionalMinType
2618     : ','                           {$$ = NULL;}
2619     | ',' MinKeyword                {$$ = $2;}
2620     ;
2621 
2622 OptionalNameString
2623     :                               {$$ = NULL;}
2624     | ','                           {$$ = NULL;}
2625     | ',' NameString                {$$ = $2;}
2626     ;
2627 
2628 OptionalNameString_Last
2629     :                               {$$ = NULL;}
2630     | ','                           {$$ = NULL;}
2631     | ',' NameString                {$$ = $2;}
2632     ;
2633 
2634 OptionalNameString_First
2635     :                               {$$ = TrCreateLeafNode (PARSEOP_ZERO);}
2636     | NameString                    {$$ = $1;}
2637     ;
2638 
2639 OptionalObjectTypeKeyword
2640     :                               {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
2641     | ',' ObjectTypeKeyword         {$$ = $2;}
2642     ;
2643 
2644 OptionalParityType
2645     : ','                           {$$ = NULL;}
2646     | ',' ParityTypeKeyword         {$$ = $2;}
2647     ;
2648 
2649 OptionalQWordConstExpr
2650     :                               {$$ = NULL;}
2651     | ','                           {$$ = NULL;}
2652     | ',' QWordConstExpr            {$$ = $2;}
2653     ;
2654 
2655 OptionalRangeType
2656     : ','                           {$$ = NULL;}
2657     | ',' RangeTypeKeyword          {$$ = $2;}
2658     ;
2659 
2660 OptionalReadWriteKeyword
2661     :                                   {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
2662     | PARSEOP_READWRITETYPE_BOTH        {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
2663     | PARSEOP_READWRITETYPE_READONLY    {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_READONLY);}
2664     ;
2665 
2666 OptionalReference
2667     :                               {$$ = TrCreateLeafNode (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
2668     | ','                           {$$ = TrCreateLeafNode (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
2669     | ',' TermArg                   {$$ = $2;}
2670     ;
2671 
2672 OptionalResourceType_First
2673     :                               {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
2674     | ResourceTypeKeyword           {$$ = $1;}
2675     ;
2676 
2677 OptionalResourceType
2678     :                               {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
2679     | ','                           {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
2680     | ',' ResourceTypeKeyword       {$$ = $2;}
2681     ;
2682 
2683 OptionalReturnArg
2684     :                               {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN);}       /* Placeholder is a ZeroOp object */
2685     | TermArg                       {$$ = $1;}
2686     ;
2687 
2688 OptionalSerializeRuleKeyword
2689     :                               {$$ = NULL;}
2690     | ','                           {$$ = NULL;}
2691     | ',' SerializeRuleKeyword      {$$ = $2;}
2692     ;
2693 
2694 OptionalSlaveMode
2695     : ','                           {$$ = NULL;}
2696     | ',' SlaveModeKeyword          {$$ = $2;}
2697     ;
2698 
2699 OptionalShareType
2700     :                               {$$ = NULL;}
2701     | ','                           {$$ = NULL;}
2702     | ',' ShareTypeKeyword          {$$ = $2;}
2703     ;
2704 
2705 OptionalShareType_First
2706     :                               {$$ = NULL;}
2707     | ShareTypeKeyword              {$$ = $1;}
2708     ;
2709 
2710 OptionalStopBits
2711     : ','                           {$$ = NULL;}
2712     | ',' StopBitsKeyword           {$$ = $2;}
2713     ;
2714 
2715 OptionalStringData
2716     :                               {$$ = NULL;}
2717     | ','                           {$$ = NULL;}
2718     | ',' StringData                {$$ = $2;}
2719     ;
2720 
2721 OptionalTermArg
2722     :                               {$$ = NULL;}
2723     | TermArg                       {$$ = $1;}
2724     ;
2725 
2726 OptionalType
2727     :                               {$$ = NULL;}
2728     | ','                           {$$ = NULL;}
2729     | ',' TypeKeyword               {$$ = $2;}
2730     ;
2731 
2732 OptionalType_Last
2733     :                               {$$ = NULL;}
2734     | ','                           {$$ = NULL;}
2735     | ',' TypeKeyword               {$$ = $2;}
2736     ;
2737 
2738 OptionalTranslationType_Last
2739     :                               {$$ = NULL;}
2740     | ','                           {$$ = NULL;}
2741     | ',' TranslationKeyword        {$$ = $2;}
2742     ;
2743 
2744 OptionalWireMode
2745     : ','                           {$$ = NULL;}
2746     | ',' WireModeKeyword           {$$ = $2;}
2747     ;
2748 
2749 OptionalWordConst
2750     :                               {$$ = NULL;}
2751     | WordConst                     {$$ = $1;}
2752     ;
2753 
2754 OptionalWordConstExpr
2755     : ','                           {$$ = NULL;}
2756     | ',' WordConstExpr             {$$ = $2;}
2757     ;
2758 
2759 OptionalXferSize
2760     :                               {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
2761     | ','                           {$$ = TrCreateValuedLeafNode (PARSEOP_XFERSIZE_32, 2);}
2762     | ',' XferSizeKeyword           {$$ = $2;}
2763     ;
2764