acpica/source/compiler/aslcompiler.y

%{
/******************************************************************************
 *
 * 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#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 <i> ACCESSAS
%token <i> ACCESSATTRIB_BLOCK
%token <i> ACCESSATTRIB_BYTE
%token <i> ACCESSATTRIB_CALL
%token <i> ACCESSATTRIB_QUICK
%token <i> ACCESSATTRIB_SND_RCV
%token <i> ACCESSATTRIB_WORD
%token <i> ACCESSTYPE_ANY
%token <i> ACCESSTYPE_BUF
%token <i> ACCESSTYPE_BYTE
%token <i> ACCESSTYPE_DWORD
%token <i> ACCESSTYPE_QWORD
%token <i> ACCESSTYPE_WORD
%token <i> ACQUIRE
%token <i> ADD
%token <i> ADDRESSSPACE_FFIXEDHW
%token <i> ADDRESSTYPE_ACPI
%token <i> ADDRESSTYPE_MEMORY
%token <i> ADDRESSTYPE_NVS
%token <i> ADDRESSTYPE_RESERVED
%token <i> ALIAS
%token <i> AND
%token <i> ARG0
%token <i> ARG1
%token <i> ARG2
%token <i> ARG3
%token <i> ARG4
%token <i> ARG5
%token <i> ARG6
%token <i> BANKFIELD
%token <i> BREAK
%token <i> BREAKPOINT
%token <i> BUFFER
%token <i> BUSMASTERTYPE_MASTER
%token <i> BUSMASTERTYPE_NOTMASTER
%token <i> BYTECONST
%token <i> CASE
%token <i> CONCATENATE
%token <i> CONCATENATERESTEMPLATE
%token <i> CONDREFOF
%token <i> CONTINUE
%token <i> COPY
%token <i> CREATEBITFIELD
%token <i> CREATEBYTEFIELD
%token <i> CREATEDWORDFIELD
%token <i> CREATEFIELD
%token <i> CREATEQWORDFIELD
%token <i> CREATEWORDFIELD
%token <i> DATATABLEREGION
%token <i> DEBUG
%token <i> DECODETYPE_POS
%token <i> DECODETYPE_SUB
%token <i> DECREMENT
%token <i> DEFAULT
%token <i> DEFAULT_ARG
%token <i> DEFINITIONBLOCK
%token <i> DEREFOF
%token <i> DEVICE
%token <i> DIVIDE
%token <i> DMA
%token <i> DMATYPE_A
%token <i> DMATYPE_COMPATIBILITY
%token <i> DMATYPE_B
%token <i> DMATYPE_F
%token <i> DWORDCONST
%token <i> DWORDIO
%token <i> DWORDMEMORY
%token <i> EISAID
%token <i> ELSE
%token <i> ELSEIF
%token <i> ENDDEPENDENTFN
%token <i> EVENT
%token <i> EXTERNAL
%token <i> FATAL
%token <i> FIELD
%token <i> FINDSETLEFTBIT
%token <i> FINDSETRIGHTBIT
%token <i> FIXEDIO
%token <i> FROMBCD
%token <i> IF
%token <i> INCLUDE
%token <i> INCLUDE_CSTYLE
%token <i> INCLUDE_END
%token <i> INCREMENT
%token <i> INDEX
%token <i> INDEXFIELD
%token <i> INTEGER
%token <i> INTEGER_BYTE
%token <i> INTEGER_WORD
%token <i> INTEGER_DWORD
%token <i> INTEGER_QWORD
%token <i> INTERRUPT
%token <i> INTLEVEL_ACTIVEHIGH
%token <i> INTLEVEL_ACTIVELOW
%token <i> INTTYPE_EDGE
%token <i> INTTYPE_LEVEL
%token <i> IO
%token <i> IODECODETYPE_10
%token <i> IODECODETYPE_16
%token <i> IRQ
%token <i> IRQNOFLAGS
%token <i> LAND
%token <i> LEQUAL
%token <i> LGREATER
%token <i> LGREATEREQUAL
%token <i> LLESS
%token <i> LLESSEQUAL
%token <i> LNOT
%token <i> LNOTEQUAL
%token <i> LOAD
%token <i> LOADTABLE
%token <i> LOCAL0
%token <i> LOCAL1
%token <i> LOCAL2
%token <i> LOCAL3
%token <i> LOCAL4
%token <i> LOCAL5
%token <i> LOCAL6
%token <i> LOCAL7
%token <i> LOCKRULE_LOCK
%token <i> LOCKRULE_NOLOCK
%token <i> LOR
%token <i> MATCH
%token <i> MATCHTYPE_MEQ
%token <i> MATCHTYPE_MGE
%token <i> MATCHTYPE_MGT
%token <i> MATCHTYPE_MLE
%token <i> MATCHTYPE_MLT
%token <i> MATCHTYPE_MTR
%token <i> MAXTYPE_FIXED
%token <i> MAXTYPE_NOTFIXED
%token <i> MEMORY24
%token <i> MEMORY32
%token <i> MEMORY32FIXED
%token <i> MEMTYPE_CACHEABLE
%token <i> MEMTYPE_NONCACHEABLE
%token <i> MEMTYPE_PREFETCHABLE
%token <i> MEMTYPE_WRITECOMBINING
%token <i> METHOD
%token <i> METHODCALL
%token <i> MID
%token <i> MINTYPE_FIXED
%token <i> MINTYPE_NOTFIXED
%token <i> MOD
%token <i> MULTIPLY
%token <i> MUTEX
%token <i> NAME
%token <s> NAMESEG
%token <s> NAMESTRING
%token <i> NAND
%token <i> NOOP
%token <i> NOR
%token <i> NOT
%token <i> NOTIFY
%token <i> OBJECTTYPE
%token <i> OBJECTTYPE_BFF
%token <i> OBJECTTYPE_BUF
%token <i> OBJECTTYPE_DDB
%token <i> OBJECTTYPE_DEV
%token <i> OBJECTTYPE_EVT
%token <i> OBJECTTYPE_FLD
%token <i> OBJECTTYPE_INT
%token <i> OBJECTTYPE_MTH
%token <i> OBJECTTYPE_MTX
%token <i> OBJECTTYPE_OPR
%token <i> OBJECTTYPE_PKG
%token <i> OBJECTTYPE_POW
%token <i> OBJECTTYPE_STR
%token <i> OBJECTTYPE_THZ
%token <i> OBJECTTYPE_UNK
%token <i> OFFSET
%token <i> ONE
%token <i> ONES
%token <i> OPERATIONREGION
%token <i> OR
%token <i> PACKAGE
%token <i> PACKAGE_LENGTH
%token <i> POWERRESOURCE
%token <i> PROCESSOR
%token <i> QWORDCONST
%token <i> QWORDIO
%token <i> QWORDMEMORY
%token <i> RANGETYPE_ENTIRE
%token <i> RANGETYPE_ISAONLY
%token <i> RANGETYPE_NONISAONLY
%token <i> RAW_DATA
%token <i> READWRITETYPE_BOTH
%token <i> READWRITETYPE_READONLY
%token <i> REFOF
%token <i> REGIONSPACE_CMOS
%token <i> REGIONSPACE_EC
%token <i> REGIONSPACE_IO
%token <i> REGIONSPACE_MEM
%token <i> REGIONSPACE_PCI
%token <i> REGIONSPACE_PCIBAR
%token <i> REGIONSPACE_SMBUS
%token <i> REGISTER
%token <i> RELEASE
%token <i> RESERVED_BYTES
%token <i> RESET
%token <i> RESOURCETEMPLATE
%token <i> RESOURCETYPE_CONSUMER
%token <i> RESOURCETYPE_PRODUCER
%token <i> RETURN
%token <i> SCOPE
%token <i> SERIALIZERULE_NOTSERIAL
%token <i> SERIALIZERULE_SERIAL
%token <i> SHARETYPE_EXCLUSIVE
%token <i> SHARETYPE_SHARED
%token <i> SHIFTLEFT
%token <i> SHIFTRIGHT
%token <i> SIGNAL
%token <i> SIZEOF
%token <i> SLEEP
%token <i> STALL
%token <i> STARTDEPENDENTFN
%token <i> STARTDEPENDENTFN_NOPRI
%token <i> STORE
%token <s> STRING_LITERAL
%token <i> SUBTRACT
%token <i> SWITCH
%token <i> THERMALZONE
%token <i> TOBCD
%token <i> TOBUFFER
%token <i> TODECIMALSTRING
%token <i> TOHEXSTRING
%token <i> TOINTEGER
%token <i> TOSTRING
%token <i> TRANSLATIONTYPE_DENSE
%token <i> TRANSLATIONTYPE_SPARSE
%token <i> TYPE_STATIC
%token <i> TYPE_TRANSLATION
%token <i> UNICODE
%token <i> UNLOAD
%token <i> UPDATERULE_ONES
%token <i> UPDATERULE_PRESERVE
%token <i> UPDATERULE_ZEROS
%token <i> VENDORLONG
%token <i> VENDORSHORT
%token <i> WAIT
%token <i> WHILE
%token <i> WORDBUSNUMBER
%token <i> WORDCONST
%token <i> WORDIO
%token <i> XFERTYPE_8
%token <i> XFERTYPE_8_16
%token <i> XFERTYPE_16
%token <i> XOR
%token <i> ZERO


/*
 * Production names
 */

%type <n> ASLCode
%type <n> DefinitionBlockTerm
%type <n> TermList
%type <n> Term
%type <n> CompilerDirective
%type <n> ObjectList
%type <n> Object
%type <n> DataObject
%type <n> DataRefObject
%type <n> BufferData
%type <n> PackageData
%type <n> IntegerData
%type <n> StringData
%type <n> NamedObject
%type <n> NameSpaceModifier
%type <n> UserTerm
%type <n> ArgList
%type <n> ArgListTail
%type <n> TermArg
%type <n> Target

%type <n> Type1Opcode
%type <n> Type2Opcode
%type <n> Type2IntegerOpcode
%type <n> Type2StringOpcode
%type <n> Type2BufferOpcode
%type <n> Type2BufferOrStringOpcode
%type <n> Type3Opcode

/* Obsolete %type <n> Type4Opcode */

%type <n> Type5Opcode
%type <n> Type6Opcode


%type <n> IncludeTerm
%type <n> IncludeCStyleTerm
%type <n> ExternalTerm

%type <n> FieldUnitList
%type <n> FieldUnitListTail
%type <n> FieldUnit
%type <n> FieldUnitEntry

%type <n> OffsetTerm
%type <n> AccessAsTerm
%type <n> OptionalAccessAttribTerm



/* Named Objects */

%type <n> BankFieldTerm
%type <n> CreateBitFieldTerm
%type <n> CreateByteFieldTerm
%type <n> CreateDWordFieldTerm
%type <n> CreateFieldTerm
%type <n> CreateQWordFieldTerm
%type <n> CreateWordFieldTerm
%type <n> DataRegionTerm
%type <n> DeviceTerm
%type <n> EventTerm
%type <n> FieldTerm
%type <n> IndexFieldTerm
%type <n> MethodTerm
%type <n> MutexTerm
%type <n> OpRegionTerm
%type <n> OpRegionSpaceIdTerm
%type <n> PowerResTerm
%type <n> ProcessorTerm
%type <n> ThermalZoneTerm


/* Namespace modifiers */

%type <n> AliasTerm
%type <n> NameTerm
%type <n> ScopeTerm

/* Type 1 opcodes */

%type <n> BreakTerm
%type <n> BreakPointTerm
%type <n> ContinueTerm
%type <n> FatalTerm
%type <n> IfElseTerm
%type <n> IfTerm
%type <n> ElseTerm
%type <n> LoadTerm
%type <n> NoOpTerm
%type <n> NotifyTerm
%type <n> ReleaseTerm
%type <n> ResetTerm
%type <n> ReturnTerm
%type <n> SignalTerm
%type <n> SleepTerm
%type <n> StallTerm
%type <n> SwitchTerm
%type <n> CaseTermList
%type <n> DefaultTermList
%type <n> CaseTerm
%type <n> DefaultTerm
%type <n> UnloadTerm
%type <n> WhileTerm

/* Type 2 opcodes */

%type <n> AcquireTerm
%type <n> AddTerm
%type <n> AndTerm
%type <n> ConcatTerm
%type <n> ConcatResTerm
%type <n> CondRefOfTerm
%type <n> CopyTerm
%type <n> CopyTarget
%type <n> DecTerm
%type <n> DerefOfTerm
%type <n> DivideTerm
%type <n> FindSetLeftBitTerm
%type <n> FindSetRightBitTerm
%type <n> FromBCDTerm
%type <n> IncTerm
%type <n> IndexTerm
%type <n> LAndTerm
%type <n> LEqualTerm
%type <n> LGreaterTerm
%type <n> LGreaterEqualTerm
%type <n> LLessTerm
%type <n> LLessEqualTerm 
%type <n> LNotTerm
%type <n> LNotEqualTerm
%type <n> LoadTableTerm
%type <n> LOrTerm
%type <n> MatchTerm
%type <n> MidTerm
%type <n> ModTerm
%type <n> MultiplyTerm
%type <n> NAndTerm
%type <n> NOrTerm
%type <n> NotTerm
%type <n> ObjectTypeTerm
%type <n> OrTerm
%type <n> RefOfTerm
%type <n> ShiftLeftTerm
%type <n> ShiftRightTerm
%type <n> SizeOfTerm
%type <n> StoreTerm
%type <n> SubtractTerm
%type <n> ToBCDTerm
%type <n> ToBufferTerm
%type <n> ToDecimalStringTerm
%type <n> ToHexStringTerm
%type <n> ToIntegerTerm
%type <n> ToStringTerm
%type <n> WaitTerm
%type <n> XOrTerm

%type <n> OptionalTermArg
%type <n> OptionalListTermArg


/* Keywords */

%type <n> ObjectTypeKeyword
%type <n> AccessTypeKeyword
%type <n> AccessAttribKeyword
%type <n> LockRuleKeyword
%type <n> UpdateRuleKeyword
%type <n> RegionSpaceKeyword
%type <n> AddressSpaceKeyword
%type <n> UserDefRegionSpace
%type <n> MatchOpKeyword
%type <n> SerializeRuleKeyword
%type <n> DMATypeKeyword
%type <n> BusMasterKeyword
%type <n> XferTypeKeyword
%type <n> ResourceTypeKeyword
%type <n> MinKeyword
%type <n> MaxKeyword
%type <n> DecodeKeyword
%type <n> RangeTypeKeyword
%type <n> MemTypeKeyword
%type <n> ReadWriteKeyword
%type <n> InterruptTypeKeyword
%type <n> InterruptLevel
%type <n> ShareTypeKeyword
%type <n> IODecodeKeyword
%type <n> TypeKeyword
%type <n> TranslationKeyword
%type <n> AddressKeyword

/* Types */

%type <n> SuperName
%type <n> ArgTerm
%type <n> LocalTerm
%type <n> DebugTerm


%type <n> Integer

%type <n> ByteConst
%type <n> WordConst
%type <n> DwordConst
%type <n> QwordConst

/* Useless
%type <n> WordConst
%type <n> QwordConst
*/

%type <n> String

%type <n> ConstTerm
%type <n> ByteConstExpr
%type <n> WordConstExpr
%type <n> DWordConstExpr
%type <n> QWordConstExpr
%type <n> ConstExprTerm

%type <n> BufferTerm
%type <n> BufferData
%type <n> ByteList
%type <n> ByteListTail
%type <n> DWordList
%type <n> DWordListTail

%type <n> PackageTerm
%type <n> PackageLengthTerm
%type <n> PackageList
%type <n> PackageListTail
%type <n> PackageElement

%type <n> EISAIDTerm
%type <n> ResourceTemplateTerm
%type <n> UnicodeTerm
%type <n> ResourceMacroList
%type <n> ResourceMacroTerm

%type <n> DMATerm
%type <n> DWordIOTerm
%type <n> DWordMemoryTerm
%type <n> EndDependentFnTerm
%type <n> FixedIOTerm
%type <n> InterruptTerm
%type <n> IOTerm
%type <n> IRQNoFlagsTerm
%type <n> IRQTerm
%type <n> Memory24Term
%type <n> Memory32FixedTerm
%type <n> Memory32Term
%type <n> QWordIOTerm
%type <n> QWordMemoryTerm
%type <n> RegisterTerm
%type <n> StartDependentFnTerm
%type <n> StartDependentFnNoPriTerm
%type <n> VendorLongTerm
%type <n> VendorShortTerm
%type <n> WordBusNumberTerm
%type <n> WordIOTerm


/* TBD: Could not find in spec */

%type <n> ObjectReference


%type <n> NameString
%type <n> NameSeg


/* Local types that help construct the AML, not in ACPI spec */

%type <n> IncludeEndTerm
%type <n> AmlPackageLengthTerm
%type <n> OptionalByteConstExpr
%type <n> OptionalDWordConstExpr
%type <n> OptionalSerializeRuleKeyword
%type <n> OptionalResourceType_First
%type <n> OptionalMinType
%type <n> OptionalMaxType
%type <n> OptionalMemType
%type <n> OptionalDecodeType
%type <n> OptionalRangeType
%type <n> OptionalShareType
%type <n> OptionalType
%type <n> OptionalType_Last
%type <n> OptionalTranslationType_Last
%type <n> OptionalStringData 
%type <n> OptionalNameString 
%type <n> OptionalNameString_First 
%type <n> OptionalNameString_Last
%type <n> OptionalAddressRange

/* NOT USED %type <n> OptionalAccessAttribKeyword */

%%


/*******************************************************************************
 *
 * Production rules start here
 *
 ******************************************************************************/

/*
 * ASL Names
 */



/*
 * Blocks, Data, and Opcodes
 */

ASLCode
    : DefinitionBlockTerm
    ;

DefinitionBlockTerm
    : DEFINITIONBLOCK '('       {$$ = TrCreateLeafNode (DEFINITIONBLOCK)}
        String ','
        String ','
        ByteConst ','
        String ','
        String ','
        DwordConst
        ')'                     {TrSetEndLineNumber ($<n>3)}
            '{' TermList '}'    {$$ = TrLinkChildren ($<n>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 ($<n>3,1,$4);FlOpenIncludeFile ($4);}
        TermList        
        IncludeEndTerm          {$$ = TrLinkPeerNodes (3,$<n>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 ($<n>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 ($<n>3,3,$4,$6,$8)}
    | CREATEBITFIELD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

CreateByteFieldTerm
    : CREATEBYTEFIELD '('       {$$ = TrCreateLeafNode (CREATEBYTEFIELD)}
        TermArg ','
        TermArg ','
        NameString 
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$8)}
    | CREATEBYTEFIELD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

CreateDWordFieldTerm
    : CREATEDWORDFIELD '('      {$$ = TrCreateLeafNode (CREATEDWORDFIELD)}
        TermArg ','
        TermArg ','
        NameString 
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$8)}
    | CREATEDWORDFIELD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

