0,0 → 1,3189 |
|
%{ |
/****************************************************************************** |
* |
* Module Name: aslcompiler.y - Bison input file (ASL grammar and actions) |
* |
*****************************************************************************/ |
|
/****************************************************************************** |
* |
* 1. Copyright Notice |
* |
* Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. |
* All rights reserved. |
* |
* 2. License |
* |
* 2.1. This is your license from Intel Corp. under its intellectual property |
* rights. You may have additional license terms from the party that provided |
* you this software, covering your right to use that party's intellectual |
* property rights. |
* |
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a |
* copy of the source code appearing in this file ("Covered Code") an |
* irrevocable, perpetual, worldwide license under Intel's copyrights in the |
* base code distributed originally by Intel ("Original Intel Code") to copy, |
* make derivatives, distribute, use and display any portion of the Covered |
* Code in any form, with the right to sublicense such rights; and |
* |
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent |
* license (with the right to sublicense), under only those claims of Intel |
* patents that are infringed by the Original Intel Code, to make, use, sell, |
* offer to sell, and import the Covered Code and derivative works thereof |
* solely to the minimum extent necessary to exercise the above copyright |
* license, and in no event shall the patent license extend to any additions |
* to or modifications of the Original Intel Code. No other license or right |
* is granted directly or by implication, estoppel or otherwise; |
* |
* The above copyright and patent license is granted only if the following |
* conditions are met: |
* |
* 3. Conditions |
* |
* 3.1. Redistribution of Source with Rights to Further Distribute Source. |
* Redistribution of source code of any substantial portion of the Covered |
* Code or modification with rights to further distribute source must include |
* the above Copyright Notice, the above License, this list of Conditions, |
* and the following Disclaimer and Export Compliance provision. In addition, |
* Licensee must cause all Covered Code to which Licensee contributes to |
* contain a file documenting the changes Licensee made to create that Covered |
* Code and the date of any change. Licensee must include in that file the |
* documentation of any changes made by any predecessor Licensee. Licensee |
* must include a prominent statement that the modification is derived, |
* directly or indirectly, from Original Intel Code. |
* |
* 3.2. Redistribution of Source with no Rights to Further Distribute Source. |
* Redistribution of source code of any substantial portion of the Covered |
* Code or modification without rights to further distribute source must |
* include the following Disclaimer and Export Compliance provision in the |
* documentation and/or other materials provided with distribution. In |
* addition, Licensee may not authorize further sublicense of source of any |
* portion of the Covered Code, and must include terms to the effect that the |
* license from Licensee to its licensee is limited to the intellectual |
* property embodied in the software Licensee provides to its licensee, and |
* not to intellectual property embodied in modifications its licensee may |
* make. |
* |
* 3.3. Redistribution of Executable. Redistribution in executable form of any |
* substantial portion of the Covered Code or modification must reproduce the |
* above Copyright Notice, and the following Disclaimer and Export Compliance |
* provision in the documentation and/or other materials provided with the |
* distribution. |
* |
* 3.4. Intel retains all right, title, and interest in and to the Original |
* Intel Code. |
* |
* 3.5. Neither the name Intel nor any other trademark owned or controlled by |
* Intel shall be used in advertising or otherwise to promote the sale, use or |
* other dealings in products derived from or relating to the Covered Code |
* without prior written authorization from Intel. |
* |
* 4. Disclaimer and Export Compliance |
* |
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED |
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE |
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, |
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY |
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY |
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A |
* PARTICULAR PURPOSE. |
* |
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES |
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR |
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, |
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY |
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL |
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS |
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY |
* LIMITED REMEDY. |
* |
* 4.3. Licensee shall not export, either directly or indirectly, any of this |
* software or system incorporating such software without first obtaining any |
* required license or other approval from the U. S. Department of Commerce or |
* any other agency or department of the United States Government. In the |
* event Licensee exports any such software from the United States or |
* re-exports any such software from a foreign destination, Licensee shall |
* ensure that the distribution and export/re-export of the software is in |
* compliance with all laws, regulations, orders, or other restrictions of the |
* U.S. Export Administration Regulations. Licensee agrees that neither it nor |
* any of its subsidiaries will export/re-export any technical data, process, |
* software, or service, directly or indirectly, to any country for which the |
* United States government or any agency thereof requires an export license, |
* other governmental approval, or letter of assurance, without first obtaining |
* such license, approval or letter. |
* |
*****************************************************************************/ |
|
#define YYDEBUG 1 |
#define YYERROR_VERBOSE 1 |
|
/* |
* State stack - compiler will fault if it overflows. (Default was 200) |
*/ |
#define YYINITDEPTH 600 |
|
#include "aslcompiler.h" |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#include "acpi.h" |
#include "accommon.h" |
|
#define _COMPONENT ACPI_COMPILER |
ACPI_MODULE_NAME ("aslparse") |
|
/* |
* Global Notes: |
* |
* October 2005: The following list terms have been optimized (from the |
* original ASL grammar in the ACPI specification) to force the immediate |
* reduction of each list item so that the parse stack use doesn't increase on |
* each list element and possibly overflow on very large lists (>4000 items). |
* This dramatically reduces use of the parse stack overall. |
* |
* ArgList, TermList, Objectlist, ByteList, DWordList, PackageList, |
* ResourceMacroList, and FieldUnitList |
*/ |
|
|
/* |
* Next statement is important - this makes everything public so that |
* we can access some of the parser tables from other modules |
*/ |
#define static |
#undef alloca |
#define alloca AslLocalAllocate |
#define YYERROR_VERBOSE 1 |
|
void * |
AslLocalAllocate (unsigned int Size); |
|
/* |
* The windows version of bison defines this incorrectly as "32768" (Not negative). |
* Using a custom (edited binary) version of bison that defines YYFLAG as YYFBAD |
* instead (#define YYFBAD 32768), so we can define it correctly here. |
* |
* The problem is that if YYFLAG is positive, the extended syntax error messages |
* are disabled. |
*/ |
|
#define YYFLAG -32768 |
|
|
%} |
|
|
/* |
* Declare the type of values in the grammar |
*/ |
|
%union { |
UINT64 i; |
char *s; |
ACPI_PARSE_OBJECT *n; |
} |
|
|
/*! [Begin] no source code translation */ |
|
/* |
* These shift/reduce conflicts are expected. There should be zero |
* reduce/reduce conflicts. |
*/ |
%expect 60 |
|
|
/* |
* Token types: These are returned by the lexer |
* |
* NOTE: This list MUST match the AslKeywordMapping table found |
* in aslmap.c EXACTLY! Double check any changes! |
*/ |
|
%token <i> PARSEOP_ACCESSAS |
%token <i> PARSEOP_ACCESSATTRIB_BLOCK |
%token <i> PARSEOP_ACCESSATTRIB_BLOCK_CALL |
%token <i> PARSEOP_ACCESSATTRIB_BYTE |
%token <i> PARSEOP_ACCESSATTRIB_WORD_CALL |
%token <i> PARSEOP_ACCESSATTRIB_QUICK |
%token <i> PARSEOP_ACCESSATTRIB_SND_RCV |
%token <i> PARSEOP_ACCESSATTRIB_WORD |
%token <i> PARSEOP_ACCESSTYPE_ANY |
%token <i> PARSEOP_ACCESSTYPE_BUF |
%token <i> PARSEOP_ACCESSTYPE_BYTE |
%token <i> PARSEOP_ACCESSTYPE_DWORD |
%token <i> PARSEOP_ACCESSTYPE_QWORD |
%token <i> PARSEOP_ACCESSTYPE_WORD |
%token <i> PARSEOP_ACQUIRE |
%token <i> PARSEOP_ADD |
%token <i> PARSEOP_ADDRESSSPACE_FFIXEDHW |
%token <i> PARSEOP_ADDRESSTYPE_ACPI |
%token <i> PARSEOP_ADDRESSTYPE_MEMORY |
%token <i> PARSEOP_ADDRESSTYPE_NVS |
%token <i> PARSEOP_ADDRESSTYPE_RESERVED |
%token <i> PARSEOP_ALIAS |
%token <i> PARSEOP_AND |
%token <i> PARSEOP_ARG0 |
%token <i> PARSEOP_ARG1 |
%token <i> PARSEOP_ARG2 |
%token <i> PARSEOP_ARG3 |
%token <i> PARSEOP_ARG4 |
%token <i> PARSEOP_ARG5 |
%token <i> PARSEOP_ARG6 |
%token <i> PARSEOP_BANKFIELD |
%token <i> PARSEOP_BREAK |
%token <i> PARSEOP_BREAKPOINT |
%token <i> PARSEOP_BUFFER |
%token <i> PARSEOP_BUSMASTERTYPE_MASTER |
%token <i> PARSEOP_BUSMASTERTYPE_NOTMASTER |
%token <i> PARSEOP_BYTECONST |
%token <i> PARSEOP_CASE |
%token <i> PARSEOP_CONCATENATE |
%token <i> PARSEOP_CONCATENATERESTEMPLATE |
%token <i> PARSEOP_CONDREFOF |
%token <i> PARSEOP_CONTINUE |
%token <i> PARSEOP_COPYOBJECT |
%token <i> PARSEOP_CREATEBITFIELD |
%token <i> PARSEOP_CREATEBYTEFIELD |
%token <i> PARSEOP_CREATEDWORDFIELD |
%token <i> PARSEOP_CREATEFIELD |
%token <i> PARSEOP_CREATEQWORDFIELD |
%token <i> PARSEOP_CREATEWORDFIELD |
%token <i> PARSEOP_DATATABLEREGION |
%token <i> PARSEOP_DEBUG |
%token <i> PARSEOP_DECODETYPE_POS |
%token <i> PARSEOP_DECODETYPE_SUB |
%token <i> PARSEOP_DECREMENT |
%token <i> PARSEOP_DEFAULT |
%token <i> PARSEOP_DEFAULT_ARG |
%token <i> PARSEOP_DEFINITIONBLOCK |
%token <i> PARSEOP_DEREFOF |
%token <i> PARSEOP_DEVICE |
%token <i> PARSEOP_DIVIDE |
%token <i> PARSEOP_DMA |
%token <i> PARSEOP_DMATYPE_A |
%token <i> PARSEOP_DMATYPE_COMPATIBILITY |
%token <i> PARSEOP_DMATYPE_B |
%token <i> PARSEOP_DMATYPE_F |
%token <i> PARSEOP_DWORDCONST |
%token <i> PARSEOP_DWORDIO |
%token <i> PARSEOP_DWORDMEMORY |
%token <i> PARSEOP_DWORDSPACE |
%token <i> PARSEOP_EISAID |
%token <i> PARSEOP_ELSE |
%token <i> PARSEOP_ELSEIF |
%token <i> PARSEOP_ENDDEPENDENTFN |
%token <i> PARSEOP_ENDTAG |
%token <i> PARSEOP_ERRORNODE |
%token <i> PARSEOP_EVENT |
%token <i> PARSEOP_EXTENDEDIO |
%token <i> PARSEOP_EXTENDEDMEMORY |
%token <i> PARSEOP_EXTENDEDSPACE |
%token <i> PARSEOP_EXTERNAL |
%token <i> PARSEOP_FATAL |
%token <i> PARSEOP_FIELD |
%token <i> PARSEOP_FINDSETLEFTBIT |
%token <i> PARSEOP_FINDSETRIGHTBIT |
%token <i> PARSEOP_FIXEDIO |
%token <i> PARSEOP_FROMBCD |
%token <i> PARSEOP_FUNCTION |
%token <i> PARSEOP_IF |
%token <i> PARSEOP_INCLUDE |
%token <i> PARSEOP_INCLUDE_CSTYLE |
%token <i> PARSEOP_INCLUDE_END |
%token <i> PARSEOP_INCREMENT |
%token <i> PARSEOP_INDEX |
%token <i> PARSEOP_INDEXFIELD |
%token <i> PARSEOP_INTEGER |
%token <i> PARSEOP_INTERRUPT |
%token <i> PARSEOP_INTLEVEL_ACTIVEHIGH |
%token <i> PARSEOP_INTLEVEL_ACTIVELOW |
%token <i> PARSEOP_INTTYPE_EDGE |
%token <i> PARSEOP_INTTYPE_LEVEL |
%token <i> PARSEOP_IO |
%token <i> PARSEOP_IODECODETYPE_10 |
%token <i> PARSEOP_IODECODETYPE_16 |
%token <i> PARSEOP_IRQ |
%token <i> PARSEOP_IRQNOFLAGS |
%token <i> PARSEOP_LAND |
%token <i> PARSEOP_LEQUAL |
%token <i> PARSEOP_LGREATER |
%token <i> PARSEOP_LGREATEREQUAL |
%token <i> PARSEOP_LINE_CSTYLE |
%token <i> PARSEOP_LLESS |
%token <i> PARSEOP_LLESSEQUAL |
%token <i> PARSEOP_LNOT |
%token <i> PARSEOP_LNOTEQUAL |
%token <i> PARSEOP_LOAD |
%token <i> PARSEOP_LOADTABLE |
%token <i> PARSEOP_LOCAL0 |
%token <i> PARSEOP_LOCAL1 |
%token <i> PARSEOP_LOCAL2 |
%token <i> PARSEOP_LOCAL3 |
%token <i> PARSEOP_LOCAL4 |
%token <i> PARSEOP_LOCAL5 |
%token <i> PARSEOP_LOCAL6 |
%token <i> PARSEOP_LOCAL7 |
%token <i> PARSEOP_LOCKRULE_LOCK |
%token <i> PARSEOP_LOCKRULE_NOLOCK |
%token <i> PARSEOP_LOR |
%token <i> PARSEOP_MATCH |
%token <i> PARSEOP_MATCHTYPE_MEQ |
%token <i> PARSEOP_MATCHTYPE_MGE |
%token <i> PARSEOP_MATCHTYPE_MGT |
%token <i> PARSEOP_MATCHTYPE_MLE |
%token <i> PARSEOP_MATCHTYPE_MLT |
%token <i> PARSEOP_MATCHTYPE_MTR |
%token <i> PARSEOP_MAXTYPE_FIXED |
%token <i> PARSEOP_MAXTYPE_NOTFIXED |
%token <i> PARSEOP_MEMORY24 |
%token <i> PARSEOP_MEMORY32 |
%token <i> PARSEOP_MEMORY32FIXED |
%token <i> PARSEOP_MEMTYPE_CACHEABLE |
%token <i> PARSEOP_MEMTYPE_NONCACHEABLE |
%token <i> PARSEOP_MEMTYPE_PREFETCHABLE |
%token <i> PARSEOP_MEMTYPE_WRITECOMBINING |
%token <i> PARSEOP_METHOD |
%token <i> PARSEOP_METHODCALL |
%token <i> PARSEOP_MID |
%token <i> PARSEOP_MINTYPE_FIXED |
%token <i> PARSEOP_MINTYPE_NOTFIXED |
%token <i> PARSEOP_MOD |
%token <i> PARSEOP_MULTIPLY |
%token <i> PARSEOP_MUTEX |
%token <i> PARSEOP_NAME |
%token <s> PARSEOP_NAMESEG |
%token <s> PARSEOP_NAMESTRING |
%token <i> PARSEOP_NAND |
%token <i> PARSEOP_NOOP |
%token <i> PARSEOP_NOR |
%token <i> PARSEOP_NOT |
%token <i> PARSEOP_NOTIFY |
%token <i> PARSEOP_OBJECTTYPE |
%token <i> PARSEOP_OBJECTTYPE_BFF |
%token <i> PARSEOP_OBJECTTYPE_BUF |
%token <i> PARSEOP_OBJECTTYPE_DDB |
%token <i> PARSEOP_OBJECTTYPE_DEV |
%token <i> PARSEOP_OBJECTTYPE_EVT |
%token <i> PARSEOP_OBJECTTYPE_FLD |
%token <i> PARSEOP_OBJECTTYPE_INT |
%token <i> PARSEOP_OBJECTTYPE_MTH |
%token <i> PARSEOP_OBJECTTYPE_MTX |
%token <i> PARSEOP_OBJECTTYPE_OPR |
%token <i> PARSEOP_OBJECTTYPE_PKG |
%token <i> PARSEOP_OBJECTTYPE_POW |
%token <i> PARSEOP_OBJECTTYPE_PRO |
%token <i> PARSEOP_OBJECTTYPE_STR |
%token <i> PARSEOP_OBJECTTYPE_THZ |
%token <i> PARSEOP_OBJECTTYPE_UNK |
%token <i> PARSEOP_OFFSET |
%token <i> PARSEOP_ONE |
%token <i> PARSEOP_ONES |
%token <i> PARSEOP_OPERATIONREGION |
%token <i> PARSEOP_OR |
%token <i> PARSEOP_PACKAGE |
%token <i> PARSEOP_PACKAGE_LENGTH |
%token <i> PARSEOP_POWERRESOURCE |
%token <i> PARSEOP_PROCESSOR |
%token <i> PARSEOP_QWORDCONST |
%token <i> PARSEOP_QWORDIO |
%token <i> PARSEOP_QWORDMEMORY |
%token <i> PARSEOP_QWORDSPACE |
%token <i> PARSEOP_RANGETYPE_ENTIRE |
%token <i> PARSEOP_RANGETYPE_ISAONLY |
%token <i> PARSEOP_RANGETYPE_NONISAONLY |
%token <i> PARSEOP_RAW_DATA |
%token <i> PARSEOP_READWRITETYPE_BOTH |
%token <i> PARSEOP_READWRITETYPE_READONLY |
%token <i> PARSEOP_REFOF |
%token <i> PARSEOP_REGIONSPACE_CMOS |
%token <i> PARSEOP_REGIONSPACE_EC |
%token <i> PARSEOP_REGIONSPACE_IO |
%token <i> PARSEOP_REGIONSPACE_IPMI |
%token <i> PARSEOP_REGIONSPACE_MEM |
%token <i> PARSEOP_REGIONSPACE_PCI |
%token <i> PARSEOP_REGIONSPACE_PCIBAR |
%token <i> PARSEOP_REGIONSPACE_SMBUS |
%token <i> PARSEOP_REGISTER |
%token <i> PARSEOP_RELEASE |
%token <i> PARSEOP_RESERVED_BYTES |
%token <i> PARSEOP_RESET |
%token <i> PARSEOP_RESOURCETEMPLATE |
%token <i> PARSEOP_RESOURCETYPE_CONSUMER |
%token <i> PARSEOP_RESOURCETYPE_PRODUCER |
%token <i> PARSEOP_RETURN |
%token <i> PARSEOP_REVISION |
%token <i> PARSEOP_SCOPE |
%token <i> PARSEOP_SERIALIZERULE_NOTSERIAL |
%token <i> PARSEOP_SERIALIZERULE_SERIAL |
%token <i> PARSEOP_SHARETYPE_EXCLUSIVE |
%token <i> PARSEOP_SHARETYPE_SHARED |
%token <i> PARSEOP_SHIFTLEFT |
%token <i> PARSEOP_SHIFTRIGHT |
%token <i> PARSEOP_SIGNAL |
%token <i> PARSEOP_SIZEOF |
%token <i> PARSEOP_SLEEP |
%token <i> PARSEOP_STALL |
%token <i> PARSEOP_STARTDEPENDENTFN |
%token <i> PARSEOP_STARTDEPENDENTFN_NOPRI |
%token <i> PARSEOP_STORE |
%token <s> PARSEOP_STRING_LITERAL |
%token <i> PARSEOP_SUBTRACT |
%token <i> PARSEOP_SWITCH |
%token <i> PARSEOP_THERMALZONE |
%token <i> PARSEOP_TIMER |
%token <i> PARSEOP_TOBCD |
%token <i> PARSEOP_TOBUFFER |
%token <i> PARSEOP_TODECIMALSTRING |
%token <i> PARSEOP_TOHEXSTRING |
%token <i> PARSEOP_TOINTEGER |
%token <i> PARSEOP_TOSTRING |
%token <i> PARSEOP_TOUUID |
%token <i> PARSEOP_TRANSLATIONTYPE_DENSE |
%token <i> PARSEOP_TRANSLATIONTYPE_SPARSE |
%token <i> PARSEOP_TYPE_STATIC |
%token <i> PARSEOP_TYPE_TRANSLATION |
%token <i> PARSEOP_UNICODE |
%token <i> PARSEOP_UNLOAD |
%token <i> PARSEOP_UPDATERULE_ONES |
%token <i> PARSEOP_UPDATERULE_PRESERVE |
%token <i> PARSEOP_UPDATERULE_ZEROS |
%token <i> PARSEOP_VAR_PACKAGE |
%token <i> PARSEOP_VENDORLONG |
%token <i> PARSEOP_VENDORSHORT |
%token <i> PARSEOP_WAIT |
%token <i> PARSEOP_WHILE |
%token <i> PARSEOP_WORDBUSNUMBER |
%token <i> PARSEOP_WORDCONST |
%token <i> PARSEOP_WORDIO |
%token <i> PARSEOP_WORDSPACE |
%token <i> PARSEOP_XFERTYPE_8 |
%token <i> PARSEOP_XFERTYPE_8_16 |
%token <i> PARSEOP_XFERTYPE_16 |
%token <i> PARSEOP_XOR |
%token <i> PARSEOP_ZERO |
|
|
/* |
* Production names |
*/ |
|
%type <n> ASLCode |
%type <n> DefinitionBlockTerm |
%type <n> TermList |
%type <n> Term |
%type <n> CompilerDirective |
%type <n> ObjectList |
%type <n> Object |
%type <n> DataObject |
%type <n> BufferData |
%type <n> PackageData |
%type <n> IntegerData |
%type <n> StringData |
%type <n> NamedObject |
%type <n> NameSpaceModifier |
%type <n> UserTerm |
%type <n> ArgList |
%type <n> TermArg |
%type <n> Target |
%type <n> RequiredTarget |
%type <n> SimpleTarget |
%type <n> BufferTermData |
%type <n> ParameterTypePackage |
%type <n> ParameterTypePackageList |
%type <n> ParameterTypesPackage |
%type <n> ParameterTypesPackageList |
|
%type <n> Type1Opcode |
%type <n> Type2Opcode |
%type <n> Type2IntegerOpcode |
%type <n> Type2StringOpcode |
%type <n> Type2BufferOpcode |
%type <n> Type2BufferOrStringOpcode |
%type <n> Type3Opcode |
|
/* Obsolete %type <n> Type4Opcode */ |
|
%type <n> Type5Opcode |
%type <n> Type6Opcode |
|
%type <n> LineTerm |
%type <n> IncludeTerm |
%type <n> IncludeCStyleTerm |
%type <n> ExternalTerm |
|
%type <n> FieldUnitList |
%type <n> FieldUnit |
%type <n> FieldUnitEntry |
|
%type <n> OffsetTerm |
%type <n> AccessAsTerm |
%type <n> OptionalAccessAttribTerm |
|
|
/* Named Objects */ |
|
%type <n> BankFieldTerm |
%type <n> CreateBitFieldTerm |
%type <n> CreateByteFieldTerm |
%type <n> CreateDWordFieldTerm |
%type <n> CreateFieldTerm |
%type <n> CreateQWordFieldTerm |
%type <n> CreateWordFieldTerm |
%type <n> DataRegionTerm |
%type <n> DeviceTerm |
%type <n> EventTerm |
%type <n> FieldTerm |
%type <n> FunctionTerm |
%type <n> IndexFieldTerm |
%type <n> MethodTerm |
%type <n> MutexTerm |
%type <n> OpRegionTerm |
%type <n> OpRegionSpaceIdTerm |
%type <n> PowerResTerm |
%type <n> ProcessorTerm |
%type <n> ThermalZoneTerm |
|
|
/* Namespace modifiers */ |
|
%type <n> AliasTerm |
%type <n> NameTerm |
%type <n> ScopeTerm |
|
/* Type 1 opcodes */ |
|
%type <n> BreakTerm |
%type <n> BreakPointTerm |
%type <n> ContinueTerm |
%type <n> FatalTerm |
%type <n> IfElseTerm |
%type <n> IfTerm |
%type <n> ElseTerm |
%type <n> LoadTerm |
%type <n> NoOpTerm |
%type <n> NotifyTerm |
%type <n> ReleaseTerm |
%type <n> ResetTerm |
%type <n> ReturnTerm |
%type <n> SignalTerm |
%type <n> SleepTerm |
%type <n> StallTerm |
%type <n> SwitchTerm |
%type <n> CaseDefaultTermList |
//%type <n> CaseTermList |
%type <n> CaseTerm |
%type <n> DefaultTerm |
%type <n> UnloadTerm |
%type <n> WhileTerm |
|
/* Type 2 opcodes */ |
|
%type <n> AcquireTerm |
%type <n> AddTerm |
%type <n> AndTerm |
%type <n> ConcatTerm |
%type <n> ConcatResTerm |
%type <n> CondRefOfTerm |
%type <n> CopyObjectTerm |
%type <n> DecTerm |
%type <n> DerefOfTerm |
%type <n> DivideTerm |
%type <n> FindSetLeftBitTerm |
%type <n> FindSetRightBitTerm |
%type <n> FromBCDTerm |
%type <n> IncTerm |
%type <n> IndexTerm |
%type <n> LAndTerm |
%type <n> LEqualTerm |
%type <n> LGreaterTerm |
%type <n> LGreaterEqualTerm |
%type <n> LLessTerm |
%type <n> LLessEqualTerm |
%type <n> LNotTerm |
%type <n> LNotEqualTerm |
%type <n> LoadTableTerm |
%type <n> LOrTerm |
%type <n> MatchTerm |
%type <n> MidTerm |
%type <n> ModTerm |
%type <n> MultiplyTerm |
%type <n> NAndTerm |
%type <n> NOrTerm |
%type <n> NotTerm |
%type <n> ObjectTypeTerm |
%type <n> OrTerm |
%type <n> RefOfTerm |
%type <n> ShiftLeftTerm |
%type <n> ShiftRightTerm |
%type <n> SizeOfTerm |
%type <n> StoreTerm |
%type <n> SubtractTerm |
%type <n> TimerTerm |
%type <n> ToBCDTerm |
%type <n> ToBufferTerm |
%type <n> ToDecimalStringTerm |
%type <n> ToHexStringTerm |
%type <n> ToIntegerTerm |
%type <n> ToStringTerm |
%type <n> WaitTerm |
%type <n> XOrTerm |
|
%type <n> OptionalTermArg |
%type <n> OptionalReturnArg |
%type <n> OptionalListString |
|
|
/* Keywords */ |
|
%type <n> ObjectTypeKeyword |
%type <n> AccessTypeKeyword |
%type <n> AccessAttribKeyword |
%type <n> LockRuleKeyword |
%type <n> UpdateRuleKeyword |
%type <n> RegionSpaceKeyword |
%type <n> AddressSpaceKeyword |
%type <n> MatchOpKeyword |
%type <n> SerializeRuleKeyword |
%type <n> DMATypeKeyword |
%type <n> OptionalBusMasterKeyword |
%type <n> XferTypeKeyword |
%type <n> ResourceTypeKeyword |
%type <n> MinKeyword |
%type <n> MaxKeyword |
%type <n> DecodeKeyword |
%type <n> RangeTypeKeyword |
%type <n> MemTypeKeyword |
%type <n> OptionalReadWriteKeyword |
%type <n> InterruptTypeKeyword |
%type <n> InterruptLevel |
%type <n> ShareTypeKeyword |
%type <n> IODecodeKeyword |
%type <n> TypeKeyword |
%type <n> TranslationKeyword |
%type <n> AddressKeyword |
|
/* Types */ |
|
%type <n> SuperName |
%type <n> ArgTerm |
%type <n> LocalTerm |
%type <n> DebugTerm |
|
%type <n> Integer |
%type <n> ByteConst |
%type <n> WordConst |
%type <n> DWordConst |
%type <n> QWordConst |
%type <n> String |
|
%type <n> ConstTerm |
%type <n> ByteConstExpr |
%type <n> WordConstExpr |
%type <n> DWordConstExpr |
%type <n> QWordConstExpr |
%type <n> ConstExprTerm |
|
%type <n> BufferTerm |
%type <n> ByteList |
%type <n> DWordList |
|
%type <n> PackageTerm |
%type <n> PackageList |
%type <n> PackageElement |
|
%type <n> VarPackageLengthTerm |
|
/* Macros */ |
|
%type <n> EISAIDTerm |
%type <n> ResourceTemplateTerm |
%type <n> ToUUIDTerm |
%type <n> UnicodeTerm |
%type <n> ResourceMacroList |
%type <n> ResourceMacroTerm |
|
%type <n> DMATerm |
%type <n> DWordIOTerm |
%type <n> DWordMemoryTerm |
%type <n> DWordSpaceTerm |
%type <n> EndDependentFnTerm |
%type <n> ExtendedIOTerm |
%type <n> ExtendedMemoryTerm |
%type <n> ExtendedSpaceTerm |
%type <n> FixedIOTerm |
%type <n> InterruptTerm |
%type <n> IOTerm |
%type <n> IRQNoFlagsTerm |
%type <n> IRQTerm |
%type <n> Memory24Term |
%type <n> Memory32FixedTerm |
%type <n> Memory32Term |
%type <n> QWordIOTerm |
%type <n> QWordMemoryTerm |
%type <n> QWordSpaceTerm |
%type <n> RegisterTerm |
%type <n> StartDependentFnTerm |
%type <n> StartDependentFnNoPriTerm |
%type <n> VendorLongTerm |
%type <n> VendorShortTerm |
%type <n> WordBusNumberTerm |
%type <n> WordIOTerm |
%type <n> WordSpaceTerm |
|
%type <n> NameString |
%type <n> NameSeg |
|
|
/* Local types that help construct the AML, not in ACPI spec */ |
|
%type <n> IncludeEndTerm |
%type <n> AmlPackageLengthTerm |
%type <n> OptionalByteConstExpr |
%type <n> OptionalDWordConstExpr |
%type <n> OptionalQWordConstExpr |
%type <n> OptionalSerializeRuleKeyword |
%type <n> OptionalResourceType_First |
%type <n> OptionalResourceType |
%type <n> OptionalMinType |
%type <n> OptionalMaxType |
%type <n> OptionalMemType |
%type <n> OptionalCount |
%type <n> OptionalDecodeType |
%type <n> OptionalRangeType |
%type <n> OptionalShareType |
%type <n> OptionalType |
%type <n> OptionalType_Last |
%type <n> OptionalTranslationType_Last |
%type <n> OptionalStringData |
%type <n> OptionalNameString |
%type <n> OptionalNameString_First |
%type <n> OptionalNameString_Last |
%type <n> OptionalAddressRange |
%type <n> OptionalObjectTypeKeyword |
%type <n> OptionalParameterTypePackage |
%type <n> OptionalParameterTypesPackage |
%type <n> OptionalReference |
%type <n> OptionalAccessSize |
|
|
%type <n> TermArgItem |
%type <n> NameStringItem |
|
%% |
|
|
/******************************************************************************* |
* |
* Production rules start here |
* |
******************************************************************************/ |
|
/* |
* ASL Names |
*/ |
|
|
/* |
* Blocks, Data, and Opcodes |
*/ |
|
ASLCode |
: DefinitionBlockTerm |
| error {YYABORT; $$ = NULL;} |
; |
|
DefinitionBlockTerm |
: PARSEOP_DEFINITIONBLOCK '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITIONBLOCK);} |
String ',' |
String ',' |
ByteConst ',' |
String ',' |
String ',' |
DWordConst |
')' {TrSetEndLineNumber ($<n>3);} |
'{' TermList '}' {$$ = TrLinkChildren ($<n>3,7,$4,$6,$8,$10,$12,$14,$18);} |
; |
|
/* ACPI 3.0 -- allow semicolons between terms */ |
|
TermList |
: {$$ = NULL;} |
| TermList Term {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);} |
| TermList ';' Term {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);} |
; |
|
Term |
: Object {} |
| Type1Opcode {} |
| Type2Opcode {} |
| Type2IntegerOpcode {} |
| Type2StringOpcode {} |
| Type2BufferOpcode {} |
| Type2BufferOrStringOpcode {} |
| error {$$ = AslDoError(); yyclearin;} |
; |
|
CompilerDirective |
: IncludeTerm {} |
| IncludeCStyleTerm {$$ = NULL;} |
| LineTerm {$$ = NULL;} |
| ExternalTerm {} |
; |
|
ObjectList |
: {$$ = NULL;} |
| ObjectList Object {$$ = TrLinkPeerNode ($1,$2);} |
| error {$$ = AslDoError(); yyclearin;} |
; |
|
Object |
: CompilerDirective {} |
| NamedObject {} |
| NameSpaceModifier {} |
; |
|
DataObject |
: BufferData {} |
| PackageData {} |
| IntegerData {} |
| StringData {} |
; |
|
BufferData |
: Type5Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);} |
| Type2BufferOrStringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);} |
| Type2BufferOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);} |
| BufferTerm {} |
; |
|
PackageData |
: PackageTerm {} |
; |
|
IntegerData |
: Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);} |
| Type3Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);} |
| Integer {} |
| ConstTerm {} |
; |
|
StringData |
: Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);} |
| String {} |
; |
|
NamedObject |
: BankFieldTerm {} |
| CreateBitFieldTerm {} |
| CreateByteFieldTerm {} |
| CreateDWordFieldTerm {} |
| CreateFieldTerm {} |
| CreateQWordFieldTerm {} |
| CreateWordFieldTerm {} |
| DataRegionTerm {} |
| DeviceTerm {} |
| EventTerm {} |
| FieldTerm {} |
| FunctionTerm {} |
| IndexFieldTerm {} |
| MethodTerm {} |
| MutexTerm {} |
| OpRegionTerm {} |
| PowerResTerm {} |
| ProcessorTerm {} |
| ThermalZoneTerm {} |
; |
|
NameSpaceModifier |
: AliasTerm {} |
| NameTerm {} |
| ScopeTerm {} |
; |
|
UserTerm |
: NameString '(' {TrUpdateNode (PARSEOP_METHODCALL, $1);} |
ArgList ')' {$$ = TrLinkChildNode ($1,$4);} |
; |
|
ArgList |
: {$$ = NULL;} |
| TermArg |
| ArgList ',' /* Allows a trailing comma at list end */ |
| ArgList ',' |
TermArg {$$ = TrLinkPeerNode ($1,$3);} |
; |
|
/* |
Removed from TermArg due to reduce/reduce conflicts |
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
| Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
| Type2BufferOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
| Type2BufferOrStringOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
|
*/ |
|
TermArg |
: Type2Opcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
| DataObject {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
| NameString {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
| ArgTerm {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
| LocalTerm {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} |
; |
|
Target |
: {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_TARGET | NODE_COMPILE_TIME_CONST);} /* Placeholder is a ZeroOp object */ |
| ',' {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_TARGET | NODE_COMPILE_TIME_CONST);} /* Placeholder is a ZeroOp object */ |
| ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);} |
; |
|
RequiredTarget |
: ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);} |
; |
|
SimpleTarget |
: NameString {} |
| LocalTerm {} |
| ArgTerm {} |
; |
|
/* Rules for specifying the type of one method argument or return value */ |
|
ParameterTypePackage |
: {$$ = NULL;} |
| ObjectTypeKeyword {$$ = $1;} |
| ParameterTypePackage ',' |
ObjectTypeKeyword {$$ = TrLinkPeerNodes (2,$1,$3);} |
; |
|
ParameterTypePackageList |
: {$$ = NULL;} |
| ObjectTypeKeyword {$$ = $1;} |
| '{' ParameterTypePackage '}' {$$ = $2;} |
; |
|
OptionalParameterTypePackage |
: {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);} |
| ',' ParameterTypePackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);} |
; |
|
/* Rules for specifying the types for method arguments */ |
|
ParameterTypesPackage |
: ParameterTypePackageList {$$ = $1;} |
| ParameterTypesPackage ',' |
ParameterTypePackageList {$$ = TrLinkPeerNodes (2,$1,$3);} |
; |
|
ParameterTypesPackageList |
: {$$ = NULL;} |
| ObjectTypeKeyword {$$ = $1;} |
| '{' ParameterTypesPackage '}' {$$ = $2;} |
; |
|
OptionalParameterTypesPackage |
: {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);} |
| ',' ParameterTypesPackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);} |
; |
|
|
/* Opcode types */ |
|
Type1Opcode |
: BreakTerm {} |
| BreakPointTerm {} |
| ContinueTerm {} |
| FatalTerm {} |
| IfElseTerm {} |
| LoadTerm {} |
| NoOpTerm {} |
| NotifyTerm {} |
| ReleaseTerm {} |
| ResetTerm {} |
| ReturnTerm {} |
| SignalTerm {} |
| SleepTerm {} |
| StallTerm {} |
| SwitchTerm {} |
| UnloadTerm {} |
| WhileTerm {} |
; |
|
Type2Opcode |
: AcquireTerm {} |
| CondRefOfTerm {} |
| CopyObjectTerm {} |
| DerefOfTerm {} |
| ObjectTypeTerm {} |
| RefOfTerm {} |
| SizeOfTerm {} |
| StoreTerm {} |
| TimerTerm {} |
| WaitTerm {} |
| UserTerm {} |
; |
|
/* |
* Type 3/4/5 opcodes |
*/ |
|
Type2IntegerOpcode /* "Type3" opcodes */ |
: AddTerm {} |
| AndTerm {} |
| DecTerm {} |
| DivideTerm {} |
| FindSetLeftBitTerm {} |
| FindSetRightBitTerm {} |
| FromBCDTerm {} |
| IncTerm {} |
| IndexTerm {} |
| LAndTerm {} |
| LEqualTerm {} |
| LGreaterTerm {} |
| LGreaterEqualTerm {} |
| LLessTerm {} |
| LLessEqualTerm {} |
| LNotTerm {} |
| LNotEqualTerm {} |
| LoadTableTerm {} |
| LOrTerm {} |
| MatchTerm {} |
| ModTerm {} |
| MultiplyTerm {} |
| NAndTerm {} |
| NOrTerm {} |
| NotTerm {} |
| OrTerm {} |
| ShiftLeftTerm {} |
| ShiftRightTerm {} |
| SubtractTerm {} |
| ToBCDTerm {} |
| ToIntegerTerm {} |
| XOrTerm {} |
; |
|
Type2StringOpcode /* "Type4" Opcodes */ |
: ToDecimalStringTerm {} |
| ToHexStringTerm {} |
| ToStringTerm {} |
; |
|
Type2BufferOpcode /* "Type5" Opcodes */ |
: ToBufferTerm {} |
| ConcatResTerm {} |
; |
|
Type2BufferOrStringOpcode |
: ConcatTerm {} |
| MidTerm {} |
; |
|
/* |
* A type 3 opcode evaluates to an Integer and cannot have a destination operand |
*/ |
|
Type3Opcode |
: EISAIDTerm {} |
; |
|
/* Obsolete |
Type4Opcode |
: ConcatTerm {} |
| ToDecimalStringTerm {} |
| ToHexStringTerm {} |
| MidTerm {} |
| ToStringTerm {} |
; |
*/ |
|
|
Type5Opcode |
: ResourceTemplateTerm {} |
| UnicodeTerm {} |
| ToUUIDTerm {} |
; |
|
Type6Opcode |
: RefOfTerm {} |
| DerefOfTerm {} |
| IndexTerm {} |
| UserTerm {} |
; |
|
IncludeTerm |
: PARSEOP_INCLUDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCLUDE);} |
String ')' {TrLinkChildren ($<n>3,1,$4);FlOpenIncludeFile ($4);} |
TermList |
IncludeEndTerm {$$ = TrLinkPeerNodes (3,$<n>3,$7,$8);} |
; |
|
IncludeEndTerm |
: PARSEOP_INCLUDE_END {$$ = TrCreateLeafNode (PARSEOP_INCLUDE_END);} |
; |
|
IncludeCStyleTerm |
: PARSEOP_INCLUDE_CSTYLE |
String {FlOpenIncludeFile ($2);} |
; |
|
LineTerm |
: PARSEOP_LINE_CSTYLE |
Integer {FlSetLineNumber ($2);} |
; |
|
ExternalTerm |
: PARSEOP_EXTERNAL '(' |
NameString |
OptionalObjectTypeKeyword |
OptionalParameterTypePackage |
OptionalParameterTypesPackage |
')' {$$ = TrCreateNode (PARSEOP_EXTERNAL,4,$3,$4,$5,$6);} |
| PARSEOP_EXTERNAL '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
|
/******* Named Objects *******************************************************/ |
|
|
BankFieldTerm |
: PARSEOP_BANKFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BANKFIELD);} |
NameString |
NameStringItem |
TermArgItem |
',' AccessTypeKeyword |
',' LockRuleKeyword |
',' UpdateRuleKeyword |
')' '{' |
FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,7,$4,$5,$6,$8,$10,$12,$15);} |
| PARSEOP_BANKFIELD '(' |
error ')' '{' error '}' {$$ = AslDoError(); yyclearin;} |
; |
|
FieldUnitList |
: {$$ = NULL;} |
| FieldUnit |
| FieldUnitList ',' /* Allows a trailing comma at list end */ |
| FieldUnitList ',' |
FieldUnit {$$ = TrLinkPeerNode ($1,$3);} |
; |
|
FieldUnit |
: FieldUnitEntry {} |
| OffsetTerm {} |
| AccessAsTerm {} |
; |
|
FieldUnitEntry |
: ',' AmlPackageLengthTerm {$$ = TrCreateNode (PARSEOP_RESERVED_BYTES,1,$2);} |
| NameSeg ',' |
AmlPackageLengthTerm {$$ = TrLinkChildNode ($1,$3);} |
; |
|
OffsetTerm |
: PARSEOP_OFFSET '(' |
AmlPackageLengthTerm |
')' {$$ = TrCreateNode (PARSEOP_OFFSET,1,$3);} |
| PARSEOP_OFFSET '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
AccessAsTerm |
: PARSEOP_ACCESSAS '(' |
AccessTypeKeyword |
OptionalAccessAttribTerm |
')' {$$ = TrCreateNode (PARSEOP_ACCESSAS,2,$3,$4);} |
| PARSEOP_ACCESSAS '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
CreateBitFieldTerm |
: PARSEOP_CREATEBITFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);} |
TermArg |
TermArgItem |
NameStringItem |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} |
| PARSEOP_CREATEBITFIELD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
CreateByteFieldTerm |
: PARSEOP_CREATEBYTEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);} |
TermArg |
TermArgItem |
NameStringItem |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} |
| PARSEOP_CREATEBYTEFIELD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
CreateDWordFieldTerm |
: PARSEOP_CREATEDWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);} |
TermArg |
TermArgItem |
NameStringItem |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} |
| PARSEOP_CREATEDWORDFIELD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
CreateFieldTerm |
: PARSEOP_CREATEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);} |
TermArg |
TermArgItem |
TermArgItem |
NameStringItem |
')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,TrSetNodeFlags ($7, NODE_IS_NAME_DECLARATION));} |
| PARSEOP_CREATEFIELD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
CreateQWordFieldTerm |
: PARSEOP_CREATEQWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);} |
TermArg |
TermArgItem |
NameStringItem |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} |
| PARSEOP_CREATEQWORDFIELD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
CreateWordFieldTerm |
: PARSEOP_CREATEWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);} |
TermArg |
TermArgItem |
NameStringItem |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} |
| PARSEOP_CREATEWORDFIELD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DataRegionTerm |
: PARSEOP_DATATABLEREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);} |
NameString |
TermArgItem |
TermArgItem |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$6,$7);} |
| PARSEOP_DATATABLEREGION '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DeviceTerm |
: PARSEOP_DEVICE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEVICE);} |
NameString |
')' '{' |
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);} |
| PARSEOP_DEVICE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
EventTerm |
: PARSEOP_EVENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EVENT);} |
NameString |
')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));} |
| PARSEOP_EVENT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
FieldTerm |
: PARSEOP_FIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIELD);} |
NameString |
',' AccessTypeKeyword |
',' LockRuleKeyword |
',' UpdateRuleKeyword |
')' '{' |
FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$6,$8,$10,$13);} |
| PARSEOP_FIELD '(' |
error ')' '{' error '}' {$$ = AslDoError(); yyclearin;} |
; |
|
FunctionTerm |
: PARSEOP_FUNCTION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);} |
NameString |
OptionalParameterTypePackage |
OptionalParameterTypesPackage |
')' '{' |
TermList '}' {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION), |
TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0), |
TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL), |
TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),$5,$6,$9);} |
| PARSEOP_FUNCTION '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
IndexFieldTerm |
: PARSEOP_INDEXFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);} |
NameString |
NameStringItem |
',' AccessTypeKeyword |
',' LockRuleKeyword |
',' UpdateRuleKeyword |
')' '{' |
FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,6,$4,$5,$7,$9,$11,$14);} |
| PARSEOP_INDEXFIELD '(' |
error ')' '{' error '}' {$$ = AslDoError(); yyclearin;} |
; |
|
MethodTerm |
: PARSEOP_METHOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);} |
NameString |
OptionalByteConstExpr {UtCheckIntegerRange ($5, 0, 7);} |
OptionalSerializeRuleKeyword |
OptionalByteConstExpr |
OptionalParameterTypePackage |
OptionalParameterTypesPackage |
')' '{' |
TermList '}' {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$7,$8,$9,$10,$13);} |
| PARSEOP_METHOD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
MutexTerm |
: PARSEOP_MUTEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MUTEX);} |
NameString |
',' ByteConstExpr |
')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);} |
| PARSEOP_MUTEX '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
OpRegionTerm |
: PARSEOP_OPERATIONREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);} |
NameString |
',' OpRegionSpaceIdTerm |
TermArgItem |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8);} |
| PARSEOP_OPERATIONREGION '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
OpRegionSpaceIdTerm |
: RegionSpaceKeyword {} |
| ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);} |
; |
|
PowerResTerm |
: PARSEOP_POWERRESOURCE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);} |
NameString |
',' ByteConstExpr |
',' WordConstExpr |
')' '{' |
ObjectList '}' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$8,$11);} |
| PARSEOP_POWERRESOURCE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ProcessorTerm |
: PARSEOP_PROCESSOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_PROCESSOR);} |
NameString |
',' ByteConstExpr |
OptionalDWordConstExpr |
OptionalByteConstExpr |
')' '{' |
ObjectList '}' {$$ = TrLinkChildren ($<n>3,5,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8,$11);} |
| PARSEOP_PROCESSOR '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ThermalZoneTerm |
: PARSEOP_THERMALZONE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_THERMALZONE);} |
NameString |
')' '{' |
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);} |
| PARSEOP_THERMALZONE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
|
/******* Namespace modifiers *************************************************/ |
|
|
AliasTerm |
: PARSEOP_ALIAS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ALIAS);} |
NameString |
NameStringItem |
')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));} |
| PARSEOP_ALIAS '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
NameTerm |
: PARSEOP_NAME '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAME);} |
NameString |
',' DataObject |
')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);} |
| PARSEOP_NAME '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ScopeTerm |
: PARSEOP_SCOPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SCOPE);} |
NameString |
')' '{' |
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);} |
| PARSEOP_SCOPE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
|
/******* Type 1 opcodes *******************************************************/ |
|
|
BreakTerm |
: PARSEOP_BREAK {$$ = TrCreateNode (PARSEOP_BREAK, 0);} |
; |
|
BreakPointTerm |
: PARSEOP_BREAKPOINT {$$ = TrCreateNode (PARSEOP_BREAKPOINT, 0);} |
; |
|
ContinueTerm |
: PARSEOP_CONTINUE {$$ = TrCreateNode (PARSEOP_CONTINUE, 0);} |
; |
|
FatalTerm |
: PARSEOP_FATAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FATAL);} |
ByteConstExpr |
',' DWordConstExpr |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);} |
| PARSEOP_FATAL '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
IfElseTerm |
: IfTerm ElseTerm {$$ = TrLinkPeerNode ($1,$2);} |
; |
|
IfTerm |
: PARSEOP_IF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IF);} |
TermArg |
')' '{' |
TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
|
| PARSEOP_IF '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ElseTerm |
: {$$ = NULL;} |
| PARSEOP_ELSE '{' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);} |
TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);} |
|
| PARSEOP_ELSE '{' |
error '}' {$$ = AslDoError(); yyclearin;} |
|
| PARSEOP_ELSE |
error {$$ = AslDoError(); yyclearin;} |
|
| PARSEOP_ELSEIF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);} |
TermArg {$<n>$ = TrCreateLeafNode (PARSEOP_IF);} |
')' '{' |
TermList '}' {TrLinkChildren ($<n>5,2,$4,$8);} |
ElseTerm {TrLinkPeerNode ($<n>5,$11);} |
{$$ = TrLinkChildren ($<n>3,1,$<n>5);} |
|
| PARSEOP_ELSEIF '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
|
| PARSEOP_ELSEIF |
error {$$ = AslDoError(); yyclearin;} |
; |
|
LoadTerm |
: PARSEOP_LOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOAD);} |
NameString |
RequiredTarget |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_LOAD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
NoOpTerm |
: PARSEOP_NOOP {$$ = TrCreateNode (PARSEOP_NOOP, 0);} |
; |
|
NotifyTerm |
: PARSEOP_NOTIFY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOTIFY);} |
SuperName |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_NOTIFY '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ReleaseTerm |
: PARSEOP_RELEASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RELEASE);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_RELEASE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ResetTerm |
: PARSEOP_RESET '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RESET);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_RESET '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ReturnTerm |
: PARSEOP_RETURN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RETURN);} |
OptionalReturnArg |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_RETURN {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_RETURN),1,TrCreateLeafNode (PARSEOP_ZERO));} |
| PARSEOP_RETURN '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
SignalTerm |
: PARSEOP_SIGNAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIGNAL);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_SIGNAL '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
SleepTerm |
: PARSEOP_SLEEP '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SLEEP);} |
TermArg |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_SLEEP '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
StallTerm |
: PARSEOP_STALL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STALL);} |
TermArg |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_STALL '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
SwitchTerm |
: PARSEOP_SWITCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SWITCH);} |
TermArg |
')' '{' |
CaseDefaultTermList '}' |
{$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
| PARSEOP_SWITCH '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
/* |
* Case-Default list; allow only one Default term and unlimited Case terms |
*/ |
|
CaseDefaultTermList |
: {$$ = NULL;} |
| CaseTerm {} |
| DefaultTerm {} |
| CaseDefaultTermList |
CaseTerm {$$ = TrLinkPeerNode ($1,$2);} |
| CaseDefaultTermList |
DefaultTerm {$$ = TrLinkPeerNode ($1,$2);} |
|
/* Original - attempts to force zero or one default term within the switch */ |
|
/* |
CaseDefaultTermList |
: {$$ = NULL;} |
| CaseTermList |
DefaultTerm |
CaseTermList {$$ = TrLinkPeerNode ($1,TrLinkPeerNode ($2, $3));} |
| CaseTermList |
CaseTerm {$$ = TrLinkPeerNode ($1,$2);} |
; |
|
CaseTermList |
: {$$ = NULL;} |
| CaseTerm {} |
| CaseTermList |
CaseTerm {$$ = TrLinkPeerNode ($1,$2);} |
; |
*/ |
|
CaseTerm |
: PARSEOP_CASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CASE);} |
DataObject |
')' '{' |
TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
| PARSEOP_CASE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DefaultTerm |
: PARSEOP_DEFAULT '{' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFAULT);} |
TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_DEFAULT '{' |
error '}' {$$ = AslDoError(); yyclearin;} |
; |
|
UnloadTerm |
: PARSEOP_UNLOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNLOAD);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_UNLOAD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
WhileTerm |
: PARSEOP_WHILE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WHILE);} |
TermArg |
')' '{' TermList '}' |
{$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
| PARSEOP_WHILE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
|
/******* Type 2 opcodes *******************************************************/ |
|
AcquireTerm |
: PARSEOP_ACQUIRE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACQUIRE);} |
SuperName |
',' WordConstExpr |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$6);} |
| PARSEOP_ACQUIRE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
AddTerm |
: PARSEOP_ADD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_ADD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
AndTerm |
: PARSEOP_AND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_AND);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_AND '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ConcatTerm |
: PARSEOP_CONCATENATE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATE);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_CONCATENATE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ConcatResTerm |
: PARSEOP_CONCATENATERESTEMPLATE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATERESTEMPLATE);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_CONCATENATERESTEMPLATE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
CondRefOfTerm |
: PARSEOP_CONDREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONDREFOF);} |
SuperName |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_CONDREFOF '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
CopyObjectTerm |
: PARSEOP_COPYOBJECT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);} |
TermArg |
',' SimpleTarget |
')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));} |
| PARSEOP_COPYOBJECT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DecTerm |
: PARSEOP_DECREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DECREMENT);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_DECREMENT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DerefOfTerm |
: PARSEOP_DEREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEREFOF);} |
TermArg |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_DEREFOF '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DivideTerm |
: PARSEOP_DIVIDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DIVIDE);} |
TermArg |
TermArgItem |
Target |
Target |
')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);} |
| PARSEOP_DIVIDE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
FindSetLeftBitTerm |
: PARSEOP_FINDSETLEFTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_FINDSETLEFTBIT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
FindSetRightBitTerm |
: PARSEOP_FINDSETRIGHTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_FINDSETRIGHTBIT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
FromBCDTerm |
: PARSEOP_FROMBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FROMBCD);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_FROMBCD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
IncTerm |
: PARSEOP_INCREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCREMENT);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_INCREMENT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
IndexTerm |
: PARSEOP_INDEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEX);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_INDEX '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LAndTerm |
: PARSEOP_LAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LAND);} |
TermArg |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_LAND '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LEqualTerm |
: PARSEOP_LEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);} |
TermArg |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_LEQUAL '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LGreaterTerm |
: PARSEOP_LGREATER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);} |
TermArg |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_LGREATER '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LGreaterEqualTerm |
: PARSEOP_LGREATEREQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);} |
TermArg |
TermArgItem |
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));} |
| PARSEOP_LGREATEREQUAL '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LLessTerm |
: PARSEOP_LLESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);} |
TermArg |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_LLESS '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LLessEqualTerm |
: PARSEOP_LLESSEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);} |
TermArg |
TermArgItem |
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));} |
| PARSEOP_LLESSEQUAL '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LNotTerm |
: PARSEOP_LNOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LNOT);} |
TermArg |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_LNOT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LNotEqualTerm |
: PARSEOP_LNOTEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);} |
TermArg |
TermArgItem |
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));} |
| PARSEOP_LNOTEQUAL '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LoadTableTerm |
: PARSEOP_LOADTABLE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOADTABLE);} |
TermArg |
TermArgItem |
TermArgItem |
OptionalListString |
OptionalListString |
OptionalReference |
')' {$$ = TrLinkChildren ($<n>3,6,$4,$5,$6,$7,$8,$9);} |
| PARSEOP_LOADTABLE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
LOrTerm |
: PARSEOP_LOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOR);} |
TermArg |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_LOR '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
MatchTerm |
: PARSEOP_MATCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MATCH);} |
TermArg |
',' MatchOpKeyword |
TermArgItem |
',' MatchOpKeyword |
TermArgItem |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$7,$9,$10,$11);} |
| PARSEOP_MATCH '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
MidTerm |
: PARSEOP_MID '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MID);} |
TermArg |
TermArgItem |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);} |
| PARSEOP_MID '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ModTerm |
: PARSEOP_MOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MOD);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_MOD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
MultiplyTerm |
: PARSEOP_MULTIPLY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MULTIPLY);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_MULTIPLY '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
NAndTerm |
: PARSEOP_NAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAND);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_NAND '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
NOrTerm |
: PARSEOP_NOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOR);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_NOR '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
NotTerm |
: PARSEOP_NOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOT);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_NOT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ObjectTypeTerm |
: PARSEOP_OBJECTTYPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_OBJECTTYPE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
OrTerm |
: PARSEOP_OR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OR);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_OR '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
/* |
* In RefOf, the node isn't really a target, but we can't keep track of it after |
* we've taken a pointer to it. (hard to tell if a local becomes initialized this way.) |
*/ |
RefOfTerm |
: PARSEOP_REFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_REFOF);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));} |
| PARSEOP_REFOF '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ShiftLeftTerm |
: PARSEOP_SHIFTLEFT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_SHIFTLEFT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ShiftRightTerm |
: PARSEOP_SHIFTRIGHT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_SHIFTRIGHT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
SizeOfTerm |
: PARSEOP_SIZEOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIZEOF);} |
SuperName |
')' {$$ = TrLinkChildren ($<n>3,1,$4);} |
| PARSEOP_SIZEOF '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
StoreTerm |
: PARSEOP_STORE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STORE);} |
TermArg |
',' SuperName |
')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));} |
| PARSEOP_STORE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
SubtractTerm |
: PARSEOP_SUBTRACT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SUBTRACT);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_SUBTRACT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
TimerTerm |
: PARSEOP_TIMER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TIMER);} |
')' {$$ = TrLinkChildren ($<n>3,0);} |
| PARSEOP_TIMER {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_TIMER),0);} |
| PARSEOP_TIMER '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ToBCDTerm |
: PARSEOP_TOBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBCD);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_TOBCD '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ToBufferTerm |
: PARSEOP_TOBUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBUFFER);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_TOBUFFER '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ToDecimalStringTerm |
: PARSEOP_TODECIMALSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_TODECIMALSTRING '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ToHexStringTerm |
: PARSEOP_TOHEXSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_TOHEXSTRING '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ToIntegerTerm |
: PARSEOP_TOINTEGER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOINTEGER);} |
TermArg |
Target |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_TOINTEGER '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ToStringTerm |
: PARSEOP_TOSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOSTRING);} |
TermArg |
OptionalCount |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_TOSTRING '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ToUUIDTerm |
: PARSEOP_TOUUID '(' |
StringData ')' {$$ = TrUpdateNode (PARSEOP_TOUUID, $3);} |
| PARSEOP_TOUUID '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
WaitTerm |
: PARSEOP_WAIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WAIT);} |
SuperName |
TermArgItem |
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} |
| PARSEOP_WAIT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
XOrTerm |
: PARSEOP_XOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_XOR);} |
TermArg |
TermArgItem |
Target |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);} |
| PARSEOP_XOR '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
|
/******* Keywords *************************************************************/ |
|
|
ObjectTypeKeyword |
: PARSEOP_OBJECTTYPE_UNK {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);} |
| PARSEOP_OBJECTTYPE_INT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_INT);} |
| PARSEOP_OBJECTTYPE_STR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_STR);} |
| PARSEOP_OBJECTTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BUF);} |
| PARSEOP_OBJECTTYPE_PKG {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PKG);} |
| PARSEOP_OBJECTTYPE_FLD {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_FLD);} |
| PARSEOP_OBJECTTYPE_DEV {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DEV);} |
| PARSEOP_OBJECTTYPE_EVT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_EVT);} |
| PARSEOP_OBJECTTYPE_MTH {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTH);} |
| PARSEOP_OBJECTTYPE_MTX {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTX);} |
| PARSEOP_OBJECTTYPE_OPR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_OPR);} |
| PARSEOP_OBJECTTYPE_POW {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_POW);} |
| PARSEOP_OBJECTTYPE_PRO {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PRO);} |
| PARSEOP_OBJECTTYPE_THZ {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_THZ);} |
| PARSEOP_OBJECTTYPE_BFF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BFF);} |
| PARSEOP_OBJECTTYPE_DDB {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DDB);} |
; |
|
AccessTypeKeyword |
: PARSEOP_ACCESSTYPE_ANY {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_ANY);} |
| PARSEOP_ACCESSTYPE_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BYTE);} |
| PARSEOP_ACCESSTYPE_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_WORD);} |
| PARSEOP_ACCESSTYPE_DWORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_DWORD);} |
| PARSEOP_ACCESSTYPE_QWORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_QWORD);} |
| PARSEOP_ACCESSTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BUF);} |
; |
|
AccessAttribKeyword |
: PARSEOP_ACCESSATTRIB_QUICK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_QUICK );} |
| PARSEOP_ACCESSATTRIB_SND_RCV {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_SND_RCV);} |
| PARSEOP_ACCESSATTRIB_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BYTE);} |
| PARSEOP_ACCESSATTRIB_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD);} |
| PARSEOP_ACCESSATTRIB_BLOCK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK);} |
| PARSEOP_ACCESSATTRIB_WORD_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD_CALL);} |
| PARSEOP_ACCESSATTRIB_BLOCK_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK_CALL);} |
; |
|
LockRuleKeyword |
: PARSEOP_LOCKRULE_LOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_LOCK);} |
| PARSEOP_LOCKRULE_NOLOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_NOLOCK);} |
; |
|
UpdateRuleKeyword |
: PARSEOP_UPDATERULE_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_PRESERVE);} |
| PARSEOP_UPDATERULE_ONES {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ONES);} |
| PARSEOP_UPDATERULE_ZEROS {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ZEROS);} |
; |
|
|
RegionSpaceKeyword |
: PARSEOP_REGIONSPACE_IO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IO);} |
| PARSEOP_REGIONSPACE_MEM {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_MEM);} |
| PARSEOP_REGIONSPACE_PCI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCI);} |
| PARSEOP_REGIONSPACE_EC {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_EC);} |
| PARSEOP_REGIONSPACE_SMBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_SMBUS);} |
| PARSEOP_REGIONSPACE_CMOS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_CMOS);} |
| PARSEOP_REGIONSPACE_PCIBAR {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCIBAR);} |
| PARSEOP_REGIONSPACE_IPMI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IPMI);} |
; |
|
AddressSpaceKeyword |
: ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);} |
| RegionSpaceKeyword {} |
| PARSEOP_ADDRESSSPACE_FFIXEDHW {$$ = TrCreateLeafNode (PARSEOP_ADDRESSSPACE_FFIXEDHW);} |
; |
|
|
SerializeRuleKeyword |
: PARSEOP_SERIALIZERULE_SERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_SERIAL);} |
| PARSEOP_SERIALIZERULE_NOTSERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL);} |
; |
|
MatchOpKeyword |
: PARSEOP_MATCHTYPE_MTR {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MTR);} |
| PARSEOP_MATCHTYPE_MEQ {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MEQ);} |
| PARSEOP_MATCHTYPE_MLE {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLE);} |
| PARSEOP_MATCHTYPE_MLT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLT);} |
| PARSEOP_MATCHTYPE_MGE {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGE);} |
| PARSEOP_MATCHTYPE_MGT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGT);} |
; |
|
DMATypeKeyword |
: PARSEOP_DMATYPE_A {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_A);} |
| PARSEOP_DMATYPE_COMPATIBILITY {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_COMPATIBILITY);} |
| PARSEOP_DMATYPE_B {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_B);} |
| PARSEOP_DMATYPE_F {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_F);} |
; |
|
XferTypeKeyword |
: PARSEOP_XFERTYPE_8 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8);} |
| PARSEOP_XFERTYPE_8_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8_16);} |
| PARSEOP_XFERTYPE_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_16);} |
; |
|
ResourceTypeKeyword |
: PARSEOP_RESOURCETYPE_CONSUMER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);} |
| PARSEOP_RESOURCETYPE_PRODUCER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_PRODUCER);} |
; |
|
MinKeyword |
: PARSEOP_MINTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_FIXED);} |
| PARSEOP_MINTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_NOTFIXED);} |
; |
|
MaxKeyword |
: PARSEOP_MAXTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_FIXED);} |
| PARSEOP_MAXTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_NOTFIXED);} |
; |
|
DecodeKeyword |
: PARSEOP_DECODETYPE_POS {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_POS);} |
| PARSEOP_DECODETYPE_SUB {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_SUB);} |
; |
|
RangeTypeKeyword |
: PARSEOP_RANGETYPE_ISAONLY {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ISAONLY);} |
| PARSEOP_RANGETYPE_NONISAONLY {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_NONISAONLY);} |
| PARSEOP_RANGETYPE_ENTIRE {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ENTIRE);} |
; |
|
MemTypeKeyword |
: PARSEOP_MEMTYPE_CACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_CACHEABLE);} |
| PARSEOP_MEMTYPE_WRITECOMBINING {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_WRITECOMBINING);} |
| PARSEOP_MEMTYPE_PREFETCHABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_PREFETCHABLE);} |
| PARSEOP_MEMTYPE_NONCACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_NONCACHEABLE);} |
; |
|
OptionalReadWriteKeyword |
: {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);} |
| PARSEOP_READWRITETYPE_BOTH {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);} |
| PARSEOP_READWRITETYPE_READONLY {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_READONLY);} |
; |
|
InterruptTypeKeyword |
: PARSEOP_INTTYPE_EDGE {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_EDGE);} |
| PARSEOP_INTTYPE_LEVEL {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_LEVEL);} |
; |
|
InterruptLevel |
: PARSEOP_INTLEVEL_ACTIVEHIGH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEHIGH);} |
| PARSEOP_INTLEVEL_ACTIVELOW {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVELOW);} |
; |
|
ShareTypeKeyword |
: PARSEOP_SHARETYPE_SHARED {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHARED);} |
| PARSEOP_SHARETYPE_EXCLUSIVE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVE);} |
; |
|
IODecodeKeyword |
: PARSEOP_IODECODETYPE_16 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_16);} |
| PARSEOP_IODECODETYPE_10 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_10);} |
; |
|
TypeKeyword |
: PARSEOP_TYPE_TRANSLATION {$$ = TrCreateLeafNode (PARSEOP_TYPE_TRANSLATION);} |
| PARSEOP_TYPE_STATIC {$$ = TrCreateLeafNode (PARSEOP_TYPE_STATIC);} |
; |
|
TranslationKeyword |
: PARSEOP_TRANSLATIONTYPE_SPARSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_SPARSE);} |
| PARSEOP_TRANSLATIONTYPE_DENSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_DENSE);} |
; |
|
AddressKeyword |
: PARSEOP_ADDRESSTYPE_MEMORY {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_MEMORY);} |
| PARSEOP_ADDRESSTYPE_RESERVED {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_RESERVED);} |
| PARSEOP_ADDRESSTYPE_NVS {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_NVS);} |
| PARSEOP_ADDRESSTYPE_ACPI {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_ACPI);} |
; |
|
|
/******* Miscellaneous Types **************************************************/ |
|
|
SuperName |
: NameString {} |
| ArgTerm {} |
| LocalTerm {} |
| DebugTerm {} |
| Type6Opcode {} |
/* | UserTerm {} */ /* Caused reduce/reduce with Type6Opcode->UserTerm */ |
; |
|
ArgTerm |
: PARSEOP_ARG0 {$$ = TrCreateLeafNode (PARSEOP_ARG0);} |
| PARSEOP_ARG1 {$$ = TrCreateLeafNode (PARSEOP_ARG1);} |
| PARSEOP_ARG2 {$$ = TrCreateLeafNode (PARSEOP_ARG2);} |
| PARSEOP_ARG3 {$$ = TrCreateLeafNode (PARSEOP_ARG3);} |
| PARSEOP_ARG4 {$$ = TrCreateLeafNode (PARSEOP_ARG4);} |
| PARSEOP_ARG5 {$$ = TrCreateLeafNode (PARSEOP_ARG5);} |
| PARSEOP_ARG6 {$$ = TrCreateLeafNode (PARSEOP_ARG6);} |
; |
|
LocalTerm |
: PARSEOP_LOCAL0 {$$ = TrCreateLeafNode (PARSEOP_LOCAL0);} |
| PARSEOP_LOCAL1 {$$ = TrCreateLeafNode (PARSEOP_LOCAL1);} |
| PARSEOP_LOCAL2 {$$ = TrCreateLeafNode (PARSEOP_LOCAL2);} |
| PARSEOP_LOCAL3 {$$ = TrCreateLeafNode (PARSEOP_LOCAL3);} |
| PARSEOP_LOCAL4 {$$ = TrCreateLeafNode (PARSEOP_LOCAL4);} |
| PARSEOP_LOCAL5 {$$ = TrCreateLeafNode (PARSEOP_LOCAL5);} |
| PARSEOP_LOCAL6 {$$ = TrCreateLeafNode (PARSEOP_LOCAL6);} |
| PARSEOP_LOCAL7 {$$ = TrCreateLeafNode (PARSEOP_LOCAL7);} |
; |
|
DebugTerm |
: PARSEOP_DEBUG {$$ = TrCreateLeafNode (PARSEOP_DEBUG);} |
; |
|
|
ByteConst |
: Integer {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);} |
; |
|
WordConst |
: Integer {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);} |
; |
|
DWordConst |
: Integer {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);} |
; |
|
QWordConst |
: Integer {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);} |
; |
|
Integer |
: PARSEOP_INTEGER {$$ = TrCreateValuedLeafNode (PARSEOP_INTEGER, AslCompilerlval.i);} |
; |
|
String |
: PARSEOP_STRING_LITERAL {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, (ACPI_NATIVE_INT) AslCompilerlval.s);} |
; |
|
ConstTerm |
: ConstExprTerm {} |
| PARSEOP_REVISION {$$ = TrCreateLeafNode (PARSEOP_REVISION);} |
; |
|
ByteConstExpr |
: Type3Opcode {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);} |
| Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);} |
| ConstExprTerm {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);} |
| ByteConst {} |
; |
|
WordConstExpr |
: Type3Opcode {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);} |
| Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);} |
| ConstExprTerm {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);} |
| WordConst {} |
; |
|
DWordConstExpr |
: Type3Opcode {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);} |
| Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);} |
| ConstExprTerm {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);} |
| DWordConst {} |
; |
|
QWordConstExpr |
: Type3Opcode {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);} |
| Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);} |
| ConstExprTerm {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);} |
| QWordConst {} |
; |
|
ConstExprTerm |
: PARSEOP_ZERO {$$ = TrCreateValuedLeafNode (PARSEOP_ZERO, 0);} |
| PARSEOP_ONE {$$ = TrCreateValuedLeafNode (PARSEOP_ONE, 1);} |
| PARSEOP_ONES {$$ = TrCreateValuedLeafNode (PARSEOP_ONES, ACPI_UINT64_MAX);} |
; |
|
/* OptionalCount must appear before ByteList or an incorrect reduction will result */ |
|
OptionalCount |
: {$$ = TrCreateLeafNode (PARSEOP_ONES);} /* Placeholder is a OnesOp object */ |
| ',' {$$ = TrCreateLeafNode (PARSEOP_ONES);} /* Placeholder is a OnesOp object */ |
| ',' TermArg {$$ = $2;} |
; |
|
|
BufferTerm |
: PARSEOP_BUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BUFFER);} |
OptionalTermArg |
')' '{' |
BufferTermData '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
| PARSEOP_BUFFER '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
BufferTermData |
: ByteList {} |
| StringData {} |
; |
|
ByteList |
: {$$ = NULL;} |
| ByteConstExpr |
| ByteList ',' /* Allows a trailing comma at list end */ |
| ByteList ',' |
ByteConstExpr {$$ = TrLinkPeerNode ($1,$3);} |
; |
|
DWordList |
: {$$ = NULL;} |
| DWordConstExpr |
| DWordList ',' /* Allows a trailing comma at list end */ |
| DWordList ',' |
DWordConstExpr {$$ = TrLinkPeerNode ($1,$3);} |
; |
|
PackageTerm |
: PARSEOP_PACKAGE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VAR_PACKAGE);} |
VarPackageLengthTerm |
')' '{' |
PackageList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
| PARSEOP_PACKAGE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
VarPackageLengthTerm |
: {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);} |
| TermArg {$$ = $1;} |
; |
|
PackageList |
: {$$ = NULL;} |
| PackageElement |
| PackageList ',' /* Allows a trailing comma at list end */ |
| PackageList ',' |
PackageElement {$$ = TrLinkPeerNode ($1,$3);} |
; |
|
PackageElement |
: DataObject {} |
| NameString {} |
; |
|
EISAIDTerm |
: PARSEOP_EISAID '(' |
StringData ')' {$$ = TrUpdateNode (PARSEOP_EISAID, $3);} |
| PARSEOP_EISAID '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
|
/******* Resources and Memory ***********************************************/ |
|
|
/* |
* Note: Create two default nodes to allow conversion to a Buffer AML opcode |
* Also, insert the EndTag at the end of the template. |
*/ |
ResourceTemplateTerm |
: PARSEOP_RESOURCETEMPLATE '(' ')' |
'{' |
ResourceMacroList '}' {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,4, |
TrCreateLeafNode (PARSEOP_DEFAULT_ARG), |
TrCreateLeafNode (PARSEOP_DEFAULT_ARG), |
$5, |
TrCreateLeafNode (PARSEOP_ENDTAG));} |
; |
|
UnicodeTerm |
: PARSEOP_UNICODE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNICODE);} |
StringData |
')' {$$ = TrLinkChildren ($<n>3,2,0,$4);} |
| PARSEOP_UNICODE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ResourceMacroList |
: {$$ = NULL;} |
| ResourceMacroList |
ResourceMacroTerm {$$ = TrLinkPeerNode ($1,$2);} |
; |
|
ResourceMacroTerm |
: DMATerm {} |
| DWordIOTerm {} |
| DWordMemoryTerm {} |
| DWordSpaceTerm {} |
| EndDependentFnTerm {} |
| ExtendedIOTerm {} |
| ExtendedMemoryTerm {} |
| ExtendedSpaceTerm {} |
| FixedIOTerm {} |
| InterruptTerm {} |
| IOTerm {} |
| IRQNoFlagsTerm {} |
| IRQTerm {} |
| Memory24Term {} |
| Memory32FixedTerm {} |
| Memory32Term {} |
| QWordIOTerm {} |
| QWordMemoryTerm {} |
| QWordSpaceTerm {} |
| RegisterTerm {} |
| StartDependentFnTerm {} |
| StartDependentFnNoPriTerm {} |
| VendorLongTerm {} |
| VendorShortTerm {} |
| WordBusNumberTerm {} |
| WordIOTerm {} |
| WordSpaceTerm {} |
; |
|
DMATerm |
: PARSEOP_DMA '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DMA);} |
DMATypeKeyword |
OptionalBusMasterKeyword |
',' XferTypeKeyword |
OptionalNameString_Last |
')' '{' |
ByteList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$5,$7,$8,$11);} |
| PARSEOP_DMA '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DWordIOTerm |
: PARSEOP_DWORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDIO);} |
OptionalResourceType_First |
OptionalMinType |
OptionalMaxType |
OptionalDecodeType |
OptionalRangeType |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString |
OptionalType |
OptionalTranslationType_Last |
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);} |
| PARSEOP_DWORDIO '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DWordMemoryTerm |
: PARSEOP_DWORDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDMEMORY);} |
OptionalResourceType_First |
OptionalDecodeType |
OptionalMinType |
OptionalMaxType |
OptionalMemType |
',' OptionalReadWriteKeyword |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString |
OptionalAddressRange |
OptionalType_Last |
')' {$$ = TrLinkChildren ($<n>3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);} |
| PARSEOP_DWORDMEMORY '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
DWordSpaceTerm |
: PARSEOP_DWORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDSPACE);} |
ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);} |
OptionalResourceType |
OptionalDecodeType |
OptionalMinType |
OptionalMaxType |
',' ByteConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);} |
| PARSEOP_DWORDSPACE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
|
EndDependentFnTerm |
: PARSEOP_ENDDEPENDENTFN '(' |
')' {$$ = TrCreateLeafNode (PARSEOP_ENDDEPENDENTFN);} |
| PARSEOP_ENDDEPENDENTFN '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ExtendedIOTerm |
: PARSEOP_EXTENDEDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDIO);} |
OptionalResourceType_First |
OptionalMinType |
OptionalMaxType |
OptionalDecodeType |
OptionalRangeType |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
OptionalQWordConstExpr |
OptionalNameString |
OptionalType |
OptionalTranslationType_Last |
')' {$$ = TrLinkChildren ($<n>3,14,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22);} |
| PARSEOP_EXTENDEDIO '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ExtendedMemoryTerm |
: PARSEOP_EXTENDEDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDMEMORY);} |
OptionalResourceType_First |
OptionalDecodeType |
OptionalMinType |
OptionalMaxType |
OptionalMemType |
',' OptionalReadWriteKeyword |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
OptionalQWordConstExpr |
OptionalNameString |
OptionalAddressRange |
OptionalType_Last |
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24);} |
| PARSEOP_EXTENDEDMEMORY '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
ExtendedSpaceTerm |
: PARSEOP_EXTENDEDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDSPACE);} |
ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);} |
OptionalResourceType |
OptionalDecodeType |
OptionalMinType |
OptionalMaxType |
',' ByteConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
OptionalQWordConstExpr |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,13,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23);} |
| PARSEOP_EXTENDEDSPACE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
FixedIOTerm |
: PARSEOP_FIXEDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDIO);} |
WordConstExpr |
',' ByteConstExpr |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);} |
| PARSEOP_FIXEDIO '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
InterruptTerm |
: PARSEOP_INTERRUPT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INTERRUPT);} |
OptionalResourceType_First |
',' InterruptTypeKeyword |
',' InterruptLevel |
OptionalShareType |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString_Last |
')' '{' |
DWordList '}' {$$ = TrLinkChildren ($<n>3,8,$4,$6,$8,$9,$10,$11,$12,$15);} |
| PARSEOP_INTERRUPT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
IOTerm |
: PARSEOP_IO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IO);} |
IODecodeKeyword |
',' WordConstExpr |
',' WordConstExpr |
',' ByteConstExpr |
',' ByteConstExpr |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);} |
| PARSEOP_IO '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
IRQNoFlagsTerm |
: PARSEOP_IRQNOFLAGS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IRQNOFLAGS);} |
OptionalNameString_First |
')' '{' |
ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
| PARSEOP_IRQNOFLAGS '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
IRQTerm |
: PARSEOP_IRQ '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IRQ);} |
InterruptTypeKeyword |
',' InterruptLevel |
OptionalShareType |
OptionalNameString_Last |
')' '{' |
ByteList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$6,$7,$8,$11);} |
| PARSEOP_IRQ '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
Memory24Term |
: PARSEOP_MEMORY24 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY24);} |
OptionalReadWriteKeyword |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);} |
| PARSEOP_MEMORY24 '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
Memory32FixedTerm |
: PARSEOP_MEMORY32FIXED '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32FIXED);} |
OptionalReadWriteKeyword |
',' DWordConstExpr |
',' DWordConstExpr |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$9);} |
| PARSEOP_MEMORY32FIXED '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
Memory32Term |
: PARSEOP_MEMORY32 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32);} |
OptionalReadWriteKeyword |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
',' DWordConstExpr |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);} |
| PARSEOP_MEMORY32 '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
QWordIOTerm |
: PARSEOP_QWORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDIO);} |
OptionalResourceType_First |
OptionalMinType |
OptionalMaxType |
OptionalDecodeType |
OptionalRangeType |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString |
OptionalType |
OptionalTranslationType_Last |
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);} |
| PARSEOP_QWORDIO '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
QWordMemoryTerm |
: PARSEOP_QWORDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDMEMORY);} |
OptionalResourceType_First |
OptionalDecodeType |
OptionalMinType |
OptionalMaxType |
OptionalMemType |
',' OptionalReadWriteKeyword |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString |
OptionalAddressRange |
OptionalType_Last |
')' {$$ = TrLinkChildren ($<n>3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);} |
| PARSEOP_QWORDMEMORY '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
QWordSpaceTerm |
: PARSEOP_QWORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDSPACE);} |
ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);} |
OptionalResourceType |
OptionalDecodeType |
OptionalMinType |
OptionalMaxType |
',' ByteConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
',' QWordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);} |
| PARSEOP_QWORDSPACE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
RegisterTerm |
: PARSEOP_REGISTER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_REGISTER);} |
AddressSpaceKeyword |
',' ByteConstExpr |
',' ByteConstExpr |
',' QWordConstExpr |
OptionalAccessSize |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$11,$12);} |
| PARSEOP_REGISTER '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
StartDependentFnTerm |
: PARSEOP_STARTDEPENDENTFN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN);} |
ByteConstExpr |
',' ByteConstExpr |
')' '{' |
ResourceMacroList '}' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$9);} |
| PARSEOP_STARTDEPENDENTFN '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
StartDependentFnNoPriTerm |
: PARSEOP_STARTDEPENDENTFN_NOPRI '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);} |
')' '{' |
ResourceMacroList '}' {$$ = TrLinkChildren ($<n>3,1,$6);} |
| PARSEOP_STARTDEPENDENTFN_NOPRI '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
VendorLongTerm |
: PARSEOP_VENDORLONG '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORLONG);} |
OptionalNameString_First |
')' '{' |
ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
| PARSEOP_VENDORLONG '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
VendorShortTerm |
: PARSEOP_VENDORSHORT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORSHORT);} |
OptionalNameString_First |
')' '{' |
ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} |
| PARSEOP_VENDORSHORT '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
WordBusNumberTerm |
: PARSEOP_WORDBUSNUMBER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDBUSNUMBER);} |
OptionalResourceType_First |
OptionalMinType |
OptionalMaxType |
OptionalDecodeType |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,12,$4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);} |
| PARSEOP_WORDBUSNUMBER '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
WordIOTerm |
: PARSEOP_WORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDIO);} |
OptionalResourceType_First |
OptionalMinType |
OptionalMaxType |
OptionalDecodeType |
OptionalRangeType |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString |
OptionalType |
OptionalTranslationType_Last |
')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);} |
| PARSEOP_WORDIO '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
WordSpaceTerm |
: PARSEOP_WORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDSPACE);} |
ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);} |
OptionalResourceType |
OptionalDecodeType |
OptionalMinType |
OptionalMaxType |
',' ByteConstExpr |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
',' WordConstExpr |
OptionalByteConstExpr |
OptionalStringData |
OptionalNameString_Last |
')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);} |
| PARSEOP_WORDSPACE '(' |
error ')' {$$ = AslDoError(); yyclearin;} |
; |
|
|
/******* Object References ***********************************************/ |
|
/* Allow IO, DMA, IRQ Resource macro names to also be used as identifiers */ |
|
NameString |
: NameSeg {} |
| PARSEOP_NAMESTRING {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) AslCompilerlval.s);} |
| PARSEOP_IO {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IO");} |
| PARSEOP_DMA {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "DMA");} |
| PARSEOP_IRQ {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IRQ");} |
; |
|
NameSeg |
: PARSEOP_NAMESEG {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESEG, (ACPI_NATIVE_INT) AslCompilerlval.s);} |
; |
|
|
/******* Helper rules ****************************************************/ |
|
|
AmlPackageLengthTerm |
: Integer {$$ = TrUpdateNode (PARSEOP_PACKAGE_LENGTH,(ACPI_PARSE_OBJECT *) $1);} |
; |
|
OptionalBusMasterKeyword |
: ',' {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);} |
| ',' PARSEOP_BUSMASTERTYPE_MASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);} |
| ',' PARSEOP_BUSMASTERTYPE_NOTMASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_NOTMASTER);} |
; |
|
OptionalAccessAttribTerm |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' ByteConstExpr {$$ = $2;} |
| ',' AccessAttribKeyword {$$ = $2;} |
; |
|
OptionalAccessSize |
: {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);} |
| ',' {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);} |
| ',' ByteConstExpr {$$ = $2;} |
; |
|
OptionalAddressRange |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' AddressKeyword {$$ = $2;} |
; |
|
OptionalByteConstExpr |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' ByteConstExpr {$$ = $2;} |
; |
|
OptionalDecodeType |
: ',' {$$ = NULL;} |
| ',' DecodeKeyword {$$ = $2;} |
; |
|
OptionalDWordConstExpr |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' DWordConstExpr {$$ = $2;} |
; |
|
OptionalListString |
: {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */ |
| ',' {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */ |
| ',' TermArg {$$ = $2;} |
; |
|
OptionalMaxType |
: ',' {$$ = NULL;} |
| ',' MaxKeyword {$$ = $2;} |
; |
|
OptionalMemType |
: ',' {$$ = NULL;} |
| ',' MemTypeKeyword {$$ = $2;} |
; |
|
OptionalMinType |
: ',' {$$ = NULL;} |
| ',' MinKeyword {$$ = $2;} |
; |
|
OptionalNameString |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' NameString {$$ = $2;} |
; |
|
OptionalNameString_Last |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' NameString {$$ = $2;} |
; |
|
OptionalNameString_First |
: {$$ = TrCreateLeafNode (PARSEOP_ZERO);} |
| NameString {$$ = $1;} |
; |
|
OptionalObjectTypeKeyword |
: {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);} |
| ',' ObjectTypeKeyword {$$ = $2;} |
; |
|
OptionalQWordConstExpr |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' QWordConstExpr {$$ = $2;} |
; |
|
OptionalRangeType |
: ',' {$$ = NULL;} |
| ',' RangeTypeKeyword {$$ = $2;} |
; |
|
OptionalReference |
: {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */ |
| ',' {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */ |
| ',' TermArg {$$ = $2;} |
; |
|
OptionalResourceType_First |
: {$$ = NULL;} |
| ResourceTypeKeyword {$$ = $1;} |
; |
|
OptionalResourceType |
: ',' {$$ = NULL;} |
| ',' ResourceTypeKeyword {$$ = $2;} |
; |
|
OptionalSerializeRuleKeyword |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' SerializeRuleKeyword {$$ = $2;} |
; |
|
OptionalShareType |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' ShareTypeKeyword {$$ = $2;} |
; |
|
OptionalStringData |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' StringData {$$ = $2;} |
; |
|
OptionalTermArg |
: {$$ = NULL;} |
| TermArg {$$ = $1;} |
; |
|
OptionalReturnArg |
: {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */ |
| TermArg {$$ = $1;} |
; |
|
OptionalType |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' TypeKeyword {$$ = $2;} |
; |
|
OptionalType_Last |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' TypeKeyword {$$ = $2;} |
; |
|
OptionalTranslationType_Last |
: {$$ = NULL;} |
| ',' {$$ = NULL;} |
| ',' TranslationKeyword {$$ = $2;} |
; |
|
|
TermArgItem |
: ',' TermArg {$$ = $2;} |
| ',' error {$$ = AslDoError (); yyclearin;} |
; |
|
NameStringItem |
: ',' NameString {$$ = $2;} |
| ',' error {$$ = AslDoError (); yyclearin;} |
; |
|
|
%% |
|
|
/* |
* Local support functions |
*/ |
|
int |
AslCompilerwrap(void) |
{ |
return 1; |
} |
|
/*! [End] no source code translation !*/ |
|
void * |
AslLocalAllocate (unsigned int Size) |
{ |
void *Mem; |
|
|
DbgPrint (ASL_PARSE_OUTPUT, "\nAslLocalAllocate: Expanding Stack to %u\n\n", Size); |
|
Mem = ACPI_ALLOCATE_ZEROED (Size); |
if (!Mem) |
{ |
AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION, |
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, |
Gbl_InputByteCount, Gbl_CurrentColumn, |
Gbl_Files[ASL_FILE_INPUT].Filename, NULL); |
exit (1); |
} |
|
return (Mem); |
} |
|
ACPI_PARSE_OBJECT * |
AslDoError (void) |
{ |
|
|
return (TrCreateLeafNode (PARSEOP_ERRORNODE)); |
|
} |