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

   1 NoEcho('
   2 /******************************************************************************
   3  *
   4  * Module Name: aslrules.y - Main Bison/Yacc production rules
   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  * ASL Root and Secondary Terms
 160  *
 161  ******************************************************************************/
 162
 163 /*
 164  * Root term. Allow multiple #line directives before the definition block
 165  * to handle output from preprocessors
 166  */
 167 AslCode
 168     : DefinitionBlockList           {$<n>$ = TrLinkOpChildren (
 169                                         TrCreateLeafOp (PARSEOP_ASL_CODE),1, $1);}
 170     | error                         {YYABORT; $$ = NULL;}
 171     ;
 172
 173
 174 /*
 175  * Note concerning support for "module-level code".
 176  *
 177  * ACPI 1.0 allowed Type1 and Type2 executable opcodes outside of control
 178  * methods (the so-called module-level code.) This support was explicitly
 179  * removed in ACPI 2.0, but this type of code continues to be created by
 180  * BIOS vendors. In order to support the disassembly and recompilation of
 181  * such code (and the porting of ASL code to iASL), iASL supports this
 182  * code in violation of the current ACPI specification.
 183  *
 184  * The grammar change to support module-level code is to revert the
 185  * {ObjectList} portion of the DefinitionBlockTerm in ACPI 2.0 to the
 186  * original use of {TermList} instead (see below.) This allows the use
 187  * of Type1 and Type2 opcodes at module level.
 188  *
 189  * 04/2016: The module-level code is now allowed in the following terms:
 190  * DeviceTerm, PowerResTerm, ProcessorTerm, ScopeTerm, ThermalZoneTerm.
 191  * The ObjectList term is obsolete and has been removed.
 192  */
 193 DefinitionBlockTerm
 194     : PARSEOP_DEFINITION_BLOCK
 195         PARSEOP_OPEN_PAREN          {$<n>$ = TrCreateLeafOp (PARSEOP_DEFINITION_BLOCK); COMMENT_CAPTURE_OFF;}
 196         String ','
 197         String ','
 198         ByteConst ','
 199         String ','
 200         String ','
 201         DWordConst
 202         PARSEOP_CLOSE_PAREN         {TrSetOpIntegerWidth ($6,$8);
 203                                         TrSetOpEndLineNumber ($<n>3); COMMENT_CAPTURE_ON;}
 204             '{' TermList '}'        {$$ = TrLinkOpChildren ($<n>3,7,
 205                                         $4,$6,$8,$10,$12,$14,$18);}
 206     ;
 207
 208 DefinitionBlockList
 209     : DefinitionBlockTerm
 210     | DefinitionBlockTerm
 211         DefinitionBlockList         {$$ = TrLinkPeerOps (2, $1,$2);}
 212     ;
 213
 214
 215 /******* Basic ASCII identifiers **************************************************/
 216
 217 /* Allow IO, DMA, IRQ Resource macro and FOR macro names to also be used as identifiers */
 218
 219 NameString
 220     : NameSeg                       {}
 221     | PARSEOP_NAMESTRING            {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) $1);}
 222     | PARSEOP_IO                    {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IO");}
 223     | PARSEOP_DMA                   {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "DMA");}
 224     | PARSEOP_IRQ                   {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IRQ");}
 225     | PARSEOP_FOR                   {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "FOR");}
 226     ;
 227 /*
 228 NameSeg
 229     : PARSEOP_NAMESEG               {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESEG, (ACPI_NATIVE_INT)
 230                                         TrNormalizeNameSeg ($1));}
 231     ;
 232 */
 233
 234 NameSeg
 235     : PARSEOP_NAMESEG               {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESEG,
 236                                         (ACPI_NATIVE_INT) AslCompilerlval.s);}
 237     ;
 238
 239
 240 /******* Fundamental argument/statement types ***********************************/
 241
 242 Term
 243     : Object                        {}
 244     | Type1Opcode                   {}
 245     | Type2Opcode                   {}
 246     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 247     | Type2StringOpcode             {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 248     | Type2BufferOpcode             {}
 249     | Type2BufferOrStringOpcode     {}
 250     | error                         {$$ = AslDoError(); yyclearin;}
 251     ;
 252
 253 SuperName
 254     : SimpleName                    {}
 255     | DebugTerm                     {}
 256     | Type6Opcode                   {}
 257     ;
 258
 259 Target
 260     :                               {$$ = TrCreateNullTargetOp ();} /* Placeholder is a ZeroOp object */
 261     | ','                           {$$ = TrCreateNullTargetOp ();} /* Placeholder is a ZeroOp object */
 262     | ',' SuperName                 {$$ = TrSetOpFlags ($2, OP_IS_TARGET);}
 263     ;
 264
 265 RequiredTarget
 266     : ',' SuperName                 {$$ = TrSetOpFlags ($2, OP_IS_TARGET);}
 267     ;
 268
 269 TermArg
 270     : SimpleName                    {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);}
 271     | Type2Opcode                   {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);}
 272     | DataObject                    {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);}
 273     | PARSEOP_OPEN_PAREN
 274         TermArg
 275         PARSEOP_CLOSE_PAREN         {$$ = TrSetOpFlags ($2, OP_IS_TERM_ARG);}
 276     ;
 277
 278 /*
 279  NOTE: Removed from TermArg due to reduce/reduce conflicts:
 280     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);}
 281     | Type2StringOpcode             {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);}
 282     | Type2BufferOpcode             {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);}
 283     | Type2BufferOrStringOpcode     {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);}
 284
 285 */
 286
 287 MethodInvocationTerm
 288     : NameString
 289         PARSEOP_OPEN_PAREN          {TrSetOpIntegerValue (PARSEOP_METHODCALL, $1); COMMENT_CAPTURE_OFF;}
 290         ArgList
 291         PARSEOP_CLOSE_PAREN         {$$ = TrLinkChildOp ($1,$4); COMMENT_CAPTURE_ON;}
 292     ;
 293
 294 /* OptionalCount must appear before ByteList or an incorrect reduction will result */
 295
 296 OptionalCount
 297     :                               {$$ = TrCreateLeafOp (PARSEOP_ONES);}       /* Placeholder is a OnesOp object */
 298     | ','                           {$$ = TrCreateLeafOp (PARSEOP_ONES);}       /* Placeholder is a OnesOp object */
 299     | ',' TermArg                   {$$ = $2;}
 300     ;
 301
 302 /*
 303  * Data count for buffers and packages (byte count for buffers,
 304  * element count for packages).
 305  */
 306 OptionalDataCount
 307
 308         /* Legacy ASL */
 309     :                               {$$ = NULL;}
 310     | PARSEOP_OPEN_PAREN
 311         TermArg
 312         PARSEOP_CLOSE_PAREN         {$$ = $2;}
 313     | PARSEOP_OPEN_PAREN
 314         PARSEOP_CLOSE_PAREN         {$$ = NULL;}
 315
 316         /* C-style (ASL+) -- adds equals term */
 317
 318     |  PARSEOP_EXP_EQUALS           {$$ = NULL;}
 319
 320     | PARSEOP_OPEN_PAREN
 321         TermArg
 322         PARSEOP_CLOSE_PAREN
 323         PARSEOP_EXP_EQUALS          {$$ = $2;}
 324
 325     | PARSEOP_OPEN_PAREN
 326         PARSEOP_CLOSE_PAREN
 327         String
 328         PARSEOP_EXP_EQUALS          {$$ = NULL;}
 329     ;
 330
 331
 332 /******* List Terms **************************************************/
 333
 334     /* ACPI 3.0 -- allow semicolons between terms */
 335
 336 TermList
 337     :                               {$$ = NULL;}
 338     | TermList Term                 {$$ = TrLinkPeerOp (
 339                                         TrSetOpFlags ($1, OP_RESULT_NOT_USED),$2);}
 340     | TermList Term ';'             {$$ = TrLinkPeerOp (
 341                                         TrSetOpFlags ($1, OP_RESULT_NOT_USED),$2);}
 342     | TermList ';' Term             {$$ = TrLinkPeerOp (
 343                                         TrSetOpFlags ($1, OP_RESULT_NOT_USED),$3);}
 344     | TermList ';' Term ';'         {$$ = TrLinkPeerOp (
 345                                         TrSetOpFlags ($1, OP_RESULT_NOT_USED),$3);}
 346     ;
 347
 348 ArgList
 349     :                               {$$ = NULL;}
 350     | TermArg
 351     | ArgList ','                   /* Allows a trailing comma at list end */
 352     | ArgList ','
 353         TermArg                     {$$ = TrLinkPeerOp ($1,$3);}
 354     ;
 355
 356 ByteList
 357     :                               {$$ = NULL;}
 358     | ByteConstExpr
 359     | ByteList ','                  /* Allows a trailing comma at list end */
 360     | ByteList ','
 361         ByteConstExpr               {$$ = TrLinkPeerOp ($1,$3);}
 362     ;
 363
 364 DWordList
 365     :                               {$$ = NULL;}
 366     | DWordConstExpr
 367     | DWordList ','                 /* Allows a trailing comma at list end */
 368     | DWordList ','
 369         DWordConstExpr              {$$ = TrLinkPeerOp ($1,$3);}
 370     ;
 371
 372 FieldUnitList
 373     :                               {$$ = NULL;}
 374     | FieldUnit
 375     | FieldUnitList ','             /* Allows a trailing comma at list end */
 376     | FieldUnitList ','
 377         FieldUnit                   {$$ = TrLinkPeerOp ($1,$3);}
 378     ;
 379
 380 FieldUnit
 381     : FieldUnitEntry                {}
 382     | OffsetTerm                    {}
 383     | AccessAsTerm                  {}
 384     | ConnectionTerm                {}
 385     ;
 386
 387 FieldUnitEntry
 388     : ',' AmlPackageLengthTerm      {$$ = TrCreateOp (PARSEOP_RESERVED_BYTES,1,$2);}
 389     | NameSeg ','
 390         AmlPackageLengthTerm        {$$ = TrLinkChildOp ($1,$3);}
 391     ;
 392
 393 Object
 394     : CompilerDirective             {}
 395     | NamedObject                   {}
 396     | NameSpaceModifier             {}
 397 /*    | StructureTerm                 {} */
 398     ;
 399
 400 PackageList
 401     :                               {$$ = NULL;}
 402     | PackageElement
 403     | PackageList ','               /* Allows a trailing comma at list end */
 404     | PackageList ','
 405         PackageElement              {$$ = TrLinkPeerOp ($1,$3);}
 406     ;
 407
 408 PackageElement
 409     : DataObject                    {}
 410     | NameString                    {}
 411     ;
 412
 413     /* Rules for specifying the type of one method argument or return value */
 414
 415 ParameterTypePackage
 416     :                               {$$ = NULL;}
 417     | ObjectTypeKeyword             {$$ = $1;}
 418     | ParameterTypePackage ','
 419         ObjectTypeKeyword           {$$ = TrLinkPeerOps (2,$1,$3);}
 420     ;
 421
 422 ParameterTypePackageList
 423     :                               {$$ = NULL;}
 424     | ObjectTypeKeyword             {$$ = $1;}
 425     | '{' ParameterTypePackage '}'  {$$ = $2;}
 426     ;
 427
 428 OptionalParameterTypePackage
 429     :                               {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);}
 430     | ',' ParameterTypePackageList  {$$ = TrLinkOpChildren (
 431                                         TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);}
 432     ;
 433
 434     /* Rules for specifying the types for method arguments */
 435
 436 ParameterTypesPackage
 437     : ParameterTypePackageList      {$$ = $1;}
 438     | ParameterTypesPackage ','
 439         ParameterTypePackageList    {$$ = TrLinkPeerOps (2,$1,$3);}
 440     ;
 441
 442 ParameterTypesPackageList
 443     :                               {$$ = NULL;}
 444     | ObjectTypeKeyword             {$$ = $1;}
 445     | '{' ParameterTypesPackage '}' {$$ = $2;}
 446     ;
 447
 448 OptionalParameterTypesPackage
 449     :                               {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);}
 450     | ',' ParameterTypesPackageList {$$ = TrLinkOpChildren (
 451                                         TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);}
 452     ;
 453
 454 /*
 455  * Case-Default list; allow only one Default term and unlimited Case terms
 456  */
 457 CaseDefaultTermList
 458     :                               {$$ = NULL;}
 459     | CaseTerm                      {}
 460     | DefaultTerm                   {}
 461     | CaseDefaultTermList
 462         CaseTerm                    {$$ = TrLinkPeerOp ($1,$2);}
 463     | CaseDefaultTermList
 464         DefaultTerm                 {$$ = TrLinkPeerOp ($1,$2);}
 465
 466 /* Original - attempts to force zero or one default term within the switch */
 467
 468 /*
 469 CaseDefaultTermList
 470     :                               {$$ = NULL;}
 471     | CaseTermList
 472         DefaultTerm
 473         CaseTermList                {$$ = TrLinkPeerOp ($1,TrLinkPeerOp ($2, $3));}
 474     | CaseTermList
 475         CaseTerm                    {$$ = TrLinkPeerOp ($1,$2);}
 476     ;
 477
 478 CaseTermList
 479     :                               {$$ = NULL;}
 480     | CaseTerm                      {}
 481     | CaseTermList
 482         CaseTerm                    {$$ = TrLinkPeerOp ($1,$2);}
 483     ;
 484 */
 485
 486
 487 /*******************************************************************************
 488  *
 489  * ASL Data and Constant Terms
 490  *
 491  ******************************************************************************/
 492
 493 DataObject
 494     : BufferData                    {}
 495     | PackageData                   {}
 496     | IntegerData                   {}
 497     | StringData                    {}
 498     ;
 499
 500 BufferData
 501     : Type5Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 502     | Type2BufferOrStringOpcode     {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 503     | Type2BufferOpcode             {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 504     | BufferTerm                    {}
 505     ;
 506
 507 PackageData
 508     : PackageTerm                   {}
 509     ;
 510
 511 IntegerData
 512     : Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 513     | Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 514     | Integer                       {}
 515     | ConstTerm                     {}
 516     ;
 517
 518 StringData
 519     : Type2StringOpcode             {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 520     | String                        {}
 521     ;
 522
 523 ByteConst
 524     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_BYTECONST, $1);}
 525     ;
 526
 527 WordConst
 528     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_WORDCONST, $1);}
 529     ;
 530
 531 DWordConst
 532     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_DWORDCONST, $1);}
 533     ;
 534
 535 QWordConst
 536     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_QWORDCONST, $1);}
 537     ;
 538
 539 /*
 540  * The OP_COMPILE_TIME_CONST flag in the following constant expressions
 541  * enables compile-time constant folding to reduce the Type3Opcodes/Type2IntegerOpcodes
 542  * to simple integers. It is an error if these types of expressions cannot be
 543  * reduced, since the AML grammar for ****ConstExpr requires a simple constant.
 544  * Note: The required byte length of the constant is passed through to the
 545  * constant folding code in the node AmlLength field.
 546  */
 547 ByteConstExpr
 548     : Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
 549                                         TrSetOpAmlLength ($1, 1);}
 550     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
 551                                         TrSetOpAmlLength ($1, 1);}
 552     | ConstExprTerm                 {$$ = TrSetOpIntegerValue (PARSEOP_BYTECONST, $1);}
 553     | ByteConst                     {}
 554     ;
 555
 556 WordConstExpr
 557     : Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
 558                                         TrSetOpAmlLength ($1, 2);}
 559     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
 560                                         TrSetOpAmlLength ($1, 2);}
 561     | ConstExprTerm                 {$$ = TrSetOpIntegerValue (PARSEOP_WORDCONST, $1);}
 562     | WordConst                     {}
 563     ;
 564
 565 DWordConstExpr
 566     : Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
 567                                         TrSetOpAmlLength ($1, 4);}
 568     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
 569                                         TrSetOpAmlLength ($1, 4);}
 570     | ConstExprTerm                 {$$ = TrSetOpIntegerValue (PARSEOP_DWORDCONST, $1);}
 571     | DWordConst                    {}
 572     ;
 573
 574 QWordConstExpr
 575     : Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
 576                                         TrSetOpAmlLength ($1, 8);}
 577     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
 578                                         TrSetOpAmlLength ($1, 8);}
 579     | ConstExprTerm                 {$$ = TrSetOpIntegerValue (PARSEOP_QWORDCONST, $1);}
 580     | QWordConst                    {}
 581     ;
 582
 583 ConstTerm
 584     : ConstExprTerm                 {}
 585     | PARSEOP_REVISION              {$$ = TrCreateLeafOp (PARSEOP_REVISION);}
 586     ;
 587
 588 ConstExprTerm
 589     : PARSEOP_ZERO                  {$$ = TrCreateValuedLeafOp (PARSEOP_ZERO, 0);}
 590     | PARSEOP_ONE                   {$$ = TrCreateValuedLeafOp (PARSEOP_ONE, 1);}
 591     | PARSEOP_ONES                  {$$ = TrCreateValuedLeafOp (PARSEOP_ONES, ACPI_UINT64_MAX);}
 592     | PARSEOP___DATE__              {$$ = TrCreateConstantLeafOp (PARSEOP___DATE__);}
 593     | PARSEOP___FILE__              {$$ = TrCreateConstantLeafOp (PARSEOP___FILE__);}
 594     | PARSEOP___LINE__              {$$ = TrCreateConstantLeafOp (PARSEOP___LINE__);}
 595     | PARSEOP___PATH__              {$$ = TrCreateConstantLeafOp (PARSEOP___PATH__);}
 596     | PARSEOP___METHOD__            {$$ = TrCreateConstantLeafOp (PARSEOP___METHOD__);}
 597     ;
 598
 599 Integer
 600     : PARSEOP_INTEGER               {$$ = TrCreateValuedLeafOp (PARSEOP_INTEGER,
 601                                         AslCompilerlval.i);}
 602     ;
 603
 604 String
 605     : PARSEOP_STRING_LITERAL        {$$ = TrCreateValuedLeafOp (PARSEOP_STRING_LITERAL,
 606                                         (ACPI_NATIVE_INT) AslCompilerlval.s);}
 607     ;
 608
 609
 610 /*******************************************************************************
 611  *
 612  * ASL Opcode Terms
 613  *
 614  ******************************************************************************/
 615
 616 CompilerDirective
 617     : IncludeTerm                   {}
 618     | IncludeEndTerm                {}
 619     | ExternalTerm                  {}
 620     ;
 621
 622 NamedObject
 623     : BankFieldTerm                 {}
 624     | CreateBitFieldTerm            {}
 625     | CreateByteFieldTerm           {}
 626     | CreateDWordFieldTerm          {}
 627     | CreateFieldTerm               {}
 628     | CreateQWordFieldTerm          {}
 629     | CreateWordFieldTerm           {}
 630     | DataRegionTerm                {}
 631     | DeviceTerm                    {}
 632     | EventTerm                     {}
 633     | FieldTerm                     {}
 634     | FunctionTerm                  {}
 635     | IndexFieldTerm                {}
 636     | MethodTerm                    {}
 637     | MutexTerm                     {}
 638     | OpRegionTerm                  {}
 639     | PowerResTerm                  {}
 640     | ProcessorTerm                 {}
 641     | ThermalZoneTerm               {}
 642     ;
 643
 644 NameSpaceModifier
 645     : AliasTerm                     {}
 646     | NameTerm                      {}
 647 /*    | NameTermAslPlus               {} */
 648     | ScopeTerm                     {}
 649     ;
 650
 651 SimpleName
 652     : NameString                    {}
 653     | LocalTerm                     {}
 654     | ArgTerm                       {}
 655     ;
 656
 657 /* For ObjectType(), SuperName except for MethodInvocationTerm */
 658
 659 ObjectTypeSource
 660     : SimpleName                    {}
 661     | DebugTerm                     {}
 662     | RefOfTerm                     {}
 663     | DerefOfTerm                   {}
 664     | IndexTerm                     {}
 665     | IndexExpTerm                  {}
 666     ;
 667
 668 /* For DeRefOf(), SuperName except for DerefOf and Debug */
 669
 670 DerefOfSource
 671     : SimpleName                    {}
 672     | RefOfTerm                     {}
 673     | DerefOfTerm                   {}
 674     | IndexTerm                     {}
 675     | IndexExpTerm                  {}
 676     | StoreTerm                     {}
 677     | EqualsTerm                    {}
 678     | MethodInvocationTerm          {}
 679     ;
 680
 681 /* For RefOf(), SuperName except for RefOf and MethodInvocationTerm */
 682
 683 RefOfSource
 684     : SimpleName                    {}
 685     | DebugTerm                     {}
 686     | DerefOfTerm                   {}
 687     | IndexTerm                     {}
 688     | IndexExpTerm                  {}
 689     ;
 690
 691 /* For CondRefOf(), SuperName except for RefOf and MethodInvocationTerm */
 692
 693 CondRefOfSource
 694     : SimpleName                    {}
 695     | DebugTerm                     {}
 696     | DerefOfTerm                   {}
 697     | IndexTerm                     {}
 698     | IndexExpTerm                  {}
 699     ;
 700
 701 /*
 702  * Opcode types, as defined in the ACPI specification
 703  */
 704 Type1Opcode
 705     : BreakTerm                     {}
 706     | BreakPointTerm                {}
 707     | ContinueTerm                  {}
 708     | FatalTerm                     {}
 709     | ForTerm                       {}
 710     | ElseIfTerm                    {}
 711     | LoadTerm                      {}
 712     | NoOpTerm                      {}
 713     | NotifyTerm                    {}
 714     | ReleaseTerm                   {}
 715     | ResetTerm                     {}
 716     | ReturnTerm                    {}
 717     | SignalTerm                    {}
 718     | SleepTerm                     {}
 719     | StallTerm                     {}
 720     | SwitchTerm                    {}
 721     | UnloadTerm                    {}
 722     | WhileTerm                     {}
 723     ;
 724
 725 Type2Opcode
 726     : AcquireTerm                   {}
 727     | CondRefOfTerm                 {}
 728     | CopyObjectTerm                {}
 729     | DerefOfTerm                   {}
 730     | ObjectTypeTerm                {}
 731     | RefOfTerm                     {}
 732     | SizeOfTerm                    {}
 733     | StoreTerm                     {}
 734     | EqualsTerm                    {}
 735     | TimerTerm                     {}
 736     | WaitTerm                      {}
 737     | MethodInvocationTerm          {}
 738     ;
 739
 740 /*
 741  * Type 3/4/5 opcodes
 742  */
 743 Type2IntegerOpcode                  /* "Type3" opcodes */
 744     : Expression                    {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 745     | AddTerm                       {}
 746     | AndTerm                       {}
 747     | DecTerm                       {}
 748     | DivideTerm                    {}
 749     | FindSetLeftBitTerm            {}
 750     | FindSetRightBitTerm           {}
 751     | FromBCDTerm                   {}
 752     | IncTerm                       {}
 753     | IndexTerm                     {}
 754 /*    | StructureIndexTerm            {} */
 755 /*    | StructurePointerTerm          {} */
 756     | LAndTerm                      {}
 757     | LEqualTerm                    {}
 758     | LGreaterTerm                  {}
 759     | LGreaterEqualTerm             {}
 760     | LLessTerm                     {}
 761     | LLessEqualTerm                {}
 762     | LNotTerm                      {}
 763     | LNotEqualTerm                 {}
 764     | LoadTableTerm                 {}
 765     | LOrTerm                       {}
 766     | MatchTerm                     {}
 767     | ModTerm                       {}
 768     | MultiplyTerm                  {}
 769     | NAndTerm                      {}
 770     | NOrTerm                       {}
 771     | NotTerm                       {}
 772     | OrTerm                        {}
 773     | ShiftLeftTerm                 {}
 774     | ShiftRightTerm                {}
 775     | SubtractTerm                  {}
 776     | ToBCDTerm                     {}
 777     | ToIntegerTerm                 {}
 778     | XOrTerm                       {}
 779     ;
 780
 781 Type2StringOpcode                   /* "Type4" Opcodes */
 782     : ToDecimalStringTerm           {}
 783     | ToHexStringTerm               {}
 784     | ToStringTerm                  {}
 785     ;
 786
 787 Type2BufferOpcode                   /* "Type5" Opcodes */
 788     : ToBufferTerm                  {}
 789     | ConcatResTerm                 {}
 790     ;
 791
 792 Type2BufferOrStringOpcode
 793     : ConcatTerm                    {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
 794     | PrintfTerm                    {}
 795     | FprintfTerm                   {}
 796     | MidTerm                       {}
 797     ;
 798
 799 /*
 800  * A type 3 opcode evaluates to an Integer and cannot have a destination operand
 801  */
 802 Type3Opcode
 803     : EISAIDTerm                    {}
 804     ;
 805
 806 /* Obsolete
 807 Type4Opcode
 808     : ConcatTerm                    {}
 809     | ToDecimalStringTerm           {}
 810     | ToHexStringTerm               {}
 811     | MidTerm                       {}
 812     | ToStringTerm                  {}
 813     ;
 814 */
 815
 816 /* Type 5 opcodes are a subset of Type2 opcodes, and return a constant */
 817
 818 Type5Opcode
 819     : ResourceTemplateTerm          {}
 820     | UnicodeTerm                   {}
 821     | ToPLDTerm                     {}
 822     | ToUUIDTerm                    {}
 823     ;
 824
 825 Type6Opcode
 826     : RefOfTerm                     {}
 827     | DerefOfTerm                   {}
 828     | IndexTerm                     {}
 829     | IndexExpTerm                  {}
 830 /*    | StructureIndexTerm            {} */
 831 /*    | StructurePointerTerm          {} */
 832     | MethodInvocationTerm          {}
 833     ;
 834
 835
 836 /*******************************************************************************
 837  *
 838  * ASL Helper Terms
 839  *
 840  ******************************************************************************/
 841
 842 AmlPackageLengthTerm
 843     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_PACKAGE_LENGTH,
 844                                         (ACPI_PARSE_OBJECT *) $1);}
 845     ;
 846
 847 NameStringItem
 848     : ',' NameString                {$$ = $2;}
 849     | ',' error                     {$$ = AslDoError (); yyclearin;}
 850     ;
 851
 852 TermArgItem
 853     : ',' TermArg                   {$$ = $2;}
 854     | ',' error                     {$$ = AslDoError (); yyclearin;}
 855     ;
 856
 857 OptionalReference
 858     :                               {$$ = TrCreateLeafOp (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
 859     | ','                           {$$ = TrCreateLeafOp (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
 860     | ',' TermArg                   {$$ = $2;}
 861     ;
 862
 863 OptionalReturnArg
 864     :                               {$$ = TrSetOpFlags (TrCreateLeafOp (PARSEOP_ZERO),
 865                                             OP_IS_NULL_RETURN);}       /* Placeholder is a ZeroOp object */
 866     | TermArg                       {$$ = $1;}
 867     ;
 868
 869 OptionalSerializeRuleKeyword
 870     :                               {$$ = NULL;}
 871     | ','                           {$$ = NULL;}
 872     | ',' SerializeRuleKeyword      {$$ = $2;}
 873     ;
 874
 875 OptionalTermArg
 876     :                               {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);}
 877     | TermArg                       {$$ = $1;}
 878     ;
 879
 880 OptionalWordConst
 881     :                               {$$ = NULL;}
 882     | WordConst                     {$$ = $1;}
 883     ;