CreateFieldTerm
    : CREATEFIELD '('           {$$ = TrCreateLeafNode (CREATEFIELD)}
        TermArg ','
        TermArg ','
        TermArg ','
        NameString 
        ')'                     {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$10)}
    | CREATEFIELD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

CreateQWordFieldTerm
    : CREATEQWORDFIELD '('      {$$ = TrCreateLeafNode (CREATEQWORDFIELD)}
        TermArg ','
        TermArg ','
        NameString 
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$8)}
    | CREATEQWORDFIELD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

CreateWordFieldTerm
    : CREATEWORDFIELD '('       {$$ = TrCreateLeafNode (CREATEWORDFIELD)}
        TermArg ','
        TermArg ','
        NameString 
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$8)}
    | CREATEWORDFIELD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

DataRegionTerm
    : DATATABLEREGION '('       {$$ = TrCreateLeafNode (DATATABLEREGION)}
        NameString ','
        TermArg ','
        TermArg ','
        TermArg 
        ')'                     {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$10)}
    | DATATABLEREGION '('
        error ')'               {$$ = NULL; yyerrok}
    ;

DeviceTerm
    : DEVICE '('                {$$ = TrCreateLeafNode (DEVICE)}
        NameString
        ')' '{' 
            ObjectList '}'      {$$ = TrLinkChildren ($<n>3,2,$4,$7)}
    | DEVICE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

