Home | History | Annotate | Line # | Download | only in compiler
      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 - 2025, 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             {$$ = TrLinkOpChildren (
    425                                         TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$1);}
    426     | '{' ParameterTypePackage '}'  {$$ = TrLinkOpChildren (
    427                                         TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);}
    428     ;
    429 
    430 
    431 OptionalParameterTypePackage
    432     :                               {$$ = NULL;}
    433     | ',' ParameterTypePackageList  {$$ = $2;}
    434     ;
    435 
    436     /* Rules for specifying the types for method arguments */
    437 
    438 ParameterTypesPackage
    439     : ParameterTypePackageList      {$$ = $1;}
    440     | ParameterTypesPackage ','
    441         ParameterTypePackageList    {$$ = TrLinkPeerOps (2,$1,$3);}
    442     ;
    443 
    444 ParameterTypesPackageList
    445     :                               {$$ = NULL;}
    446     | ObjectTypeKeyword             {$$ = TrLinkOpChildren (
    447                                         TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$1);}
    448     | '{' ParameterTypesPackage '}' {$$ = TrLinkOpChildren (
    449                                         TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);}
    450     ;
    451 
    452 OptionalParameterTypesPackage
    453     :                               {$$ = NULL;}
    454     | ',' ParameterTypesPackageList {$$ = $2;}
    455     ;
    456 
    457 /*
    458  * Case-Default list; allow only one Default term and unlimited Case terms
    459  */
    460 CaseDefaultTermList
    461     :                               {$$ = NULL;}
    462     | CaseTerm                      {}
    463     | DefaultTerm                   {}
    464     | CaseDefaultTermList
    465         CaseTerm                    {$$ = TrLinkPeerOp ($1,$2);}
    466     | CaseDefaultTermList
    467         DefaultTerm                 {$$ = TrLinkPeerOp ($1,$2);}
    468 
    469 /* Original - attempts to force zero or one default term within the switch */
    470 
    471 /*
    472 CaseDefaultTermList
    473     :                               {$$ = NULL;}
    474     | CaseTermList
    475         DefaultTerm
    476         CaseTermList                {$$ = TrLinkPeerOp ($1,TrLinkPeerOp ($2, $3));}
    477     | CaseTermList
    478         CaseTerm                    {$$ = TrLinkPeerOp ($1,$2);}
    479     ;
    480 
    481 CaseTermList
    482     :                               {$$ = NULL;}
    483     | CaseTerm                      {}
    484     | CaseTermList
    485         CaseTerm                    {$$ = TrLinkPeerOp ($1,$2);}
    486     ;
    487 */
    488 
    489 
    490 /*******************************************************************************
    491  *
    492  * ASL Data and Constant Terms
    493  *
    494  ******************************************************************************/
    495 
    496 DataObject
    497     : BufferData                    {}
    498     | PackageData                   {}
    499     | IntegerData                   {}
    500     | StringData                    {}
    501     ;
    502 
    503 BufferData
    504     : Type5Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
    505     | Type2BufferOrStringOpcode     {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
    506     | Type2BufferOpcode             {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
    507     | BufferTerm                    {}
    508     ;
    509 
    510 PackageData
    511     : PackageTerm                   {}
    512     ;
    513 
    514 IntegerData
    515     : Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
    516     | Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
    517     | Integer                       {}
    518     | ConstTerm                     {}
    519     ;
    520 
    521 StringData
    522     : Type2StringOpcode             {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
    523     | String                        {}
    524     ;
    525 
    526 StringLiteral
    527     : String                        {}
    528     ;
    529 
    530 ByteConst
    531     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_BYTECONST, $1);}
    532     ;
    533 
    534 WordConst
    535     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_WORDCONST, $1);}
    536     ;
    537 
    538 DWordConst
    539     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_DWORDCONST, $1);}
    540     ;
    541 
    542 QWordConst
    543     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_QWORDCONST, $1);}
    544     ;
    545 
    546 /*
    547  * The OP_COMPILE_TIME_CONST flag in the following constant expressions
    548  * enables compile-time constant folding to reduce the Type3Opcodes/Type2IntegerOpcodes
    549  * to simple integers. It is an error if these types of expressions cannot be
    550  * reduced, since the AML grammar for ****ConstExpr requires a simple constant.
    551  * Note: The required byte length of the constant is passed through to the
    552  * constant folding code in the node AmlLength field.
    553  */
    554 ByteConstExpr
    555     : Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
    556                                         TrSetOpAmlLength ($1, 1);}
    557     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
    558                                         TrSetOpAmlLength ($1, 1);}
    559     | ConstExprTerm                 {$$ = TrSetOpIntegerValue (PARSEOP_BYTECONST, $1);}
    560     | ByteConst                     {}
    561     ;
    562 
    563 WordConstExpr
    564     : Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
    565                                         TrSetOpAmlLength ($1, 2);}
    566     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
    567                                         TrSetOpAmlLength ($1, 2);}
    568     | ConstExprTerm                 {$$ = TrSetOpIntegerValue (PARSEOP_WORDCONST, $1);}
    569     | WordConst                     {}
    570     ;
    571 
    572 DWordConstExpr
    573     : Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
    574                                         TrSetOpAmlLength ($1, 4);}
    575     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
    576                                         TrSetOpAmlLength ($1, 4);}
    577     | ConstExprTerm                 {$$ = TrSetOpIntegerValue (PARSEOP_DWORDCONST, $1);}
    578     | DWordConst                    {}
    579     ;
    580 
    581 QWordConstExpr
    582     : Type3Opcode                   {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
    583                                         TrSetOpAmlLength ($1, 8);}
    584     | Type2IntegerOpcode            {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);
    585                                         TrSetOpAmlLength ($1, 8);}
    586     | ConstExprTerm                 {$$ = TrSetOpIntegerValue (PARSEOP_QWORDCONST, $1);}
    587     | QWordConst                    {}
    588     ;
    589 
    590 ConstTerm
    591     : ConstExprTerm                 {}
    592     | PARSEOP_REVISION              {$$ = TrCreateLeafOp (PARSEOP_REVISION);}
    593     ;
    594 
    595 ConstExprTerm
    596     : PARSEOP_ZERO                  {$$ = TrCreateValuedLeafOp (PARSEOP_ZERO, 0);}
    597     | PARSEOP_ONE                   {$$ = TrCreateValuedLeafOp (PARSEOP_ONE, 1);}
    598     | PARSEOP_ONES                  {$$ = TrCreateValuedLeafOp (PARSEOP_ONES, ACPI_UINT64_MAX);}
    599     | PARSEOP___DATE__              {$$ = TrCreateConstantLeafOp (PARSEOP___DATE__);}
    600     | PARSEOP___FILE__              {$$ = TrCreateConstantLeafOp (PARSEOP___FILE__);}
    601     | PARSEOP___LINE__              {$$ = TrCreateConstantLeafOp (PARSEOP___LINE__);}
    602     | PARSEOP___PATH__              {$$ = TrCreateConstantLeafOp (PARSEOP___PATH__);}
    603     | PARSEOP___METHOD__            {$$ = TrCreateConstantLeafOp (PARSEOP___METHOD__);}
    604     ;
    605 
    606 Integer
    607     : PARSEOP_INTEGER               {$$ = TrCreateValuedLeafOp (PARSEOP_INTEGER,
    608                                         AslCompilerlval.i);}
    609     ;
    610 
    611 String
    612     : PARSEOP_STRING_LITERAL        {$$ = TrCreateValuedLeafOp (PARSEOP_STRING_LITERAL,
    613                                         (ACPI_NATIVE_INT) AslCompilerlval.s);}
    614     ;
    615 
    616 
    617 /*******************************************************************************
    618  *
    619  * ASL Opcode Terms
    620  *
    621  ******************************************************************************/
    622 
    623 CompilerDirective
    624     : IncludeTerm                   {}
    625     | IncludeEndTerm                {}
    626     | ExternalTerm                  {}
    627     ;
    628 
    629 NamedObject
    630     : BankFieldTerm                 {}
    631     | CreateBitFieldTerm            {}
    632     | CreateByteFieldTerm           {}
    633     | CreateDWordFieldTerm          {}
    634     | CreateFieldTerm               {}
    635     | CreateQWordFieldTerm          {}
    636     | CreateWordFieldTerm           {}
    637     | DataRegionTerm                {}
    638     | DeviceTerm                    {}
    639     | EventTerm                     {}
    640     | FieldTerm                     {}
    641     | FunctionTerm                  {}
    642     | IndexFieldTerm                {}
    643     | MethodTerm                    {}
    644     | MutexTerm                     {}
    645     | OpRegionTerm                  {}
    646     | PowerResTerm                  {}
    647     | ProcessorTerm                 {}
    648     | ThermalZoneTerm               {}
    649     ;
    650 
    651 NameSpaceModifier
    652     : AliasTerm                     {}
    653     | NameTerm                      {}
    654 /*    | NameTermAslPlus               {} */
    655     | ScopeTerm                     {}
    656     ;
    657 
    658 SimpleName
    659     : NameString                    {}
    660     | LocalTerm                     {}
    661     | ArgTerm                       {}
    662     ;
    663 
    664 /* For ObjectType(), SuperName except for MethodInvocationTerm */
    665 
    666 ObjectTypeSource
    667     : SimpleName                    {}
    668     | DebugTerm                     {}
    669     | RefOfTerm                     {}
    670     | DerefOfTerm                   {}
    671     | IndexTerm                     {}
    672     | IndexExpTerm                  {}
    673     ;
    674 
    675 /* For DeRefOf(), SuperName except for DerefOf and Debug */
    676 
    677 DerefOfSource
    678     : SimpleName                    {}
    679     | RefOfTerm                     {}
    680     | DerefOfTerm                   {}
    681     | IndexTerm                     {}
    682     | IndexExpTerm                  {}
    683     | StoreTerm                     {}
    684     | EqualsTerm                    {}
    685     | MethodInvocationTerm          {}
    686     ;
    687 
    688 /* For RefOf(), SuperName except for RefOf and MethodInvocationTerm */
    689 
    690 RefOfSource
    691     : SimpleName                    {}
    692     | DebugTerm                     {}
    693     | DerefOfTerm                   {}
    694     | IndexTerm                     {}
    695     | IndexExpTerm                  {}
    696     ;
    697 
    698 /* For CondRefOf(), SuperName except for RefOf and MethodInvocationTerm */
    699 
    700 CondRefOfSource
    701     : SimpleName                    {}
    702     | DebugTerm                     {}
    703     | DerefOfTerm                   {}
    704     | IndexTerm                     {}
    705     | IndexExpTerm                  {}
    706     ;
    707 
    708 /*
    709  * Opcode types, as defined in the ACPI specification
    710  */
    711 Type1Opcode
    712     : BreakTerm                     {}
    713     | BreakPointTerm                {}
    714     | ContinueTerm                  {}
    715     | FatalTerm                     {}
    716     | ForTerm                       {}
    717     | ElseIfTerm                    {}
    718     | NoOpTerm                      {}
    719     | NotifyTerm                    {}
    720     | ReleaseTerm                   {}
    721     | ResetTerm                     {}
    722     | ReturnTerm                    {}
    723     | SignalTerm                    {}
    724     | SleepTerm                     {}
    725     | StallTerm                     {}
    726     | SwitchTerm                    {}
    727     | UnloadTerm                    {}
    728     | WhileTerm                     {}
    729     ;
    730 
    731 Type2Opcode
    732     : AcquireTerm                   {}
    733     | CondRefOfTerm                 {}
    734     | CopyObjectTerm                {}
    735     | DerefOfTerm                   {}
    736     | LoadTerm                      {} /* Moved from Type1 -- now returns an integer (ACPI 6.4) */
    737     | ObjectTypeTerm                {}
    738     | RefOfTerm                     {}
    739     | SizeOfTerm                    {}
    740     | StoreTerm                     {}
    741     | EqualsTerm                    {}
    742     | TimerTerm                     {}
    743     | WaitTerm                      {}
    744     | MethodInvocationTerm          {}
    745     ;
    746 
    747 /*
    748  * Type 3/4/5 opcodes
    749  */
    750 Type2IntegerOpcode                  /* "Type3" opcodes */
    751     : Expression                    {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
    752     | AddTerm                       {}
    753     | AndTerm                       {}
    754     | DecTerm                       {}
    755     | DivideTerm                    {}
    756     | FindSetLeftBitTerm            {}
    757     | FindSetRightBitTerm           {}
    758     | FromBCDTerm                   {}
    759     | IncTerm                       {}
    760     | IndexTerm                     {}
    761 /*    | StructureIndexTerm            {} */
    762 /*    | StructurePointerTerm          {} */
    763     | LAndTerm                      {}
    764     | LEqualTerm                    {}
    765     | LGreaterTerm                  {}
    766     | LGreaterEqualTerm             {}
    767     | LLessTerm                     {}
    768     | LLessEqualTerm                {}
    769     | LNotTerm                      {}
    770     | LNotEqualTerm                 {}
    771     | LoadTableTerm                 {}
    772     | LOrTerm                       {}
    773     | MatchTerm                     {}
    774     | ModTerm                       {}
    775     | MultiplyTerm                  {}
    776     | NAndTerm                      {}
    777     | NOrTerm                       {}
    778     | NotTerm                       {}
    779     | OrTerm                        {}
    780     | ShiftLeftTerm                 {}
    781     | ShiftRightTerm                {}
    782     | SubtractTerm                  {}
    783     | ToBCDTerm                     {}
    784     | ToIntegerTerm                 {}
    785     | XOrTerm                       {}
    786     ;
    787 
    788 Type2StringOpcode                   /* "Type4" Opcodes */
    789     : ToDecimalStringTerm           {}
    790     | ToHexStringTerm               {}
    791     | ToStringTerm                  {}
    792     ;
    793 
    794 Type2BufferOpcode                   /* "Type5" Opcodes */
    795     : ToBufferTerm                  {}
    796     | ConcatResTerm                 {}
    797     ;
    798 
    799 Type2BufferOrStringOpcode
    800     : ConcatTerm                    {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);}
    801     | PrintfTerm                    {}
    802     | FprintfTerm                   {}
    803     | MidTerm                       {}
    804     ;
    805 
    806 /*
    807  * A type 3 opcode evaluates to an Integer and cannot have a destination operand
    808  */
    809 Type3Opcode
    810     : EISAIDTerm                    {}
    811     ;
    812 
    813 /* Obsolete
    814 Type4Opcode
    815     : ConcatTerm                    {}
    816     | ToDecimalStringTerm           {}
    817     | ToHexStringTerm               {}
    818     | MidTerm                       {}
    819     | ToStringTerm                  {}
    820     ;
    821 */
    822 
    823 /* Type 5 opcodes are a subset of Type2 opcodes, and return a constant */
    824 
    825 Type5Opcode
    826     : ResourceTemplateTerm          {}
    827     | UnicodeTerm                   {}
    828     | ToPLDTerm                     {}
    829     | ToUUIDTerm                    {}
    830     ;
    831 
    832 Type6Opcode
    833     : RefOfTerm                     {}
    834     | DerefOfTerm                   {}
    835     | IndexTerm                     {}
    836     | IndexExpTerm                  {}
    837 /*    | StructureIndexTerm            {} */
    838 /*    | StructurePointerTerm          {} */
    839     | MethodInvocationTerm          {}
    840     ;
    841 
    842 
    843 /*******************************************************************************
    844  *
    845  * ASL Helper Terms
    846  *
    847  ******************************************************************************/
    848 
    849 AmlPackageLengthTerm
    850     : Integer                       {$$ = TrSetOpIntegerValue (PARSEOP_PACKAGE_LENGTH,
    851                                         (ACPI_PARSE_OBJECT *) $1);}
    852     ;
    853 
    854 NameStringItem
    855     : ',' NameString                {$$ = $2;}
    856     | ',' error                     {$$ = AslDoError (); yyclearin;}
    857     ;
    858 
    859 TermArgItem
    860     : ',' TermArg                   {$$ = $2;}
    861     | ',' error                     {$$ = AslDoError (); yyclearin;}
    862     ;
    863 
    864 OptionalReference
    865     :                               {$$ = TrCreateLeafOp (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
    866     | ','                           {$$ = TrCreateLeafOp (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
    867     | ',' TermArg                   {$$ = $2;}
    868     ;
    869 
    870 OptionalReturnArg
    871     :                               {$$ = TrSetOpFlags (TrCreateLeafOp (PARSEOP_ZERO),
    872                                             OP_IS_NULL_RETURN);}       /* Placeholder is a ZeroOp object */
    873     | TermArg                       {$$ = $1;}
    874     ;
    875 
    876 OptionalSerializeRuleKeyword
    877     :                               {$$ = NULL;}
    878     | ','                           {$$ = NULL;}
    879     | ',' SerializeRuleKeyword      {$$ = $2;}
    880     ;
    881 
    882 OptionalTermArg
    883     :                               {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);}
    884     | TermArg                       {$$ = $1;}
    885     ;
    886 
    887 OptionalWordConst
    888     :                               {$$ = NULL;}
    889     | WordConst                     {$$ = $1;}
    890     ;
    891