%{ /****************************************************************************** * * Module Name: aslcompiler.y - Bison input file (ASL grammar and actions) * $Revision: 1.37 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 2000, 2001, 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 COMPILER 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; ASL_PARSE_NODE *n; } /* * Token types: These are returned by the lexer */ %token ACCESSAS %token ACCESSATTRIB_BLOCK %token ACCESSATTRIB_BYTE %token ACCESSATTRIB_CALL %token ACCESSATTRIB_QUICK %token ACCESSATTRIB_SND_RCV %token ACCESSATTRIB_WORD %token ACCESSTYPE_ANY %token ACCESSTYPE_BUF %token ACCESSTYPE_BYTE %token ACCESSTYPE_DWORD %token ACCESSTYPE_QWORD %token ACCESSTYPE_WORD %token ACQUIRE %token ADD %token ADDRESSSPACE_FFIXEDHW %token ADDRESSTYPE_ACPI %token ADDRESSTYPE_MEMORY %token ADDRESSTYPE_NVS %token ADDRESSTYPE_RESERVED %token ALIAS %token AND %token ARG0 %token ARG1 %token ARG2 %token ARG3 %token ARG4 %token ARG5 %token ARG6 %token BANKFIELD %token BREAK %token BREAKPOINT %token BUFFER %token BUSMASTERTYPE_MASTER %token BUSMASTERTYPE_NOTMASTER %token BYTECONST %token CASE %token CONCATENATE %token CONCATENATERESTEMPLATE %token CONDREFOF %token CONTINUE %token COPYOBJECT %token CREATEBITFIELD %token CREATEBYTEFIELD %token CREATEDWORDFIELD %token CREATEFIELD %token CREATEQWORDFIELD %token CREATEWORDFIELD %token DATATABLEREGION %token DEBUG %token DECODETYPE_POS %token DECODETYPE_SUB %token DECREMENT %token DEFAULT %token DEFAULT_ARG %token DEFINITIONBLOCK %token DEREFOF %token DEVICE %token DIVIDE %token DMA %token DMATYPE_A %token DMATYPE_COMPATIBILITY %token DMATYPE_B %token DMATYPE_F %token DWORDCONST %token DWORDIO %token DWORDMEMORY %token EISAID %token ELSE %token ELSEIF %token ENDDEPENDENTFN %token ERRORNODE %token EVENT %token EXTERNAL %token FATAL %token FIELD %token FINDSETLEFTBIT %token FINDSETRIGHTBIT %token FIXEDIO %token FROMBCD %token IF %token INCLUDE %token INCLUDE_CSTYLE %token INCLUDE_END %token INCREMENT %token INDEX %token INDEXFIELD %token INTEGER %token INTERRUPT %token INTLEVEL_ACTIVEHIGH %token INTLEVEL_ACTIVELOW %token INTTYPE_EDGE %token INTTYPE_LEVEL %token IO %token IODECODETYPE_10 %token IODECODETYPE_16 %token IRQ %token IRQNOFLAGS %token LAND %token LEQUAL %token LGREATER %token LGREATEREQUAL %token LLESS %token LLESSEQUAL %token LNOT %token LNOTEQUAL %token LOAD %token LOADTABLE %token LOCAL0 %token LOCAL1 %token LOCAL2 %token LOCAL3 %token LOCAL4 %token LOCAL5 %token LOCAL6 %token LOCAL7 %token LOCKRULE_LOCK %token LOCKRULE_NOLOCK %token LOR %token MATCH %token MATCHTYPE_MEQ %token MATCHTYPE_MGE %token MATCHTYPE_MGT %token MATCHTYPE_MLE %token MATCHTYPE_MLT %token MATCHTYPE_MTR %token MAXTYPE_FIXED %token MAXTYPE_NOTFIXED %token MEMORY24 %token MEMORY32 %token MEMORY32FIXED %token MEMTYPE_CACHEABLE %token MEMTYPE_NONCACHEABLE %token MEMTYPE_PREFETCHABLE %token MEMTYPE_WRITECOMBINING %token METHOD %token METHODCALL %token MID %token MINTYPE_FIXED %token MINTYPE_NOTFIXED %token MOD %token MULTIPLY %token MUTEX %token NAME %token NAMESEG %token NAMESTRING %token NAND %token NOOP %token NOR %token NOT %token NOTIFY %token OBJECTTYPE %token OBJECTTYPE_BFF %token OBJECTTYPE_BUF %token OBJECTTYPE_DDB %token OBJECTTYPE_DEV %token OBJECTTYPE_EVT %token OBJECTTYPE_FLD %token OBJECTTYPE_INT %token OBJECTTYPE_MTH %token OBJECTTYPE_MTX %token OBJECTTYPE_OPR %token OBJECTTYPE_PKG %token OBJECTTYPE_POW %token OBJECTTYPE_STR %token OBJECTTYPE_THZ %token OBJECTTYPE_UNK %token OFFSET %token ONE %token ONES %token OPERATIONREGION %token OR %token PACKAGE %token PACKAGE_LENGTH %token POWERRESOURCE %token PROCESSOR %token QWORDCONST %token QWORDIO %token QWORDMEMORY %token RANGETYPE_ENTIRE %token RANGETYPE_ISAONLY %token RANGETYPE_NONISAONLY %token RAW_DATA %token READWRITETYPE_BOTH %token READWRITETYPE_READONLY %token REFOF %token REGIONSPACE_CMOS %token REGIONSPACE_EC %token REGIONSPACE_IO %token REGIONSPACE_MEM %token REGIONSPACE_PCI %token REGIONSPACE_PCIBAR %token REGIONSPACE_SMBUS %token REGISTER %token RELEASE %token RESERVED_BYTES %token RESET %token RESOURCETEMPLATE %token RESOURCETYPE_CONSUMER %token RESOURCETYPE_PRODUCER %token RETURN %token REVISION %token SCOPE %token SERIALIZERULE_NOTSERIAL %token SERIALIZERULE_SERIAL %token SHARETYPE_EXCLUSIVE %token SHARETYPE_SHARED %token SHIFTLEFT %token SHIFTRIGHT %token SIGNAL %token SIZEOF %token SLEEP %token STALL %token STARTDEPENDENTFN %token STARTDEPENDENTFN_NOPRI %token STORE %token STRING_LITERAL %token SUBTRACT %token SWITCH %token THERMALZONE %token TOBCD %token TOBUFFER %token TODECIMALSTRING %token TOHEXSTRING %token TOINTEGER %token TOSTRING %token TRANSLATIONTYPE_DENSE %token TRANSLATIONTYPE_SPARSE %token TYPE_STATIC %token TYPE_TRANSLATION %token UNICODE %token UNLOAD %token UPDATERULE_ONES %token UPDATERULE_PRESERVE %token UPDATERULE_ZEROS %token VENDORLONG %token VENDORSHORT %token WAIT %token WHILE %token WORDBUSNUMBER %token WORDCONST %token WORDIO %token XFERTYPE_8 %token XFERTYPE_8_16 %token XFERTYPE_16 %token XOR %token 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 SimpleTarget %type Type1Opcode %type Type2Opcode %type Type2IntegerOpcode %type Type2StringOpcode %type Type2BufferOpcode %type Type2BufferOrStringOpcode %type Type3Opcode /* Obsolete %type Type4Opcode */ %type Type5Opcode %type Type6Opcode %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 OptionalListTermArg /* 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 BufferData %type ByteList %type ByteListTail %type DWordList %type DWordListTail %type PackageTerm %type PackageLengthTerm %type PackageList %type PackageListTail %type PackageElement %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 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 TermArgItem %type NameStringItem %% /******************************************************************************* * * Production rules start here * ******************************************************************************/ /* * ASL Names */ /* * Blocks, Data, and Opcodes */ ASLCode : DefinitionBlockTerm | error {YYABORT; $$ = NULL;} ; DefinitionBlockTerm : DEFINITIONBLOCK '(' {$$ = TrCreateLeafNode (DEFINITIONBLOCK);} String ',' String ',' ByteConst ',' String ',' String ',' DWordConst ')' {TrSetEndLineNumber ($3);} '{' TermList '}' {$$ = 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; yyerrok;} ; CompilerDirective : IncludeTerm {} | IncludeCStyleTerm {$$ = NULL;} | ExternalTerm {} ; ObjectList : {$$ = NULL;} | Object ObjectList {$$ = TrLinkPeerNode ($1,$2);} ; Object : CompilerDirective {} | NamedObject {} | NameSpaceModifier {} ; DataObject : BufferData {} | PackageData {} | IntegerData {} /* | StringData {} */ /* Caused a reduce/reduce conflict BufferData->StringData */ ; BufferData : Type5Opcode {} | Type2BufferOrStringOpcode {} | Type2BufferOpcode {} | BufferTerm {} ; PackageData : PackageTerm {} ; IntegerData : Type2IntegerOpcode {} | Type3Opcode {} | Integer {} | ConstTerm {} ; StringData : Type2StringOpcode {} | 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 (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 {} | Type2IntegerOpcode {} | Type2StringOpcode {} | Type2BufferOpcode {} | Type2BufferOrStringOpcode {} | DataObject {} | NameString {} | ArgTerm {} | LocalTerm {} ; Target : {$$ = TrCreateLeafNode (ZERO);} /* Placeholder is a ZeroOp object */ | ',' {$$ = TrCreateLeafNode (ZERO);} /* Placeholder is a ZeroOp object */ | ',' 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 : INCLUDE '(' {$$ = TrCreateLeafNode (INCLUDE);} String ')' {$$ = TrLinkChildren ($3,1,$4);FlOpenIncludeFile ($4);} TermList IncludeEndTerm {$$ = TrLinkPeerNodes (3,$3,$7,$8);} ; IncludeEndTerm : INCLUDE_END {$$ = TrCreateLeafNode (INCLUDE_END);} ; IncludeCStyleTerm : INCLUDE_CSTYLE String {FlOpenIncludeFile ($2);} ; ExternalTerm : EXTERNAL '(' NameString ',' ObjectTypeKeyword ')' {$$ = TrCreateNode (EXTERNAL,2,$3,$5);} | EXTERNAL '(' error ')' {$$ = AslDoError(); yyerrok;} ; /******* Named Objects *******************************************************/ BankFieldTerm : BANKFIELD '(' {$$ = TrCreateLeafNode (BANKFIELD);} NameString NameStringItem TermArgItem ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,7,$4,$5,$6,$8,$10,$12,$15);} | BANKFIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; 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 (RESERVED_BYTES,1,$2);} | NameSeg ',' AmlPackageLengthTerm {$$ = TrLinkChildNode ($1,$3);} ; OffsetTerm : OFFSET '(' AmlPackageLengthTerm ')' {$$ = TrCreateNode (OFFSET,1,$3);} | OFFSET '(' error ')' {$$ = AslDoError(); yyerrok;} ; AccessAsTerm : ACCESSAS '(' AccessTypeKeyword OptionalAccessAttribTerm ')' {$$ = TrCreateNode (ACCESSAS,2,$3,$4);} | ACCESSAS '(' error ')' {$$ = AslDoError(); yyerrok;} ; CreateBitFieldTerm : CREATEBITFIELD '(' {$$ = TrCreateLeafNode (CREATEBITFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | CREATEBITFIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; CreateByteFieldTerm : CREATEBYTEFIELD '(' {$$ = TrCreateLeafNode (CREATEBYTEFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | CREATEBYTEFIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; CreateDWordFieldTerm : CREATEDWORDFIELD '(' {$$ = TrCreateLeafNode (CREATEDWORDFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | CREATEDWORDFIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; CreateFieldTerm : CREATEFIELD '(' {$$ = TrCreateLeafNode (CREATEFIELD);} TermArg TermArgItem TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,4,$4,$5,$6,$7);} | CREATEFIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; CreateQWordFieldTerm : CREATEQWORDFIELD '(' {$$ = TrCreateLeafNode (CREATEQWORDFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | CREATEQWORDFIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; CreateWordFieldTerm : CREATEWORDFIELD '(' {$$ = TrCreateLeafNode (CREATEWORDFIELD);} TermArg TermArgItem NameStringItem ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | CREATEWORDFIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; DataRegionTerm : DATATABLEREGION '(' {$$ = TrCreateLeafNode (DATATABLEREGION);} NameString TermArgItem TermArgItem TermArgItem ')' {$$ = TrLinkChildren ($3,4,$4,$5,$6,$7);} | DATATABLEREGION '(' error ')' {$$ = AslDoError(); yyerrok;} ; DeviceTerm : DEVICE '(' {$$ = TrCreateLeafNode (DEVICE);} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | DEVICE '(' error ')' {$$ = AslDoError(); yyerrok;} ; EventTerm : EVENT '(' {$$ = TrCreateLeafNode (EVENT);} NameString ')' {$$ = TrLinkChildren ($3,1,$4);} | EVENT '(' error ')' {$$ = AslDoError(); yyerrok;} ; FieldTerm : FIELD '(' {$$ = TrCreateLeafNode (FIELD);} NameString ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$8,$10,$13);} | FIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; IndexFieldTerm : INDEXFIELD '(' {$$ = TrCreateLeafNode (INDEXFIELD);} NameString NameStringItem ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,6,$4,$5,$7,$9,$11,$14);} | INDEXFIELD '(' error ')' {$$ = AslDoError(); yyerrok;} ; MethodTerm : METHOD '(' {$$ = TrCreateLeafNode (METHOD);} NameString OptionalByteConstExpr OptionalSerializeRuleKeyword OptionalByteConstExpr ')' '{' TermList '}' {$$ = TrLinkChildren ($3,5,$4,$5,$6,$7,$10);} | METHOD '(' error ')' {$$ = AslDoError(); yyerrok;} ; MutexTerm : MUTEX '(' {$$ = TrCreateLeafNode (MUTEX);} NameString ',' ByteConstExpr ')' {$$ = TrLinkChildren ($3,2,$4,$6);} | MUTEX '(' error ')' {$$ = AslDoError(); yyerrok;} ; OpRegionTerm : OPERATIONREGION '(' {$$ = TrCreateLeafNode (OPERATIONREGION);} NameString ',' OpRegionSpaceIdTerm TermArgItem TermArgItem ')' {$$ = TrLinkChildren ($3,4,$4,$6,$7,$8);} | OPERATIONREGION '(' error ')' {$$ = AslDoError(); yyerrok;} ; OpRegionSpaceIdTerm : RegionSpaceKeyword {} | ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);} ; PowerResTerm : POWERRESOURCE '(' {$$ = TrCreateLeafNode (POWERRESOURCE);} NameString ',' ByteConstExpr ',' WordConstExpr ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$11);} | POWERRESOURCE '(' error ')' {$$ = AslDoError(); yyerrok;} ; ProcessorTerm : PROCESSOR '(' {$$ = TrCreateLeafNode (PROCESSOR);} NameString ',' ByteConstExpr OptionalDWordConstExpr OptionalByteConstExpr ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$7,$8,$11);} | PROCESSOR '(' error ')' {$$ = AslDoError(); yyerrok;} ; ThermalZoneTerm : THERMALZONE '(' {$$ = TrCreateLeafNode (THERMALZONE);} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | THERMALZONE '(' error ')' {$$ = AslDoError(); yyerrok;} ; /******* Namespace modifiers *************************************************/ AliasTerm : ALIAS '(' {$$ = TrCreateLeafNode (ALIAS);} NameString NameStringItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | ALIAS '(' error ')' {$$ = AslDoError(); yyerrok;} ; NameTerm : NAME '(' {$$ = TrCreateLeafNode (NAME);} NameString ',' DataObject ')' {$$ = TrLinkChildren ($3,2,$4,$6);} | NAME '(' error ')' {$$ = AslDoError(); yyerrok;} ; ScopeTerm : SCOPE '(' {$$ = TrCreateLeafNode (SCOPE);} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | SCOPE '(' error ')' {$$ = AslDoError(); yyerrok;} ; /******* Type 1 opcodes *******************************************************/ BreakTerm : BREAK {$$ = TrCreateNode (BREAK, 0);} ; BreakPointTerm : BREAKPOINT {$$ = TrCreateNode (BREAKPOINT, 0);} ; ContinueTerm : CONTINUE {$$ = TrCreateNode (CONTINUE, 0);} ; FatalTerm : FATAL '(' {$$ = TrCreateLeafNode (FATAL);} ByteConstExpr ',' DWordConstExpr TermArgItem ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7);} | FATAL '(' error ')' {$$ = AslDoError(); yyerrok;} ; IfElseTerm : IfTerm ElseTerm {$$ = TrLinkPeerNode ($1,$2);} ; IfTerm : IF '(' {$$ = TrCreateLeafNode (IF);} TermArg ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | IF '(' error ')' {$$ = AslDoError(); yyerrok;} ; ElseTerm : {$$ = NULL;} | ELSE '{' {$$ = TrCreateLeafNode (ELSE);} TermList '}' {$$ = TrLinkChildren ($3,1,$4);} | ELSEIF '{' {$$ = TrCreateLeafNode (ELSEIF);} TermList '}' ElseTerm {$$ = TrLinkChildren ($3,2,$4,$6);} ; LoadTerm : LOAD '(' {$$ = TrCreateLeafNode (LOAD);} NameString ',' SuperName ')' {$$ = TrLinkChildren ($3,2,$4,$6);} | LOAD '(' error ')' {$$ = AslDoError(); yyerrok;} ; NoOpTerm : NOOP {$$ = TrCreateNode (NOOP, 0);} ; NotifyTerm : NOTIFY '(' {$$ = TrCreateLeafNode (NOTIFY);} SuperName TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | NOTIFY '(' error ')' {$$ = AslDoError(); yyerrok;} ; ReleaseTerm : RELEASE '(' {$$ = TrCreateLeafNode (RELEASE);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | RELEASE '(' error ')' {$$ = AslDoError(); yyerrok;} ; ResetTerm : RESET '(' {$$ = TrCreateLeafNode (RESET);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | RESET '(' error ')' {$$ = AslDoError(); yyerrok;} ; ReturnTerm : RETURN '(' {$$ = TrCreateLeafNode (RETURN);} OptionalTermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | RETURN '(' error ')' {$$ = AslDoError(); yyerrok;} ; SignalTerm : SIGNAL '(' {$$ = TrCreateLeafNode (SIGNAL);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | SIGNAL '(' error ')' {$$ = AslDoError(); yyerrok;} ; SleepTerm : SLEEP '(' {$$ = TrCreateLeafNode (SLEEP);} TermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | SLEEP '(' error ')' {$$ = AslDoError(); yyerrok;} ; StallTerm : STALL '(' {$$ = TrCreateLeafNode (STALL);} TermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | STALL '(' error ')' {$$ = AslDoError(); yyerrok;} ; SwitchTerm : SWITCH '(' {$$ = TrCreateLeafNode (SWITCH);} TermArg ')' '{' CaseTermList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | SWITCH '(' error ')' {$$ = AslDoError(); yyerrok;} ; CaseTermList : {} | CaseTerm {} | DefaultTerm DefaultTermList {} | CaseTerm CaseTermList {} ; DefaultTermList : {} | CaseTerm {} | CaseTerm DefaultTermList {} ; CaseTerm : CASE '(' {$$ = TrCreateLeafNode (CASE);} DataObject ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | CASE '(' error ')' {$$ = AslDoError(); yyerrok;} ; DefaultTerm : DEFAULT '{' {$$ = TrCreateLeafNode (DEFAULT);} TermList '}' {$$ = TrLinkChildren ($3,1,$4);} ; UnloadTerm : UNLOAD '(' {$$ = TrCreateLeafNode (UNLOAD);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | UNLOAD '(' error ')' {$$ = AslDoError(); yyerrok;} ; WhileTerm : WHILE '(' {$$ = TrCreateLeafNode (WHILE);} TermArg ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | WHILE '(' error ')' {$$ = AslDoError(); yyerrok;} ; /******* Type 2 opcodes *******************************************************/ AcquireTerm : ACQUIRE '(' {$$ = TrCreateLeafNode (ACQUIRE);} SuperName ',' WordConstExpr ')' {$$ = TrLinkChildren ($3,2,$4,$6);} | ACQUIRE '(' error ')' {$$ = AslDoError(); yyerrok;} ; AddTerm : ADD '(' {$$ = TrCreateLeafNode (ADD);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | ADD '(' error ')' {$$ = AslDoError(); yyerrok;} ; AndTerm : AND '(' {$$ = TrCreateLeafNode (AND);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | AND '(' error ')' {$$ = AslDoError(); yyerrok;} ; ConcatTerm : CONCATENATE '(' {$$ = TrCreateLeafNode (CONCATENATE);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | CONCATENATE '(' error ')' {$$ = AslDoError(); yyerrok;} ; ConcatResTerm : CONCATENATERESTEMPLATE '(' {$$ = TrCreateLeafNode (CONCATENATERESTEMPLATE);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | CONCATENATERESTEMPLATE '(' error ')' {$$ = AslDoError(); yyerrok;} ; CondRefOfTerm : CONDREFOF '(' {$$ = TrCreateLeafNode (CONDREFOF);} SuperName Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | CONDREFOF '(' error ')' {$$ = AslDoError(); yyerrok;} ; CopyObjectTerm : COPYOBJECT '(' {$$ = TrCreateLeafNode (COPYOBJECT);} TermArg ',' SimpleTarget ')' {$$ = TrLinkChildren ($3,2,$4,$6);} | COPYOBJECT '(' error ')' {$$ = AslDoError(); yyerrok;} ; DecTerm : DECREMENT '(' {$$ = TrCreateLeafNode (DECREMENT);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | DECREMENT '(' error ')' {$$ = AslDoError(); yyerrok;} ; DerefOfTerm : DEREFOF '(' {$$ = TrCreateLeafNode (DEREFOF);} TermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | DEREFOF '(' error ')' {$$ = AslDoError(); yyerrok;} ; DivideTerm : DIVIDE '(' {$$ = TrCreateLeafNode (DIVIDE);} TermArg TermArgItem Target Target ')' {$$ = TrLinkChildren ($3,4,$4,$5,$6,$7);} | DIVIDE '(' error ')' {$$ = AslDoError(); yyerrok;} ; FindSetLeftBitTerm : FINDSETLEFTBIT '(' {$$ = TrCreateLeafNode (FINDSETLEFTBIT);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | FINDSETLEFTBIT '(' error ')' {$$ = AslDoError(); yyerrok;} ; FindSetRightBitTerm : FINDSETRIGHTBIT '(' {$$ = TrCreateLeafNode (FINDSETRIGHTBIT);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | FINDSETRIGHTBIT '(' error ')' {$$ = AslDoError(); yyerrok;} ; FromBCDTerm : FROMBCD '(' {$$ = TrCreateLeafNode (FROMBCD);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | FROMBCD '(' error ')' {$$ = AslDoError(); yyerrok;} ; IncTerm : INCREMENT '(' {$$ = TrCreateLeafNode (INCREMENT);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | INCREMENT '(' error ')' {$$ = AslDoError(); yyerrok;} ; IndexTerm : INDEX '(' {$$ = TrCreateLeafNode (INDEX);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | INDEX '(' error ')' {$$ = AslDoError(); yyerrok;} ; LAndTerm : LAND '(' {$$ = TrCreateLeafNode (LAND);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | LAND '(' error ')' {$$ = AslDoError(); yyerrok;} ; LEqualTerm : LEQUAL '(' {$$ = TrCreateLeafNode (LEQUAL);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | LEQUAL '(' error ')' {$$ = AslDoError(); yyerrok;} ; LGreaterTerm : LGREATER '(' {$$ = TrCreateLeafNode (LGREATER);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | LGREATER '(' error ')' {$$ = AslDoError(); yyerrok;} ; LGreaterEqualTerm : LGREATEREQUAL '(' {$$ = TrCreateLeafNode (LGREATEREQUAL);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | LGREATEREQUAL '(' error ')' {$$ = AslDoError(); yyerrok;} ; LLessTerm : LLESS '(' {$$ = TrCreateLeafNode (LLESS);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | LLESS '(' error ')' {$$ = AslDoError(); yyerrok;} ; LLessEqualTerm : LLESSEQUAL '(' {$$ = TrCreateLeafNode (LLESSEQUAL);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | LLESSEQUAL '(' error ')' {$$ = AslDoError(); yyerrok;} ; LNotTerm : LNOT '(' {$$ = TrCreateLeafNode (LNOT);} TermArg ')' {$$ = TrLinkChildren ($3,1,$4);} | LNOT '(' error ')' {$$ = AslDoError(); yyerrok;} ; LNotEqualTerm : LNOTEQUAL '(' {$$ = TrCreateLeafNode (LNOTEQUAL);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | LNOTEQUAL '(' error ')' {$$ = AslDoError(); yyerrok;} ; LoadTableTerm : LOADTABLE '(' {$$ = TrCreateLeafNode (LOADTABLE);} TermArg TermArgItem TermArgItem OptionalListTermArg OptionalListTermArg OptionalListTermArg ')' {$$ = TrLinkChildren ($3,6,$4,$5,$6,$7,$8,$9);} | LOADTABLE '(' error ')' {$$ = AslDoError(); yyerrok;} ; LOrTerm : LOR '(' {$$ = TrCreateLeafNode (LOR);} TermArg TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | LOR '(' error ')' {$$ = AslDoError(); yyerrok;} ; MatchTerm : MATCH '(' {$$ = TrCreateLeafNode (MATCH);} TermArg ',' MatchOpKeyword TermArgItem ',' MatchOpKeyword TermArgItem TermArgItem ')' {$$ = TrLinkChildren ($3,6,$4,$6,$7,$9,$10,$11);} | MATCH '(' error ')' {$$ = AslDoError(); yyerrok;} ; MidTerm : MID '(' {$$ = TrCreateLeafNode (MID);} TermArg TermArgItem TermArgItem Target ')' {$$ = TrLinkChildren ($3,4,$4,$5,$6,$7);} | MID '(' error ')' {$$ = AslDoError(); yyerrok;} ; ModTerm : MOD '(' {$$ = TrCreateLeafNode (MOD);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | MOD '(' error ')' {$$ = AslDoError(); yyerrok;} ; MultiplyTerm : MULTIPLY '(' {$$ = TrCreateLeafNode (MULTIPLY);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | MULTIPLY '(' error ')' {$$ = AslDoError(); yyerrok;} ; NAndTerm : NAND '(' {$$ = TrCreateLeafNode (NAND);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | NAND '(' error ')' {$$ = AslDoError(); yyerrok;} ; NOrTerm : NOR '(' {$$ = TrCreateLeafNode (NOR);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | NOR '(' error ')' {$$ = AslDoError(); yyerrok;} ; NotTerm : NOT '(' {$$ = TrCreateLeafNode (NOT);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | NOT '(' error ')' {$$ = AslDoError(); yyerrok;} ; ObjectTypeTerm : OBJECTTYPE '(' {$$ = TrCreateLeafNode (OBJECTTYPE);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | OBJECTTYPE '(' error ')' {$$ = AslDoError(); yyerrok;} ; OrTerm : OR '(' {$$ = TrCreateLeafNode (OR);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | OR '(' error ')' {$$ = AslDoError(); yyerrok;} ; /* * 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 : REFOF '(' {$$ = TrCreateLeafNode (REFOF);} SuperName ')' {$$ = TrLinkChildren ($3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));} | REFOF '(' error ')' {$$ = AslDoError(); yyerrok;} ; ShiftLeftTerm : SHIFTLEFT '(' {$$ = TrCreateLeafNode (SHIFTLEFT);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | SHIFTLEFT '(' error ')' {$$ = AslDoError(); yyerrok;} ; ShiftRightTerm : SHIFTRIGHT '(' {$$ = TrCreateLeafNode (SHIFTRIGHT);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | SHIFTRIGHT '(' error ')' {$$ = AslDoError(); yyerrok;} ; SizeOfTerm : SIZEOF '(' {$$ = TrCreateLeafNode (SIZEOF);} SuperName ')' {$$ = TrLinkChildren ($3,1,$4);} | SIZEOF '(' error ')' {$$ = AslDoError(); yyerrok;} ; StoreTerm : STORE '(' {$$ = TrCreateLeafNode (STORE);} TermArg ',' SuperName ')' {$$ = TrLinkChildren ($3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));} | STORE '(' error ')' {$$ = AslDoError(); yyerrok;} ; SubtractTerm : SUBTRACT '(' {$$ = TrCreateLeafNode (SUBTRACT);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | SUBTRACT '(' error ')' {$$ = AslDoError(); yyerrok;} ; ToBCDTerm : TOBCD '(' {$$ = TrCreateLeafNode (TOBCD);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | TOBCD '(' error ')' {$$ = AslDoError(); yyerrok;} ; ToBufferTerm : TOBUFFER '(' {$$ = TrCreateLeafNode (TOBUFFER);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | TOBUFFER '(' error ')' {$$ = AslDoError(); yyerrok;} ; ToDecimalStringTerm : TODECIMALSTRING '(' {$$ = TrCreateLeafNode (TODECIMALSTRING);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | TODECIMALSTRING '(' error ')' {$$ = AslDoError(); yyerrok;} ; ToHexStringTerm : TOHEXSTRING '(' {$$ = TrCreateLeafNode (TOHEXSTRING);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | TOHEXSTRING '(' error ')' {$$ = AslDoError(); yyerrok;} ; ToIntegerTerm : TOINTEGER '(' {$$ = TrCreateLeafNode (TOINTEGER);} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | TOINTEGER '(' error ')' {$$ = AslDoError(); yyerrok;} ; ToStringTerm : TOSTRING '(' {$$ = TrCreateLeafNode (TOSTRING);} TermArg OptionalListTermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | TOSTRING '(' error ')' {$$ = AslDoError(); yyerrok;} ; WaitTerm : WAIT '(' {$$ = TrCreateLeafNode (WAIT);} SuperName TermArgItem ')' {$$ = TrLinkChildren ($3,2,$4,$5);} | WAIT '(' error ')' {$$ = AslDoError(); yyerrok;} ; XOrTerm : XOR '(' {$$ = TrCreateLeafNode (XOR);} TermArg TermArgItem Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6);} | XOR '(' error ')' {$$ = AslDoError(); yyerrok;} ; /******* Keywords *************************************************************/ ObjectTypeKeyword : OBJECTTYPE_UNK {$$ = TrCreateLeafNode (OBJECTTYPE_UNK);} | OBJECTTYPE_INT {$$ = TrCreateLeafNode (OBJECTTYPE_INT);} | OBJECTTYPE_STR {$$ = TrCreateLeafNode (OBJECTTYPE_STR);} | OBJECTTYPE_BUF {$$ = TrCreateLeafNode (OBJECTTYPE_BUF);} | OBJECTTYPE_PKG {$$ = TrCreateLeafNode (OBJECTTYPE_PKG);} | OBJECTTYPE_FLD {$$ = TrCreateLeafNode (OBJECTTYPE_FLD);} | OBJECTTYPE_DEV {$$ = TrCreateLeafNode (OBJECTTYPE_DEV);} | OBJECTTYPE_EVT {$$ = TrCreateLeafNode (OBJECTTYPE_EVT);} | OBJECTTYPE_MTH {$$ = TrCreateLeafNode (OBJECTTYPE_MTH);} | OBJECTTYPE_MTX {$$ = TrCreateLeafNode (OBJECTTYPE_MTX);} | OBJECTTYPE_OPR {$$ = TrCreateLeafNode (OBJECTTYPE_OPR);} | OBJECTTYPE_POW {$$ = TrCreateLeafNode (OBJECTTYPE_POW);} | OBJECTTYPE_THZ {$$ = TrCreateLeafNode (OBJECTTYPE_THZ);} | OBJECTTYPE_BFF {$$ = TrCreateLeafNode (OBJECTTYPE_BFF);} | OBJECTTYPE_DDB {$$ = TrCreateLeafNode (OBJECTTYPE_DDB);} ; AccessTypeKeyword : ACCESSTYPE_ANY {$$ = TrCreateLeafNode (ACCESSTYPE_ANY);} | ACCESSTYPE_BYTE {$$ = TrCreateLeafNode (ACCESSTYPE_BYTE);} | ACCESSTYPE_WORD {$$ = TrCreateLeafNode (ACCESSTYPE_WORD);} | ACCESSTYPE_DWORD {$$ = TrCreateLeafNode (ACCESSTYPE_DWORD);} | ACCESSTYPE_QWORD {$$ = TrCreateLeafNode (ACCESSTYPE_QWORD);} | ACCESSTYPE_BUF {$$ = TrCreateLeafNode (ACCESSTYPE_BUF);} ; AccessAttribKeyword : ACCESSATTRIB_QUICK {$$ = TrCreateLeafNode (ACCESSATTRIB_QUICK );} | ACCESSATTRIB_SND_RCV {$$ = TrCreateLeafNode (ACCESSATTRIB_SND_RCV);} | ACCESSATTRIB_BYTE {$$ = TrCreateLeafNode (ACCESSATTRIB_BYTE);} | ACCESSATTRIB_WORD {$$ = TrCreateLeafNode (ACCESSATTRIB_WORD);} | ACCESSATTRIB_BLOCK {$$ = TrCreateLeafNode (ACCESSATTRIB_BLOCK);} | ACCESSATTRIB_CALL {$$ = TrCreateLeafNode (ACCESSATTRIB_CALL);} ; LockRuleKeyword : LOCKRULE_LOCK {$$ = TrCreateLeafNode (LOCKRULE_LOCK);} | LOCKRULE_NOLOCK {$$ = TrCreateLeafNode (LOCKRULE_NOLOCK);} ; UpdateRuleKeyword : UPDATERULE_PRESERVE {$$ = TrCreateLeafNode (UPDATERULE_PRESERVE);} | UPDATERULE_ONES {$$ = TrCreateLeafNode (UPDATERULE_ONES);} | UPDATERULE_ZEROS {$$ = TrCreateLeafNode (UPDATERULE_ZEROS);} ; RegionSpaceKeyword : REGIONSPACE_IO {$$ = TrCreateLeafNode (REGIONSPACE_IO);} | REGIONSPACE_MEM {$$ = TrCreateLeafNode (REGIONSPACE_MEM);} | REGIONSPACE_PCI {$$ = TrCreateLeafNode (REGIONSPACE_PCI);} | REGIONSPACE_EC {$$ = TrCreateLeafNode (REGIONSPACE_EC);} | REGIONSPACE_SMBUS {$$ = TrCreateLeafNode (REGIONSPACE_SMBUS);} | REGIONSPACE_CMOS {$$ = TrCreateLeafNode (REGIONSPACE_CMOS);} | REGIONSPACE_PCIBAR {$$ = TrCreateLeafNode (REGIONSPACE_PCIBAR);} ; AddressSpaceKeyword : RegionSpaceKeyword {} | ADDRESSSPACE_FFIXEDHW {$$ = TrCreateLeafNode (ADDRESSSPACE_FFIXEDHW);} ; SerializeRuleKeyword : SERIALIZERULE_SERIAL {$$ = TrCreateLeafNode (SERIALIZERULE_SERIAL);} | SERIALIZERULE_NOTSERIAL {$$ = TrCreateLeafNode (SERIALIZERULE_NOTSERIAL);} ; MatchOpKeyword : MATCHTYPE_MTR {$$ = TrCreateLeafNode (MATCHTYPE_MTR);} | MATCHTYPE_MEQ {$$ = TrCreateLeafNode (MATCHTYPE_MEQ);} | MATCHTYPE_MLE {$$ = TrCreateLeafNode (MATCHTYPE_MLE);} | MATCHTYPE_MLT {$$ = TrCreateLeafNode (MATCHTYPE_MLT);} | MATCHTYPE_MGE {$$ = TrCreateLeafNode (MATCHTYPE_MGE);} | MATCHTYPE_MGT {$$ = TrCreateLeafNode (MATCHTYPE_MGT);} ; DMATypeKeyword : DMATYPE_A {$$ = TrCreateLeafNode (DMATYPE_A);} | DMATYPE_COMPATIBILITY {$$ = TrCreateLeafNode (DMATYPE_COMPATIBILITY);} | DMATYPE_B {$$ = TrCreateLeafNode (DMATYPE_B);} | DMATYPE_F {$$ = TrCreateLeafNode (DMATYPE_F);} ; BusMasterKeyword : BUSMASTERTYPE_MASTER {$$ = TrCreateLeafNode (BUSMASTERTYPE_MASTER);} | BUSMASTERTYPE_NOTMASTER {$$ = TrCreateLeafNode (BUSMASTERTYPE_NOTMASTER);} ; XferTypeKeyword : XFERTYPE_8 {$$ = TrCreateLeafNode (XFERTYPE_8);} | XFERTYPE_8_16 {$$ = TrCreateLeafNode (XFERTYPE_8_16);} | XFERTYPE_16 {$$ = TrCreateLeafNode (XFERTYPE_16);} ; ResourceTypeKeyword : RESOURCETYPE_CONSUMER {$$ = TrCreateLeafNode (RESOURCETYPE_CONSUMER);} | RESOURCETYPE_PRODUCER {$$ = TrCreateLeafNode (RESOURCETYPE_PRODUCER);} ; MinKeyword : MINTYPE_FIXED {$$ = TrCreateLeafNode (MINTYPE_FIXED);} | MINTYPE_NOTFIXED {$$ = TrCreateLeafNode (MINTYPE_NOTFIXED);} ; MaxKeyword : MAXTYPE_FIXED {$$ = TrCreateLeafNode (MAXTYPE_FIXED);} | MAXTYPE_NOTFIXED {$$ = TrCreateLeafNode (MAXTYPE_NOTFIXED);} ; DecodeKeyword : DECODETYPE_POS {$$ = TrCreateLeafNode (DECODETYPE_POS);} | DECODETYPE_SUB {$$ = TrCreateLeafNode (DECODETYPE_SUB);} ; RangeTypeKeyword : RANGETYPE_ISAONLY {$$ = TrCreateLeafNode (RANGETYPE_ISAONLY);} | RANGETYPE_NONISAONLY {$$ = TrCreateLeafNode (RANGETYPE_NONISAONLY);} | RANGETYPE_ENTIRE {$$ = TrCreateLeafNode (RANGETYPE_ENTIRE);} ; MemTypeKeyword : MEMTYPE_CACHEABLE {$$ = TrCreateLeafNode (MEMTYPE_CACHEABLE);} | MEMTYPE_WRITECOMBINING {$$ = TrCreateLeafNode (MEMTYPE_WRITECOMBINING);} | MEMTYPE_PREFETCHABLE {$$ = TrCreateLeafNode (MEMTYPE_PREFETCHABLE);} | MEMTYPE_NONCACHEABLE {$$ = TrCreateLeafNode (MEMTYPE_NONCACHEABLE);} ; ReadWriteKeyword : READWRITETYPE_BOTH {$$ = TrCreateLeafNode (READWRITETYPE_BOTH);} | READWRITETYPE_READONLY {$$ = TrCreateLeafNode (READWRITETYPE_READONLY);} ; InterruptTypeKeyword : INTTYPE_EDGE {$$ = TrCreateLeafNode (INTTYPE_EDGE);} | INTTYPE_LEVEL {$$ = TrCreateLeafNode (INTTYPE_LEVEL);} ; InterruptLevel : INTLEVEL_ACTIVEHIGH {$$ = TrCreateLeafNode (INTLEVEL_ACTIVEHIGH);} | INTLEVEL_ACTIVELOW {$$ = TrCreateLeafNode (INTLEVEL_ACTIVELOW);} ; ShareTypeKeyword : SHARETYPE_SHARED {$$ = TrCreateLeafNode (SHARETYPE_SHARED);} | SHARETYPE_EXCLUSIVE {$$ = TrCreateLeafNode (SHARETYPE_EXCLUSIVE);} ; IODecodeKeyword : IODECODETYPE_16 {$$ = TrCreateLeafNode (IODECODETYPE_16);} | IODECODETYPE_10 {$$ = TrCreateLeafNode (IODECODETYPE_10);} ; TypeKeyword : TYPE_TRANSLATION {$$ = TrCreateLeafNode (TYPE_TRANSLATION);} | TYPE_STATIC {$$ = TrCreateLeafNode (TYPE_STATIC);} ; TranslationKeyword : TRANSLATIONTYPE_SPARSE {$$ = TrCreateLeafNode (TRANSLATIONTYPE_SPARSE);} | TRANSLATIONTYPE_DENSE {$$ = TrCreateLeafNode (TRANSLATIONTYPE_DENSE);} ; AddressKeyword : ADDRESSTYPE_MEMORY {$$ = TrCreateLeafNode (ADDRESSTYPE_MEMORY);} | ADDRESSTYPE_RESERVED {$$ = TrCreateLeafNode (ADDRESSTYPE_RESERVED);} | ADDRESSTYPE_NVS {$$ = TrCreateLeafNode (ADDRESSTYPE_NVS);} | ADDRESSTYPE_ACPI {$$ = TrCreateLeafNode (ADDRESSTYPE_ACPI);} ; /******* Miscellaneous Types **************************************************/ SuperName : NameString {} | ArgTerm {} | LocalTerm {} | DebugTerm {} | Type6Opcode {} /* | UserTerm {} */ /* Caused reduce/reduce with Type6Opcode->UserTerm */ ; ArgTerm : ARG0 {$$ = TrCreateLeafNode (ARG0);} | ARG1 {$$ = TrCreateLeafNode (ARG1);} | ARG2 {$$ = TrCreateLeafNode (ARG2);} | ARG3 {$$ = TrCreateLeafNode (ARG3);} | ARG4 {$$ = TrCreateLeafNode (ARG4);} | ARG5 {$$ = TrCreateLeafNode (ARG5);} | ARG6 {$$ = TrCreateLeafNode (ARG6);} ; LocalTerm : LOCAL0 {$$ = TrCreateLeafNode (LOCAL0);} | LOCAL1 {$$ = TrCreateLeafNode (LOCAL1);} | LOCAL2 {$$ = TrCreateLeafNode (LOCAL2);} | LOCAL3 {$$ = TrCreateLeafNode (LOCAL3);} | LOCAL4 {$$ = TrCreateLeafNode (LOCAL4);} | LOCAL5 {$$ = TrCreateLeafNode (LOCAL5);} | LOCAL6 {$$ = TrCreateLeafNode (LOCAL6);} | LOCAL7 {$$ = TrCreateLeafNode (LOCAL7);} ; DebugTerm : DEBUG {$$ = TrCreateLeafNode (DEBUG);} ; ByteConst : Integer {$$ = TrUpdateNode (BYTECONST, $1);} ; WordConst : Integer {$$ = TrUpdateNode (WORDCONST, $1);} ; DWordConst : Integer {$$ = TrUpdateNode (DWORDCONST, $1);} ; QWordConst : Integer {$$ = TrUpdateNode (QWORDCONST, $1);} ; Integer : INTEGER {$$ = TrCreateValuedLeafNode (INTEGER, AslCompilerlval.i);} ; String : STRING_LITERAL {$$ = TrCreateValuedLeafNode (STRING_LITERAL, (ACPI_INTEGER) AslCompilerlval.s);} ; ConstTerm : ConstExprTerm {} | REVISION {$$ = TrCreateLeafNode (REVISION);} ; ByteConstExpr : Type3Opcode {$$ = TrUpdateNode (BYTECONST, $1);} | Type2IntegerOpcode {$$ = TrUpdateNode (BYTECONST, $1);} | ConstExprTerm {$$ = TrUpdateNode (BYTECONST, $1);} | ByteConst {} ; WordConstExpr : Type3Opcode {$$ = TrUpdateNode (WORDCONST, $1);} | Type2IntegerOpcode {$$ = TrUpdateNode (WORDCONST, $1);} | ConstExprTerm {$$ = TrUpdateNode (WORDCONST, $1);} | WordConst {} ; DWordConstExpr : Type3Opcode {$$ = TrUpdateNode (DWORDCONST, $1);} | Type2IntegerOpcode {$$ = TrUpdateNode (DWORDCONST, $1);} | ConstExprTerm {$$ = TrUpdateNode (DWORDCONST, $1);} | DWordConst {} ; QWordConstExpr : Type3Opcode {$$ = TrUpdateNode (QWORDCONST, $1);} | Type2IntegerOpcode {$$ = TrUpdateNode (QWORDCONST, $1);} | ConstExprTerm {$$ = TrUpdateNode (QWORDCONST, $1);} | QWordConst {} ; ConstExprTerm : ZERO {$$ = TrCreateLeafNode (ZERO);} | ONE {$$ = TrCreateLeafNode (ONE);} | ONES {$$ = TrCreateLeafNode (ONES);} ; BufferTerm : BUFFER '(' {$$ = TrCreateLeafNode (BUFFER);} OptionalTermArg ')' '{' BufferData '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | BUFFER '(' error ')' {$$ = AslDoError(); yyerrok;} ; BufferData : 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 : PACKAGE '(' {$$ = TrCreateLeafNode (PACKAGE);} PackageLengthTerm ')' '{' PackageList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | PACKAGE '(' error ')' {$$ = AslDoError(); yyerrok;} ; PackageLengthTerm : {$$ = NULL;} | ByteConstExpr {} | 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 : EISAID '(' StringData ')' {$$ = TrUpdateNode (EISAID, $3);} | EISAID '(' error ')' {$$ = AslDoError(); yyerrok;} ; /******* Resources and Memory ***********************************************/ ResourceTemplateTerm : RESOURCETEMPLATE '(' ')' '{' ResourceMacroList '}' {$$ = TrCreateNode (RESOURCETEMPLATE,3, TrCreateLeafNode (DEFAULT_ARG), TrCreateLeafNode (DEFAULT_ARG),$5);} ; UnicodeTerm : UNICODE '(' {$$ = TrCreateLeafNode (UNICODE);} StringData ')' {$$ = TrLinkChildren ($3,2,0,$4);} | UNICODE '(' error ')' {$$ = AslDoError(); yyerrok;} ; 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 : DMA '(' {$$ = TrCreateLeafNode (DMA);} DMATypeKeyword ',' BusMasterKeyword ',' XferTypeKeyword OptionalNameString_Last ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$8,$9,$12);} | DMA '(' error ')' {$$ = AslDoError(); yyerrok;} ; DWordIOTerm : DWORDIO '(' {$$ = TrCreateLeafNode (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);} | DWORDIO '(' error ')' {$$ = AslDoError(); yyerrok;} ; DWordMemoryTerm : DWORDMEMORY '(' {$$ = TrCreateLeafNode (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);} | DWORDMEMORY '(' error ')' {$$ = AslDoError(); yyerrok;} ; EndDependentFnTerm : ENDDEPENDENTFN '(' ')' {$$ = TrCreateLeafNode (ENDDEPENDENTFN);} | ENDDEPENDENTFN '(' error ')' {$$ = AslDoError(); yyerrok;} ; FixedIOTerm : FIXEDIO '(' {$$ = TrCreateLeafNode (FIXEDIO);} WordConstExpr ',' ByteConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7);} | FIXEDIO '(' error ')' {$$ = AslDoError(); yyerrok;} ; InterruptTerm : INTERRUPT '(' {$$ = TrCreateLeafNode (INTERRUPT);} OptionalResourceType_First InterruptTypeKeyword ',' InterruptLevel OptionalShareType OptionalByteConstExpr OptionalStringData OptionalNameString_Last ')' '{' DWordList '}' {$$ = TrLinkChildren ($3,8,$4,$5,$7,$8,$9,$10,$11,$14);} | INTERRUPT '(' error ')' {$$ = AslDoError(); yyerrok;} ; IOTerm : IO '(' {$$ = TrCreateLeafNode (IO);} IODecodeKeyword ',' WordConstExpr ',' WordConstExpr ',' ByteConstExpr ',' ByteConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);} | IO '(' error ')' {$$ = AslDoError(); yyerrok;} ; IRQNoFlagsTerm : IRQNOFLAGS '(' {$$ = TrCreateLeafNode (IRQNOFLAGS);} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | IRQNOFLAGS '(' error ')' {$$ = AslDoError(); yyerrok;} ; IRQTerm : IRQ '(' {$$ = TrCreateLeafNode (IRQ);} InterruptTypeKeyword ',' InterruptLevel OptionalShareType OptionalNameString_Last ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$7,$8,$11);} | IRQ '(' error ')' {$$ = AslDoError(); yyerrok;} ; Memory24Term : MEMORY24 '(' {$$ = TrCreateLeafNode (MEMORY24);} ReadWriteKeyword ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);} | MEMORY24 '(' error ')' {$$ = AslDoError(); yyerrok;} ; Memory32FixedTerm : MEMORY32FIXED '(' {$$ = TrCreateLeafNode (MEMORY32FIXED);} ReadWriteKeyword ',' DWordConstExpr ',' DWordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$9);} | MEMORY32FIXED '(' error ')' {$$ = AslDoError(); yyerrok;} ; Memory32Term : MEMORY32 '(' {$$ = TrCreateLeafNode (MEMORY32);} ReadWriteKeyword ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);} | MEMORY32 '(' error ')' {$$ = AslDoError(); yyerrok;} ; QWordIOTerm : QWORDIO '(' {$$ = TrCreateLeafNode (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);} | QWORDIO '(' error ')' {$$ = AslDoError(); yyerrok;} ; QWordMemoryTerm : QWORDMEMORY '(' {$$ = TrCreateLeafNode (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);} | QWORDMEMORY '(' error ')' {$$ = AslDoError(); yyerrok;} ; RegisterTerm : REGISTER '(' {$$ = TrCreateLeafNode (REGISTER);} AddressSpaceKeyword ',' ByteConstExpr ',' ByteConstExpr ',' QWordConstExpr ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$10);} | REGISTER '(' error ')' {$$ = AslDoError(); yyerrok;} ; StartDependentFnTerm : STARTDEPENDENTFN '(' {$$ = TrCreateLeafNode (STARTDEPENDENTFN);} ByteConstExpr ',' ByteConstExpr ')' '{' ResourceMacroList '}' {$$ = TrLinkChildren ($3,3,$4,$6,$9);} | STARTDEPENDENTFN '(' error ')' {$$ = AslDoError(); yyerrok;} ; StartDependentFnNoPriTerm : STARTDEPENDENTFN_NOPRI '(' {$$ = TrCreateLeafNode (STARTDEPENDENTFN_NOPRI);} ')' '{' ResourceMacroList '}' {$$ = TrLinkChildren ($3,1,$6);} | STARTDEPENDENTFN_NOPRI '(' error ')' {$$ = AslDoError(); yyerrok;} ; VendorLongTerm : VENDORLONG '(' {$$ = TrCreateLeafNode (VENDORLONG);} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | VENDORLONG '(' error ')' {$$ = AslDoError(); yyerrok;} ; VendorShortTerm : VENDORSHORT '(' {$$ = TrCreateLeafNode (VENDORSHORT);} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7);} | VENDORSHORT '(' error ')' {$$ = AslDoError(); yyerrok;} ; WordBusNumberTerm : WORDBUSNUMBER '(' {$$ = TrCreateLeafNode (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);} | WORDBUSNUMBER '(' error ')' {$$ = AslDoError(); yyerrok;} ; WordIOTerm : WORDIO '(' {$$ = TrCreateLeafNode (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);} | WORDIO '(' error ')' {$$ = AslDoError(); yyerrok;} ; /******* Object References ***********************************************/ NameString : NameSeg {} | NAMESTRING {$$ = TrCreateValuedLeafNode (NAMESTRING, (ACPI_INTEGER) AslCompilerlval.s);} ; NameSeg : NAMESEG {$$ = TrCreateValuedLeafNode (NAMESEG, (ACPI_INTEGER) AslCompilerlval.s);} ; /******* Helper rules ****************************************************/ AmlPackageLengthTerm : Integer {$$ = TrUpdateNode (PACKAGE_LENGTH,(ASL_PARSE_NODE *) $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;} ; OptionalListTermArg : {$$ = NULL;} | ',' 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 : {$$ = NULL;} | NameString {$$ = $1;} ; OptionalRangeType : ',' {$$ = NULL;} | ',' RangeTypeKeyword {$$ = $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 (); yyerrok;} ; NameStringItem : ',' NameString {$$ = $2;} | ',' error {$$ = AslDoError (); yyerrok;} ; %% /* programs */ int AslCompilerwrap(void) { return 1; } void * AslLocalAllocate (unsigned int Size) { void *Mem; DbgPrint (ASL_PARSE_OUTPUT, "\nAslLocalAllocate: Expanding Stack to %d\n\n", Size); Mem = _CmCallocate (Size, 0, "", 0); 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); } ASL_PARSE_NODE * AslDoError (void) { return (TrCreateLeafNode (ERRORNODE)); }