EventTerm
    : EVENT '('                 {$$ = TrCreateLeafNode (EVENT)}
        NameString
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | EVENT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

FieldTerm
    : FIELD '('                 {$$ = TrCreateLeafNode (FIELD)}
        NameString ','
        AccessTypeKeyword ','
        LockRuleKeyword ','
        UpdateRuleKeyword
        ')' '{' 
            FieldUnitList '}'   {$$ = TrLinkChildren ($<n>3,5,$4,$6,$8,$10,$13)}
    | FIELD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

IndexFieldTerm
    : INDEXFIELD '('            {$$ = TrCreateLeafNode (INDEXFIELD)}
        NameString ','
        NameString ','
        AccessTypeKeyword ','
        LockRuleKeyword ','
        UpdateRuleKeyword
        ')' '{' 
            FieldUnitList '}'   {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$15)}
    | INDEXFIELD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

MethodTerm
    : METHOD  '('               {$$ = TrCreateLeafNode (METHOD)}
        NameString
        OptionalByteConstExpr
        OptionalSerializeRuleKeyword
        OptionalByteConstExpr
        ')' '{' 
            TermList '}'        {$$ = TrLinkChildren ($<n>3,5,$4,$5,$6,$7,$10)}
    | METHOD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

MutexTerm
    : MUTEX '('                 {$$ = TrCreateLeafNode (MUTEX)}
        NameString ','
        ByteConstExpr
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | MUTEX '('
        error ')'               {$$ = NULL; yyerrok}
    ;

