sys/contrib/dev/acpica/source/compiler/aslresources.y

   1 NoEcho('
   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 - 2018, 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  */
 168 ResourceTemplateTerm
 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
 180 OptionalParentheses
 181     :                               {$$ = NULL;}
 182     | PARSEOP_OPEN_PAREN
 183         PARSEOP_CLOSE_PAREN         {$$ = NULL;}
 184     ;
 185
 186 ResourceMacroList
 187     :                               {$$ = NULL;}
 188     | ResourceMacroList
 189         ResourceMacroTerm           {$$ = TrLinkPeerOp ($1,$2);}
 190     ;
 191
 192 ResourceMacroTerm
 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
 236 DMATerm
 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
 250 DWordIOTerm
 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
 275 DWordMemoryTerm
 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
 301 DWordSpaceTerm
 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
 325 EndDependentFnTerm
 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
 334 ExtendedIOTerm
 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
 358 ExtendedMemoryTerm
 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
 383 ExtendedSpaceTerm
 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
 405 FixedDmaTerm
 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
 418 FixedIOTerm
 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
 430 GpioIntTerm
 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
 451 GpioIoTerm
 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
 472 I2cSerialBusTerm
 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
 492 I2cSerialBusTermV2
 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
 512 InterruptTerm
 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
 530 IOTerm
 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
 545 IRQNoFlagsTerm
 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
 556 IRQTerm
 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
 570 Memory24Term
 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
 585 Memory32FixedTerm
 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
 598 Memory32Term
 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
 613 PinConfigTerm
 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
 632 PinFunctionTerm
 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
 651 PinGroupTerm
 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
 665 PinGroupConfigTerm
 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
 684 PinGroupFunctionTerm
 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
 702 QWordIOTerm
 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
 727 QWordMemoryTerm
 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
 753 QWordSpaceTerm
 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
 777 RegisterTerm
 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
 792 SpiSerialBusTerm
 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
 816 SpiSerialBusTermV2
 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
 840 StartDependentFnNoPriTerm
 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
 850 StartDependentFnTerm
 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
 862 UartSerialBusTerm
 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: Endianess */
 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
 887 UartSerialBusTermV2
 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: Endianess */
 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
 912 VendorLongTerm
 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
 923 VendorShortTerm
 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
 934 WordBusNumberTerm
 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
 956 WordIOTerm
 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
 981 WordSpaceTerm
 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     ;