%{ /****************************************************************************** * * Module Name: aslcompiler.y - Bison input file (ASL grammar and actions) * $Revision: 1.23 $ * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999, 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" extern int AslCompilererror(char* s); extern int AslCompilerlex(); extern char *AslCompilertext; /* * 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 COPY %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 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 INTEGER_BYTE %token INTEGER_WORD %token INTEGER_DWORD %token INTEGER_QWORD %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 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 DataRefObject %type BufferData %type PackageData %type IntegerData %type StringData %type NamedObject %type NameSpaceModifier %type UserTerm %type ArgList %type ArgListTail %type TermArg %type Target %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 CopyTerm %type CopyTarget %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 UserDefRegionSpace %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 /* TBD: Could not find in spec */ %type ObjectReference %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 /* NOT USED %type OptionalAccessAttribKeyword */ %% /******************************************************************************* * * Production rules start here * ******************************************************************************/ /* * ASL Names */ /* * Blocks, Data, and Opcodes */ ASLCode : DefinitionBlockTerm ; DefinitionBlockTerm : DEFINITIONBLOCK '(' {$$ = TrCreateLeafNode (DEFINITIONBLOCK)} String ',' String ',' ByteConst ',' String ',' String ',' DwordConst ')' {TrSetEndLineNumber ($3)} '{' TermList '}' {$$ = TrLinkChildren ($3,7,$4,$6,$8,$10,$12,$14,$18)} | error {$$ = NULL} ; TermList : {$$ = NULL} | Term TermList {$$ = TrLinkPeerNode ($1,$2)} ; Term : Object {} | Type1Opcode {} | Type2Opcode {} | Type2IntegerOpcode {} | Type2StringOpcode {} | Type2BufferOpcode {} | Type2BufferOrStringOpcode {} ; 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 */ ; DataRefObject : DataObject {} | ObjectReference {} ; /* Useless rule ComputationalData : BufferData {} | IntegerData {} | StringData {} ; */ BufferData : Type5Opcode {} | Type2BufferOrStringOpcode {} | Type2BufferOpcode {} | BufferTerm {} ; PackageData : PackageTerm {} ; IntegerData : ByteConstExpr {$$ = TrUpdateNode (INTEGER, $1)} | WordConstExpr {$$ = TrUpdateNode (INTEGER, $1)} | DWordConstExpr {$$ = TrUpdateNode (INTEGER, $1)} | QWordConstExpr {$$ = TrUpdateNode (INTEGER, $1)} | ConstTerm {/* Don't change the parse opcode */} ; 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)} ; /* Opcode types */ Type1Opcode : BreakTerm {} | BreakPointTerm {} | ContinueTerm {} | FatalTerm {} | IfElseTerm {} | LoadTerm {} | NoOpTerm {} | NotifyTerm {} | ReleaseTerm {} | ResetTerm {} | ReturnTerm {} | SignalTerm {} | SleepTerm {} | StallTerm {} | SwitchTerm {} | UnloadTerm {} | WhileTerm {} ; Type2Opcode : AcquireTerm {} | CondRefOfTerm {} | CopyTerm {} | DerefOfTerm {} | ObjectTypeTerm {} | RefOfTerm {} | SizeOfTerm {} | StoreTerm {} | WaitTerm {} | UserTerm {} ; /* * A type 2Integer 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 ')' {$$ = NULL; yyerrok} ; /******* Named Objects *******************************************************/ BankFieldTerm : BANKFIELD '(' {$$ = TrCreateLeafNode (BANKFIELD)} NameString ',' NameString ',' TermArg ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,7,$4,$6,$8,$10,$12,$14,$17)} | BANKFIELD '(' error ')' {$$ = NULL; 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 ')' {$$ = NULL; yyerrok} ; AccessAsTerm : ACCESSAS '(' AccessTypeKeyword OptionalAccessAttribTerm ')' {$$ = TrCreateNode (ACCESSAS,2,$3,$4)} | ACCESSAS '(' error ')' {$$ = NULL; yyerrok} ; CreateBitFieldTerm : CREATEBITFIELD '(' {$$ = TrCreateLeafNode (CREATEBITFIELD)} TermArg ',' TermArg ',' NameString ')' {$$ = TrLinkChildren ($3,3,$4,$6,$8)} | CREATEBITFIELD '(' error ')' {$$ = NULL; yyerrok} ; CreateByteFieldTerm : CREATEBYTEFIELD '(' {$$ = TrCreateLeafNode (CREATEBYTEFIELD)} TermArg ',' TermArg ',' NameString ')' {$$ = TrLinkChildren ($3,3,$4,$6,$8)} | CREATEBYTEFIELD '(' error ')' {$$ = NULL; yyerrok} ; CreateDWordFieldTerm : CREATEDWORDFIELD '(' {$$ = TrCreateLeafNode (CREATEDWORDFIELD)} TermArg ',' TermArg ',' NameString ')' {$$ = TrLinkChildren ($3,3,$4,$6,$8)} | CREATEDWORDFIELD '(' error ')' {$$ = NULL; yyerrok} ; CreateFieldTerm : CREATEFIELD '(' {$$ = TrCreateLeafNode (CREATEFIELD)} TermArg ',' TermArg ',' TermArg ',' NameString ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$10)} | CREATEFIELD '(' error ')' {$$ = NULL; yyerrok} ; CreateQWordFieldTerm : CREATEQWORDFIELD '(' {$$ = TrCreateLeafNode (CREATEQWORDFIELD)} TermArg ',' TermArg ',' NameString ')' {$$ = TrLinkChildren ($3,3,$4,$6,$8)} | CREATEQWORDFIELD '(' error ')' {$$ = NULL; yyerrok} ; CreateWordFieldTerm : CREATEWORDFIELD '(' {$$ = TrCreateLeafNode (CREATEWORDFIELD)} TermArg ',' TermArg ',' NameString ')' {$$ = TrLinkChildren ($3,3,$4,$6,$8)} | CREATEWORDFIELD '(' error ')' {$$ = NULL; yyerrok} ; DataRegionTerm : DATATABLEREGION '(' {$$ = TrCreateLeafNode (DATATABLEREGION)} NameString ',' TermArg ',' TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$10)} | DATATABLEREGION '(' error ')' {$$ = NULL; yyerrok} ; DeviceTerm : DEVICE '(' {$$ = TrCreateLeafNode (DEVICE)} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | DEVICE '(' error ')' {$$ = NULL; yyerrok} ; EventTerm : EVENT '(' {$$ = TrCreateLeafNode (EVENT)} NameString ')' {$$ = TrLinkChildren ($3,1,$4)} | EVENT '(' error ')' {$$ = NULL; yyerrok} ; FieldTerm : FIELD '(' {$$ = TrCreateLeafNode (FIELD)} NameString ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$8,$10,$13)} | FIELD '(' error ')' {$$ = NULL; yyerrok} ; IndexFieldTerm : INDEXFIELD '(' {$$ = TrCreateLeafNode (INDEXFIELD)} NameString ',' NameString ',' AccessTypeKeyword ',' LockRuleKeyword ',' UpdateRuleKeyword ')' '{' FieldUnitList '}' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$15)} | INDEXFIELD '(' error ')' {$$ = NULL; yyerrok} ; MethodTerm : METHOD '(' {$$ = TrCreateLeafNode (METHOD)} NameString OptionalByteConstExpr OptionalSerializeRuleKeyword OptionalByteConstExpr ')' '{' TermList '}' {$$ = TrLinkChildren ($3,5,$4,$5,$6,$7,$10)} | METHOD '(' error ')' {$$ = NULL; yyerrok} ; MutexTerm : MUTEX '(' {$$ = TrCreateLeafNode (MUTEX)} NameString ',' ByteConstExpr ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | MUTEX '(' error ')' {$$ = NULL; yyerrok} ; OpRegionTerm : OPERATIONREGION '(' {$$ = TrCreateLeafNode (OPERATIONREGION)} NameString ',' OpRegionSpaceIdTerm ',' TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$10)} | OPERATIONREGION '(' error ')' {$$ = NULL; yyerrok} ; OpRegionSpaceIdTerm : RegionSpaceKeyword {} | ByteConst {} ; PowerResTerm : POWERRESOURCE '(' {$$ = TrCreateLeafNode (POWERRESOURCE)} NameString ',' ByteConstExpr ',' WordConstExpr ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$11)} | POWERRESOURCE '(' error ')' {$$ = NULL; yyerrok} ; ProcessorTerm : PROCESSOR '(' {$$ = TrCreateLeafNode (PROCESSOR)} NameString ',' ByteConstExpr OptionalDWordConstExpr OptionalByteConstExpr ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$7,$8,$11)} | PROCESSOR '(' error ')' {$$ = NULL; yyerrok} ; ThermalZoneTerm : THERMALZONE '(' {$$ = TrCreateLeafNode (THERMALZONE)} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | THERMALZONE '(' error ')' {$$ = NULL; yyerrok} ; /******* Namespace modifiers *************************************************/ AliasTerm : ALIAS '(' {$$ = TrCreateLeafNode (ALIAS)} NameString ',' NameString ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | ALIAS '(' error ')' {$$ = NULL; yyerrok} ; NameTerm : NAME '(' {$$ = TrCreateLeafNode (NAME)} NameString ',' DataObject ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | NAME '(' error ')' {$$ = NULL; yyerrok} ; ScopeTerm : SCOPE '(' {$$ = TrCreateLeafNode (SCOPE)} NameString ')' '{' ObjectList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | SCOPE '(' error ')' {$$ = NULL; 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 ',' TermArg ')' {$$ = TrLinkChildren ($3,3,$4,$6,$8)} | FATAL '(' error ')' {$$ = NULL; yyerrok} ; IfElseTerm : IfTerm ElseTerm {$$ = TrLinkPeerNode ($1,$2)} ; IfTerm : IF '(' {$$ = TrCreateLeafNode (IF)} TermArg ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | IF '(' error ')' {$$ = NULL; 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 ')' {$$ = NULL; yyerrok} ; NoOpTerm : NOOP {$$ = TrCreateNode (NOOP, 0)} ; NotifyTerm : NOTIFY '(' {$$ = TrCreateLeafNode (NOTIFY)} SuperName ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | NOTIFY '(' error ')' {$$ = NULL; yyerrok} ; ReleaseTerm : RELEASE '(' {$$ = TrCreateLeafNode (RELEASE)} SuperName ')' {$$ = TrLinkChildren ($3,1,$4)} | RELEASE '(' error ')' {$$ = NULL; yyerrok} ; ResetTerm : RESET '(' {$$ = TrCreateLeafNode (RESET)} SuperName ')' {$$ = TrLinkChildren ($3,1,$4)} | RESET '(' error ')' {$$ = NULL; yyerrok} ; ReturnTerm : RETURN '(' {$$ = TrCreateLeafNode (RETURN)} OptionalTermArg ')' {$$ = TrLinkChildren ($3,1,$4)} | RETURN '(' error ')' {$$ = NULL; yyerrok} ; SignalTerm : SIGNAL '(' {$$ = TrCreateLeafNode (SIGNAL)} SuperName ')' {$$ = TrLinkChildren ($3,1,$4)} | SIGNAL '(' error ')' {$$ = NULL; yyerrok} ; SleepTerm : SLEEP '(' {$$ = TrCreateLeafNode (SLEEP)} TermArg ')' {$$ = TrLinkChildren ($3,1,$4)} | SLEEP '(' error ')' {$$ = NULL; yyerrok} ; StallTerm : STALL '(' {$$ = TrCreateLeafNode (STALL)} TermArg ')' {$$ = TrLinkChildren ($3,1,$4)} | STALL '(' error ')' {$$ = NULL; yyerrok} ; SwitchTerm : SWITCH '(' {$$ = TrCreateLeafNode (SWITCH)} TermArg ')' '{' CaseTermList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | SWITCH '(' error ')' {$$ = NULL; yyerrok} ; CaseTermList : {} | CaseTerm {} | DefaultTerm DefaultTermList {} | CaseTerm CaseTermList {} ; DefaultTermList : {} | CaseTerm {} | CaseTerm DefaultTermList {} ; CaseTerm : CASE '(' {$$ = TrCreateLeafNode (CASE)} DataObject ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | CASE '(' error ')' {$$ = NULL; yyerrok} ; DefaultTerm : DEFAULT '{' {$$ = TrCreateLeafNode (DEFAULT)} TermList '}' {$$ = TrLinkChildren ($3,1,$4)} ; UnloadTerm : UNLOAD '(' {$$ = TrCreateLeafNode (UNLOAD)} SuperName ')' {$$ = TrLinkChildren ($3,1,$4)} | UNLOAD '(' error ')' {$$ = NULL; yyerrok} ; WhileTerm : WHILE '(' {$$ = TrCreateLeafNode (WHILE)} TermArg ')' '{' TermList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | WHILE '(' error ')' {$$ = NULL; yyerrok} ; /******* Type 2 opcodes *******************************************************/ AcquireTerm : ACQUIRE '(' {$$ = TrCreateLeafNode (ACQUIRE)} SuperName ',' WordConstExpr ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | ACQUIRE '(' error ')' {$$ = NULL; yyerrok} ; AddTerm : ADD '(' {$$ = TrCreateLeafNode (ADD)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | ADD '(' error ')' {$$ = NULL; yyerrok} ; AndTerm : AND '(' {$$ = TrCreateLeafNode (AND)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | AND '(' error ')' {$$ = NULL; yyerrok} ; ConcatTerm : CONCATENATE '(' {$$ = TrCreateLeafNode (CONCATENATE)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | CONCATENATE '(' error ')' {$$ = NULL; yyerrok} ; ConcatResTerm : CONCATENATERESTEMPLATE '(' {$$ = TrCreateLeafNode (CONCATENATERESTEMPLATE)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | CONCATENATERESTEMPLATE '(' error ')' {$$ = NULL; yyerrok} ; CondRefOfTerm : CONDREFOF '(' {$$ = TrCreateLeafNode (CONDREFOF)} SuperName Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | CONDREFOF '(' error ')' {$$ = NULL; yyerrok} ; CopyTerm : COPY '(' {$$ = TrCreateLeafNode (COPY)} TermArg ',' CopyTarget ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | COPY '(' error ')' {$$ = NULL; yyerrok} ; CopyTarget : NameString {} | LocalTerm {} | ArgTerm {} ; DecTerm : DECREMENT '(' {$$ = TrCreateLeafNode (DECREMENT)} SuperName ')' {$$ = TrLinkChildren ($3,1,$4)} | DECREMENT '(' error ')' {$$ = NULL; yyerrok} ; DerefOfTerm : DEREFOF '(' {$$ = TrCreateLeafNode (DEREFOF)} TermArg ')' {$$ = TrLinkChildren ($3,1,$4)} | DEREFOF '(' error ')' {$$ = NULL; yyerrok} ; DivideTerm : DIVIDE '(' {$$ = TrCreateLeafNode (DIVIDE)} TermArg ',' TermArg Target Target ')' {$$ = TrLinkChildren ($3,4,$4,$6,$7,$8)} | DIVIDE '(' error ')' {$$ = NULL; yyerrok} ; FindSetLeftBitTerm : FINDSETLEFTBIT '(' {$$ = TrCreateLeafNode (FINDSETLEFTBIT)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | FINDSETLEFTBIT '(' error ')' {$$ = NULL; yyerrok} ; FindSetRightBitTerm : FINDSETRIGHTBIT '(' {$$ = TrCreateLeafNode (FINDSETRIGHTBIT)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | FINDSETRIGHTBIT '(' error ')' {$$ = NULL; yyerrok} ; FromBCDTerm : FROMBCD '(' {$$ = TrCreateLeafNode (FROMBCD)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | FROMBCD '(' error ')' {$$ = NULL; yyerrok} ; IncTerm : INCREMENT '(' {$$ = TrCreateLeafNode (INCREMENT)} SuperName ')' {$$ = TrLinkChildren ($3,1,$4)} | INCREMENT '(' error ')' {$$ = NULL; yyerrok} ; IndexTerm : INDEX '(' {$$ = TrCreateLeafNode (INDEX)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | INDEX '(' error ')' {$$ = NULL; yyerrok} ; LAndTerm : LAND '(' {$$ = TrCreateLeafNode (LAND)} TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | LAND '(' error ')' {$$ = NULL; yyerrok} ; LEqualTerm : LEQUAL '(' {$$ = TrCreateLeafNode (LEQUAL)} TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | LEQUAL '(' error ')' {$$ = NULL; yyerrok} ; LGreaterTerm : LGREATER '(' {$$ = TrCreateLeafNode (LGREATER)} TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | LGREATER '(' error ')' {$$ = NULL; yyerrok} ; LGreaterEqualTerm : LGREATEREQUAL '(' {$$ = TrCreateLeafNode (LGREATEREQUAL)} TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | LGREATEREQUAL '(' error ')' {$$ = NULL; yyerrok} ; LLessTerm : LLESS '(' {$$ = TrCreateLeafNode (LLESS)} TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | LLESS '(' error ')' {$$ = NULL; yyerrok} ; LLessEqualTerm : LLESSEQUAL '(' {$$ = TrCreateLeafNode (LLESSEQUAL)} TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | LLESSEQUAL '(' error ')' {$$ = NULL; yyerrok} ; LNotTerm : LNOT '(' {$$ = TrCreateLeafNode (LNOT)} TermArg ')' {$$ = TrLinkChildren ($3,1,$4)} | LNOT '(' error ')' {$$ = NULL; yyerrok} ; LNotEqualTerm : LNOTEQUAL '(' {$$ = TrCreateLeafNode (LNOTEQUAL)} TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | LNOTEQUAL '(' error ')' {$$ = NULL; yyerrok} ; LoadTableTerm : LOADTABLE '(' {$$ = TrCreateLeafNode (LOADTABLE)} TermArg ',' TermArg ',' TermArg OptionalListTermArg OptionalListTermArg OptionalListTermArg ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$9,$10,$11)} | LOADTABLE '(' error ')' {$$ = NULL; yyerrok} ; LOrTerm : LOR '(' {$$ = TrCreateLeafNode (LOR)} TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | LOR '(' error ')' {$$ = NULL; yyerrok} ; MatchTerm : MATCH '(' {$$ = TrCreateLeafNode (MATCH)} TermArg ',' MatchOpKeyword ',' TermArg ',' MatchOpKeyword ',' TermArg ',' TermArg ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$14)} | MATCH '(' error ')' {$$ = NULL; yyerrok} ; MidTerm : MID '(' {$$ = TrCreateLeafNode (MID)} TermArg ',' TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$9)} | MID '(' error ')' {$$ = NULL; yyerrok} ; ModTerm : MOD '(' {$$ = TrCreateLeafNode (MOD)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | MOD '(' error ')' {$$ = NULL; yyerrok} ; MultiplyTerm : MULTIPLY '(' {$$ = TrCreateLeafNode (MULTIPLY)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | MULTIPLY '(' error ')' {$$ = NULL; yyerrok} ; NAndTerm : NAND '(' {$$ = TrCreateLeafNode (NAND)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | NAND '(' error ')' {$$ = NULL; yyerrok} ; NOrTerm : NOR '(' {$$ = TrCreateLeafNode (NOR)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | NOR '(' error ')' {$$ = NULL; yyerrok} ; NotTerm : NOT '(' {$$ = TrCreateLeafNode (NOT)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | NOT '(' error ')' {$$ = NULL; yyerrok} ; ObjectTypeTerm : OBJECTTYPE '(' {$$ = TrCreateLeafNode (OBJECTTYPE)} SuperName ')' {$$ = TrLinkChildren ($3,1,$4)} | OBJECTTYPE '(' error ')' {$$ = NULL; yyerrok} ; OrTerm : OR '(' {$$ = TrCreateLeafNode (OR)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | OR '(' error ')' {$$ = NULL; 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 ')' {$$ = NULL; yyerrok} ; ShiftLeftTerm : SHIFTLEFT '(' {$$ = TrCreateLeafNode (SHIFTLEFT)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | SHIFTLEFT '(' error ')' {$$ = NULL; yyerrok} ; ShiftRightTerm : SHIFTRIGHT '(' {$$ = TrCreateLeafNode (SHIFTRIGHT)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | SHIFTRIGHT '(' error ')' {$$ = NULL; yyerrok} ; SizeOfTerm : SIZEOF '(' {$$ = TrCreateLeafNode (SIZEOF)} SuperName ')' {$$ = TrLinkChildren ($3,1,$4)} | SIZEOF '(' error ')' {$$ = NULL; yyerrok} ; StoreTerm : STORE '(' {$$ = TrCreateLeafNode (STORE)} TermArg ',' SuperName ')' {$$ = TrLinkChildren ($3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET))} | STORE '(' error ')' {$$ = NULL; yyerrok} ; SubtractTerm : SUBTRACT '(' {$$ = TrCreateLeafNode (SUBTRACT)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | SUBTRACT '(' error ')' {$$ = NULL; yyerrok} ; ToBCDTerm : TOBCD '(' {$$ = TrCreateLeafNode (TOBCD)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | TOBCD '(' error ')' {$$ = NULL; yyerrok} ; ToBufferTerm : TOBUFFER '(' {$$ = TrCreateLeafNode (TOBUFFER)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | TOBUFFER '(' error ')' {$$ = NULL; yyerrok} ; ToDecimalStringTerm : TODECIMALSTRING '(' {$$ = TrCreateLeafNode (TODECIMALSTRING)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | TODECIMALSTRING '(' error ')' {$$ = NULL; yyerrok} ; ToHexStringTerm : TOHEXSTRING '(' {$$ = TrCreateLeafNode (TOHEXSTRING)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | TOHEXSTRING '(' error ')' {$$ = NULL; yyerrok} ; ToIntegerTerm : TOINTEGER '(' {$$ = TrCreateLeafNode (TOINTEGER)} TermArg Target ')' {$$ = TrLinkChildren ($3,2,$4,$5)} | TOINTEGER '(' error ')' {$$ = NULL; yyerrok} ; ToStringTerm : TOSTRING '(' {$$ = TrCreateLeafNode (TOSTRING)} TermArg OptionalListTermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$5,$6)} | TOSTRING '(' error ')' {$$ = NULL; yyerrok} ; WaitTerm : WAIT '(' {$$ = TrCreateLeafNode (WAIT)} SuperName ',' TermArg ')' {$$ = TrLinkChildren ($3,2,$4,$6)} | WAIT '(' error ')' {$$ = NULL; yyerrok} ; XOrTerm : XOR '(' {$$ = TrCreateLeafNode (XOR)} TermArg ',' TermArg Target ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | XOR '(' error ')' {$$ = NULL; 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 : UserDefRegionSpace {} | 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)} ; UserDefRegionSpace : ByteConst {} ; 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_BYTE {$$ = TrCreateValuedLeafNode (BYTECONST, (void *) AslCompilerlval.i)} ; WordConst : ByteConst {$$ = TrUpdateNode (WORDCONST, $1)} | INTEGER_WORD {$$ = TrCreateValuedLeafNode (WORDCONST, (void *) AslCompilerlval.i)} ; DwordConst : WordConst {$$ = TrUpdateNode (DWORDCONST, $1)} | INTEGER_DWORD {$$ = TrCreateValuedLeafNode (DWORDCONST, (void *) AslCompilerlval.i)} ; QwordConst : DwordConst {$$ = TrUpdateNode (QWORDCONST, $1)} | INTEGER_QWORD {$$ = TrCreateValuedLeafNode (QWORDCONST, (void *) AslCompilerlval.i)} ; Integer : ByteConst {$$ = TrUpdateNode (INTEGER, $1)} | WordConst {$$ = TrUpdateNode (INTEGER, $1)} | DwordConst {$$ = TrUpdateNode (INTEGER, $1)} | QwordConst {$$ = TrUpdateNode (INTEGER, $1)} ; String : STRING_LITERAL {$$ = TrCreateValuedLeafNode (STRING_LITERAL, AslCompilerlval.s)} ; /* * TBD: Needs | REVISION */ ConstTerm : ConstExprTerm {} ; ByteConstExpr : Type3Opcode {$$ = TrUpdateNode (BYTECONST, $1)} | Type2IntegerOpcode {$$ = TrUpdateNode (BYTECONST, $1)} | ConstExprTerm {$$ = TrUpdateNode (BYTECONST, $1)} | ByteConst {} ; WordConstExpr : ByteConstExpr {$$ = TrUpdateNode (WORDCONST, $1)} | WordConst {} ; DWordConstExpr : WordConstExpr {$$ = TrUpdateNode (DWORDCONST, $1)} | DwordConst {} ; QWordConstExpr : DWordConstExpr {$$ = 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 ')' {$$ = NULL; 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 ')' {$$ = NULL; 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 ')' {$$ = NULL; 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 ')' {$$ = NULL; 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 ')' {$$ = NULL; 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 ')' {$$ = NULL; 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 ')' {$$ = NULL; yyerrok} ; EndDependentFnTerm : ENDDEPENDENTFN '(' ')' {$$ = TrCreateLeafNode (ENDDEPENDENTFN)} | ENDDEPENDENTFN '(' error ')' {$$ = NULL; yyerrok} ; FixedIOTerm : FIXEDIO '(' {$$ = TrCreateLeafNode (FIXEDIO)} WordConstExpr ',' ByteConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,3,$4,$6,$7)} | FIXEDIO '(' error ')' {$$ = NULL; 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 ')' {$$ = NULL; yyerrok} ; IOTerm : IO '(' {$$ = TrCreateLeafNode (IO)} IODecodeKeyword ',' WordConstExpr ',' WordConstExpr ',' ByteConstExpr ',' ByteConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13)} | IO '(' error ')' {$$ = NULL; yyerrok} ; IRQNoFlagsTerm : IRQNOFLAGS '(' {$$ = TrCreateLeafNode (IRQNOFLAGS)} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | IRQNOFLAGS '(' error ')' {$$ = NULL; yyerrok} ; IRQTerm : IRQ '(' {$$ = TrCreateLeafNode (IRQ)} InterruptTypeKeyword ',' InterruptLevel OptionalShareType OptionalNameString_Last ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,5,$4,$6,$7,$8,$11)} | IRQ '(' error ')' {$$ = NULL; yyerrok} ; Memory24Term : MEMORY24 '(' {$$ = TrCreateLeafNode (MEMORY24)} ReadWriteKeyword ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr ',' WordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13)} | MEMORY24 '(' error ')' {$$ = NULL; yyerrok} ; Memory32FixedTerm : MEMORY32FIXED '(' {$$ = TrCreateLeafNode (MEMORY32FIXED)} ReadWriteKeyword ',' DWordConstExpr ',' DWordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$9)} | MEMORY32FIXED '(' error ')' {$$ = NULL; yyerrok} ; Memory32Term : MEMORY32 '(' {$$ = TrCreateLeafNode (MEMORY32)} ReadWriteKeyword ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr ',' DWordConstExpr OptionalNameString_Last ')' {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13)} | MEMORY32 '(' error ')' {$$ = NULL; 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 ')' {$$ = NULL; 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 ')' {$$ = NULL; yyerrok} ; RegisterTerm : REGISTER '(' {$$ = TrCreateLeafNode (REGISTER)} AddressSpaceKeyword ',' ByteConstExpr ',' ByteConstExpr ',' QWordConstExpr ')' {$$ = TrLinkChildren ($3,4,$4,$6,$8,$10)} | REGISTER '(' error ')' {$$ = NULL; yyerrok} ; StartDependentFnTerm : STARTDEPENDENTFN '(' {$$ = TrCreateLeafNode (STARTDEPENDENTFN)} ByteConstExpr ',' ByteConstExpr ')' '{' ResourceMacroList '}' {$$ = TrLinkChildren ($3,3,$4,$6,$9)} | STARTDEPENDENTFN '(' error ')' {$$ = NULL; yyerrok} ; StartDependentFnNoPriTerm : STARTDEPENDENTFN_NOPRI '(' {$$ = TrCreateLeafNode (STARTDEPENDENTFN_NOPRI)} ')' '{' ResourceMacroList '}' {$$ = TrLinkChildren ($3,1,$6)} | STARTDEPENDENTFN_NOPRI '(' error ')' {$$ = NULL; yyerrok} ; VendorLongTerm : VENDORLONG '(' {$$ = TrCreateLeafNode (VENDORLONG)} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | VENDORLONG '(' error ')' {$$ = NULL; yyerrok} ; VendorShortTerm : VENDORSHORT '(' {$$ = TrCreateLeafNode (VENDORSHORT)} OptionalNameString_First ')' '{' ByteList '}' {$$ = TrLinkChildren ($3,2,$4,$7)} | VENDORSHORT '(' error ')' {$$ = NULL; 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 ')' {$$ = NULL; 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 ')' {$$ = NULL; yyerrok} ; /******* Object References ***********************************************/ NameString : NameSeg {} | NAMESTRING {$$ = TrCreateValuedLeafNode (NAMESTRING, AslCompilerlval.s)} ; NameSeg : NAMESEG {$$ = TrCreateValuedLeafNode (NAMESEG, AslCompilerlval.s)} ; /* TBD: Could not find in spec */ ObjectReference : NameString {} ; /******* 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} ; %% /* programs */ int AslCompilerwrap() { return 1; } void * AslLocalAllocate (unsigned int Size) { void *Mem; DbgPrint ("\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_InputFilename, NULL); exit (1); } return (Mem); }