OpRegionTerm
    : OPERATIONREGION '('       {$$ = TrCreateLeafNode (OPERATIONREGION)}
        NameString ',' 
        OpRegionSpaceIdTerm ',' 
        TermArg ',' 
        TermArg 
        ')'                     {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$10)}
    | OPERATIONREGION '('
        error ')'               {$$ = NULL; yyerrok}
    ;

OpRegionSpaceIdTerm
    : RegionSpaceKeyword        {}
    | ByteConst                 {}
    ;

PowerResTerm
    : POWERRESOURCE '('         {$$ = TrCreateLeafNode (POWERRESOURCE)}
        NameString ','
        ByteConstExpr ','
        WordConstExpr
        ')' '{' 
            ObjectList '}'      {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$11)}
    | POWERRESOURCE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ProcessorTerm
    : PROCESSOR '('             {$$ = TrCreateLeafNode (PROCESSOR)}
        NameString ','
        ByteConstExpr
        OptionalDWordConstExpr
        OptionalByteConstExpr
        ')' '{' 
            ObjectList '}'      {$$ = TrLinkChildren ($<n>3,5,$4,$6,$7,$8,$11)}
    | PROCESSOR '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ThermalZoneTerm
    : THERMALZONE '('           {$$ = TrCreateLeafNode (THERMALZONE)}
        NameString
        ')' '{' 
            ObjectList '}'      {$$ = TrLinkChildren ($<n>3,2,$4,$7)}
    | THERMALZONE '('
        error ')'               {$$ = NULL; yyerrok}
    ;



