%{ /****************************************************************************** * * Module Name: aslcompiler.y - Bison input file (ASL grammar and actions) * $Revision: $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999 - 2003, 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 #include #include #include "acpi.h" #define _COMPONENT ACPI_COMPILER ACPI_MODULE_NAME ("aslparse") /* * 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 */ /* * 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 PARSEOP_ACCESSAS %token PARSEOP_ACCESSATTRIB_BLOCK %token PARSEOP_ACCESSATTRIB_BLOCK_CALL %token PARSEOP_ACCESSATTRIB_BYTE %token PARSEOP_ACCESSATTRIB_WORD_CALL %token PARSEOP_ACCESSATTRIB_QUICK %token PARSEOP_ACCESSATTRIB_SND_RCV %token PARSEOP_ACCESSATTRIB_WORD %token PARSEOP_ACCESSTYPE_ANY %token PARSEOP_ACCESSTYPE_BUF %token PARSEOP_ACCESSTYPE_BYTE %token PARSEOP_ACCESSTYPE_DWORD %token PARSEOP_ACCESSTYPE_QWORD %token PARSEOP_ACCESSTYPE_WORD %token PARSEOP_ACQUIRE %token PARSEOP_ADD %token PARSEOP_ADDRESSSPACE_FFIXEDHW %token PARSEOP_ADDRESSTYPE_ACPI %token PARSEOP_ADDRESSTYPE_MEMORY %token PARSEOP_ADDRESSTYPE_NVS %token PARSEOP_ADDRESSTYPE_RESERVED %token PARSEOP_ALIAS %token PARSEOP_AND %token PARSEOP_ARG0 %token PARSEOP_ARG1 %token PARSEOP_ARG2 %token PARSEOP_ARG3 %token PARSEOP_ARG4 %token PARSEOP_ARG5 %token PARSEOP_ARG6 %token PARSEOP_BANKFIELD %token PARSEOP_BREAK %token PARSEOP_BREAKPOINT %token PARSEOP_BUFFER %token PARSEOP_BUSMASTERTYPE_MASTER %token PARSEOP_BUSMASTERTYPE_NOTMASTER %token PARSEOP_BYTECONST %token PARSEOP_CASE %token PARSEOP_CONCATENATE %token PARSEOP_CONCATENATERESTEMPLATE %token PARSEOP_CONDREFOF %token PARSEOP_CONTINUE %token PARSEOP_COPYOBJECT %token PARSEOP_CREATEBITFIELD %token PARSEOP_CREATEBYTEFIELD %token PARSEOP_CREATEDWORDFIELD %token PARSEOP_CREATEFIELD %token PARSEOP_CREATEQWORDFIELD %token PARSEOP_CREATEWORDFIELD %token PARSEOP_DATATABLEREGION %token PARSEOP_DEBUG %token PARSEOP_DECODETYPE_POS %token PARSEOP_DECODETYPE_SUB %token PARSEOP_DECREMENT %token PARSEOP_DEFAULT %token PARSEOP_DEFAULT_ARG %token PARSEOP_DEFINITIONBLOCK %token PARSEOP_DEREFOF %token PARSEOP_DEVICE %token PARSEOP_DIVIDE %token PARSEOP_DMA %token PARSEOP_DMATYPE_A %token PARSEOP_DMATYPE_COMPATIBILITY %token PARSEOP_DMATYPE_B %token PARSEOP_DMATYPE_F %token PARSEOP_DWORDCONST %token PARSEOP_DWORDIO %token PARSEOP_DWORDMEMORY %token PARSEOP_EISAID %token PARSEOP_ELSE %token PARSEOP_ELSEIF %token PARSEOP_ENDDEPENDENTFN %token PARSEOP_ERRORNODE %token PARSEOP_EVENT %token PARSEOP_EXTERNAL %token PARSEOP_FATAL %token PARSEOP_FIELD %token PARSEOP_FINDSETLEFTBIT %token PARSEOP_FINDSETRIGHTBIT %token PARSEOP_FIXEDIO %token PARSEOP_FROMBCD %token PARSEOP_IF %token PARSEOP_INCLUDE %token PARSEOP_INCLUDE_CSTYLE %token PARSEOP_INCLUDE_END %token PARSEOP_INCREMENT %token PARSEOP_INDEX %token PARSEOP_INDEXFIELD %token PARSEOP_INTEGER %token PARSEOP_INTERRUPT %token PARSEOP_INTLEVEL_ACTIVEHIGH %token PARSEOP_INTLEVEL_ACTIVELOW %token PARSEOP_INTTYPE_EDGE %token PARSEOP_INTTYPE_LEVEL %token PARSEOP_IO %token PARSEOP_IODECODETYPE_10 %token PARSEOP_IODECODETYPE_16 %token PARSEOP_IRQ %token PARSEOP_IRQNOFLAGS %token PARSEOP_LAND %token PARSEOP_LEQUAL %token PARSEOP_LGREATER %token PARSEOP_LGREATEREQUAL %token PARSEOP_LINE_CSTYLE %token PARSEOP_LLESS %token PARSEOP_LLESSEQUAL %token PARSEOP_LNOT %token PARSEOP_LNOTEQUAL %token PARSEOP_LOAD %token PARSEOP_LOADTABLE %token PARSEOP_LOCAL0 %token PARSEOP_LOCAL1 %token PARSEOP_LOCAL2 %token PARSEOP_LOCAL3 %token PARSEOP_LOCAL4 %token PARSEOP_LOCAL5 %token PARSEOP_LOCAL6 %token PARSEOP_LOCAL7 %token PARSEOP_LOCKRULE_LOCK %token PARSEOP_LOCKRULE_NOLOCK %token PARSEOP_LOR %token PARSEOP_MATCH %token PARSEOP_MATCHTYPE_MEQ %token PARSEOP_MATCHTYPE_MGE %token PARSEOP_MATCHTYPE_MGT %token PARSEOP_MATCHTYPE_MLE %token PARSEOP_MATCHTYPE_MLT %token PARSEOP_MATCHTYPE_MTR %token PARSEOP_MAXTYPE_FIXED %token PARSEOP_MAXTYPE_NOTFIXED %token PARSEOP_MEMORY24 %token PARSEOP_MEMORY32 %token PARSEOP_MEMORY32FIXED %token PARSEOP_MEMTYPE_CACHEABLE %token PARSEOP_MEMTYPE_NONCACHEABLE %token PARSEOP_MEMTYPE_PREFETCHABLE %token PARSEOP_MEMTYPE_WRITECOMBINING %token PARSEOP_METHOD %token PARSEOP_METHODCALL %token PARSEOP_MID %token PARSEOP_MINTYPE_FIXED %token PARSEOP_MINTYPE_NOTFIXED %token PARSEOP_MOD %token PARSEOP_MULTIPLY %token PARSEOP_MUTEX %token PARSEOP_NAME %token PARSEOP_NAMESEG %token PARSEOP_NAMESTRING %token PARSEOP_NAND %token PARSEOP_NOOP %token PARSEOP_NOR %token PARSEOP_NOT %token PARSEOP_NOTIFY %token PARSEOP_OBJECTTYPE %token PARSEOP_OBJECTTYPE_BFF %token PARSEOP_OBJECTTYPE_BUF %token PARSEOP_OBJECTTYPE_DDB %token PARSEOP_OBJECTTYPE_DEV %token PARSEOP_OBJECTTYPE_EVT %token PARSEOP_OBJECTTYPE_FLD %token PARSEOP_OBJECTTYPE_INT %token PARSEOP_OBJECTTYPE_MTH %token PARSEOP_OBJECTTYPE_MTX %token PARSEOP_OBJECTTYPE_OPR %token PARSEOP_OBJECTTYPE_PKG %token PARSEOP_OBJECTTYPE_POW %token PARSEOP_OBJECTTYPE_STR %token PARSEOP_OBJECTTYPE_THZ %token PARSEOP_OBJECTTYPE_UNK %token PARSEOP_OFFSET %token PARSEOP_ONE %token PARSEOP_ONES %token PARSEOP_OPERATIONREGION %token PARSEOP_OR %token PARSEOP_PACKAGE %token PARSEOP_PACKAGE_LENGTH %token PARSEOP_POWERRESOURCE %token PARSEOP_PROCESSOR %token PARSEOP_QWORDCONST %token PARSEOP_QWORDIO %token PARSEOP_QWORDMEMORY %token PARSEOP_RANGETYPE_ENTIRE %token PARSEOP_RANGETYPE_ISAONLY %token PARSEOP_RANGETYPE_NONISAONLY %token PARSEOP_RAW_DATA %token PARSEOP_READWRITETYPE_BOTH %token PARSEOP_READWRITETYPE_READONLY %token PARSEOP_REFOF %token PARSEOP_REGIONSPACE_CMOS %token PARSEOP_REGIONSPACE_EC %token PARSEOP_REGIONSPACE_IO %token PARSEOP_REGIONSPACE_MEM %token PARSEOP_REGIONSPACE_PCI %token PARSEOP_REGIONSPACE_PCIBAR %token PARSEOP_REGIONSPACE_SMBUS %token PARSEOP_REGISTER %token PARSEOP_RELEASE %token PARSEOP_RESERVED_BYTES %token PARSEOP_RESET %token PARSEOP_RESOURCETEMPLATE %token PARSEOP_RESOURCETYPE_CONSUMER %token PARSEOP_RESOURCETYPE_PRODUCER %token PARSEOP_RETURN %token PARSEOP_REVISION %token PARSEOP_SCOPE %token PARSEOP_SERIALIZERULE_NOTSERIAL %token PARSEOP_SERIALIZERULE_SERIAL %token PARSEOP_SHARETYPE_EXCLUSIVE %token PARSEOP_SHARETYPE_SHARED %token PARSEOP_SHIFTLEFT %token PARSEOP_SHIFTRIGHT %token PARSEOP_SIGNAL %token PARSEOP_SIZEOF %token PARSEOP_SLEEP %token PARSEOP_STALL %token PARSEOP_STARTDEPENDENTFN %token PARSEOP_STARTDEPENDENTFN_NOPRI %token PARSEOP_STORE %token PARSEOP_STRING_LITERAL %token PARSEOP_SUBTRACT %token PARSEOP_SWITCH %token PARSEOP_THERMALZONE %token PARSEOP_TOBCD %token PARSEOP_TOBUFFER %token PARSEOP_TODECIMALSTRING %token PARSEOP_TOHEXSTRING %token PARSEOP_TOINTEGER %token PARSEOP_TOSTRING %token PARSEOP_TRANSLATIONTYPE_DENSE %token PARSEOP_TRANSLATIONTYPE_SPARSE %token PARSEOP_TYPE_STATIC %token PARSEOP_TYPE_TRANSLATION %token PARSEOP_UNICODE %token PARSEOP_UNLOAD %token PARSEOP_UPDATERULE_ONES %token PARSEOP_UPDATERULE_PRESERVE %token PARSEOP_UPDATERULE_ZEROS %token PARSEOP_VAR_PACKAGE %token PARSEOP_VENDORLONG %token PARSEOP_VENDORSHORT %token PARSEOP_WAIT %token PARSEOP_WHILE %token PARSEOP_WORDBUSNUMBER %token PARSEOP_WORDCONST %token PARSEOP_WORDIO %token PARSEOP_XFERTYPE_8 %token PARSEOP_XFERTYPE_8_16 %token PARSEOP_XFERTYPE_16 %token PARSEOP_XOR %token PARSEOP_ZERO /* * Production names */ %type ASLCode %type DefinitionBlockTerm %type TermList %type Term %type CompilerDirective %type ObjectList %type Object %type DataObject %type BufferData %type PackageData %type IntegerData %type StringData %type NamedObject %type NameSpaceModifier %type UserTerm %type ArgList %type ArgListTail %type TermArg %type Target %type RequiredTarget %type SimpleTarget %type BufferTermData %type Type1Opcode %type Type2Opcode %type Type2IntegerOpcode %type Type2StringOpcode %type Type2BufferOpcode %type Type2BufferOrStringOpcode %type Type3Opcode /* Obsolete %type Type4Opcode */ %type Type5Opcode %type Type6Opcode %type LineTerm %type IncludeTerm %type IncludeCStyleTerm %type ExternalTerm %type FieldUnitList %type FieldUnitListTail %type FieldUnit %type FieldUnitEntry %type OffsetTerm %type AccessAsTerm %type OptionalAccessAttribTerm /* Named Objects */ %type BankFieldTerm %type CreateBitFieldTerm %type CreateByteFieldTerm %type CreateDWordFieldTerm %type CreateFieldTerm %type CreateQWordFieldTerm %type CreateWordFieldTerm %type DataRegionTerm %type DeviceTerm %type EventTerm %type FieldTerm %type IndexFieldTerm %type MethodTerm %type MutexTerm %type OpRegionTerm %type OpRegionSpaceIdTerm %type PowerResTerm %type ProcessorTerm %type ThermalZoneTerm /* Namespace modifiers */ %type AliasTerm %type NameTerm %type ScopeTerm /* Type 1 opcodes */ %type BreakTerm %type BreakPointTerm %type ContinueTerm %type FatalTerm %type IfElseTerm %type IfTerm %type ElseTerm %type LoadTerm %type NoOpTerm %type NotifyTerm %type ReleaseTerm %type ResetTerm %type ReturnTerm %type SignalTerm %type SleepTerm %type StallTerm %type SwitchTerm %type CaseTermList %type DefaultTermList %type CaseTerm %type DefaultTerm %type UnloadTerm %type WhileTerm /* Type 2 opcodes */ %type AcquireTerm %type AddTerm %type AndTerm %type ConcatTerm %type ConcatResTerm %type CondRefOfTerm %type CopyObjectTerm %type DecTerm %type DerefOfTerm %type DivideTerm %type FindSetLeftBitTerm %type FindSetRightBitTerm %type FromBCDTerm %type IncTerm %type IndexTerm %type LAndTerm %type LEqualTerm %type LGreaterTerm %type LGreaterEqualTerm %type LLessTerm %type LLessEqualTerm %type LNotTerm %type LNotEqualTerm %type LoadTableTerm %type LOrTerm %type MatchTerm %type MidTerm %type ModTerm %type MultiplyTerm %type NAndTerm %type NOrTerm %type NotTerm %type ObjectTypeTerm %type OrTerm %type RefOfTerm %type ShiftLeftTerm %type ShiftRightTerm %type SizeOfTerm %type StoreTerm %type SubtractTerm %type ToBCDTerm %type ToBufferTerm %type ToDecimalStringTerm %type ToHexStringTerm %type ToIntegerTerm %type ToStringTerm %type WaitTerm %type XOrTerm %type OptionalTermArg %type OptionalListString /* Keywords */ %type ObjectTypeKeyword %type AccessTypeKeyword %type AccessAttribKeyword %type LockRuleKeyword %type UpdateRuleKeyword %type RegionSpaceKeyword %type AddressSpaceKeyword %type MatchOpKeyword %type SerializeRuleKeyword %type DMATypeKeyword %type BusMasterKeyword %type XferTypeKeyword %type ResourceTypeKeyword %type MinKeyword %type MaxKeyword %type DecodeKeyword %type RangeTypeKeyword %type MemTypeKeyword %type ReadWriteKeyword %type InterruptTypeKeyword %type InterruptLevel %type ShareTypeKeyword %type IODecodeKeyword %type TypeKeyword %type TranslationKeyword %type AddressKeyword /* Types */ %type SuperName %type ArgTerm %type LocalTerm %type DebugTerm %type Integer %type ByteConst %type WordConst %type DWordConst %type QWordConst /* Useless %type WordConst %type QWordConst */ %type String %type ConstTerm %type ByteConstExpr %type WordConstExpr %type DWordConstExpr %type QWordConstExpr %type ConstExprTerm %type BufferTerm %type ByteList %type ByteListTail %type DWordList %type DWordListTail %type PackageTerm %type PackageLengthTerm %type PackageList %type PackageListTail %type PackageElement %type VarPackageLengthTerm %type EISAIDTerm %type ResourceTemplateTerm %type UnicodeTerm %type ResourceMacroList %type ResourceMacroTerm %type DMATerm %type DWordIOTerm %type DWordMemoryTerm %type EndDependentFnTerm %type FixedIOTerm %type InterruptTerm %type IOTerm %type IRQNoFlagsTerm %type IRQTerm %type Memory24Term %type Memory32FixedTerm %type Memory32Term %type QWordIOTerm %type QWordMemoryTerm %type RegisterTerm %type StartDependentFnTerm %type StartDependentFnNoPriTerm %type VendorLongTerm %type VendorShortTerm %type WordBusNumberTerm %type WordIOTerm %type NameString %type NameSeg /* Local types that help construct the AML, not in ACPI spec */ %type IncludeEndTerm %type AmlPackageLengthTerm %type OptionalByteConstExpr %type OptionalDWordConstExpr %type OptionalSerializeRuleKeyword %type OptionalResourceType_First %type OptionalMinType %type OptionalMaxType %type OptionalMemType %type OptionalCount %type OptionalDecodeType %type OptionalRangeType %type OptionalShareType %type OptionalType %type OptionalType_Last %type OptionalTranslationType_Last %type OptionalStringData %type OptionalNameString %type OptionalNameString_First %type OptionalNameString_Last %type OptionalAddressRange %type OptionalObjectTypeKeyword %type OptionalReference %type TermArgItem %type NameStringItem %% /******************************************************************************* * * Production rules start here * ******************************************************************************/ /* * ASL Names */ /* * Blocks, Data, and Opcodes */ ASLCode : DefinitionBlockTerm | error {YYABORT; $$ = NULL;} ; DefinitionBlockTerm : PARSEOP_DEFINITIONBLOCK '(' {$$ = TrCreateLeafNode (PARSEOP_DEFINITIONBLOCK);} String ',' String ',' ByteConst ',' String ',' String ',' DWordConst ')' {TrSetEndLineNumber ($3);} '{' ObjectList '}' {$$ = TrLinkChildren ($3,7,$4,$6,$8,$10,$12,$14,$18);} ; TermList : {$$ = NULL;} | Term TermList {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);} ; Term : Object {} | Type1Opcode {} | Type2Opcode {} | Type2IntegerOpcode {} | Type2StringOpcode {} | Type2BufferOpcode {} | Type2BufferOrStringOpcode {} | error {$$ = AslDoError(); yyclearin;} ; CompilerDirective : IncludeTerm {} | IncludeCStyleTerm {$$ = NULL;} | LineTerm {$$ = NULL;} | ExternalTerm {} ; ObjectList : {$$ = NULL;} | Object ObjectList {$$ = 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 {} | IndexFieldTerm {} | MethodTerm {} | MutexTerm {} | OpRegionTerm {} | PowerResTerm {} | ProcessorTerm {} | ThermalZoneTerm {} ; NameSpaceModifier : AliasTerm {} | NameTerm {} | ScopeTerm {} ; UserTerm : NameString '(' {TrUpdateNode (PARSEOP_METHODCALL, $1);} ArgList ')' {$$ = TrLinkChildNode ($1,$4);} ; ArgList : {$$ = NULL;} | TermArg ArgListTail {$$ = TrLinkPeerNode ($1,$2);} ; ArgListTail : {$$ = NULL;} | ',' TermArg ArgListTail {$$ = TrLinkPeerNode ($2,$3);} | ',' {$$ = NULL;} /* Allows a trailing comma at list end */ ; TermArg : Type2Opcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);} | 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);} | 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 {} ; /* 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 {} | WaitTerm {} | UserTerm {} ; /* * A type 2 opcode evaluates to an Integer and cannot have a destination operand */ 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 {} ; Type6Opcode : RefOfTerm {} | DerefOfTerm {} | IndexTerm {} | UserTerm {} ; IncludeTerm : PARSEOP_INCLUDE '(' {$$ = TrCreateLeafNode (PARSEOP_INCLUDE);} String ')' {$$ = TrLinkChildren ($3,1,$4);FlOpenIncludeFile ($4);} TermList IncludeEndTerm {$$ = TrLinkPeerNodes (3,$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 ')' {$$ = TrCreateNode (PARSEOP_EXTERNAL,2,$3,$4);} | PARSEOP_EXTERNAL '(' error ')' {$$ = AslDoError(); yyclearin;} ; /******* Named Objects *******************************************************/ BankFieldTerm : PARSEOP_BANKFIELD '(' {$$ = TrCreateLeafNode (PARSEOP_BANKFIELD);} NameString NameStringItem TermArgItem ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,7,$4,$5,$6,$8,$10,$12,$15);} | PARSEOP_BANKFIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; FieldUnitList : {$$ = NULL;} | FieldUnit FieldUnitListTail {$$ = TrLinkPeerNode ($1,$2);} ; FieldUnitListTail : {$$ = NULL;} | ',' {$$ = NULL;} /* Allows a trailing comma at list end */ | ',' FieldUnit FieldUnitListTail {$$ = TrLinkPeerNode ($2,$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 '(' {$$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} | PARSEOP_CREATEBITFIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; CreateByteFieldTerm : PARSEOP_CREATEBYTEFIELD '(' {$$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} | PARSEOP_CREATEBYTEFIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; CreateDWordFieldTerm : PARSEOP_CREATEDWORDFIELD '(' {$$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} | PARSEOP_CREATEDWORDFIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; CreateFieldTerm : PARSEOP_CREATEFIELD '(' {$$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);} TermArg TermArgItem TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,4,$4,$5,$6,TrSetNodeFlags ($7, NODE_IS_NAME_DECLARATION));} | PARSEOP_CREATEFIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; CreateQWordFieldTerm : PARSEOP_CREATEQWORDFIELD '(' {$$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} | PARSEOP_CREATEQWORDFIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; CreateWordFieldTerm : PARSEOP_CREATEWORDFIELD '(' {$$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));} | PARSEOP_CREATEWORDFIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; DataRegionTerm : PARSEOP_DATATABLEREGION '(' {$$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);} NameString TermArgItem TermArgItem TermArgItem ')' {$$ = TrLinkChildren ($3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$6,$7);} | PARSEOP_DATATABLEREGION '(' error ')' {$$ = AslDoError(); yyclearin;} ; DeviceTerm : PARSEOP_DEVICE '(' {$$ = TrCreateLeafNode (PARSEOP_DEVICE);} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);} | PARSEOP_DEVICE '(' error ')' {$$ = AslDoError(); yyclearin;} ; EventTerm : PARSEOP_EVENT '(' {$$ = TrCreateLeafNode (PARSEOP_EVENT);} NameString ')' {$$ = TrLinkChildren ($3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));} | PARSEOP_EVENT '(' error ')' {$$ = AslDoError(); yyclearin;} ; FieldTerm : PARSEOP_FIELD '(' {$$ = TrCreateLeafNode (PARSEOP_FIELD);} NameString ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$8,$10,$13);} | PARSEOP_FIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; IndexFieldTerm : PARSEOP_INDEXFIELD '(' {$$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);} NameString NameStringItem ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,6,$4,$5,$7,$9,$11,$14);} | PARSEOP_INDEXFIELD '(' error ')' {$$ = AslDoError(); yyclearin;} ; MethodTerm : PARSEOP_METHOD '(' {$$ = TrCreateLeafNode (PARSEOP_METHOD);} NameString OptionalByteConstExpr {$$ = UtCheckIntegerRange ($5, 0, 7);} OptionalSerializeRuleKeyword OptionalByteConstExpr ')' '{' TermList '}' {$$ = TrLinkChildren ($3,5,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$7,$8,$11);} | PARSEOP_METHOD '(' error ')' {$$ = AslDoError(); yyclearin;} ; MutexTerm : PARSEOP_MUTEX '(' {$$ = TrCreateLeafNode (PARSEOP_MUTEX);} NameString ',' ByteConstExpr ')' {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);} | PARSEOP_MUTEX '(' error ')' {$$ = AslDoError(); yyclearin;} ; OpRegionTerm : PARSEOP_OPERATIONREGION '(' {$$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);} NameString ',' OpRegionSpaceIdTerm TermArgItem TermArgItem ')' {$$ = TrLinkChildren ($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 '(' {$$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);} NameString ',' ByteConstExpr ',' WordConstExpr ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$8,$11);} | PARSEOP_POWERRESOURCE '(' error ')' {$$ = AslDoError(); yyclearin;} ; ProcessorTerm : PARSEOP_PROCESSOR '(' {$$ = TrCreateLeafNode (PARSEOP_PROCESSOR);} NameString ',' ByteConstExpr OptionalDWordConstExpr OptionalByteConstExpr ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,5,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8,$11);} | PARSEOP_PROCESSOR '(' error ')' {$$ = AslDoError(); yyclearin;} ; ThermalZoneTerm : PARSEOP_THERMALZONE '(' {$$ = TrCreateLeafNode (PARSEOP_THERMALZONE);} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);} | PARSEOP_THERMALZONE '(' error ')' {$$ = AslDoError(); yyclearin;} ; /******* Namespace modifiers *************************************************/ AliasTerm : PARSEOP_ALIAS '(' {$$ = TrCreateLeafNode (PARSEOP_ALIAS);} NameString NameStringItem ')' {$$ = TrLinkChildren ($3,2,$4,TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));} | PARSEOP_ALIAS '(' error ')' {$$ = AslDoError(); yyclearin;} ; NameTerm : PARSEOP_NAME '(' {$$ = TrCreateLeafNode (PARSEOP_NAME);} NameString ',' DataObject ')' {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);} | PARSEOP_NAME '(' error ')' {$$ = AslDoError(); yyclearin;} ; ScopeTerm : PARSEOP_SCOPE '(' {$$ = TrCreateLeafNode (PARSEOP_SCOPE);} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($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 '(' {$$ = TrCreateLeafNode (PARSEOP_FATAL);} ByteConstExpr ',' DWordConstExpr TermArgItem ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7);} | PARSEOP_FATAL '(' error ')' {$$ = AslDoError(); yyclearin;} ; IfElseTerm : IfTerm ElseTerm {$$ = TrLinkPeerNode ($1,$2);} ; IfTerm : PARSEOP_IF '(' {$$ = TrCreateLeafNode (PARSEOP_IF);} TermArg ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_IF '(' error ')' {$$ = AslDoError(); yyclearin;} ; ElseTerm : {$$ = NULL;} | PARSEOP_ELSE '{' {$$ = TrCreateLeafNode (PARSEOP_ELSE);} TermList '}' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_ELSEIF '(' {$$ = TrCreateLeafNode (PARSEOP_ELSEIF);} TermArg ')' '{' TermList '}' ElseTerm {$$ = TrLinkChildren ($3,3,$4,$7,$9);} | PARSEOP_ELSEIF '(' error ')' {$$ = AslDoError(); yyclearin;} ; LoadTerm : PARSEOP_LOAD '(' {$$ = TrCreateLeafNode (PARSEOP_LOAD);} NameString RequiredTarget ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_LOAD '(' error ')' {$$ = AslDoError(); yyclearin;} ; NoOpTerm : PARSEOP_NOOP {$$ = TrCreateNode (PARSEOP_NOOP, 0);} ; NotifyTerm : PARSEOP_NOTIFY '(' {$$ = TrCreateLeafNode (PARSEOP_NOTIFY);} SuperName TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_NOTIFY '(' error ')' {$$ = AslDoError(); yyclearin;} ; ReleaseTerm : PARSEOP_RELEASE '(' {$$ = TrCreateLeafNode (PARSEOP_RELEASE);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_RELEASE '(' error ')' {$$ = AslDoError(); yyclearin;} ; ResetTerm : PARSEOP_RESET '(' {$$ = TrCreateLeafNode (PARSEOP_RESET);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_RESET '(' error ')' {$$ = AslDoError(); yyclearin;} ; ReturnTerm : PARSEOP_RETURN '(' {$$ = TrCreateLeafNode (PARSEOP_RETURN);} OptionalTermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_RETURN '(' error ')' {$$ = AslDoError(); yyclearin;} ; SignalTerm : PARSEOP_SIGNAL '(' {$$ = TrCreateLeafNode (PARSEOP_SIGNAL);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_SIGNAL '(' error ')' {$$ = AslDoError(); yyclearin;} ; SleepTerm : PARSEOP_SLEEP '(' {$$ = TrCreateLeafNode (PARSEOP_SLEEP);} TermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_SLEEP '(' error ')' {$$ = AslDoError(); yyclearin;} ; StallTerm : PARSEOP_STALL '(' {$$ = TrCreateLeafNode (PARSEOP_STALL);} TermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_STALL '(' error ')' {$$ = AslDoError(); yyclearin;} ; SwitchTerm : PARSEOP_SWITCH '(' {$$ = TrCreateLeafNode (PARSEOP_SWITCH);} TermArg ')' '{' CaseTermList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_SWITCH '(' error ')' {$$ = AslDoError(); yyclearin;} ; CaseTermList : {$$ = NULL;} | CaseTerm {} | DefaultTerm DefaultTermList {$$ = TrLinkPeerNode ($1,$2);} | CaseTerm CaseTermList {$$ = TrLinkPeerNode ($1,$2);} ; DefaultTermList : {$$ = NULL;} | CaseTerm {} | CaseTerm DefaultTermList {$$ = TrLinkPeerNode ($1,$2);} ; CaseTerm : PARSEOP_CASE '(' {$$ = TrCreateLeafNode (PARSEOP_CASE);} DataObject ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_CASE '(' error ')' {$$ = AslDoError(); yyclearin;} ; DefaultTerm : PARSEOP_DEFAULT '{' {$$ = TrCreateLeafNode (PARSEOP_DEFAULT);} TermList '}' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_DEFAULT '(' error ')' {$$ = AslDoError(); yyclearin;} ; UnloadTerm : PARSEOP_UNLOAD '(' {$$ = TrCreateLeafNode (PARSEOP_UNLOAD);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_UNLOAD '(' error ')' {$$ = AslDoError(); yyclearin;} ; WhileTerm : PARSEOP_WHILE '(' {$$ = TrCreateLeafNode (PARSEOP_WHILE);} TermArg ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_WHILE '(' error ')' {$$ = AslDoError(); yyclearin;} ; /******* Type 2 opcodes *******************************************************/ AcquireTerm : PARSEOP_ACQUIRE '(' {$$ = TrCreateLeafNode (PARSEOP_ACQUIRE);} SuperName ',' WordConstExpr ')' {$$ = TrLinkChildren ($3,2,$4,$6);} | PARSEOP_ACQUIRE '(' error ')' {$$ = AslDoError(); yyclearin;} ; AddTerm : PARSEOP_ADD '(' {$$ = TrCreateLeafNode (PARSEOP_ADD);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_ADD '(' error ')' {$$ = AslDoError(); yyclearin;} ; AndTerm : PARSEOP_AND '(' {$$ = TrCreateLeafNode (PARSEOP_AND);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_AND '(' error ')' {$$ = AslDoError(); yyclearin;} ; ConcatTerm : PARSEOP_CONCATENATE '(' {$$ = TrCreateLeafNode (PARSEOP_CONCATENATE);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_CONCATENATE '(' error ')' {$$ = AslDoError(); yyclearin;} ; ConcatResTerm : PARSEOP_CONCATENATERESTEMPLATE '(' {$$ = TrCreateLeafNode (PARSEOP_CONCATENATERESTEMPLATE);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_CONCATENATERESTEMPLATE '(' error ')' {$$ = AslDoError(); yyclearin;} ; CondRefOfTerm : PARSEOP_CONDREFOF '(' {$$ = TrCreateLeafNode (PARSEOP_CONDREFOF);} SuperName Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_CONDREFOF '(' error ')' {$$ = AslDoError(); yyclearin;} ; CopyObjectTerm : PARSEOP_COPYOBJECT '(' {$$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);} TermArg ',' SimpleTarget ')' {$$ = TrLinkChildren ($3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));} | PARSEOP_COPYOBJECT '(' error ')' {$$ = AslDoError(); yyclearin;} ; DecTerm : PARSEOP_DECREMENT '(' {$$ = TrCreateLeafNode (PARSEOP_DECREMENT);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_DECREMENT '(' error ')' {$$ = AslDoError(); yyclearin;} ; DerefOfTerm : PARSEOP_DEREFOF '(' {$$ = TrCreateLeafNode (PARSEOP_DEREFOF);} TermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_DEREFOF '(' error ')' {$$ = AslDoError(); yyclearin;} ; DivideTerm : PARSEOP_DIVIDE '(' {$$ = TrCreateLeafNode (PARSEOP_DIVIDE);} TermArg TermArgItem Target Target ')' {$$ = TrLinkChildren ($3,4,$4,$5,$6,$7);} | PARSEOP_DIVIDE '(' error ')' {$$ = AslDoError(); yyclearin;} ; FindSetLeftBitTerm : PARSEOP_FINDSETLEFTBIT '(' {$$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_FINDSETLEFTBIT '(' error ')' {$$ = AslDoError(); yyclearin;} ; FindSetRightBitTerm : PARSEOP_FINDSETRIGHTBIT '(' {$$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_FINDSETRIGHTBIT '(' error ')' {$$ = AslDoError(); yyclearin;} ; FromBCDTerm : PARSEOP_FROMBCD '(' {$$ = TrCreateLeafNode (PARSEOP_FROMBCD);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_FROMBCD '(' error ')' {$$ = AslDoError(); yyclearin;} ; IncTerm : PARSEOP_INCREMENT '(' {$$ = TrCreateLeafNode (PARSEOP_INCREMENT);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_INCREMENT '(' error ')' {$$ = AslDoError(); yyclearin;} ; IndexTerm : PARSEOP_INDEX '(' {$$ = TrCreateLeafNode (PARSEOP_INDEX);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_INDEX '(' error ')' {$$ = AslDoError(); yyclearin;} ; LAndTerm : PARSEOP_LAND '(' {$$ = TrCreateLeafNode (PARSEOP_LAND);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_LAND '(' error ')' {$$ = AslDoError(); yyclearin;} ; LEqualTerm : PARSEOP_LEQUAL '(' {$$ = TrCreateLeafNode (PARSEOP_LEQUAL);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_LEQUAL '(' error ')' {$$ = AslDoError(); yyclearin;} ; LGreaterTerm : PARSEOP_LGREATER '(' {$$ = TrCreateLeafNode (PARSEOP_LGREATER);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_LGREATER '(' error ')' {$$ = AslDoError(); yyclearin;} ; LGreaterEqualTerm : PARSEOP_LGREATEREQUAL '(' {$$ = TrCreateLeafNode (PARSEOP_LLESS);} TermArg TermArgItem ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($3,2,$4,$5));} | PARSEOP_LGREATEREQUAL '(' error ')' {$$ = AslDoError(); yyclearin;} ; LLessTerm : PARSEOP_LLESS '(' {$$ = TrCreateLeafNode (PARSEOP_LLESS);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_LLESS '(' error ')' {$$ = AslDoError(); yyclearin;} ; LLessEqualTerm : PARSEOP_LLESSEQUAL '(' {$$ = TrCreateLeafNode (PARSEOP_LGREATER);} TermArg TermArgItem ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($3,2,$4,$5));} | PARSEOP_LLESSEQUAL '(' error ')' {$$ = AslDoError(); yyclearin;} ; LNotTerm : PARSEOP_LNOT '(' {$$ = TrCreateLeafNode (PARSEOP_LNOT);} TermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_LNOT '(' error ')' {$$ = AslDoError(); yyclearin;} ; LNotEqualTerm : PARSEOP_LNOTEQUAL '(' {$$ = TrCreateLeafNode (PARSEOP_LEQUAL);} TermArg TermArgItem ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($3,2,$4,$5));} | PARSEOP_LNOTEQUAL '(' error ')' {$$ = AslDoError(); yyclearin;} ; LoadTableTerm : PARSEOP_LOADTABLE '(' {$$ = TrCreateLeafNode (PARSEOP_LOADTABLE);} TermArg TermArgItem TermArgItem OptionalListString OptionalListString OptionalReference ')' {$$ = TrLinkChildren ($3,6,$4,$5,$6,$7,$8,$9);} | PARSEOP_LOADTABLE '(' error ')' {$$ = AslDoError(); yyclearin;} ; LOrTerm : PARSEOP_LOR '(' {$$ = TrCreateLeafNode (PARSEOP_LOR);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_LOR '(' error ')' {$$ = AslDoError(); yyclearin;} ; MatchTerm : PARSEOP_MATCH '(' {$$ = TrCreateLeafNode (PARSEOP_MATCH);} TermArg ',' MatchOpKeyword TermArgItem ',' MatchOpKeyword TermArgItem TermArgItem ')' {$$ = TrLinkChildren ($3,6,$4,$6,$7,$9,$10,$11);} | PARSEOP_MATCH '(' error ')' {$$ = AslDoError(); yyclearin;} ; MidTerm : PARSEOP_MID '(' {$$ = TrCreateLeafNode (PARSEOP_MID);} TermArg TermArgItem TermArgItem Target ')' {$$ = TrLinkChildren ($3,4,$4,$5,$6,$7);} | PARSEOP_MID '(' error ')' {$$ = AslDoError(); yyclearin;} ; ModTerm : PARSEOP_MOD '(' {$$ = TrCreateLeafNode (PARSEOP_MOD);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_MOD '(' error ')' {$$ = AslDoError(); yyclearin;} ; MultiplyTerm : PARSEOP_MULTIPLY '(' {$$ = TrCreateLeafNode (PARSEOP_MULTIPLY);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_MULTIPLY '(' error ')' {$$ = AslDoError(); yyclearin;} ; NAndTerm : PARSEOP_NAND '(' {$$ = TrCreateLeafNode (PARSEOP_NAND);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_NAND '(' error ')' {$$ = AslDoError(); yyclearin;} ; NOrTerm : PARSEOP_NOR '(' {$$ = TrCreateLeafNode (PARSEOP_NOR);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_NOR '(' error ')' {$$ = AslDoError(); yyclearin;} ; NotTerm : PARSEOP_NOT '(' {$$ = TrCreateLeafNode (PARSEOP_NOT);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_NOT '(' error ')' {$$ = AslDoError(); yyclearin;} ; ObjectTypeTerm : PARSEOP_OBJECTTYPE '(' {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_OBJECTTYPE '(' error ')' {$$ = AslDoError(); yyclearin;} ; OrTerm : PARSEOP_OR '(' {$$ = TrCreateLeafNode (PARSEOP_OR);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($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 '(' {$$ = TrCreateLeafNode (PARSEOP_REFOF);} SuperName ')' {$$ = TrLinkChildren ($3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));} | PARSEOP_REFOF '(' error ')' {$$ = AslDoError(); yyclearin;} ; ShiftLeftTerm : PARSEOP_SHIFTLEFT '(' {$$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_SHIFTLEFT '(' error ')' {$$ = AslDoError(); yyclearin;} ; ShiftRightTerm : PARSEOP_SHIFTRIGHT '(' {$$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_SHIFTRIGHT '(' error ')' {$$ = AslDoError(); yyclearin;} ; SizeOfTerm : PARSEOP_SIZEOF '(' {$$ = TrCreateLeafNode (PARSEOP_SIZEOF);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | PARSEOP_SIZEOF '(' error ')' {$$ = AslDoError(); yyclearin;} ; StoreTerm : PARSEOP_STORE '(' {$$ = TrCreateLeafNode (PARSEOP_STORE);} TermArg ',' SuperName ')' {$$ = TrLinkChildren ($3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));} | PARSEOP_STORE '(' error ')' {$$ = AslDoError(); yyclearin;} ; SubtractTerm : PARSEOP_SUBTRACT '(' {$$ = TrCreateLeafNode (PARSEOP_SUBTRACT);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_SUBTRACT '(' error ')' {$$ = AslDoError(); yyclearin;} ; ToBCDTerm : PARSEOP_TOBCD '(' {$$ = TrCreateLeafNode (PARSEOP_TOBCD);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_TOBCD '(' error ')' {$$ = AslDoError(); yyclearin;} ; ToBufferTerm : PARSEOP_TOBUFFER '(' {$$ = TrCreateLeafNode (PARSEOP_TOBUFFER);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_TOBUFFER '(' error ')' {$$ = AslDoError(); yyclearin;} ; ToDecimalStringTerm : PARSEOP_TODECIMALSTRING '(' {$$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_TODECIMALSTRING '(' error ')' {$$ = AslDoError(); yyclearin;} ; ToHexStringTerm : PARSEOP_TOHEXSTRING '(' {$$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_TOHEXSTRING '(' error ')' {$$ = AslDoError(); yyclearin;} ; ToIntegerTerm : PARSEOP_TOINTEGER '(' {$$ = TrCreateLeafNode (PARSEOP_TOINTEGER);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_TOINTEGER '(' error ')' {$$ = AslDoError(); yyclearin;} ; ToStringTerm : PARSEOP_TOSTRING '(' {$$ = TrCreateLeafNode (PARSEOP_TOSTRING);} TermArg OptionalCount Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | PARSEOP_TOSTRING '(' error ')' {$$ = AslDoError(); yyclearin;} ; WaitTerm : PARSEOP_WAIT '(' {$$ = TrCreateLeafNode (PARSEOP_WAIT);} SuperName TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | PARSEOP_WAIT '(' error ')' {$$ = AslDoError(); yyclearin;} ; XOrTerm : PARSEOP_XOR '(' {$$ = TrCreateLeafNode (PARSEOP_XOR);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($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_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);} ; 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);} ; BusMasterKeyword : PARSEOP_BUSMASTERTYPE_MASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);} | PARSEOP_BUSMASTERTYPE_NOTMASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_NOTMASTER);} ; 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);} ; ReadWriteKeyword : 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, 0xFFFFFFFFFFFFFFFF);} ; /* 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 '(' {$$ = TrCreateLeafNode (PARSEOP_BUFFER);} OptionalTermArg ')' '{' BufferTermData '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_BUFFER '(' error ')' {$$ = AslDoError(); yyclearin;} ; BufferTermData : ByteList {} | StringData {} ; ByteList : {$$ = NULL;} | ByteConstExpr ByteListTail {$$ = TrLinkPeerNode ($1,$2);} ; ByteListTail : {$$ = NULL;} | ',' {$$ = NULL;} /* Allows a trailing comma at list end */ | ',' ByteConstExpr ByteListTail {$$ = TrLinkPeerNode ($2,$3);} ; DWordList : {$$ = NULL;} | DWordConstExpr DWordListTail {$$ = TrLinkPeerNode ($1,$2);} ; DWordListTail : {$$ = NULL;} | ',' {$$ = NULL;} /* Allows a trailing comma at list end */ | ',' DWordConstExpr DWordListTail {$$ = TrLinkPeerNode ($2,$3);} ; PackageTerm : PARSEOP_PACKAGE '(' {$$ = TrCreateLeafNode (PARSEOP_PACKAGE);} PackageLengthTerm ')' '{' PackageList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_PACKAGE '(' {$$ = TrCreateLeafNode (PARSEOP_VAR_PACKAGE);} VarPackageLengthTerm ')' '{' PackageList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_PACKAGE '(' error ')' {$$ = AslDoError(); yyclearin;} ; PackageLengthTerm : {$$ = NULL;} | ByteConstExpr {} ; VarPackageLengthTerm : TermArg {} ; PackageList : {$$ = NULL;} | PackageElement PackageListTail {$$ = TrLinkPeerNode ($1,$2);} ; PackageListTail : {$$ = NULL;} | ',' {$$ = NULL;} /* Allows a trailing comma at list end */ | ',' PackageElement PackageListTail {$$ = TrLinkPeerNode ($2,$3);} ; PackageElement : DataObject {} | NameString {} ; EISAIDTerm : PARSEOP_EISAID '(' StringData ')' {$$ = TrUpdateNode (PARSEOP_EISAID, $3);} | PARSEOP_EISAID '(' error ')' {$$ = AslDoError(); yyclearin;} ; /******* Resources and Memory ***********************************************/ ResourceTemplateTerm : PARSEOP_RESOURCETEMPLATE '(' ')' '{' ResourceMacroList '}' {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,3, TrCreateLeafNode (PARSEOP_DEFAULT_ARG), TrCreateLeafNode (PARSEOP_DEFAULT_ARG),$5);} ; UnicodeTerm : PARSEOP_UNICODE '(' {$$ = TrCreateLeafNode (PARSEOP_UNICODE);} StringData ')' {$$ = TrLinkChildren ($3,2,0,$4);} | PARSEOP_UNICODE '(' error ')' {$$ = AslDoError(); yyclearin;} ; ResourceMacroList : {$$ = NULL;} | ResourceMacroTerm ResourceMacroList {$$ = TrLinkPeerNode ($1,$2);} ; ResourceMacroTerm : DMATerm {} | DWordIOTerm {} | DWordMemoryTerm {} | EndDependentFnTerm {} | FixedIOTerm {} | InterruptTerm {} | IOTerm {} | IRQNoFlagsTerm {} | IRQTerm {} | Memory24Term {} | Memory32FixedTerm {} | Memory32Term {} | QWordIOTerm {} | QWordMemoryTerm {} | RegisterTerm {} | StartDependentFnTerm {} | StartDependentFnNoPriTerm {} | VendorLongTerm {} | VendorShortTerm {} | WordBusNumberTerm {} | WordIOTerm {} ; DMATerm : PARSEOP_DMA '(' {$$ = TrCreateLeafNode (PARSEOP_DMA);} DMATypeKeyword ',' BusMasterKeyword ',' XferTypeKeyword OptionalNameString_Last ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$8,$9,$12);} | PARSEOP_DMA '(' error ')' {$$ = AslDoError(); yyclearin;} ; DWordIOTerm : PARSEOP_DWORDIO '(' {$$ = TrCreateLeafNode (PARSEOP_DWORDIO);} OptionalResourceType_First OptionalMinType OptionalMaxType OptionalDecodeType OptionalRangeType ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr OptionalByteConstExpr OptionalStringData OptionalNameString OptionalType OptionalTranslationType_Last ')' {$$ = TrLinkChildren ($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 '(' {$$ = TrCreateLeafNode (PARSEOP_DWORDMEMORY);} OptionalResourceType_First OptionalDecodeType OptionalMinType OptionalMaxType OptionalMemType ',' ReadWriteKeyword ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr OptionalByteConstExpr OptionalStringData OptionalNameString OptionalAddressRange OptionalType_Last ')' {$$ = TrLinkChildren ($3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);} | PARSEOP_DWORDMEMORY '(' error ')' {$$ = AslDoError(); yyclearin;} ; EndDependentFnTerm : PARSEOP_ENDDEPENDENTFN '(' ')' {$$ = TrCreateLeafNode (PARSEOP_ENDDEPENDENTFN);} | PARSEOP_ENDDEPENDENTFN '(' error ')' {$$ = AslDoError(); yyclearin;} ; FixedIOTerm : PARSEOP_FIXEDIO '(' {$$ = TrCreateLeafNode (PARSEOP_FIXEDIO);} WordConstExpr ',' ByteConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7);} | PARSEOP_FIXEDIO '(' error ')' {$$ = AslDoError(); yyclearin;} ; InterruptTerm : PARSEOP_INTERRUPT '(' {$$ = TrCreateLeafNode (PARSEOP_INTERRUPT);} OptionalResourceType_First ',' InterruptTypeKeyword ',' InterruptLevel OptionalShareType OptionalByteConstExpr OptionalStringData OptionalNameString_Last ')' '{' DWordList '}' {$$ = TrLinkChildren ($3,8,$4,$6,$8,$9,$10,$11,$12,$15);} | PARSEOP_INTERRUPT '(' error ')' {$$ = AslDoError(); yyclearin;} ; IOTerm : PARSEOP_IO '(' {$$ = TrCreateLeafNode (PARSEOP_IO);} IODecodeKeyword ',' WordConstExpr ',' WordConstExpr ',' ByteConstExpr ',' ByteConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);} | PARSEOP_IO '(' error ')' {$$ = AslDoError(); yyclearin;} ; IRQNoFlagsTerm : PARSEOP_IRQNOFLAGS '(' {$$ = TrCreateLeafNode (PARSEOP_IRQNOFLAGS);} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_IRQNOFLAGS '(' error ')' {$$ = AslDoError(); yyclearin;} ; IRQTerm : PARSEOP_IRQ '(' {$$ = TrCreateLeafNode (PARSEOP_IRQ);} InterruptTypeKeyword ',' InterruptLevel OptionalShareType OptionalNameString_Last ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$7,$8,$11);} | PARSEOP_IRQ '(' error ')' {$$ = AslDoError(); yyclearin;} ; Memory24Term : PARSEOP_MEMORY24 '(' {$$ = TrCreateLeafNode (PARSEOP_MEMORY24);} ReadWriteKeyword ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);} | PARSEOP_MEMORY24 '(' error ')' {$$ = AslDoError(); yyclearin;} ; Memory32FixedTerm : PARSEOP_MEMORY32FIXED '(' {$$ = TrCreateLeafNode (PARSEOP_MEMORY32FIXED);} ReadWriteKeyword ',' DWordConstExpr ',' DWordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$9);} | PARSEOP_MEMORY32FIXED '(' error ')' {$$ = AslDoError(); yyclearin;} ; Memory32Term : PARSEOP_MEMORY32 '(' {$$ = TrCreateLeafNode (PARSEOP_MEMORY32);} ReadWriteKeyword ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);} | PARSEOP_MEMORY32 '(' error ')' {$$ = AslDoError(); yyclearin;} ; QWordIOTerm : PARSEOP_QWORDIO '(' {$$ = TrCreateLeafNode (PARSEOP_QWORDIO);} OptionalResourceType_First OptionalMinType OptionalMaxType OptionalDecodeType OptionalRangeType ',' QWordConstExpr ',' QWordConstExpr ',' QWordConstExpr ',' QWordConstExpr ',' QWordConstExpr OptionalByteConstExpr OptionalStringData OptionalNameString OptionalType OptionalTranslationType_Last ')' {$$ = TrLinkChildren ($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 '(' {$$ = TrCreateLeafNode (PARSEOP_QWORDMEMORY);} OptionalResourceType_First OptionalDecodeType OptionalMinType OptionalMaxType OptionalMemType ',' ReadWriteKeyword ',' QWordConstExpr ',' QWordConstExpr ',' QWordConstExpr ',' QWordConstExpr ',' QWordConstExpr OptionalByteConstExpr OptionalStringData OptionalNameString OptionalAddressRange OptionalType_Last ')' {$$ = TrLinkChildren ($3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);} | PARSEOP_QWORDMEMORY '(' error ')' {$$ = AslDoError(); yyclearin;} ; RegisterTerm : PARSEOP_REGISTER '(' {$$ = TrCreateLeafNode (PARSEOP_REGISTER);} AddressSpaceKeyword ',' ByteConstExpr ',' ByteConstExpr ',' QWordConstExpr ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$10);} | PARSEOP_REGISTER '(' error ')' {$$ = AslDoError(); yyclearin;} ; StartDependentFnTerm : PARSEOP_STARTDEPENDENTFN '(' {$$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN);} ByteConstExpr ',' ByteConstExpr ')' '{' ResourceMacroList '}' {$$ = TrLinkChildren ($3,3,$4,$6,$9);} | PARSEOP_STARTDEPENDENTFN '(' error ')' {$$ = AslDoError(); yyclearin;} ; StartDependentFnNoPriTerm : PARSEOP_STARTDEPENDENTFN_NOPRI '(' {$$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);} ')' '{' ResourceMacroList '}' {$$ = TrLinkChildren ($3,1,$6);} | PARSEOP_STARTDEPENDENTFN_NOPRI '(' error ')' {$$ = AslDoError(); yyclearin;} ; VendorLongTerm : PARSEOP_VENDORLONG '(' {$$ = TrCreateLeafNode (PARSEOP_VENDORLONG);} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_VENDORLONG '(' error ')' {$$ = AslDoError(); yyclearin;} ; VendorShortTerm : PARSEOP_VENDORSHORT '(' {$$ = TrCreateLeafNode (PARSEOP_VENDORSHORT);} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PARSEOP_VENDORSHORT '(' error ')' {$$ = AslDoError(); yyclearin;} ; WordBusNumberTerm : PARSEOP_WORDBUSNUMBER '(' {$$ = TrCreateLeafNode (PARSEOP_WORDBUSNUMBER);} OptionalResourceType_First OptionalMinType OptionalMaxType OptionalDecodeType ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr OptionalByteConstExpr OptionalStringData OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,12,$4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);} | PARSEOP_WORDBUSNUMBER '(' error ')' {$$ = AslDoError(); yyclearin;} ; WordIOTerm : PARSEOP_WORDIO '(' {$$ = TrCreateLeafNode (PARSEOP_WORDIO);} OptionalResourceType_First OptionalMinType OptionalMaxType OptionalDecodeType OptionalRangeType ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr OptionalByteConstExpr OptionalStringData OptionalNameString OptionalType OptionalTranslationType_Last ')' {$$ = TrLinkChildren ($3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);} | PARSEOP_WORDIO '(' error ')' {$$ = AslDoError(); yyclearin;} ; /******* Object References ***********************************************/ NameString : NameSeg {} | PARSEOP_NAMESTRING {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) AslCompilerlval.s);} ; NameSeg : PARSEOP_NAMESEG {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESEG, (ACPI_NATIVE_INT) AslCompilerlval.s);} ; /******* Helper rules ****************************************************/ AmlPackageLengthTerm : Integer {$$ = TrUpdateNode (PARSEOP_PACKAGE_LENGTH,(ACPI_PARSE_OBJECT *) $1);} ; OptionalAccessAttribTerm : {$$ = NULL;} | ',' {$$ = NULL;} | ',' ByteConstExpr {$$ = $2;} | ',' AccessAttribKeyword {$$ = $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;} ; OptionalRangeType : ',' {$$ = NULL;} | ',' RangeTypeKeyword {$$ = $2;} ; OptionalReference : {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */ | ',' {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */ | ',' DataObject {$$ = $2;} | ',' NameString {$$ = $2;} ; OptionalResourceType_First : {$$ = NULL;} | ResourceTypeKeyword {$$ = $1;} ; OptionalSerializeRuleKeyword : {$$ = NULL;} | ',' {$$ = NULL;} | ',' SerializeRuleKeyword {$$ = $2;} ; OptionalShareType : {$$ = NULL;} | ',' {$$ = NULL;} | ',' ShareTypeKeyword {$$ = $2;} ; OptionalStringData : {$$ = NULL;} | ',' {$$ = NULL;} | ',' StringData {$$ = $2;} ; OptionalTermArg : {$$ = NULL;} | 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 %d\n\n", Size); Mem = ACPI_MEM_CALLOCATE (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)); }