blob: dcf3c22d87c9bd8ccb9f8c8cdf302192faf3de6d [file] [log] [blame]
NoEcho('
/******************************************************************************
*
* Module Name: aslrules.y - Main Bison/Yacc production rules
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2016, Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*/
')
/*******************************************************************************
*
* ASL Root and Secondary Terms
*
******************************************************************************/
/*
* Root term. Allow multiple #line directives before the definition block
* to handle output from preprocessors
*/
AslCode
: DefinitionBlockList {$<n>$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_ASL_CODE),1, $1);}
| error {YYABORT; $$ = NULL;}
;
/*
* Note concerning support for "module-level code".
*
* ACPI 1.0 allowed Type1 and Type2 executable opcodes outside of control
* methods (the so-called module-level code.) This support was explicitly
* removed in ACPI 2.0, but this type of code continues to be created by
* BIOS vendors. In order to support the disassembly and recompilation of
* such code (and the porting of ASL code to iASL), iASL supports this
* code in violation of the current ACPI specification.
*
* The grammar change to support module-level code is to revert the
* {ObjectList} portion of the DefinitionBlockTerm in ACPI 2.0 to the
* original use of {TermList} instead (see below.) This allows the use
* of Type1 and Type2 opcodes at module level.
*/
DefinitionBlockTerm
: PARSEOP_DEFINITION_BLOCK '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITION_BLOCK);}
String ','
String ','
ByteConst ','
String ','
String ','
DWordConst
')' {TrSetEndLineNumber ($<n>3);}
'{' TermList '}' {$$ = TrLinkChildren ($<n>3,7,$4,$6,$8,$10,$12,$14,$18);}
;
DefinitionBlockList
: DefinitionBlockTerm
| DefinitionBlockTerm
DefinitionBlockList {$$ = TrLinkPeerNodes (2, $1,$2);}
;
SuperName
: NameString {}
| ArgTerm {}
| LocalTerm {}
| DebugTerm {}
| Type6Opcode {}
Target
: {$$ = TrCreateNullTarget ();} /* Placeholder is a ZeroOp object */
| ',' {$$ = TrCreateNullTarget ();} /* Placeholder is a ZeroOp object */
| ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
;
TermArg
: Type2Opcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| DataObject {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| NameString {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| ArgTerm {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| LocalTerm {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
;
/*
NOTE: Removed from TermArg due to reduce/reduce conflicts:
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| Type2BufferOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
| Type2BufferOrStringOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
*/
MethodInvocationTerm
: NameString '(' {TrUpdateNode (PARSEOP_METHODCALL, $1);}
ArgList ')' {$$ = TrLinkChildNode ($1,$4);}
;
/* OptionalCount must appear before ByteList or an incorrect reduction will result */
OptionalCount
: {$$ = TrCreateLeafNode (PARSEOP_ONES);} /* Placeholder is a OnesOp object */
| ',' {$$ = TrCreateLeafNode (PARSEOP_ONES);} /* Placeholder is a OnesOp object */
| ',' TermArg {$$ = $2;}
;
VarPackageLengthTerm
: {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
| TermArg {$$ = $1;}
;
/******* List Terms **************************************************/
ArgList
: {$$ = NULL;}
| TermArg
| ArgList ',' /* Allows a trailing comma at list end */
| ArgList ','
TermArg {$$ = TrLinkPeerNode ($1,$3);}
;
ByteList
: {$$ = NULL;}
| ByteConstExpr
| ByteList ',' /* Allows a trailing comma at list end */
| ByteList ','
ByteConstExpr {$$ = TrLinkPeerNode ($1,$3);}
;
DWordList
: {$$ = NULL;}
| DWordConstExpr
| DWordList ',' /* Allows a trailing comma at list end */
| DWordList ','
DWordConstExpr {$$ = TrLinkPeerNode ($1,$3);}
;
FieldUnitList
: {$$ = NULL;}
| FieldUnit
| FieldUnitList ',' /* Allows a trailing comma at list end */
| FieldUnitList ','
FieldUnit {$$ = TrLinkPeerNode ($1,$3);}
;
FieldUnit
: FieldUnitEntry {}
| OffsetTerm {}
| AccessAsTerm {}
| ConnectionTerm {}
;
FieldUnitEntry
: ',' AmlPackageLengthTerm {$$ = TrCreateNode (PARSEOP_RESERVED_BYTES,1,$2);}
| NameSeg ','
AmlPackageLengthTerm {$$ = TrLinkChildNode ($1,$3);}
;
ObjectList
: {$$ = NULL;}
| ObjectList Object {$$ = TrLinkPeerNode ($1,$2);}
| error {$$ = AslDoError(); yyclearin;}
;
Object
: CompilerDirective {}
| NamedObject {}
| NameSpaceModifier {}
;
PackageList
: {$$ = NULL;}
| PackageElement
| PackageList ',' /* Allows a trailing comma at list end */
| PackageList ','
PackageElement {$$ = TrLinkPeerNode ($1,$3);}
;
PackageElement
: DataObject {}
| NameString {}
;
/* Rules for specifying the type of one method argument or return value */
ParameterTypePackage
: {$$ = NULL;}
| ObjectTypeKeyword {$$ = $1;}
| ParameterTypePackage ','
ObjectTypeKeyword {$$ = TrLinkPeerNodes (2,$1,$3);}
;
ParameterTypePackageList
: {$$ = NULL;}
| ObjectTypeKeyword {$$ = $1;}
| '{' ParameterTypePackage '}' {$$ = $2;}
;
OptionalParameterTypePackage
: {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
| ',' ParameterTypePackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
;
/* Rules for specifying the types for method arguments */
ParameterTypesPackage
: ParameterTypePackageList {$$ = $1;}
| ParameterTypesPackage ','
ParameterTypePackageList {$$ = TrLinkPeerNodes (2,$1,$3);}
;
ParameterTypesPackageList
: {$$ = NULL;}
| ObjectTypeKeyword {$$ = $1;}
| '{' ParameterTypesPackage '}' {$$ = $2;}
;
OptionalParameterTypesPackage
: {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
| ',' ParameterTypesPackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
;
/* ACPI 3.0 -- allow semicolons between terms */
TermList
: {$$ = NULL;}
| TermList Term {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
| TermList Term ';' {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
| TermList ';' Term {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
| TermList ';' Term ';' {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
;
Term
: Object {}
| Type1Opcode {}
| Type2Opcode {}
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type2BufferOpcode {}
| Type2BufferOrStringOpcode {}
| error {$$ = AslDoError(); yyclearin;}
;
/*
* Case-Default list; allow only one Default term and unlimited Case terms
*/
CaseDefaultTermList
: {$$ = NULL;}
| CaseTerm {}
| DefaultTerm {}
| CaseDefaultTermList
CaseTerm {$$ = TrLinkPeerNode ($1,$2);}
| CaseDefaultTermList
DefaultTerm {$$ = TrLinkPeerNode ($1,$2);}
/* Original - attempts to force zero or one default term within the switch */
/*
CaseDefaultTermList
: {$$ = NULL;}
| CaseTermList
DefaultTerm
CaseTermList {$$ = TrLinkPeerNode ($1,TrLinkPeerNode ($2, $3));}
| CaseTermList
CaseTerm {$$ = TrLinkPeerNode ($1,$2);}
;
CaseTermList
: {$$ = NULL;}
| CaseTerm {}
| CaseTermList
CaseTerm {$$ = TrLinkPeerNode ($1,$2);}
;
*/
/*******************************************************************************
*
* ASL Data and Constant Terms
*
******************************************************************************/
DataObject
: BufferData {}
| PackageData {}
| IntegerData {}
| StringData {}
;
BufferData
: Type5Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type2BufferOrStringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type2BufferOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| BufferTerm {}
;
PackageData
: PackageTerm {}
;
IntegerData
: Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Type3Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| Integer {}
| ConstTerm {}
;
StringData
: Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| String {}
;
ByteConst
: Integer {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
;
WordConst
: Integer {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
;
DWordConst
: Integer {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
;
QWordConst
: Integer {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
;
/*
* The NODE_COMPILE_TIME_CONST flag in the following constant expressions
* enables compile-time constant folding to reduce the Type3Opcodes/Type2IntegerOpcodes
* to simple integers. It is an error if these types of expressions cannot be
* reduced, since the AML grammar for ****ConstExpr requires a simple constant.
* Note: The required byte length of the constant is passed through to the
* constant folding code in the node AmlLength field.
*/
ByteConstExpr
: Type3Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 1);}
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 1);}
| ConstExprTerm {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
| ByteConst {}
;
WordConstExpr
: Type3Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 2);}
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 2);}
| ConstExprTerm {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
| WordConst {}
;
DWordConstExpr
: Type3Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 4);}
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 4);}
| ConstExprTerm {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
| DWordConst {}
;
QWordConstExpr
: Type3Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 8);}
| Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST); TrSetNodeAmlLength ($1, 8);}
| ConstExprTerm {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
| QWordConst {}
;
ConstTerm
: ConstExprTerm {}
| PARSEOP_REVISION {$$ = TrCreateLeafNode (PARSEOP_REVISION);}
;
ConstExprTerm
: PARSEOP_ZERO {$$ = TrCreateValuedLeafNode (PARSEOP_ZERO, 0);}
| PARSEOP_ONE {$$ = TrCreateValuedLeafNode (PARSEOP_ONE, 1);}
| PARSEOP_ONES {$$ = TrCreateValuedLeafNode (PARSEOP_ONES, ACPI_UINT64_MAX);}
| PARSEOP___DATE__ {$$ = TrCreateConstantLeafNode (PARSEOP___DATE__);}
| PARSEOP___FILE__ {$$ = TrCreateConstantLeafNode (PARSEOP___FILE__);}
| PARSEOP___LINE__ {$$ = TrCreateConstantLeafNode (PARSEOP___LINE__);}
| PARSEOP___PATH__ {$$ = TrCreateConstantLeafNode (PARSEOP___PATH__);}
;
Integer
: PARSEOP_INTEGER {$$ = TrCreateValuedLeafNode (PARSEOP_INTEGER, AslCompilerlval.i);}
;
String
: PARSEOP_STRING_LITERAL {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, (ACPI_NATIVE_INT) AslCompilerlval.s);}
;
/*******************************************************************************
*
* ASL Opcode Terms
*
******************************************************************************/
CompilerDirective
: IncludeTerm {}
| IncludeEndTerm {}
| ExternalTerm {}
;
NamedObject
: BankFieldTerm {}
| CreateBitFieldTerm {}
| CreateByteFieldTerm {}
| CreateDWordFieldTerm {}
| CreateFieldTerm {}
| CreateQWordFieldTerm {}
| CreateWordFieldTerm {}
| DataRegionTerm {}
| DeviceTerm {}
| EventTerm {}
| FieldTerm {}
| FunctionTerm {}
| IndexFieldTerm {}
| MethodTerm {}
| MutexTerm {}
| OpRegionTerm {}
| PowerResTerm {}
| ProcessorTerm {}
| ThermalZoneTerm {}
;
NameSpaceModifier
: AliasTerm {}
| NameTerm {}
| ScopeTerm {}
;
/* For ObjectType: SuperName except for MethodInvocationTerm */
ObjectTypeName
: NameString {}
| ArgTerm {}
| LocalTerm {}
| DebugTerm {}
| RefOfTerm {}
| DerefOfTerm {}
| IndexTerm {}
/* | MethodInvocationTerm {} */ /* Caused reduce/reduce with Type6Opcode->MethodInvocationTerm */
;
RequiredTarget
: ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
;
SimpleTarget
: NameString {}
| LocalTerm {}
| ArgTerm {}
;
/* Opcode types */
Type1Opcode
: BreakTerm {}
| BreakPointTerm {}
| ContinueTerm {}
| FatalTerm {}
| ElseIfTerm {}
| LoadTerm {}
| NoOpTerm {}
| NotifyTerm {}
| ReleaseTerm {}
| ResetTerm {}
| ReturnTerm {}
| SignalTerm {}
| SleepTerm {}
| StallTerm {}
| SwitchTerm {}
| UnloadTerm {}
| WhileTerm {}
;
Type2Opcode
: AcquireTerm {}
| CondRefOfTerm {}
| CopyObjectTerm {}
| DerefOfTerm {}
| ObjectTypeTerm {}
| RefOfTerm {}
| SizeOfTerm {}
| StoreTerm {}
| EqualsTerm {}
| TimerTerm {}
| WaitTerm {}
| MethodInvocationTerm {}
;
/*
* Type 3/4/5 opcodes
*/
Type2IntegerOpcode /* "Type3" opcodes */
: Expression {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| 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 {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
| PrintfTerm {}
| FprintfTerm {}
| 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 {}
| ToPLDTerm {}
| ToUUIDTerm {}
;
Type6Opcode
: RefOfTerm {}
| DerefOfTerm {}
| IndexTerm {}
| IndexExpTerm {}
| MethodInvocationTerm {}
;
/*******************************************************************************
*
* ASL Primary Terms
*
******************************************************************************/
AccessAsTerm
: PARSEOP_ACCESSAS '('
AccessTypeKeyword
OptionalAccessAttribTerm
')' {$$ = TrCreateNode (PARSEOP_ACCESSAS,2,$3,$4);}
| PARSEOP_ACCESSAS '('
error ')' {$$ = AslDoError(); yyclearin;}
;
AcquireTerm
: PARSEOP_ACQUIRE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACQUIRE);}
SuperName
',' WordConstExpr
')' {$$ = TrLinkChildren ($<n>3,2,$4,$6);}
| PARSEOP_ACQUIRE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
AddTerm
: PARSEOP_ADD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_ADD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
AliasTerm
: PARSEOP_ALIAS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ALIAS);}
NameString
NameStringItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,
TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));}
| PARSEOP_ALIAS '('
error ')' {$$ = AslDoError(); yyclearin;}
;
AndTerm
: PARSEOP_AND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_AND);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_AND '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ArgTerm
: PARSEOP_ARG0 {$$ = TrCreateLeafNode (PARSEOP_ARG0);}
| PARSEOP_ARG1 {$$ = TrCreateLeafNode (PARSEOP_ARG1);}
| PARSEOP_ARG2 {$$ = TrCreateLeafNode (PARSEOP_ARG2);}
| PARSEOP_ARG3 {$$ = TrCreateLeafNode (PARSEOP_ARG3);}
| PARSEOP_ARG4 {$$ = TrCreateLeafNode (PARSEOP_ARG4);}
| PARSEOP_ARG5 {$$ = TrCreateLeafNode (PARSEOP_ARG5);}
| PARSEOP_ARG6 {$$ = TrCreateLeafNode (PARSEOP_ARG6);}
;
BankFieldTerm
: PARSEOP_BANKFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BANKFIELD);}
NameString
NameStringItem
TermArgItem
',' AccessTypeKeyword
',' LockRuleKeyword
',' UpdateRuleKeyword
')' '{'
FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,7,$4,$5,$6,$8,$10,$12,$15);}
| PARSEOP_BANKFIELD '('
error ')' '{' error '}' {$$ = AslDoError(); yyclearin;}
;
BreakTerm
: PARSEOP_BREAK {$$ = TrCreateNode (PARSEOP_BREAK, 0);}
;
BreakPointTerm
: PARSEOP_BREAKPOINT {$$ = TrCreateNode (PARSEOP_BREAKPOINT, 0);}
;
BufferTerm
: PARSEOP_BUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BUFFER);}
OptionalTermArg
')' '{'
BufferTermData '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_BUFFER '('
error ')' {$$ = AslDoError(); yyclearin;}
;
BufferTermData
: ByteList {}
| StringData {}
;
CaseTerm
: PARSEOP_CASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CASE);}
DataObject
')' '{'
TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_CASE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ConcatTerm
: PARSEOP_CONCATENATE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATE);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_CONCATENATE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ConcatResTerm
: PARSEOP_CONCATENATERESTEMPLATE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATERESTEMPLATE);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_CONCATENATERESTEMPLATE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ConnectionTerm
: PARSEOP_CONNECTION '('
NameString
')' {$$ = TrCreateNode (PARSEOP_CONNECTION,1,$3);}
| PARSEOP_CONNECTION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONNECTION);}
ResourceMacroTerm
')' {$$ = TrLinkChildren ($<n>3, 1,
TrLinkChildren (TrCreateLeafNode (PARSEOP_RESOURCETEMPLATE), 3,
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
$4));}
| PARSEOP_CONNECTION '('
error ')' {$$ = AslDoError(); yyclearin;}
;
CondRefOfTerm
: PARSEOP_CONDREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONDREFOF);}
SuperName
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_CONDREFOF '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ContinueTerm
: PARSEOP_CONTINUE {$$ = TrCreateNode (PARSEOP_CONTINUE, 0);}
;
CopyObjectTerm
: PARSEOP_COPYOBJECT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);}
TermArg
',' SimpleTarget
')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
| PARSEOP_COPYOBJECT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
CreateBitFieldTerm
: PARSEOP_CREATEBITFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);}
TermArg
TermArgItem
NameStringItem
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
| PARSEOP_CREATEBITFIELD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
CreateByteFieldTerm
: PARSEOP_CREATEBYTEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);}
TermArg
TermArgItem
NameStringItem
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
| PARSEOP_CREATEBYTEFIELD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
CreateDWordFieldTerm
: PARSEOP_CREATEDWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);}
TermArg
TermArgItem
NameStringItem
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
| PARSEOP_CREATEDWORDFIELD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
CreateFieldTerm
: PARSEOP_CREATEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);}
TermArg
TermArgItem
TermArgItem
NameStringItem
')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,TrSetNodeFlags ($7, NODE_IS_NAME_DECLARATION));}
| PARSEOP_CREATEFIELD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
CreateQWordFieldTerm
: PARSEOP_CREATEQWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);}
TermArg
TermArgItem
NameStringItem
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
| PARSEOP_CREATEQWORDFIELD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
CreateWordFieldTerm
: PARSEOP_CREATEWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);}
TermArg
TermArgItem
NameStringItem
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
| PARSEOP_CREATEWORDFIELD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
DataRegionTerm
: PARSEOP_DATATABLEREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);}
NameString
TermArgItem
TermArgItem
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$6,$7);}
| PARSEOP_DATATABLEREGION '('
error ')' {$$ = AslDoError(); yyclearin;}
;
DebugTerm
: PARSEOP_DEBUG {$$ = TrCreateLeafNode (PARSEOP_DEBUG);}
;
DecTerm
: PARSEOP_DECREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DECREMENT);}
SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_DECREMENT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
DefaultTerm
: PARSEOP_DEFAULT '{' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFAULT);}
TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_DEFAULT '{'
error '}' {$$ = AslDoError(); yyclearin;}
;
DerefOfTerm
: PARSEOP_DEREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEREFOF);}
TermArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_DEREFOF '('
error ')' {$$ = AslDoError(); yyclearin;}
;
DeviceTerm
: PARSEOP_DEVICE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEVICE);}
NameString
')' '{'
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
| PARSEOP_DEVICE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
DivideTerm
: PARSEOP_DIVIDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DIVIDE);}
TermArg
TermArgItem
Target
Target
')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);}
| PARSEOP_DIVIDE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
EISAIDTerm
: PARSEOP_EISAID '('
StringData ')' {$$ = TrUpdateNode (PARSEOP_EISAID, $3);}
| PARSEOP_EISAID '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ElseIfTerm
: IfTerm ElseTerm {$$ = TrLinkPeerNode ($1,$2);}
;
ElseTerm
: {$$ = NULL;}
| PARSEOP_ELSE '{' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ELSE '{'
error '}' {$$ = AslDoError(); yyclearin;}
| PARSEOP_ELSE
error {$$ = AslDoError(); yyclearin;}
| PARSEOP_ELSEIF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
TermArg {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
')' '{'
TermList '}' {TrLinkChildren ($<n>5,2,$4,$8);}
ElseTerm {TrLinkPeerNode ($<n>5,$11);}
{$$ = TrLinkChildren ($<n>3,1,$<n>5);}
| PARSEOP_ELSEIF '('
error ')' {$$ = AslDoError(); yyclearin;}
| PARSEOP_ELSEIF
error {$$ = AslDoError(); yyclearin;}
;
EventTerm
: PARSEOP_EVENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EVENT);}
NameString
')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));}
| PARSEOP_EVENT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ExternalTerm
: PARSEOP_EXTERNAL '('
NameString
OptionalObjectTypeKeyword
OptionalParameterTypePackage
OptionalParameterTypesPackage
')' {$$ = TrCreateNode (PARSEOP_EXTERNAL,4,$3,$4,$5,$6);}
| PARSEOP_EXTERNAL '('
error ')' {$$ = AslDoError(); yyclearin;}
;
FatalTerm
: PARSEOP_FATAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FATAL);}
ByteConstExpr
',' DWordConstExpr
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
| PARSEOP_FATAL '('
error ')' {$$ = AslDoError(); yyclearin;}
;
FieldTerm
: PARSEOP_FIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIELD);}
NameString
',' AccessTypeKeyword
',' LockRuleKeyword
',' UpdateRuleKeyword
')' '{'
FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$6,$8,$10,$13);}
| PARSEOP_FIELD '('
error ')' '{' error '}' {$$ = AslDoError(); yyclearin;}
;
FindSetLeftBitTerm
: PARSEOP_FINDSETLEFTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_FINDSETLEFTBIT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
FindSetRightBitTerm
: PARSEOP_FINDSETRIGHTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_FINDSETRIGHTBIT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
FprintfTerm
: PARSEOP_FPRINTF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FPRINTF);}
TermArg ','
StringData
PrintfArgList
')' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
| PARSEOP_FPRINTF '('
error ')' {$$ = AslDoError(); yyclearin;}
;
FromBCDTerm
: PARSEOP_FROMBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FROMBCD);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_FROMBCD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
FunctionTerm
: PARSEOP_FUNCTION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
NameString
OptionalParameterTypePackage
OptionalParameterTypesPackage
')' '{'
TermList '}' {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),
TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),
TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL),
TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),$5,$6,$9);}
| PARSEOP_FUNCTION '('
error ')' {$$ = AslDoError(); yyclearin;}
;
IfTerm
: PARSEOP_IF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
TermArg
')' '{'
TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_IF '('
error ')' {$$ = AslDoError(); yyclearin;}
;
IncludeTerm
: PARSEOP_INCLUDE '('
String ')' {$$ = TrUpdateNode (PARSEOP_INCLUDE, $3);
FlOpenIncludeFile ($3);}
;
IncludeEndTerm
: PARSEOP_INCLUDE_END {$<n>$ = TrCreateLeafNode (PARSEOP_INCLUDE_END); TrSetCurrentFilename ($$);}
;
IncTerm
: PARSEOP_INCREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCREMENT);}
SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_INCREMENT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
IndexFieldTerm
: PARSEOP_INDEXFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);}
NameString
NameStringItem
',' AccessTypeKeyword
',' LockRuleKeyword
',' UpdateRuleKeyword
')' '{'
FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,6,$4,$5,$7,$9,$11,$14);}
| PARSEOP_INDEXFIELD '('
error ')' '{' error '}' {$$ = AslDoError(); yyclearin;}
;
IndexTerm
: PARSEOP_INDEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEX);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_INDEX '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LAndTerm
: PARSEOP_LAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LAND);}
TermArg
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_LAND '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LEqualTerm
: PARSEOP_LEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
TermArg
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_LEQUAL '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LGreaterEqualTerm
: PARSEOP_LGREATEREQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
TermArg
TermArgItem
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
| PARSEOP_LGREATEREQUAL '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LGreaterTerm
: PARSEOP_LGREATER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
TermArg
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_LGREATER '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LLessEqualTerm
: PARSEOP_LLESSEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
TermArg
TermArgItem
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
| PARSEOP_LLESSEQUAL '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LLessTerm
: PARSEOP_LLESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
TermArg
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_LLESS '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LNotEqualTerm
: PARSEOP_LNOTEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
TermArg
TermArgItem
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
| PARSEOP_LNOTEQUAL '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LNotTerm
: PARSEOP_LNOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LNOT);}
TermArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_LNOT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LoadTableTerm
: PARSEOP_LOADTABLE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOADTABLE);}
TermArg
TermArgItem
TermArgItem
OptionalListString
OptionalListString
OptionalReference
')' {$$ = TrLinkChildren ($<n>3,6,$4,$5,$6,$7,$8,$9);}
| PARSEOP_LOADTABLE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LoadTerm
: PARSEOP_LOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOAD);}
NameString
RequiredTarget
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_LOAD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
LocalTerm
: PARSEOP_LOCAL0 {$$ = TrCreateLeafNode (PARSEOP_LOCAL0);}
| PARSEOP_LOCAL1 {$$ = TrCreateLeafNode (PARSEOP_LOCAL1);}
| PARSEOP_LOCAL2 {$$ = TrCreateLeafNode (PARSEOP_LOCAL2);}
| PARSEOP_LOCAL3 {$$ = TrCreateLeafNode (PARSEOP_LOCAL3);}
| PARSEOP_LOCAL4 {$$ = TrCreateLeafNode (PARSEOP_LOCAL4);}
| PARSEOP_LOCAL5 {$$ = TrCreateLeafNode (PARSEOP_LOCAL5);}
| PARSEOP_LOCAL6 {$$ = TrCreateLeafNode (PARSEOP_LOCAL6);}
| PARSEOP_LOCAL7 {$$ = TrCreateLeafNode (PARSEOP_LOCAL7);}
;
LOrTerm
: PARSEOP_LOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOR);}
TermArg
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_LOR '('
error ')' {$$ = AslDoError(); yyclearin;}
;
MatchTerm
: PARSEOP_MATCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MATCH);}
TermArg
',' MatchOpKeyword
TermArgItem
',' MatchOpKeyword
TermArgItem
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$7,$9,$10,$11);}
| PARSEOP_MATCH '('
error ')' {$$ = AslDoError(); yyclearin;}
;
MethodTerm
: PARSEOP_METHOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
NameString
OptionalByteConstExpr {UtCheckIntegerRange ($5, 0, 7);}
OptionalSerializeRuleKeyword
OptionalByteConstExpr
OptionalParameterTypePackage
OptionalParameterTypesPackage
')' '{'
TermList '}' {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$7,$8,$9,$10,$13);}
| PARSEOP_METHOD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
MidTerm
: PARSEOP_MID '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MID);}
TermArg
TermArgItem
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);}
| PARSEOP_MID '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ModTerm
: PARSEOP_MOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MOD);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_MOD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
MultiplyTerm
: PARSEOP_MULTIPLY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MULTIPLY);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_MULTIPLY '('
error ')' {$$ = AslDoError(); yyclearin;}
;
MutexTerm
: PARSEOP_MUTEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MUTEX);}
NameString
',' ByteConstExpr
')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
| PARSEOP_MUTEX '('
error ')' {$$ = AslDoError(); yyclearin;}
;
NameTerm
: PARSEOP_NAME '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAME);}
NameString
',' DataObject
')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
| PARSEOP_NAME '('
error ')' {$$ = AslDoError(); yyclearin;}
;
NAndTerm
: PARSEOP_NAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAND);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_NAND '('
error ')' {$$ = AslDoError(); yyclearin;}
;
NoOpTerm
: PARSEOP_NOOP {$$ = TrCreateNode (PARSEOP_NOOP, 0);}
;
NOrTerm
: PARSEOP_NOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOR);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_NOR '('
error ')' {$$ = AslDoError(); yyclearin;}
;
NotifyTerm
: PARSEOP_NOTIFY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOTIFY);}
SuperName
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_NOTIFY '('
error ')' {$$ = AslDoError(); yyclearin;}
;
NotTerm
: PARSEOP_NOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOT);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_NOT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ObjectTypeTerm
: PARSEOP_OBJECTTYPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);}
ObjectTypeName
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_OBJECTTYPE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
OffsetTerm
: PARSEOP_OFFSET '('
AmlPackageLengthTerm
')' {$$ = TrCreateNode (PARSEOP_OFFSET,1,$3);}
| PARSEOP_OFFSET '('
error ')' {$$ = AslDoError(); yyclearin;}
;
OpRegionTerm
: PARSEOP_OPERATIONREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);}
NameString
',' OpRegionSpaceIdTerm
TermArgItem
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8);}
| PARSEOP_OPERATIONREGION '('
error ')' {$$ = AslDoError(); yyclearin;}
;
OpRegionSpaceIdTerm
: RegionSpaceKeyword {}
| ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
;
OrTerm
: PARSEOP_OR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OR);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_OR '('
error ')' {$$ = AslDoError(); yyclearin;}
;
PackageTerm
: PARSEOP_PACKAGE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VAR_PACKAGE);}
VarPackageLengthTerm
')' '{'
PackageList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_PACKAGE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
PowerResTerm
: PARSEOP_POWERRESOURCE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);}
NameString
',' ByteConstExpr
',' WordConstExpr
')' '{'
ObjectList '}' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$8,$11);}
| PARSEOP_POWERRESOURCE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
PrintfTerm
: PARSEOP_PRINTF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_PRINTF);}
StringData
PrintfArgList
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_PRINTF '('
error ')' {$$ = AslDoError(); yyclearin;}
;
PrintfArgList
: {$$ = NULL;}
| TermArg {$$ = $1;}
| PrintfArgList ','
TermArg {$$ = TrLinkPeerNode ($1, $3);}
;
ProcessorTerm
: PARSEOP_PROCESSOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_PROCESSOR);}
NameString
',' ByteConstExpr
OptionalDWordConstExpr
OptionalByteConstExpr
')' '{'
ObjectList '}' {$$ = TrLinkChildren ($<n>3,5,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8,$11);}
| PARSEOP_PROCESSOR '('
error ')' {$$ = AslDoError(); yyclearin;}
;
RawDataBufferTerm
: PARSEOP_DATABUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DATABUFFER);}
OptionalWordConst
')' '{'
ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_DATABUFFER '('
error ')' {$$ = AslDoError(); yyclearin;}
;
/*
* In RefOf, the node isn't really a target, but we can't keep track of it after
* we've taken a pointer to it. (hard to tell if a local becomes initialized this way.)
*/
RefOfTerm
: PARSEOP_REFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_REFOF);}
SuperName
')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));}
| PARSEOP_REFOF '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ReleaseTerm
: PARSEOP_RELEASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RELEASE);}
SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_RELEASE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ResetTerm
: PARSEOP_RESET '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RESET);}
SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_RESET '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ReturnTerm
: PARSEOP_RETURN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RETURN);}
OptionalReturnArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_RETURN {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_RETURN),1,TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN));}
| PARSEOP_RETURN '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ScopeTerm
: PARSEOP_SCOPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SCOPE);}
NameString
')' '{'
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
| PARSEOP_SCOPE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ShiftLeftTerm
: PARSEOP_SHIFTLEFT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_SHIFTLEFT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ShiftRightTerm
: PARSEOP_SHIFTRIGHT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_SHIFTRIGHT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
SignalTerm
: PARSEOP_SIGNAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIGNAL);}
SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_SIGNAL '('
error ')' {$$ = AslDoError(); yyclearin;}
;
SizeOfTerm
: PARSEOP_SIZEOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIZEOF);}
SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_SIZEOF '('
error ')' {$$ = AslDoError(); yyclearin;}
;
SleepTerm
: PARSEOP_SLEEP '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SLEEP);}
TermArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_SLEEP '('
error ')' {$$ = AslDoError(); yyclearin;}
;
StallTerm
: PARSEOP_STALL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STALL);}
TermArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_STALL '('
error ')' {$$ = AslDoError(); yyclearin;}
;
StoreTerm
: PARSEOP_STORE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STORE);}
TermArg
',' SuperName
')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
| PARSEOP_STORE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
SubtractTerm
: PARSEOP_SUBTRACT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SUBTRACT);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_SUBTRACT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
SwitchTerm
: PARSEOP_SWITCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SWITCH);}
TermArg
')' '{'
CaseDefaultTermList '}'
{$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_SWITCH '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ThermalZoneTerm
: PARSEOP_THERMALZONE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_THERMALZONE);}
NameString
')' '{'
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
| PARSEOP_THERMALZONE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
TimerTerm
: PARSEOP_TIMER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TIMER);}
')' {$$ = TrLinkChildren ($<n>3,0);}
| PARSEOP_TIMER {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_TIMER),0);}
| PARSEOP_TIMER '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ToBCDTerm
: PARSEOP_TOBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBCD);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_TOBCD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ToBufferTerm
: PARSEOP_TOBUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBUFFER);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_TOBUFFER '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ToDecimalStringTerm
: PARSEOP_TODECIMALSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_TODECIMALSTRING '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ToHexStringTerm
: PARSEOP_TOHEXSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_TOHEXSTRING '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ToIntegerTerm
: PARSEOP_TOINTEGER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOINTEGER);}
TermArg
Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_TOINTEGER '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ToPLDTerm
: PARSEOP_TOPLD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOPLD);}
PldKeywordList
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_TOPLD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
PldKeywordList
: {$$ = NULL;}
| PldKeyword
PARSEOP_EXP_EQUALS Integer {$$ = TrLinkChildren ($1,1,$3);}
| PldKeyword
PARSEOP_EXP_EQUALS String {$$ = TrLinkChildren ($1,1,$3);}
| PldKeywordList ',' /* Allows a trailing comma at list end */
| PldKeywordList ','
PldKeyword
PARSEOP_EXP_EQUALS Integer {$$ = TrLinkPeerNode ($1,TrLinkChildren ($3,1,$5));}
| PldKeywordList ','
PldKeyword
PARSEOP_EXP_EQUALS String {$$ = TrLinkPeerNode ($1,TrLinkChildren ($3,1,$5));}
;
ToStringTerm
: PARSEOP_TOSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOSTRING);}
TermArg
OptionalCount
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_TOSTRING '('
error ')' {$$ = AslDoError(); yyclearin;}
;
ToUUIDTerm
: PARSEOP_TOUUID '('
StringData ')' {$$ = TrUpdateNode (PARSEOP_TOUUID, $3);}
| PARSEOP_TOUUID '('
error ')' {$$ = AslDoError(); yyclearin;}
;
UnicodeTerm
: PARSEOP_UNICODE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNICODE);}
StringData
')' {$$ = TrLinkChildren ($<n>3,2,0,$4);}
| PARSEOP_UNICODE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
UnloadTerm
: PARSEOP_UNLOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNLOAD);}
SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_UNLOAD '('
error ')' {$$ = AslDoError(); yyclearin;}
;
WaitTerm
: PARSEOP_WAIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WAIT);}
SuperName
TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
| PARSEOP_WAIT '('
error ')' {$$ = AslDoError(); yyclearin;}
;
XOrTerm
: PARSEOP_XOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_XOR);}
TermArg
TermArgItem
Target
')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
| PARSEOP_XOR '('
error ')' {$$ = AslDoError(); yyclearin;}
;
WhileTerm
: PARSEOP_WHILE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WHILE);}
TermArg
')' '{' TermList '}'
{$$ = TrLinkChildren ($<n>3,2,$4,$7);}
| PARSEOP_WHILE '('
error ')' {$$ = AslDoError(); yyclearin;}
;
/*******************************************************************************
*
* ASL Helper Terms
*
******************************************************************************/
AmlPackageLengthTerm
: Integer {$$ = TrUpdateNode (PARSEOP_PACKAGE_LENGTH,(ACPI_PARSE_OBJECT *) $1);}
;
NameStringItem
: ',' NameString {$$ = $2;}
| ',' error {$$ = AslDoError (); yyclearin;}
;
TermArgItem
: ',' TermArg {$$ = $2;}
| ',' error {$$ = AslDoError (); yyclearin;}
;
OptionalReference
: {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */
| ',' {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */
| ',' TermArg {$$ = $2;}
;
OptionalReturnArg
: {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN);} /* Placeholder is a ZeroOp object */
| TermArg {$$ = $1;}
;
OptionalSerializeRuleKeyword
: {$$ = NULL;}
| ',' {$$ = NULL;}
| ',' SerializeRuleKeyword {$$ = $2;}
;
OptionalTermArg
: {$$ = NULL;}
| TermArg {$$ = $1;}
;
OptionalWordConst
: {$$ = NULL;}
| WordConst {$$ = $1;}
;