/******* Namespace modifiers *************************************************/


AliasTerm
    : ALIAS '('                 {$$ = TrCreateLeafNode (ALIAS)}
        NameString ','
        NameString 
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | ALIAS '('
        error ')'               {$$ = NULL; yyerrok}
    ;

NameTerm
    : NAME '('                  {$$ = TrCreateLeafNode (NAME)}
        NameString ','
        DataObject 
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | NAME '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ScopeTerm
    : SCOPE '('                 {$$ = TrCreateLeafNode (SCOPE)}
        NameString
        ')' '{' 
            ObjectList '}'      {$$ = TrLinkChildren ($<n>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 ($<n>3,3,$4,$6,$8)}
    | FATAL '('
        error ')'               {$$ = NULL; yyerrok}
    ;

IfElseTerm
    : IfTerm ElseTerm           {$$ = TrLinkPeerNode ($1,$2)}
    ;

IfTerm 
    : IF '('                    {$$ = TrCreateLeafNode (IF)}
        TermArg
        ')' '{' 
            TermList '}' 
                                {$$ = TrLinkChildren ($<n>3,2,$4,$7)}
    | IF '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ElseTerm
    :                           {$$ = NULL}
    | ELSE '{'                  {$$ = TrCreateLeafNode (ELSE)}
        TermList '}' 
                                {$$ = TrLinkChildren ($<n>3,1,$4)}

    | ELSEIF '{'                {$$ = TrCreateLeafNode (ELSEIF)}
        TermList '}' 
        ElseTerm 
                                {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    ;

LoadTerm
    : LOAD '('                  {$$ = TrCreateLeafNode (LOAD)}
        NameString ','
        SuperName 
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LOAD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

NoOpTerm
    : NOOP                      {$$ = TrCreateNode (NOOP, 0)}
    ;

NotifyTerm 
    : NOTIFY '('                {$$ = TrCreateLeafNode (NOTIFY)}
        SuperName ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | NOTIFY '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ReleaseTerm
    : RELEASE '('               {$$ = TrCreateLeafNode (RELEASE)}
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | RELEASE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ResetTerm
    : RESET '('                 {$$ = TrCreateLeafNode (RESET)}
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | RESET '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ReturnTerm
    : RETURN '('                {$$ = TrCreateLeafNode (RETURN)}
        OptionalTermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | RETURN '('
        error ')'               {$$ = NULL; yyerrok}
    ;

SignalTerm
    : SIGNAL '('                {$$ = TrCreateLeafNode (SIGNAL)}
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | SIGNAL '('
        error ')'               {$$ = NULL; yyerrok}
    ;

SleepTerm
    : SLEEP '('                 {$$ = TrCreateLeafNode (SLEEP)}
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | SLEEP '('
        error ')'               {$$ = NULL; yyerrok}
    ;

StallTerm
    : STALL '('                 {$$ = TrCreateLeafNode (STALL)}
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | STALL '('
        error ')'               {$$ = NULL; yyerrok}
    ;

SwitchTerm
    : SWITCH '('                {$$ = TrCreateLeafNode (SWITCH)}
        TermArg
        ')' '{' 
            CaseTermList '}' 
                                {$$ = TrLinkChildren ($<n>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 ($<n>3,2,$4,$7)}
    | CASE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

DefaultTerm
    : DEFAULT '{'               {$$ = TrCreateLeafNode (DEFAULT)}  
        TermList '}' 
                                {$$ = TrLinkChildren ($<n>3,1,$4)}
    ;

UnloadTerm
    : UNLOAD '('                {$$ = TrCreateLeafNode (UNLOAD)}  
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | UNLOAD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

WhileTerm
    : WHILE '('                 {$$ = TrCreateLeafNode (WHILE)}  
        TermArg
        ')' '{' TermList '}' 
                                {$$ = TrLinkChildren ($<n>3,2,$4,$7)}
    | WHILE '('
        error ')'               {$$ = NULL; yyerrok}
    ;


/******* Type 2 opcodes *******************************************************/

AcquireTerm
    : ACQUIRE '('               {$$ = TrCreateLeafNode (ACQUIRE)}  
        SuperName ','
        WordConstExpr
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | ACQUIRE '('
        error ')'               {$$ = NULL; yyerrok}
    ;
    
AddTerm
    : ADD '('                   {$$ = TrCreateLeafNode (ADD)}  
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | ADD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

AndTerm
    : AND '('                   {$$ = TrCreateLeafNode (AND)}  
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | AND '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ConcatTerm
    : CONCATENATE '('           {$$ = TrCreateLeafNode (CONCATENATE)}  
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | CONCATENATE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ConcatResTerm
    : CONCATENATERESTEMPLATE '('    {$$ = TrCreateLeafNode (CONCATENATERESTEMPLATE)}  
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | CONCATENATERESTEMPLATE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

CondRefOfTerm
    : CONDREFOF '('             {$$ = TrCreateLeafNode (CONDREFOF)}  
        SuperName
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | CONDREFOF '('
        error ')'               {$$ = NULL; yyerrok}
    ;

CopyTerm
    : COPY '('                  {$$ = TrCreateLeafNode (COPY)}  
        TermArg ','
        CopyTarget
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | COPY '('
        error ')'               {$$ = NULL; yyerrok}
    ;

CopyTarget
    : NameString {}
    | LocalTerm {}
    | ArgTerm {}
    ;

DecTerm
    : DECREMENT '('             {$$ = TrCreateLeafNode (DECREMENT)}  
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | DECREMENT '('
        error ')'               {$$ = NULL; yyerrok}
    ;
    
DerefOfTerm
    : DEREFOF '('               {$$ = TrCreateLeafNode (DEREFOF)}  
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | DEREFOF '('
        error ')'               {$$ = NULL; yyerrok}
    ;

DivideTerm
    : DIVIDE '('                {$$ = TrCreateLeafNode (DIVIDE)}  
        TermArg ','
        TermArg
        Target
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,4,$4,$6,$7,$8)}
    | DIVIDE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

FindSetLeftBitTerm
    : FINDSETLEFTBIT '('        {$$ = TrCreateLeafNode (FINDSETLEFTBIT)}  
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | FINDSETLEFTBIT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

FindSetRightBitTerm
    : FINDSETRIGHTBIT '('       {$$ = TrCreateLeafNode (FINDSETRIGHTBIT)}  
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | FINDSETRIGHTBIT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

FromBCDTerm
    : FROMBCD '('               {$$ = TrCreateLeafNode (FROMBCD)}  
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | FROMBCD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

IncTerm
    : INCREMENT '('             {$$ = TrCreateLeafNode (INCREMENT)}  
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | INCREMENT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

IndexTerm
    : INDEX '('                 {$$ = TrCreateLeafNode (INDEX)}  
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | INDEX '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LAndTerm
    : LAND '('                  {$$ = TrCreateLeafNode (LAND)}  
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LAND '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LEqualTerm
    : LEQUAL '('                {$$ = TrCreateLeafNode (LEQUAL)}
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LEQUAL '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LGreaterTerm
    : LGREATER '('              {$$ = TrCreateLeafNode (LGREATER)}
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LGREATER '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LGreaterEqualTerm
    : LGREATEREQUAL '('         {$$ = TrCreateLeafNode (LGREATEREQUAL)}
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LGREATEREQUAL '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LLessTerm
    : LLESS '('                 {$$ = TrCreateLeafNode (LLESS)}
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LLESS '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LLessEqualTerm
    : LLESSEQUAL '('            {$$ = TrCreateLeafNode (LLESSEQUAL)}
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LLESSEQUAL '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LNotTerm
    : LNOT '('                  {$$ = TrCreateLeafNode (LNOT)}
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | LNOT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LNotEqualTerm
    : LNOTEQUAL '('             {$$ = TrCreateLeafNode (LNOTEQUAL)}
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LNOTEQUAL '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LoadTableTerm
    : LOADTABLE '('             {$$ = TrCreateLeafNode (LOADTABLE)}
        TermArg ','
        TermArg ','
        TermArg
        OptionalListTermArg
        OptionalListTermArg
        OptionalListTermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$9,$10,$11)}
    | LOADTABLE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

