1NoEcho('
2/******************************************************************************
3 *
4 * Module Name: aslresources.y - Bison/Yacc production rules for resources
5 *                             - Keep this file synched with the
6 *                               CvParseOpBlockType function in cvcompiler.c
7 *
8 *****************************************************************************/
9
10/******************************************************************************
11 *
12 * 1. Copyright Notice
13 *
14 * Some or all of this work - Copyright (c) 1999 - 2020, Intel Corp.
15 * All rights reserved.
16 *
17 * 2. License
18 *
19 * 2.1. This is your license from Intel Corp. under its intellectual property
20 * rights. You may have additional license terms from the party that provided
21 * you this software, covering your right to use that party's intellectual
22 * property rights.
23 *
24 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
25 * copy of the source code appearing in this file ("Covered Code") an
26 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
27 * base code distributed originally by Intel ("Original Intel Code") to copy,
28 * make derivatives, distribute, use and display any portion of the Covered
29 * Code in any form, with the right to sublicense such rights; and
30 *
31 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
32 * license (with the right to sublicense), under only those claims of Intel
33 * patents that are infringed by the Original Intel Code, to make, use, sell,
34 * offer to sell, and import the Covered Code and derivative works thereof
35 * solely to the minimum extent necessary to exercise the above copyright
36 * license, and in no event shall the patent license extend to any additions
37 * to or modifications of the Original Intel Code. No other license or right
38 * is granted directly or by implication, estoppel or otherwise;
39 *
40 * The above copyright and patent license is granted only if the following
41 * conditions are met:
42 *
43 * 3. Conditions
44 *
45 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
46 * Redistribution of source code of any substantial portion of the Covered
47 * Code or modification with rights to further distribute source must include
48 * the above Copyright Notice, the above License, this list of Conditions,
49 * and the following Disclaimer and Export Compliance provision. In addition,
50 * Licensee must cause all Covered Code to which Licensee contributes to
51 * contain a file documenting the changes Licensee made to create that Covered
52 * Code and the date of any change. Licensee must include in that file the
53 * documentation of any changes made by any predecessor Licensee. Licensee
54 * must include a prominent statement that the modification is derived,
55 * directly or indirectly, from Original Intel Code.
56 *
57 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
58 * Redistribution of source code of any substantial portion of the Covered
59 * Code or modification without rights to further distribute source must
60 * include the following Disclaimer and Export Compliance provision in the
61 * documentation and/or other materials provided with distribution. In
62 * addition, Licensee may not authorize further sublicense of source of any
63 * portion of the Covered Code, and must include terms to the effect that the
64 * license from Licensee to its licensee is limited to the intellectual
65 * property embodied in the software Licensee provides to its licensee, and
66 * not to intellectual property embodied in modifications its licensee may
67 * make.
68 *
69 * 3.3. Redistribution of Executable. Redistribution in executable form of any
70 * substantial portion of the Covered Code or modification must reproduce the
71 * above Copyright Notice, and the following Disclaimer and Export Compliance
72 * provision in the documentation and/or other materials provided with the
73 * distribution.
74 *
75 * 3.4. Intel retains all right, title, and interest in and to the Original
76 * Intel Code.
77 *
78 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
79 * Intel shall be used in advertising or otherwise to promote the sale, use or
80 * other dealings in products derived from or relating to the Covered Code
81 * without prior written authorization from Intel.
82 *
83 * 4. Disclaimer and Export Compliance
84 *
85 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
86 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
87 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
88 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
89 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
90 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
91 * PARTICULAR PURPOSE.
92 *
93 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
94 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
95 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
96 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
97 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
98 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
99 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
100 * LIMITED REMEDY.
101 *
102 * 4.3. Licensee shall not export, either directly or indirectly, any of this
103 * software or system incorporating such software without first obtaining any
104 * required license or other approval from the U. S. Department of Commerce or
105 * any other agency or department of the United States Government. In the
106 * event Licensee exports any such software from the United States or
107 * re-exports any such software from a foreign destination, Licensee shall
108 * ensure that the distribution and export/re-export of the software is in
109 * compliance with all laws, regulations, orders, or other restrictions of the
110 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
111 * any of its subsidiaries will export/re-export any technical data, process,
112 * software, or service, directly or indirectly, to any country for which the
113 * United States government or any agency thereof requires an export license,
114 * other governmental approval, or letter of assurance, without first obtaining
115 * such license, approval or letter.
116 *
117 *****************************************************************************
118 *
119 * Alternatively, you may choose to be licensed under the terms of the
120 * following license:
121 *
122 * Redistribution and use in source and binary forms, with or without
123 * modification, are permitted provided that the following conditions
124 * are met:
125 * 1. Redistributions of source code must retain the above copyright
126 *    notice, this list of conditions, and the following disclaimer,
127 *    without modification.
128 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
129 *    substantially similar to the "NO WARRANTY" disclaimer below
130 *    ("Disclaimer") and any redistribution must be conditioned upon
131 *    including a substantially similar Disclaimer requirement for further
132 *    binary redistribution.
133 * 3. Neither the names of the above-listed copyright holders nor the names
134 *    of any contributors may be used to endorse or promote products derived
135 *    from this software without specific prior written permission.
136 *
137 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
138 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
139 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
140 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
141 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
142 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
143 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
144 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
145 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
146 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
147 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
148 *
149 * Alternatively, you may choose to be licensed under the terms of the
150 * GNU General Public License ("GPL") version 2 as published by the Free
151 * Software Foundation.
152 *
153 *****************************************************************************/
154
155')
156
157
158/*******************************************************************************
159 *
160 * ASL Resource Template Terms
161 *
162 ******************************************************************************/
163
164/*
165 * Note: Create two default nodes to allow conversion to a Buffer AML opcode
166 * Also, insert the EndTag at the end of the template.
167 */
168ResourceTemplateTerm
169    : PARSEOP_RESOURCETEMPLATE      {COMMENT_CAPTURE_OFF;}
170        OptionalParentheses
171        '{'
172        ResourceMacroList '}'       {$$ = TrCreateOp (PARSEOP_RESOURCETEMPLATE,4,
173                                          TrCreateLeafOp (PARSEOP_DEFAULT_ARG),
174                                          TrCreateLeafOp (PARSEOP_DEFAULT_ARG),
175                                          $5,
176                                          TrCreateLeafOp (PARSEOP_ENDTAG));
177                                     COMMENT_CAPTURE_ON;}
178    ;
179
180OptionalParentheses
181    :                               {$$ = NULL;}
182    | PARSEOP_OPEN_PAREN
183        PARSEOP_CLOSE_PAREN         {$$ = NULL;}
184    ;
185
186ResourceMacroList
187    :                               {$$ = NULL;}
188    | ResourceMacroList
189        ResourceMacroTerm           {$$ = TrLinkPeerOp ($1,$2);}
190    ;
191
192ResourceMacroTerm
193    : DMATerm                       {}
194    | DWordIOTerm                   {}
195    | DWordMemoryTerm               {}
196    | DWordSpaceTerm                {}
197    | EndDependentFnTerm            {}
198    | ExtendedIOTerm                {}
199    | ExtendedMemoryTerm            {}
200    | ExtendedSpaceTerm             {}
201    | FixedDmaTerm                  {}
202    | FixedIOTerm                   {}
203    | GpioIntTerm                   {}
204    | GpioIoTerm                    {}
205    | I2cSerialBusTerm              {}
206    | I2cSerialBusTermV2            {}
207    | InterruptTerm                 {}
208    | IOTerm                        {}
209    | IRQNoFlagsTerm                {}
210    | IRQTerm                       {}
211    | Memory24Term                  {}
212    | Memory32FixedTerm             {}
213    | Memory32Term                  {}
214    | PinConfigTerm                 {}
215    | PinFunctionTerm               {}
216    | PinGroupTerm                  {}
217    | PinGroupConfigTerm            {}
218    | PinGroupFunctionTerm          {}
219    | QWordIOTerm                   {}
220    | QWordMemoryTerm               {}
221    | QWordSpaceTerm                {}
222    | RegisterTerm                  {}
223    | SpiSerialBusTerm              {}
224    | SpiSerialBusTermV2            {}
225    | StartDependentFnNoPriTerm     {}
226    | StartDependentFnTerm          {}
227    | UartSerialBusTerm             {}
228    | UartSerialBusTermV2           {}
229    | VendorLongTerm                {}
230    | VendorShortTerm               {}
231    | WordBusNumberTerm             {}
232    | WordIOTerm                    {}
233    | WordSpaceTerm                 {}
234    ;
235
236DMATerm
237    : PARSEOP_DMA
238        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_DMA);}
239        DMATypeKeyword
240        OptionalBusMasterKeyword
241        ',' XferTypeKeyword
242        OptionalNameString_Last
243        PARSEOP_CLOSE_PAREN '{'
244            ByteList '}'            {$$ = TrLinkOpChildren ($<n>3,5,$4,$5,$7,$8,$11);}
245    | PARSEOP_DMA
246        PARSEOP_OPEN_PAREN
247        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
248    ;
249
250DWordIOTerm
251    : PARSEOP_DWORDIO
252        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_DWORDIO);}
253        OptionalResourceType_First
254        OptionalMinType
255        OptionalMaxType
256        OptionalDecodeType
257        OptionalRangeType
258        ',' DWordConstExpr
259        ',' DWordConstExpr
260        ',' DWordConstExpr
261        ',' DWordConstExpr
262        ',' DWordConstExpr
263        OptionalByteConstExpr
264        OptionalStringData
265        OptionalNameString
266        OptionalType
267        OptionalTranslationType_Last
268        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,15,
269                                        $4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
270    | PARSEOP_DWORDIO
271        PARSEOP_OPEN_PAREN
272        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
273    ;
274
275DWordMemoryTerm
276    : PARSEOP_DWORDMEMORY
277        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_DWORDMEMORY);}
278        OptionalResourceType_First
279        OptionalDecodeType
280        OptionalMinType
281        OptionalMaxType
282        OptionalMemType
283        ',' OptionalReadWriteKeyword
284        ',' DWordConstExpr
285        ',' DWordConstExpr
286        ',' DWordConstExpr
287        ',' DWordConstExpr
288        ',' DWordConstExpr
289        OptionalByteConstExpr
290        OptionalStringData
291        OptionalNameString
292        OptionalAddressRange
293        OptionalType_Last
294        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,16,
295                                        $4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
296    | PARSEOP_DWORDMEMORY
297        PARSEOP_OPEN_PAREN
298        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
299    ;
300
301DWordSpaceTerm
302    : PARSEOP_DWORDSPACE
303        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_DWORDSPACE);}
304        ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
305        OptionalResourceType
306        OptionalDecodeType
307        OptionalMinType
308        OptionalMaxType
309        ',' ByteConstExpr
310        ',' DWordConstExpr
311        ',' DWordConstExpr
312        ',' DWordConstExpr
313        ',' DWordConstExpr
314        ',' DWordConstExpr
315        OptionalByteConstExpr
316        OptionalStringData
317        OptionalNameString_Last
318        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,14,
319                                        $4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
320    | PARSEOP_DWORDSPACE
321        PARSEOP_OPEN_PAREN
322        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
323    ;
324
325EndDependentFnTerm
326    : PARSEOP_ENDDEPENDENTFN
327        PARSEOP_OPEN_PAREN
328        PARSEOP_CLOSE_PAREN         {$$ = TrCreateLeafOp (PARSEOP_ENDDEPENDENTFN);}
329    | PARSEOP_ENDDEPENDENTFN
330        PARSEOP_OPEN_PAREN
331        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
332    ;
333
334ExtendedIOTerm
335    : PARSEOP_EXTENDEDIO
336        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_EXTENDEDIO);}
337        OptionalResourceType_First
338        OptionalMinType
339        OptionalMaxType
340        OptionalDecodeType
341        OptionalRangeType
342        ',' QWordConstExpr
343        ',' QWordConstExpr
344        ',' QWordConstExpr
345        ',' QWordConstExpr
346        ',' QWordConstExpr
347        OptionalQWordConstExpr
348        OptionalNameString
349        OptionalType
350        OptionalTranslationType_Last
351        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,14,
352                                        $4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22);}
353    | PARSEOP_EXTENDEDIO
354        PARSEOP_OPEN_PAREN
355        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
356    ;
357
358ExtendedMemoryTerm
359    : PARSEOP_EXTENDEDMEMORY
360        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_EXTENDEDMEMORY);}
361        OptionalResourceType_First
362        OptionalDecodeType
363        OptionalMinType
364        OptionalMaxType
365        OptionalMemType
366        ',' OptionalReadWriteKeyword
367        ',' QWordConstExpr
368        ',' QWordConstExpr
369        ',' QWordConstExpr
370        ',' QWordConstExpr
371        ',' QWordConstExpr
372        OptionalQWordConstExpr
373        OptionalNameString
374        OptionalAddressRange
375        OptionalType_Last
376        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,15,
377                                        $4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24);}
378    | PARSEOP_EXTENDEDMEMORY
379        PARSEOP_OPEN_PAREN
380        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
381    ;
382
383ExtendedSpaceTerm
384    : PARSEOP_EXTENDEDSPACE PARSEOP_OPEN_PAREN     {$<n>$ = TrCreateLeafOp (PARSEOP_EXTENDEDSPACE);}
385        ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
386        OptionalResourceType
387        OptionalDecodeType
388        OptionalMinType
389        OptionalMaxType
390        ',' ByteConstExpr
391        ',' QWordConstExpr
392        ',' QWordConstExpr
393        ',' QWordConstExpr
394        ',' QWordConstExpr
395        ',' QWordConstExpr
396        OptionalQWordConstExpr
397        OptionalNameString_Last
398        PARSEOP_CLOSE_PAREN                         {$$ = TrLinkOpChildren ($<n>3,13,
399                                        $4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23);}
400    | PARSEOP_EXTENDEDSPACE
401        PARSEOP_OPEN_PAREN
402        error PARSEOP_CLOSE_PAREN                   {$$ = AslDoError(); yyclearin;}
403    ;
404
405FixedDmaTerm
406    : PARSEOP_FIXEDDMA
407        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_FIXEDDMA);}
408        WordConstExpr               /* 04: DMA RequestLines */
409        ',' WordConstExpr           /* 06: DMA Channels */
410        OptionalXferSize            /* 07: DMA TransferSize */
411        OptionalNameString          /* 08: DescriptorName */
412        PARSEOP_CLOSE_PAREN                         {$$ = TrLinkOpChildren ($<n>3,4,$4,$6,$7,$8);}
413    | PARSEOP_FIXEDDMA
414        PARSEOP_OPEN_PAREN
415        error PARSEOP_CLOSE_PAREN                   {$$ = AslDoError(); yyclearin;}
416    ;
417
418FixedIOTerm
419    : PARSEOP_FIXEDIO
420        PARSEOP_OPEN_PAREN           {$<n>$ = TrCreateLeafOp (PARSEOP_FIXEDIO);}
421        WordConstExpr
422        ',' ByteConstExpr
423        OptionalNameString_Last
424        PARSEOP_CLOSE_PAREN                         {$$ = TrLinkOpChildren ($<n>3,3,$4,$6,$7);}
425    | PARSEOP_FIXEDIO
426        PARSEOP_OPEN_PAREN
427        error PARSEOP_CLOSE_PAREN                   {$$ = AslDoError(); yyclearin;}
428    ;
429
430GpioIntTerm
431    : PARSEOP_GPIO_INT
432        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_GPIO_INT);}
433        InterruptTypeKeyword        /* 04: InterruptType */
434        ',' InterruptLevel          /* 06: InterruptLevel */
435        OptionalShareType           /* 07: SharedType */
436        ',' PinConfigByte           /* 09: PinConfig */
437        OptionalWordConstExpr       /* 10: DebounceTimeout */
438        ',' StringData              /* 12: ResourceSource */
439        OptionalByteConstExpr       /* 13: ResourceSourceIndex */
440        OptionalResourceType        /* 14: ResourceType */
441        OptionalNameString          /* 15: DescriptorName */
442        OptionalBuffer_Last         /* 16: VendorData */
443        PARSEOP_CLOSE_PAREN '{'
444            DWordConstExpr '}'      {$$ = TrLinkOpChildren ($<n>3,11,
445                                        $4,$6,$7,$9,$10,$12,$13,$14,$15,$16,$19);}
446    | PARSEOP_GPIO_INT
447        PARSEOP_OPEN_PAREN
448        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
449    ;
450
451GpioIoTerm
452    : PARSEOP_GPIO_IO
453        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_GPIO_IO);}
454        OptionalShareType_First     /* 04: SharedType */
455        ',' PinConfigByte           /* 06: PinConfig */
456        OptionalWordConstExpr       /* 07: DebounceTimeout */
457        OptionalWordConstExpr       /* 08: DriveStrength */
458        OptionalIoRestriction       /* 09: IoRestriction */
459        ',' StringData              /* 11: ResourceSource */
460        OptionalByteConstExpr       /* 12: ResourceSourceIndex */
461        OptionalResourceType        /* 13: ResourceType */
462        OptionalNameString          /* 14: DescriptorName */
463        OptionalBuffer_Last         /* 15: VendorData */
464        PARSEOP_CLOSE_PAREN '{'
465            DWordList '}'           {$$ = TrLinkOpChildren ($<n>3,11,
466                                        $4,$6,$7,$8,$9,$11,$12,$13,$14,$15,$18);}
467    | PARSEOP_GPIO_IO
468        PARSEOP_OPEN_PAREN
469        error PARSEOP_CLOSE_PAREN                   {$$ = AslDoError(); yyclearin;}
470    ;
471
472I2cSerialBusTerm
473    : PARSEOP_I2C_SERIALBUS
474        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_I2C_SERIALBUS);}
475        WordConstExpr               /* 04: SlaveAddress */
476        OptionalSlaveMode           /* 05: SlaveMode */
477        ',' DWordConstExpr          /* 07: ConnectionSpeed */
478        OptionalAddressingMode      /* 08: AddressingMode */
479        ',' StringData              /* 10: ResourceSource */
480        OptionalByteConstExpr       /* 11: ResourceSourceIndex */
481        OptionalResourceType        /* 12: ResourceType */
482        OptionalNameString          /* 13: DescriptorName */
483        OptionalBuffer_Last         /* 14: VendorData */
484        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,10,
485                                        $4,$5,$7,$8,$10,$11,$12,$13,
486                                        TrCreateLeafOp (PARSEOP_DEFAULT_ARG),$14);}
487    | PARSEOP_I2C_SERIALBUS
488        PARSEOP_OPEN_PAREN
489        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
490    ;
491
492I2cSerialBusTermV2
493    : PARSEOP_I2C_SERIALBUS_V2
494        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_I2C_SERIALBUS_V2);}
495        WordConstExpr               /* 04: SlaveAddress */
496        OptionalSlaveMode           /* 05: SlaveMode */
497        ',' DWordConstExpr          /* 07: ConnectionSpeed */
498        OptionalAddressingMode      /* 08: AddressingMode */
499        ',' StringData              /* 10: ResourceSource */
500        OptionalByteConstExpr       /* 11: ResourceSourceIndex */
501        OptionalResourceType        /* 12: ResourceType */
502        OptionalNameString          /* 13: DescriptorName */
503        OptionalShareType           /* 14: Share */
504        OptionalBuffer_Last         /* 15: VendorData */
505        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,10,
506                                        $4,$5,$7,$8,$10,$11,$12,$13,$14,$15);}
507    | PARSEOP_I2C_SERIALBUS_V2
508        PARSEOP_OPEN_PAREN
509        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
510    ;
511
512InterruptTerm
513    : PARSEOP_INTERRUPT
514        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_INTERRUPT);}
515        OptionalResourceType_First
516        ',' InterruptTypeKeyword
517        ',' InterruptLevel
518        OptionalShareType
519        OptionalByteConstExpr
520        OptionalStringData
521        OptionalNameString_Last
522        PARSEOP_CLOSE_PAREN '{'
523            DWordList '}'           {$$ = TrLinkOpChildren ($<n>3,8,
524                                        $4,$6,$8,$9,$10,$11,$12,$15);}
525    | PARSEOP_INTERRUPT
526        PARSEOP_OPEN_PAREN
527        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
528    ;
529
530IOTerm
531    : PARSEOP_IO
532        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_IO);}
533        IODecodeKeyword
534        ',' WordConstExpr
535        ',' WordConstExpr
536        ',' ByteConstExpr
537        ',' ByteConstExpr
538        OptionalNameString_Last
539        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
540    | PARSEOP_IO
541        PARSEOP_OPEN_PAREN
542        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
543    ;
544
545IRQNoFlagsTerm
546    : PARSEOP_IRQNOFLAGS
547        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_IRQNOFLAGS);}
548        OptionalNameString_First
549        PARSEOP_CLOSE_PAREN '{'
550            ByteList '}'            {$$ = TrLinkOpChildren ($<n>3,2,$4,$7);}
551    | PARSEOP_IRQNOFLAGS
552        PARSEOP_OPEN_PAREN
553        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
554    ;
555
556IRQTerm
557    : PARSEOP_IRQ
558        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_IRQ);}
559        InterruptTypeKeyword
560        ',' InterruptLevel
561        OptionalShareType
562        OptionalNameString_Last
563        PARSEOP_CLOSE_PAREN '{'
564            ByteList '}'            {$$ = TrLinkOpChildren ($<n>3,5,$4,$6,$7,$8,$11);}
565    | PARSEOP_IRQ
566        PARSEOP_OPEN_PAREN
567        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
568    ;
569
570Memory24Term
571    : PARSEOP_MEMORY24
572        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_MEMORY24);}
573        OptionalReadWriteKeyword
574        ',' WordConstExpr
575        ',' WordConstExpr
576        ',' WordConstExpr
577        ',' WordConstExpr
578        OptionalNameString_Last
579        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
580    | PARSEOP_MEMORY24
581        PARSEOP_OPEN_PAREN
582        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
583    ;
584
585Memory32FixedTerm
586    : PARSEOP_MEMORY32FIXED
587        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_MEMORY32FIXED);}
588        OptionalReadWriteKeyword
589        ',' DWordConstExpr
590        ',' DWordConstExpr
591        OptionalNameString_Last
592        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,4,$4,$6,$8,$9);}
593    | PARSEOP_MEMORY32FIXED
594        PARSEOP_OPEN_PAREN
595        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
596    ;
597
598Memory32Term
599    : PARSEOP_MEMORY32
600        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_MEMORY32);}
601        OptionalReadWriteKeyword
602        ',' DWordConstExpr
603        ',' DWordConstExpr
604        ',' DWordConstExpr
605        ',' DWordConstExpr
606        OptionalNameString_Last
607        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
608    | PARSEOP_MEMORY32
609        PARSEOP_OPEN_PAREN
610        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
611    ;
612
613PinConfigTerm
614    : PARSEOP_PINCONFIG
615        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_PINCONFIG);}
616        OptionalShareType_First     /* 04: SharedType */
617        ',' ByteConstExpr           /* 06: PinConfigType */
618        ',' DWordConstExpr          /* 08: PinConfigValue */
619        ',' StringData              /* 10: ResourceSource */
620        OptionalByteConstExpr       /* 11: ResourceSourceIndex */
621        OptionalResourceType        /* 12: ResourceType */
622        OptionalNameString          /* 13: DescriptorName */
623        OptionalBuffer_Last         /* 14: VendorData */
624        PARSEOP_CLOSE_PAREN '{'
625            DWordList '}'           {$$ = TrLinkOpChildren ($<n>3,9,
626                                        $4,$6,$8,$10,$11,$12,$13,$14,$17);}
627    | PARSEOP_PINCONFIG
628        PARSEOP_OPEN_PAREN
629        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
630    ;
631
632PinFunctionTerm
633    : PARSEOP_PINFUNCTION
634        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_PINFUNCTION);}
635        OptionalShareType_First     /* 04: SharedType */
636        ',' PinConfigByte           /* 06: PinConfig */
637        ',' WordConstExpr           /* 08: FunctionNumber */
638        ',' StringData              /* 10: ResourceSource */
639        OptionalByteConstExpr       /* 11: ResourceSourceIndex */
640        OptionalResourceType        /* 12: ResourceType */
641        OptionalNameString          /* 13: DescriptorName */
642        OptionalBuffer_Last         /* 14: VendorData */
643        PARSEOP_CLOSE_PAREN '{'
644            DWordList '}'           {$$ = TrLinkOpChildren ($<n>3,9,
645                                        $4,$6,$8,$10,$11,$12,$13,$14,$17);}
646    | PARSEOP_PINFUNCTION
647        PARSEOP_OPEN_PAREN
648        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
649    ;
650
651PinGroupTerm
652    : PARSEOP_PINGROUP
653        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_PINGROUP);}
654        StringData                  /* 04: ResourceLabel */
655        OptionalProducerResourceType /* 05: ResourceType */
656        OptionalNameString          /* 06: DescriptorName */
657        OptionalBuffer_Last         /* 07: VendorData */
658        PARSEOP_CLOSE_PAREN '{'
659            DWordList '}'           {$$ = TrLinkOpChildren ($<n>3,5,$4,$5,$6,$7,$10);}
660    | PARSEOP_PINGROUP
661        PARSEOP_OPEN_PAREN
662        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
663    ;
664
665PinGroupConfigTerm
666    : PARSEOP_PINGROUPCONFIG
667        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_PINGROUPCONFIG);}
668        OptionalShareType_First     /* 04: SharedType */
669        ',' ByteConstExpr           /* 06: PinConfigType */
670        ',' DWordConstExpr          /* 08: PinConfigValue */
671        ',' StringData              /* 10: ResourceSource */
672        OptionalByteConstExpr       /* 11: ResourceSourceIndex */
673        ',' StringData              /* 13: ResourceSourceLabel */
674        OptionalResourceType        /* 14: ResourceType */
675        OptionalNameString          /* 15: DescriptorName */
676        OptionalBuffer_Last         /* 16: VendorData */
677        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,9,
678                                        $4,$6,$8,$10,$11,$13,$14,$15,$16);}
679    | PARSEOP_PINGROUPCONFIG
680        PARSEOP_OPEN_PAREN
681        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
682    ;
683
684PinGroupFunctionTerm
685    : PARSEOP_PINGROUPFUNCTION
686        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_PINGROUPFUNCTION);}
687        OptionalShareType_First     /* 04: SharedType */
688        ',' WordConstExpr           /* 06: FunctionNumber */
689        ',' StringData              /* 08: ResourceSource */
690        OptionalByteConstExpr       /* 09: ResourceSourceIndex */
691        ',' StringData              /* 11: ResourceSourceLabel */
692        OptionalResourceType        /* 12: ResourceType */
693        OptionalNameString          /* 13: DescriptorName */
694        OptionalBuffer_Last         /* 14: VendorData */
695        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,8,
696                                        $4,$6,$8,$9,$11,$12,$13,$14);}
697    | PARSEOP_PINGROUPFUNCTION
698        PARSEOP_OPEN_PAREN
699        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
700    ;
701
702QWordIOTerm
703    : PARSEOP_QWORDIO
704        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_QWORDIO);}
705        OptionalResourceType_First
706        OptionalMinType
707        OptionalMaxType
708        OptionalDecodeType
709        OptionalRangeType
710        ',' QWordConstExpr
711        ',' QWordConstExpr
712        ',' QWordConstExpr
713        ',' QWordConstExpr
714        ',' QWordConstExpr
715        OptionalByteConstExpr
716        OptionalStringData
717        OptionalNameString
718        OptionalType
719        OptionalTranslationType_Last
720        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,15,
721                                        $4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
722    | PARSEOP_QWORDIO
723        PARSEOP_OPEN_PAREN
724        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
725    ;
726
727QWordMemoryTerm
728    : PARSEOP_QWORDMEMORY
729        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_QWORDMEMORY);}
730        OptionalResourceType_First
731        OptionalDecodeType
732        OptionalMinType
733        OptionalMaxType
734        OptionalMemType
735        ',' OptionalReadWriteKeyword
736        ',' QWordConstExpr
737        ',' QWordConstExpr
738        ',' QWordConstExpr
739        ',' QWordConstExpr
740        ',' QWordConstExpr
741        OptionalByteConstExpr
742        OptionalStringData
743        OptionalNameString
744        OptionalAddressRange
745        OptionalType_Last
746        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,16,
747                                        $4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
748    | PARSEOP_QWORDMEMORY
749        PARSEOP_OPEN_PAREN
750        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
751    ;
752
753QWordSpaceTerm
754    : PARSEOP_QWORDSPACE
755        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_QWORDSPACE);}
756        ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
757        OptionalResourceType
758        OptionalDecodeType
759        OptionalMinType
760        OptionalMaxType
761        ',' ByteConstExpr
762        ',' QWordConstExpr
763        ',' QWordConstExpr
764        ',' QWordConstExpr
765        ',' QWordConstExpr
766        ',' QWordConstExpr
767        OptionalByteConstExpr
768        OptionalStringData
769        OptionalNameString_Last
770        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,14,
771                                        $4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
772    | PARSEOP_QWORDSPACE
773        PARSEOP_OPEN_PAREN
774        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
775    ;
776
777RegisterTerm
778    : PARSEOP_REGISTER
779        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_REGISTER);}
780        AddressSpaceKeyword
781        ',' ByteConstExpr
782        ',' ByteConstExpr
783        ',' QWordConstExpr
784        OptionalAccessSize
785        OptionalNameString_Last
786        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,6,$4,$6,$8,$10,$11,$12);}
787    | PARSEOP_REGISTER
788        PARSEOP_OPEN_PAREN
789        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
790    ;
791
792SpiSerialBusTerm
793    : PARSEOP_SPI_SERIALBUS
794        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_SPI_SERIALBUS);}
795        WordConstExpr               /* 04: DeviceSelection */
796        OptionalDevicePolarity      /* 05: DevicePolarity */
797        OptionalWireMode            /* 06: WireMode */
798        ',' ByteConstExpr           /* 08: DataBitLength */
799        OptionalSlaveMode           /* 09: SlaveMode */
800        ',' DWordConstExpr          /* 11: ConnectionSpeed */
801        ',' ClockPolarityKeyword    /* 13: ClockPolarity */
802        ',' ClockPhaseKeyword       /* 15: ClockPhase */
803        ',' StringData              /* 17: ResourceSource */
804        OptionalByteConstExpr       /* 18: ResourceSourceIndex */
805        OptionalResourceType        /* 19: ResourceType */
806        OptionalNameString          /* 20: DescriptorName */
807        OptionalBuffer_Last         /* 21: VendorData */
808        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,14,
809                                        $4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,
810                                        TrCreateLeafOp (PARSEOP_DEFAULT_ARG),$21);}
811    | PARSEOP_SPI_SERIALBUS
812        PARSEOP_OPEN_PAREN
813        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
814    ;
815
816SpiSerialBusTermV2
817    : PARSEOP_SPI_SERIALBUS_V2
818        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_SPI_SERIALBUS_V2);}
819        WordConstExpr               /* 04: DeviceSelection */
820        OptionalDevicePolarity      /* 05: DevicePolarity */
821        OptionalWireMode            /* 06: WireMode */
822        ',' ByteConstExpr           /* 08: DataBitLength */
823        OptionalSlaveMode           /* 09: SlaveMode */
824        ',' DWordConstExpr          /* 11: ConnectionSpeed */
825        ',' ClockPolarityKeyword    /* 13: ClockPolarity */
826        ',' ClockPhaseKeyword       /* 15: ClockPhase */
827        ',' StringData              /* 17: ResourceSource */
828        OptionalByteConstExpr       /* 18: ResourceSourceIndex */
829        OptionalResourceType        /* 19: ResourceType */
830        OptionalNameString          /* 20: DescriptorName */
831        OptionalShareType           /* 21: Share */
832        OptionalBuffer_Last         /* 22: VendorData */
833        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,14,
834                                        $4,$5,$6,$8,$9,$11,$13,$15,$17,$18,$19,$20,$21,$22);}
835    | PARSEOP_SPI_SERIALBUS_V2
836        PARSEOP_OPEN_PAREN
837        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
838    ;
839
840StartDependentFnNoPriTerm
841    : PARSEOP_STARTDEPENDENTFN_NOPRI
842        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_STARTDEPENDENTFN_NOPRI);}
843        PARSEOP_CLOSE_PAREN '{'
844        ResourceMacroList '}'       {$$ = TrLinkOpChildren ($<n>3,1,$6);}
845    | PARSEOP_STARTDEPENDENTFN_NOPRI
846        PARSEOP_OPEN_PAREN
847        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
848    ;
849
850StartDependentFnTerm
851    : PARSEOP_STARTDEPENDENTFN
852        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_STARTDEPENDENTFN);}
853        ByteConstExpr
854        ',' ByteConstExpr
855        PARSEOP_CLOSE_PAREN '{'
856        ResourceMacroList '}'       {$$ = TrLinkOpChildren ($<n>3,3,$4,$6,$9);}
857    | PARSEOP_STARTDEPENDENTFN
858        PARSEOP_OPEN_PAREN
859        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
860    ;
861
862UartSerialBusTerm
863    : PARSEOP_UART_SERIALBUS
864        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_UART_SERIALBUS);}
865        DWordConstExpr              /* 04: ConnectionSpeed */
866        OptionalBitsPerByte         /* 05: BitsPerByte */
867        OptionalStopBits            /* 06: StopBits */
868        ',' ByteConstExpr           /* 08: LinesInUse */
869        OptionalEndian              /* 09: Endianness */
870        OptionalParityType          /* 10: Parity */
871        OptionalFlowControl         /* 11: FlowControl */
872        ',' WordConstExpr           /* 13: Rx BufferSize */
873        ',' WordConstExpr           /* 15: Tx BufferSize */
874        ',' StringData              /* 17: ResourceSource */
875        OptionalByteConstExpr       /* 18: ResourceSourceIndex */
876        OptionalResourceType        /* 19: ResourceType */
877        OptionalNameString          /* 20: DescriptorName */
878        OptionalBuffer_Last         /* 21: VendorData */
879        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,15,
880                                        $4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,
881                                        TrCreateLeafOp (PARSEOP_DEFAULT_ARG),$21);}
882    | PARSEOP_UART_SERIALBUS
883        PARSEOP_OPEN_PAREN
884        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
885    ;
886
887UartSerialBusTermV2
888    : PARSEOP_UART_SERIALBUS_V2
889        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_UART_SERIALBUS_V2);}
890        DWordConstExpr              /* 04: ConnectionSpeed */
891        OptionalBitsPerByte         /* 05: BitsPerByte */
892        OptionalStopBits            /* 06: StopBits */
893        ',' ByteConstExpr           /* 08: LinesInUse */
894        OptionalEndian              /* 09: Endianness */
895        OptionalParityType          /* 10: Parity */
896        OptionalFlowControl         /* 11: FlowControl */
897        ',' WordConstExpr           /* 13: Rx BufferSize */
898        ',' WordConstExpr           /* 15: Tx BufferSize */
899        ',' StringData              /* 17: ResourceSource */
900        OptionalByteConstExpr       /* 18: ResourceSourceIndex */
901        OptionalResourceType        /* 19: ResourceType */
902        OptionalNameString          /* 20: DescriptorName */
903        OptionalShareType           /* 21: Share */
904        OptionalBuffer_Last         /* 22: VendorData */
905        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,15,
906                                        $4,$5,$6,$8,$9,$10,$11,$13,$15,$17,$18,$19,$20,$21,$22);}
907    | PARSEOP_UART_SERIALBUS_V2
908        PARSEOP_OPEN_PAREN
909        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
910    ;
911
912VendorLongTerm
913    : PARSEOP_VENDORLONG
914        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_VENDORLONG);}
915        OptionalNameString_First
916        PARSEOP_CLOSE_PAREN '{'
917            ByteList '}'            {$$ = TrLinkOpChildren ($<n>3,2,$4,$7);}
918    | PARSEOP_VENDORLONG
919        PARSEOP_OPEN_PAREN
920        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
921    ;
922
923VendorShortTerm
924    : PARSEOP_VENDORSHORT
925        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_VENDORSHORT);}
926        OptionalNameString_First
927        PARSEOP_CLOSE_PAREN '{'
928            ByteList '}'            {$$ = TrLinkOpChildren ($<n>3,2,$4,$7);}
929    | PARSEOP_VENDORSHORT
930        PARSEOP_OPEN_PAREN
931        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
932    ;
933
934WordBusNumberTerm
935    : PARSEOP_WORDBUSNUMBER
936        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_WORDBUSNUMBER);}
937        OptionalResourceType_First
938        OptionalMinType
939        OptionalMaxType
940        OptionalDecodeType
941        ',' WordConstExpr
942        ',' WordConstExpr
943        ',' WordConstExpr
944        ',' WordConstExpr
945        ',' WordConstExpr
946        OptionalByteConstExpr
947        OptionalStringData
948        OptionalNameString_Last
949        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,12,
950                                        $4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);}
951    | PARSEOP_WORDBUSNUMBER
952        PARSEOP_OPEN_PAREN
953        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
954    ;
955
956WordIOTerm
957    : PARSEOP_WORDIO
958        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_WORDIO);}
959        OptionalResourceType_First
960        OptionalMinType
961        OptionalMaxType
962        OptionalDecodeType
963        OptionalRangeType
964        ',' WordConstExpr
965        ',' WordConstExpr
966        ',' WordConstExpr
967        ',' WordConstExpr
968        ',' WordConstExpr
969        OptionalByteConstExpr
970        OptionalStringData
971        OptionalNameString
972        OptionalType
973        OptionalTranslationType_Last
974        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,15,
975                                        $4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
976    | PARSEOP_WORDIO
977        PARSEOP_OPEN_PAREN
978        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
979    ;
980
981WordSpaceTerm
982    : PARSEOP_WORDSPACE
983        PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_WORDSPACE);}
984        ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
985        OptionalResourceType
986        OptionalDecodeType
987        OptionalMinType
988        OptionalMaxType
989        ',' ByteConstExpr
990        ',' WordConstExpr
991        ',' WordConstExpr
992        ',' WordConstExpr
993        ',' WordConstExpr
994        ',' WordConstExpr
995        OptionalByteConstExpr
996        OptionalStringData
997        OptionalNameString_Last
998        PARSEOP_CLOSE_PAREN         {$$ = TrLinkOpChildren ($<n>3,14,
999                                        $4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
1000    | PARSEOP_WORDSPACE
1001        PARSEOP_OPEN_PAREN
1002        error PARSEOP_CLOSE_PAREN   {$$ = AslDoError(); yyclearin;}
1003    ;
1004