LOrTerm
    : LOR '('                   {$$ = TrCreateLeafNode (LOR)}
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | LOR '('
        error ')'               {$$ = NULL; yyerrok}
    ;

MatchTerm
    : MATCH '('                 {$$ = TrCreateLeafNode (MATCH)}
        TermArg ','
        MatchOpKeyword ','
        TermArg ','
        MatchOpKeyword ','
        TermArg ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$14)}
    | MATCH '('
        error ')'               {$$ = NULL; yyerrok}
    ;

MidTerm
    : MID '('                   {$$ = TrCreateLeafNode (MID)}
        TermArg ','
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$9)}
    | MID '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ModTerm
    : MOD '('                   {$$ = TrCreateLeafNode (MOD)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | MOD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

MultiplyTerm
    : MULTIPLY '('              {$$ = TrCreateLeafNode (MULTIPLY)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | MULTIPLY '('
        error ')'               {$$ = NULL; yyerrok}
    ;

NAndTerm
    : NAND '('                  {$$ = TrCreateLeafNode (NAND)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | NAND '('
        error ')'               {$$ = NULL; yyerrok}
    ;

NOrTerm
    : NOR '('                   {$$ = TrCreateLeafNode (NOR)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | NOR '('
        error ')'               {$$ = NULL; yyerrok}
    ;

NotTerm
    : NOT '('                   {$$ = TrCreateLeafNode (NOT)}
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | NOT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ObjectTypeTerm
    : OBJECTTYPE '('            {$$ = TrCreateLeafNode (OBJECTTYPE)}
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | OBJECTTYPE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

OrTerm
    : OR '('                    {$$ = TrCreateLeafNode (OR)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>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 ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_TARGET))}
    | REFOF '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ShiftLeftTerm
    : SHIFTLEFT '('             {$$ = TrCreateLeafNode (SHIFTLEFT)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | SHIFTLEFT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ShiftRightTerm
    : SHIFTRIGHT '('            {$$ = TrCreateLeafNode (SHIFTRIGHT)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | SHIFTRIGHT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

SizeOfTerm
    : SIZEOF '('                {$$ = TrCreateLeafNode (SIZEOF)}
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,1,$4)}
    | SIZEOF '('
        error ')'               {$$ = NULL; yyerrok}
    ;

StoreTerm
    : STORE '('                 {$$ = TrCreateLeafNode (STORE)}
        TermArg ','
        SuperName
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET))}
    | STORE '('
        error ')'               {$$ = NULL; yyerrok}
    ;

SubtractTerm
    : SUBTRACT '('              {$$ = TrCreateLeafNode (SUBTRACT)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7)}
    | SUBTRACT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ToBCDTerm
    : TOBCD '('                 {$$ = TrCreateLeafNode (TOBCD)}
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | TOBCD '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ToBufferTerm
    : TOBUFFER '('              {$$ = TrCreateLeafNode (TOBUFFER)}
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | TOBUFFER '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ToDecimalStringTerm
    : TODECIMALSTRING '('       {$$ = TrCreateLeafNode (TODECIMALSTRING)}
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | TODECIMALSTRING '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ToHexStringTerm
    : TOHEXSTRING '('           {$$ = TrCreateLeafNode (TOHEXSTRING)}
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | TOHEXSTRING '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ToIntegerTerm
    : TOINTEGER '('             {$$ = TrCreateLeafNode (TOINTEGER)}
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$5)}
    | TOINTEGER '('
        error ')'               {$$ = NULL; yyerrok}
    ;

ToStringTerm
    : TOSTRING '('              {$$ = TrCreateLeafNode (TOSTRING)}
        TermArg
        OptionalListTermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6)}
    | TOSTRING '('
        error ')'               {$$ = NULL; yyerrok}
    ;

WaitTerm
    : WAIT '('                  {$$ = TrCreateLeafNode (WAIT)}
        SuperName ','
        TermArg
        ')'                     {$$ = TrLinkChildren ($<n>3,2,$4,$6)}
    | WAIT '('
        error ')'               {$$ = NULL; yyerrok}
    ;

XOrTerm
    : XOR '('                   {$$ = TrCreateLeafNode (XOR)}
        TermArg ','
        TermArg
        Target
        ')'                     {$$ = TrLinkChildren ($<n>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 ($<n>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 ($<n>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 ($<n>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 ($<n>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 ($<n>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 ($<n>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 ($<n>3,3,$4,$6,$7)}
    | FIXEDIO '('
        error ')'               {$$ = NULL; yyerrok}
    ;

InterruptTerm
    : INTERRUPT '('             {$$ = TrCreateLeafNode (INTERRUPT)}
        OptionalResourceType_First
        InterruptTypeKeyword ','
        InterruptLevel
        OptionalShareType     
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString_Last
        ')' '{'
            DWordList '}'       {$$ = TrLinkChildren ($<n>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 ($<n>3,6,$4,$6,$8,$10,$12,$13)}
    | IO '('
        error ')'               {$$ = NULL; yyerrok}
    ;

IRQNoFlagsTerm
    : IRQNOFLAGS '('            {$$ = TrCreateLeafNode (IRQNOFLAGS)}
        OptionalNameString_First
        ')' '{' 
            ByteList '}'        {$$ = TrLinkChildren ($<n>3,2,$4,$7)}
    | IRQNOFLAGS '('
        error ')'               {$$ = NULL; yyerrok}
    ;

IRQTerm
    : IRQ '('                   {$$ = TrCreateLeafNode (IRQ)}
        InterruptTypeKeyword ','
        InterruptLevel
        OptionalShareType     
        OptionalNameString_Last
        ')' '{' 
            ByteList '}'        {$$ = TrLinkChildren ($<n>3,5,$4,$6,$7,$8,$11)}
    | IRQ '('
        error ')'               {$$ = NULL; yyerrok}
    ;

Memory24Term
    : MEMORY24 '('              {$$ = TrCreateLeafNode (MEMORY24)}
        ReadWriteKeyword ','
        WordConstExpr ','
        WordConstExpr ','
        WordConstExpr ','
        WordConstExpr
        OptionalNameString_Last
        ')'                     {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13)}
    | MEMORY24 '('
        error ')'               {$$ = NULL; yyerrok}
    ;

Memory32FixedTerm
    : MEMORY32FIXED '('         {$$ = TrCreateLeafNode (MEMORY32FIXED)}
        ReadWriteKeyword ','
        DWordConstExpr ','
        DWordConstExpr
        OptionalNameString_Last
        ')'                     {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$9)}
    | MEMORY32FIXED '('
        error ')'               {$$ = NULL; yyerrok}
    ;

Memory32Term
    : MEMORY32 '('              {$$ = TrCreateLeafNode (MEMORY32)}
        ReadWriteKeyword ','
        DWordConstExpr ','
        DWordConstExpr ','
        DWordConstExpr ','
        DWordConstExpr
        OptionalNameString_Last
        ')'                     {$$ = TrLinkChildren ($<n>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 ($<n>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 ($<n>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 ($<n>3,4,$4,$6,$8,$10)}
    | REGISTER '('
        error ')'               {$$ = NULL; yyerrok}
    ;

StartDependentFnTerm
    : STARTDEPENDENTFN '('      {$$ = TrCreateLeafNode (STARTDEPENDENTFN)}
        ByteConstExpr ','
        ByteConstExpr
        ')' '{' 
        ResourceMacroList '}'   {$$ = TrLinkChildren ($<n>3,3,$4,$6,$9)}
    | STARTDEPENDENTFN '('
        error ')'               {$$ = NULL; yyerrok}
    ;
                
StartDependentFnNoPriTerm
    : STARTDEPENDENTFN_NOPRI '(' {$$ = TrCreateLeafNode (STARTDEPENDENTFN_NOPRI)}
        ')' '{' 
        ResourceMacroList '}'   {$$ = TrLinkChildren ($<n>3,1,$6)}
    | STARTDEPENDENTFN_NOPRI '('
        error ')'               {$$ = NULL; yyerrok}
    ;
               
VendorLongTerm
    : VENDORLONG '('            {$$ = TrCreateLeafNode (VENDORLONG)}
        OptionalNameString_First
        ')' '{' 
            ByteList '}'        {$$ = TrLinkChildren ($<n>3,2,$4,$7)}
    | VENDORLONG '('
        error ')'               {$$ = NULL; yyerrok}
    ;
        
VendorShortTerm
    : VENDORSHORT '('           {$$ = TrCreateLeafNode (VENDORSHORT)}
        OptionalNameString_First
        ')' '{' 
            ByteList '}'        {$$ = TrLinkChildren ($<n>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 ($<n>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 ($<n>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);
}