WebSVN – Kolibri OS – Diff – /drivers/devman/acpica/compiler/aslcompiler.y


%{
/******************************************************************************
 *
 * Module Name: aslcompiler.y - Bison input file (ASL grammar and actions)
 *
 *****************************************************************************/
 
/******************************************************************************
 *
 * 1. Copyright Notice
 *
 * Some or all of this work - Copyright (c) 1999 - 2011, 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.
 *
 *****************************************************************************/
 
 
 
 
 
 
 
 
 
#include "aslcompiler.h"
#include 
#include 
#include 
#include "acpi.h"
#include "accommon.h"
 
#define _COMPONENT          ACPI_COMPILER
        ACPI_MODULE_NAME    ("aslparse")
 
/*
 * Global Notes:
 *
 * October 2005: The following list terms have been optimized (from the
 * original ASL grammar in the ACPI specification) to force the immediate
 * reduction of each list item so that the parse stack use doesn't increase on
 * each list element and possibly overflow on very large lists (>4000 items).
 * This dramatically reduces use of the parse stack overall.
 *
 *      ArgList, TermList, Objectlist, ByteList, DWordList, PackageList,
 *      ResourceMacroList, and FieldUnitList
 */
 
void *                      AslLocalAllocate (unsigned int Size);
 
/* Bison/yacc configuration */
 
 
 
 
 
#define static
#undef alloca
#define alloca              AslLocalAllocate
#define yytname             AslCompilername
 
 
#define YYINITDEPTH         600             /* State stack depth */
#define YYDEBUG             1               /* Enable debug output */
#define YYERROR_VERBOSE     1               /* Verbose error messages */
 
/*
 * The windows version of bison defines this incorrectly as "32768" (Not negative).
 * We use a custom (edited binary) version of bison that defines YYFLAG as YYFBAD
 * instead (#define YYFBAD 32768), so we can define it correctly here.
 *
 * The problem is that if YYFLAG is positive, the extended syntax error messages
 * are disabled.
 */
#define YYFLAG              -32768
 
 
 
%}
 
 
/*
 * Declare the type of values in the grammar
 */
%union {
 
    UINT64              i;
    char                *s;
    ACPI_PARSE_OBJECT   *n;
}
 
 
/*! [Begin] no source code translation */
 
/*
 * These shift/reduce conflicts are expected. There should be zero
 * reduce/reduce conflicts.
 */
%expect 60
 
 
/*
 * Token types: These are returned by the lexer
 *
 * NOTE: This list MUST match the AslKeywordMapping table found
 *       in aslmap.c EXACTLY!  Double check any changes!
 */
%token  PARSEOP_ACCESSAS
 
%token  PARSEOP_ACCESSATTRIB_BLOCK
%token  PARSEOP_ACCESSATTRIB_BLOCK_CALL
%token  PARSEOP_ACCESSATTRIB_BYTE
%token  PARSEOP_ACCESSATTRIB_WORD_CALL
%token  PARSEOP_ACCESSATTRIB_QUICK
%token  PARSEOP_ACCESSATTRIB_SND_RCV
%token  PARSEOP_ACCESSATTRIB_WORD
%token  PARSEOP_ACCESSTYPE_ANY
%token  PARSEOP_ACCESSTYPE_BUF
%token  PARSEOP_ACCESSTYPE_BYTE
%token  PARSEOP_ACCESSTYPE_DWORD
%token  PARSEOP_ACCESSTYPE_QWORD
%token  PARSEOP_ACCESSTYPE_WORD
%token  PARSEOP_ACQUIRE
%token  PARSEOP_ADD
%token  PARSEOP_ADDRESSSPACE_FFIXEDHW
%token  PARSEOP_ADDRESSTYPE_ACPI
%token  PARSEOP_ADDRESSTYPE_MEMORY
%token  PARSEOP_ADDRESSTYPE_NVS
%token  PARSEOP_ADDRESSTYPE_RESERVED
%token  PARSEOP_ALIAS
%token  PARSEOP_AND
%token  PARSEOP_ARG0
%token  PARSEOP_ARG1
%token  PARSEOP_ARG2
%token  PARSEOP_ARG3
%token  PARSEOP_ARG4
%token  PARSEOP_ARG5
%token  PARSEOP_ARG6
%token  PARSEOP_BANKFIELD
%token  PARSEOP_BREAK
%token  PARSEOP_BREAKPOINT
%token  PARSEOP_BUFFER
%token  PARSEOP_BUSMASTERTYPE_MASTER
%token  PARSEOP_BUSMASTERTYPE_NOTMASTER
%token  PARSEOP_BYTECONST
%token  PARSEOP_CASE
%token  PARSEOP_CONCATENATE
%token  PARSEOP_CONCATENATERESTEMPLATE
%token  PARSEOP_CONDREFOF
%token  PARSEOP_CONTINUE
%token  PARSEOP_COPYOBJECT
%token  PARSEOP_CREATEBITFIELD
%token  PARSEOP_CREATEBYTEFIELD
%token  PARSEOP_CREATEDWORDFIELD
%token  PARSEOP_CREATEFIELD
%token  PARSEOP_CREATEQWORDFIELD
%token  PARSEOP_CREATEWORDFIELD
%token  PARSEOP_DATATABLEREGION
%token  PARSEOP_DEBUG
%token  PARSEOP_DECODETYPE_POS
%token  PARSEOP_DECODETYPE_SUB
%token  PARSEOP_DECREMENT
%token  PARSEOP_DEFAULT
%token  PARSEOP_DEFAULT_ARG
%token  PARSEOP_DEFINITIONBLOCK
%token  PARSEOP_DEREFOF
%token  PARSEOP_DEVICE
%token  PARSEOP_DIVIDE
%token  PARSEOP_DMA
%token  PARSEOP_DMATYPE_A
%token  PARSEOP_DMATYPE_COMPATIBILITY
%token  PARSEOP_DMATYPE_B
%token  PARSEOP_DMATYPE_F
%token  PARSEOP_DWORDCONST
%token  PARSEOP_DWORDIO
%token  PARSEOP_DWORDMEMORY
%token  PARSEOP_DWORDSPACE
%token  PARSEOP_EISAID
%token  PARSEOP_ELSE
%token  PARSEOP_ELSEIF
%token  PARSEOP_ENDDEPENDENTFN
%token  PARSEOP_ENDTAG
%token  PARSEOP_ERRORNODE
%token  PARSEOP_EVENT
%token  PARSEOP_EXTENDEDIO
%token  PARSEOP_EXTENDEDMEMORY
%token  PARSEOP_EXTENDEDSPACE
%token  PARSEOP_EXTERNAL
%token  PARSEOP_FATAL
%token  PARSEOP_FIELD
%token  PARSEOP_FINDSETLEFTBIT
%token  PARSEOP_FINDSETRIGHTBIT
%token  PARSEOP_FIXEDIO
%token  PARSEOP_FROMBCD
%token  PARSEOP_FUNCTION
%token  PARSEOP_IF
%token  PARSEOP_INCLUDE
%token  PARSEOP_INCLUDE_CSTYLE
%token  PARSEOP_INCLUDE_END
%token  PARSEOP_INCREMENT
%token  PARSEOP_INDEX
%token  PARSEOP_INDEXFIELD
%token  PARSEOP_INTEGER
%token  PARSEOP_INTERRUPT
%token  PARSEOP_INTLEVEL_ACTIVEHIGH
%token  PARSEOP_INTLEVEL_ACTIVELOW
%token  PARSEOP_INTTYPE_EDGE
%token  PARSEOP_INTTYPE_LEVEL
%token  PARSEOP_IO
%token  PARSEOP_IODECODETYPE_10
%token  PARSEOP_IODECODETYPE_16
%token  PARSEOP_IRQ
%token  PARSEOP_IRQNOFLAGS
%token  PARSEOP_LAND
%token  PARSEOP_LEQUAL
%token  PARSEOP_LGREATER
%token  PARSEOP_LGREATEREQUAL
%token  PARSEOP_LINE_CSTYLE
%token  PARSEOP_LLESS
%token  PARSEOP_LLESSEQUAL
%token  PARSEOP_LNOT
%token  PARSEOP_LNOTEQUAL
%token  PARSEOP_LOAD
%token  PARSEOP_LOADTABLE
%token  PARSEOP_LOCAL0
%token  PARSEOP_LOCAL1
%token  PARSEOP_LOCAL2
%token  PARSEOP_LOCAL3
%token  PARSEOP_LOCAL4
%token  PARSEOP_LOCAL5
%token  PARSEOP_LOCAL6
%token  PARSEOP_LOCAL7
%token  PARSEOP_LOCKRULE_LOCK
%token  PARSEOP_LOCKRULE_NOLOCK
%token  PARSEOP_LOR
%token  PARSEOP_MATCH
%token  PARSEOP_MATCHTYPE_MEQ
%token  PARSEOP_MATCHTYPE_MGE
%token  PARSEOP_MATCHTYPE_MGT
%token  PARSEOP_MATCHTYPE_MLE
%token  PARSEOP_MATCHTYPE_MLT
%token  PARSEOP_MATCHTYPE_MTR
%token  PARSEOP_MAXTYPE_FIXED
%token  PARSEOP_MAXTYPE_NOTFIXED
%token  PARSEOP_MEMORY24
%token  PARSEOP_MEMORY32
%token  PARSEOP_MEMORY32FIXED
%token  PARSEOP_MEMTYPE_CACHEABLE
%token  PARSEOP_MEMTYPE_NONCACHEABLE
%token  PARSEOP_MEMTYPE_PREFETCHABLE
%token  PARSEOP_MEMTYPE_WRITECOMBINING
%token  PARSEOP_METHOD
%token  PARSEOP_METHODCALL
%token  PARSEOP_MID
%token  PARSEOP_MINTYPE_FIXED
%token  PARSEOP_MINTYPE_NOTFIXED
%token  PARSEOP_MOD
%token  PARSEOP_MULTIPLY
%token  PARSEOP_MUTEX
%token  PARSEOP_NAME
%token  PARSEOP_NAMESEG
%token  PARSEOP_NAMESTRING
%token  PARSEOP_NAND
%token  PARSEOP_NOOP
%token  PARSEOP_NOR
%token  PARSEOP_NOT
%token  PARSEOP_NOTIFY
%token  PARSEOP_OBJECTTYPE
%token  PARSEOP_OBJECTTYPE_BFF
%token  PARSEOP_OBJECTTYPE_BUF
%token  PARSEOP_OBJECTTYPE_DDB
%token  PARSEOP_OBJECTTYPE_DEV
%token  PARSEOP_OBJECTTYPE_EVT
%token  PARSEOP_OBJECTTYPE_FLD
%token  PARSEOP_OBJECTTYPE_INT
%token  PARSEOP_OBJECTTYPE_MTH
%token  PARSEOP_OBJECTTYPE_MTX
%token  PARSEOP_OBJECTTYPE_OPR
%token  PARSEOP_OBJECTTYPE_PKG
%token  PARSEOP_OBJECTTYPE_POW
%token  PARSEOP_OBJECTTYPE_PRO
%token  PARSEOP_OBJECTTYPE_STR
%token  PARSEOP_OBJECTTYPE_THZ
%token  PARSEOP_OBJECTTYPE_UNK
%token  PARSEOP_OFFSET
%token  PARSEOP_ONE
%token  PARSEOP_ONES
%token  PARSEOP_OPERATIONREGION
%token  PARSEOP_OR
%token  PARSEOP_PACKAGE
%token  PARSEOP_PACKAGE_LENGTH
%token  PARSEOP_POWERRESOURCE
%token  PARSEOP_PROCESSOR
%token  PARSEOP_QWORDCONST
%token  PARSEOP_QWORDIO
%token  PARSEOP_QWORDMEMORY
%token  PARSEOP_QWORDSPACE
%token  PARSEOP_RANGETYPE_ENTIRE
%token  PARSEOP_RANGETYPE_ISAONLY
%token  PARSEOP_RANGETYPE_NONISAONLY
%token  PARSEOP_RAW_DATA
%token  PARSEOP_READWRITETYPE_BOTH
%token  PARSEOP_READWRITETYPE_READONLY
%token  PARSEOP_REFOF
%token  PARSEOP_REGIONSPACE_CMOS
%token  PARSEOP_REGIONSPACE_EC
%token  PARSEOP_REGIONSPACE_IO
%token  PARSEOP_REGIONSPACE_IPMI
%token  PARSEOP_REGIONSPACE_MEM
%token  PARSEOP_REGIONSPACE_PCI
%token  PARSEOP_REGIONSPACE_PCIBAR
%token  PARSEOP_REGIONSPACE_SMBUS
%token  PARSEOP_REGISTER
%token  PARSEOP_RELEASE
%token  PARSEOP_RESERVED_BYTES
%token  PARSEOP_RESET
%token  PARSEOP_RESOURCETEMPLATE
%token  PARSEOP_RESOURCETYPE_CONSUMER
%token  PARSEOP_RESOURCETYPE_PRODUCER
%token  PARSEOP_RETURN
%token  PARSEOP_REVISION
%token  PARSEOP_SCOPE
%token  PARSEOP_SERIALIZERULE_NOTSERIAL
%token  PARSEOP_SERIALIZERULE_SERIAL
%token  PARSEOP_SHARETYPE_EXCLUSIVE
%token  PARSEOP_SHARETYPE_SHARED
%token  PARSEOP_SHIFTLEFT
%token  PARSEOP_SHIFTRIGHT
%token  PARSEOP_SIGNAL
%token  PARSEOP_SIZEOF
%token  PARSEOP_SLEEP
%token  PARSEOP_STALL
%token  PARSEOP_STARTDEPENDENTFN
%token  PARSEOP_STARTDEPENDENTFN_NOPRI
%token  PARSEOP_STORE
%token  PARSEOP_STRING_LITERAL
%token  PARSEOP_SUBTRACT
%token  PARSEOP_SWITCH
%token  PARSEOP_THERMALZONE
%token  PARSEOP_TIMER
%token  PARSEOP_TOBCD
%token  PARSEOP_TOBUFFER
%token  PARSEOP_TODECIMALSTRING
%token  PARSEOP_TOHEXSTRING
%token  PARSEOP_TOINTEGER
%token  PARSEOP_TOSTRING
%token  PARSEOP_TOUUID
%token  PARSEOP_TRANSLATIONTYPE_DENSE
%token  PARSEOP_TRANSLATIONTYPE_SPARSE
%token  PARSEOP_TYPE_STATIC
%token  PARSEOP_TYPE_TRANSLATION
%token  PARSEOP_UNICODE
%token  PARSEOP_UNLOAD
%token  PARSEOP_UPDATERULE_ONES
%token  PARSEOP_UPDATERULE_PRESERVE
%token  PARSEOP_UPDATERULE_ZEROS
%token  PARSEOP_VAR_PACKAGE
%token  PARSEOP_VENDORLONG
%token  PARSEOP_VENDORSHORT
%token  PARSEOP_WAIT
%token  PARSEOP_WHILE
%token  PARSEOP_WORDBUSNUMBER
%token  PARSEOP_WORDCONST
%token  PARSEOP_WORDIO
%token  PARSEOP_WORDSPACE
%token  PARSEOP_XFERTYPE_8
%token  PARSEOP_XFERTYPE_8_16
%token  PARSEOP_XFERTYPE_16
%token  PARSEOP_XOR
%token  PARSEOP_ZERO
 
/*
 * Special functions. These should probably stay at the end of this
 * table.
 */
%token  PARSEOP___DATE__
%token  PARSEOP___FILE__
%token  PARSEOP___LINE__
 
/*
 * Production names
 */
 
%type  ASLCode
%type  DefinitionBlockTerm
%type  TermList
%type  Term
%type  CompilerDirective
%type  ObjectList
%type  Object
%type  DataObject
%type  BufferData
%type  PackageData
%type  IntegerData
%type  StringData
%type  NamedObject
%type  NameSpaceModifier
%type  UserTerm
%type  ArgList
%type  TermArg
%type  Target
%type  RequiredTarget
%type  SimpleTarget
%type  BufferTermData
%type  ParameterTypePackage
%type  ParameterTypePackageList
%type  ParameterTypesPackage
%type  ParameterTypesPackageList
 
%type  Type1Opcode
%type  Type2Opcode
%type  Type2IntegerOpcode
%type  Type2StringOpcode
%type  Type2BufferOpcode
%type  Type2BufferOrStringOpcode
%type  Type3Opcode
 
/* Obsolete %type  Type4Opcode */
 
%type  Type5Opcode
%type  Type6Opcode
 
%type  LineTerm
%type  IncludeTerm
%type  IncludeCStyleTerm
%type  ExternalTerm
 
%type  FieldUnitList
%type  FieldUnit
%type  FieldUnitEntry
 
%type  OffsetTerm
%type  AccessAsTerm
%type  OptionalAccessAttribTerm
 
 
/* Named Objects */
 
%type  BankFieldTerm
%type  CreateBitFieldTerm
%type  CreateByteFieldTerm
%type  CreateDWordFieldTerm
%type  CreateFieldTerm
%type  CreateQWordFieldTerm
%type  CreateWordFieldTerm
%type  DataRegionTerm
%type  DeviceTerm
%type  EventTerm
%type  FieldTerm
%type  FunctionTerm
%type  IndexFieldTerm
%type  MethodTerm
%type  MutexTerm
%type  OpRegionTerm
%type  OpRegionSpaceIdTerm
%type  PowerResTerm
%type  ProcessorTerm
%type  ThermalZoneTerm
 
 
/* Namespace modifiers */
 
%type  AliasTerm
%type  NameTerm
%type  ScopeTerm
 
/* Type 1 opcodes */
 
%type  BreakTerm
%type  BreakPointTerm
%type  ContinueTerm
%type  FatalTerm
%type  IfElseTerm
%type  IfTerm
%type  ElseTerm
%type  LoadTerm
%type  NoOpTerm
%type  NotifyTerm
%type  ReleaseTerm
%type  ResetTerm
%type  ReturnTerm
%type  SignalTerm
%type  SleepTerm
%type  StallTerm
%type  SwitchTerm
%type  CaseDefaultTermList
//%type  CaseTermList
%type  CaseTerm
%type  DefaultTerm
%type  UnloadTerm
%type  WhileTerm
 
/* Type 2 opcodes */
 
%type  AcquireTerm
%type  AddTerm
%type  AndTerm
%type  ConcatTerm
%type  ConcatResTerm
%type  CondRefOfTerm
%type  CopyObjectTerm
%type  DecTerm
%type  DerefOfTerm
%type  DivideTerm
%type  FindSetLeftBitTerm
%type  FindSetRightBitTerm
%type  FromBCDTerm
%type  IncTerm
%type  IndexTerm
%type  LAndTerm
%type  LEqualTerm
%type  LGreaterTerm
%type  LGreaterEqualTerm
%type  LLessTerm
%type  LLessEqualTerm
%type  LNotTerm
%type  LNotEqualTerm
%type  LoadTableTerm
%type  LOrTerm
%type  MatchTerm
%type  MidTerm
%type  ModTerm
%type  MultiplyTerm
%type  NAndTerm
%type  NOrTerm
%type  NotTerm
%type  ObjectTypeTerm
%type  OrTerm
%type  RefOfTerm
%type  ShiftLeftTerm
%type  ShiftRightTerm
%type  SizeOfTerm
%type  StoreTerm
%type  SubtractTerm
%type  TimerTerm
%type  ToBCDTerm
%type  ToBufferTerm
%type  ToDecimalStringTerm
%type  ToHexStringTerm
%type  ToIntegerTerm
%type  ToStringTerm
%type  WaitTerm
%type  XOrTerm
 
%type  OptionalTermArg
%type  OptionalReturnArg
%type  OptionalListString
 
 
/* Keywords */
 
%type  ObjectTypeKeyword
%type  AccessTypeKeyword
%type  AccessAttribKeyword
%type  LockRuleKeyword
%type  UpdateRuleKeyword
%type  RegionSpaceKeyword
%type  AddressSpaceKeyword
%type  MatchOpKeyword
%type  SerializeRuleKeyword
%type  DMATypeKeyword
%type  OptionalBusMasterKeyword
%type  XferTypeKeyword
%type  ResourceTypeKeyword
%type  MinKeyword
%type  MaxKeyword
%type  DecodeKeyword
%type  RangeTypeKeyword
%type  MemTypeKeyword
%type  OptionalReadWriteKeyword
%type  InterruptTypeKeyword
%type  InterruptLevel
%type  ShareTypeKeyword
%type  IODecodeKeyword
%type  TypeKeyword
%type  TranslationKeyword
%type  AddressKeyword
 
/* Types */
 
%type  SuperName
%type  ArgTerm
%type  LocalTerm
%type  DebugTerm
 
%type  Integer
%type  ByteConst
%type  WordConst
%type  DWordConst
%type  QWordConst
%type  String
 
%type  ConstTerm
%type  ByteConstExpr
%type  WordConstExpr
%type  DWordConstExpr
%type  QWordConstExpr
%type  ConstExprTerm
 
%type  BufferTerm
%type  ByteList
%type  DWordList
 
%type  PackageTerm
%type  PackageList
%type  PackageElement
 
%type  VarPackageLengthTerm
 
/* Macros */
 
%type  EISAIDTerm
%type  ResourceTemplateTerm
%type  ToUUIDTerm
%type  UnicodeTerm
%type  ResourceMacroList
%type  ResourceMacroTerm
 
%type  DMATerm
%type  DWordIOTerm
%type  DWordMemoryTerm
%type  DWordSpaceTerm
%type  EndDependentFnTerm
%type  ExtendedIOTerm
%type  ExtendedMemoryTerm
%type  ExtendedSpaceTerm
%type  FixedIOTerm
%type  InterruptTerm
%type  IOTerm
%type  IRQNoFlagsTerm
%type  IRQTerm
%type  Memory24Term
%type  Memory32FixedTerm
%type  Memory32Term
%type  QWordIOTerm
%type  QWordMemoryTerm
%type  QWordSpaceTerm
%type  RegisterTerm
%type  StartDependentFnTerm
%type  StartDependentFnNoPriTerm
%type  VendorLongTerm
%type  VendorShortTerm
%type  WordBusNumberTerm
%type  WordIOTerm
%type  WordSpaceTerm
 
%type  NameString
%type  NameSeg
 
 
/* Local types that help construct the AML, not in ACPI spec */
 
%type  IncludeEndTerm
%type  AmlPackageLengthTerm
%type  OptionalByteConstExpr
%type  OptionalDWordConstExpr
%type  OptionalQWordConstExpr
%type  OptionalSerializeRuleKeyword
%type  OptionalResourceType_First
%type  OptionalResourceType
%type  OptionalMinType
%type  OptionalMaxType
%type  OptionalMemType
%type  OptionalCount
%type  OptionalDecodeType
%type  OptionalRangeType
%type  OptionalShareType
%type  OptionalType
%type  OptionalType_Last
%type  OptionalTranslationType_Last
%type  OptionalStringData
%type  OptionalNameString
%type  OptionalNameString_First
%type  OptionalNameString_Last
%type  OptionalAddressRange
%type  OptionalObjectTypeKeyword
%type  OptionalParameterTypePackage
%type  OptionalParameterTypesPackage
%type  OptionalReference
%type  OptionalAccessSize
 
 
%type  TermArgItem
%type  NameStringItem
 
%%
 
 
/*******************************************************************************
 *
 * Production rules start here
 *
 ******************************************************************************/
 
/*
 * ASL Names
 */
 
 
/*
 * Blocks, Data, and Opcodes
 */
 
ASLCode
    : DefinitionBlockTerm
    | 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_DEFINITIONBLOCK '('	{$$ = TrCreateLeafNode (PARSEOP_DEFINITIONBLOCK);}
        String ','
        String ','
        ByteConst ','
        String ','
        String ','
        DWordConst
        ')'                         {TrSetEndLineNumber ($3);}
            '{' TermList '}'        {$$ = TrLinkChildren ($3,7,$4,$6,$8,$10,$12,$14,$18);}
    ;
 
/* 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),$3);}
    ;
 
Term
    : Object                        {}
    | Type1Opcode                   {}
    | Type2Opcode                   {}
    | Type2IntegerOpcode            {}
    | Type2StringOpcode             {}
    | Type2BufferOpcode             {}
    | Type2BufferOrStringOpcode     {}
    | error                         {$$ = AslDoError(); yyclearin;}
    ;
 
CompilerDirective
    : IncludeTerm                   {}
    | IncludeCStyleTerm             {$$ = NULL;}
    | LineTerm						{$$ = NULL;}
    | ExternalTerm                  {}
    ;
 
ObjectList
    :                               {$$ = NULL;}
    | ObjectList Object             {$$ = TrLinkPeerNode ($1,$2);}
    | error                         {$$ = AslDoError(); yyclearin;}
    ;
 
Object
    : CompilerDirective             {}
    | NamedObject                   {}
    | NameSpaceModifier             {}
    ;
 
DataObject
    : BufferData                    {}
    | PackageData                   {}
    | IntegerData                   {}
    | StringData                    {}
    ;
 
BufferData
    : Type5Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
    | Type2BufferOrStringOpcode     {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
    | Type2BufferOpcode             {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
    | BufferTerm                    {}
    ;
 
PackageData
    : PackageTerm                   {}
    ;
 
IntegerData
    : Type2IntegerOpcode            {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
    | Type3Opcode                   {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
    | Integer                       {}
    | ConstTerm                     {}
    ;
 
StringData
    : Type2StringOpcode             {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
    | String                        {}
    ;
 
NamedObject
    : BankFieldTerm                 {}
    | CreateBitFieldTerm            {}
    | CreateByteFieldTerm           {}
    | CreateDWordFieldTerm          {}
    | CreateFieldTerm               {}
    | CreateQWordFieldTerm          {}
    | CreateWordFieldTerm           {}
    | DataRegionTerm                {}
    | DeviceTerm                    {}
    | EventTerm                     {}
    | FieldTerm                     {}
    | FunctionTerm                  {}
    | IndexFieldTerm                {}
    | MethodTerm                    {}
    | MutexTerm                     {}
    | OpRegionTerm                  {}
    | PowerResTerm                  {}
    | ProcessorTerm                 {}
    | ThermalZoneTerm               {}
    ;
 
NameSpaceModifier
    : AliasTerm                     {}
    | NameTerm                      {}
    | ScopeTerm                     {}
    ;
 
UserTerm
    : NameString '('                {TrUpdateNode (PARSEOP_METHODCALL, $1);}
        ArgList ')'                 {$$ = TrLinkChildNode ($1,$4);}
    ;
 
ArgList
    :                               {$$ = NULL;}
    | TermArg
    | ArgList ','                   /* Allows a trailing comma at list end */
    | ArgList ','
        TermArg                     {$$ = TrLinkPeerNode ($1,$3);}
    ;
 
/*
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);}
 
*/
 
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);}
    ;
 
Target
    :                               {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_TARGET | NODE_COMPILE_TIME_CONST);} /* Placeholder is a ZeroOp object */
    | ','                           {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_TARGET | NODE_COMPILE_TIME_CONST);} /* Placeholder is a ZeroOp object */
    | ',' SuperName                 {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
    ;
 
RequiredTarget
    : ',' SuperName                 {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
    ;
 
SimpleTarget
    : NameString                    {}
    | LocalTerm                     {}
    | ArgTerm                       {}
    ;
 
/* 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);}
    ;
 
 
/* Opcode types */
 
Type1Opcode
    : BreakTerm                     {}
    | BreakPointTerm                {}
    | ContinueTerm                  {}
    | FatalTerm                     {}
    | IfElseTerm                    {}
    | LoadTerm                      {}
    | NoOpTerm                      {}
    | NotifyTerm                    {}
    | ReleaseTerm                   {}
    | ResetTerm                     {}
    | ReturnTerm                    {}
    | SignalTerm                    {}
    | SleepTerm                     {}
    | StallTerm                     {}
    | SwitchTerm                    {}
    | UnloadTerm                    {}
    | WhileTerm                     {}
    ;
 
Type2Opcode
    : AcquireTerm                   {}
    | CondRefOfTerm                 {}
    | CopyObjectTerm                {}
    | DerefOfTerm                   {}
    | ObjectTypeTerm                {}
    | RefOfTerm                     {}
    | SizeOfTerm                    {}
    | StoreTerm                     {}
    | TimerTerm                     {}
    | WaitTerm                      {}
    | UserTerm                      {}
    ;
 
/*
 * Type 3/4/5 opcodes
 */
 
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                   {}
    | ToUUIDTerm                    {}
    ;
 
Type6Opcode
    : RefOfTerm                     {}
    | DerefOfTerm                   {}
    | IndexTerm                     {}
    | UserTerm                      {}
    ;
 
IncludeTerm
    : PARSEOP_INCLUDE '('			{$$ = TrCreateLeafNode (PARSEOP_INCLUDE);}
        String  ')'                 {TrLinkChildren ($3,1,$4);FlOpenIncludeFile ($4);}
        TermList
        IncludeEndTerm              {$$ = TrLinkPeerNodes (3,$3,$7,$8);}
    ;
 
IncludeEndTerm
    : PARSEOP_INCLUDE_END			{$$ = TrCreateLeafNode (PARSEOP_INCLUDE_END);}
    ;
 
IncludeCStyleTerm
    : PARSEOP_INCLUDE_CSTYLE
        String                      {FlOpenIncludeFile ($2);}
    ;
 
LineTerm
	: PARSEOP_LINE_CSTYLE
		Integer						{FlSetLineNumber ($2);}
	;
 
ExternalTerm
    : PARSEOP_EXTERNAL '('
        NameString
        OptionalObjectTypeKeyword
        OptionalParameterTypePackage
        OptionalParameterTypesPackage
        ')'                         {$$ = TrCreateNode (PARSEOP_EXTERNAL,4,$3,$4,$5,$6);}
    | PARSEOP_EXTERNAL '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
 
/******* Named Objects *******************************************************/
 
 
BankFieldTerm
    : PARSEOP_BANKFIELD '('			{$$ = TrCreateLeafNode (PARSEOP_BANKFIELD);}
        NameString
        NameStringItem
        TermArgItem
        ',' AccessTypeKeyword
        ',' LockRuleKeyword
        ',' UpdateRuleKeyword
        ')' '{'
            FieldUnitList '}'       {$$ = TrLinkChildren ($3,7,$4,$5,$6,$8,$10,$12,$15);}
    | PARSEOP_BANKFIELD '('
        error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
    ;
 
FieldUnitList
    :                               {$$ = NULL;}
    | FieldUnit
    | FieldUnitList ','             /* Allows a trailing comma at list end */
    | FieldUnitList ','
        FieldUnit                   {$$ = TrLinkPeerNode ($1,$3);}
    ;
 
FieldUnit
    : FieldUnitEntry                {}
    | OffsetTerm                    {}
    | AccessAsTerm                  {}
    ;
 
FieldUnitEntry
    : ',' AmlPackageLengthTerm      {$$ = TrCreateNode (PARSEOP_RESERVED_BYTES,1,$2);}
    | NameSeg ','
        AmlPackageLengthTerm        {$$ = TrLinkChildNode ($1,$3);}
    ;
 
OffsetTerm
    : PARSEOP_OFFSET '('
        AmlPackageLengthTerm
        ')'                         {$$ = TrCreateNode (PARSEOP_OFFSET,1,$3);}
    | PARSEOP_OFFSET '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
AccessAsTerm
    : PARSEOP_ACCESSAS '('
        AccessTypeKeyword
        OptionalAccessAttribTerm
        ')'                         {$$ = TrCreateNode (PARSEOP_ACCESSAS,2,$3,$4);}
    | PARSEOP_ACCESSAS '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
CreateBitFieldTerm
    : PARSEOP_CREATEBITFIELD '('	{$$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);}
        TermArg
        TermArgItem
        NameStringItem
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
    | PARSEOP_CREATEBITFIELD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
CreateByteFieldTerm
    : PARSEOP_CREATEBYTEFIELD '('	{$$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);}
        TermArg
        TermArgItem
        NameStringItem
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
    | PARSEOP_CREATEBYTEFIELD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
CreateDWordFieldTerm
    : PARSEOP_CREATEDWORDFIELD '('	{$$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);}
        TermArg
        TermArgItem
        NameStringItem
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
    | PARSEOP_CREATEDWORDFIELD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
CreateFieldTerm
    : PARSEOP_CREATEFIELD '('		{$$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);}
        TermArg
        TermArgItem
        TermArgItem
        NameStringItem
        ')'                         {$$ = TrLinkChildren ($3,4,$4,$5,$6,TrSetNodeFlags ($7, NODE_IS_NAME_DECLARATION));}
    | PARSEOP_CREATEFIELD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
CreateQWordFieldTerm
    : PARSEOP_CREATEQWORDFIELD '('	{$$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);}
        TermArg
        TermArgItem
        NameStringItem
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
    | PARSEOP_CREATEQWORDFIELD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
CreateWordFieldTerm
    : PARSEOP_CREATEWORDFIELD '('	{$$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);}
        TermArg
        TermArgItem
        NameStringItem
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
    | PARSEOP_CREATEWORDFIELD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DataRegionTerm
    : PARSEOP_DATATABLEREGION '('	{$$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);}
        NameString
        TermArgItem
        TermArgItem
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$6,$7);}
    | PARSEOP_DATATABLEREGION '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DeviceTerm
    : PARSEOP_DEVICE '('			{$$ = TrCreateLeafNode (PARSEOP_DEVICE);}
        NameString
        ')' '{'
            ObjectList '}'          {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
    | PARSEOP_DEVICE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
EventTerm
    : PARSEOP_EVENT '('				{$$ = TrCreateLeafNode (PARSEOP_EVENT);}
        NameString
        ')'                         {$$ = TrLinkChildren ($3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));}
    | PARSEOP_EVENT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
FieldTerm
    : PARSEOP_FIELD '('				{$$ = TrCreateLeafNode (PARSEOP_FIELD);}
        NameString
        ',' AccessTypeKeyword
        ',' LockRuleKeyword
        ',' UpdateRuleKeyword
        ')' '{'
            FieldUnitList '}'       {$$ = TrLinkChildren ($3,5,$4,$6,$8,$10,$13);}
    | PARSEOP_FIELD '('
        error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
    ;
 
FunctionTerm
    : PARSEOP_FUNCTION '('			{$$ = TrCreateLeafNode (PARSEOP_METHOD);}
        NameString
        OptionalParameterTypePackage
        OptionalParameterTypesPackage
        ')' '{'
            TermList '}'            {$$ = TrLinkChildren ($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;}
    ;
 
IndexFieldTerm
    : PARSEOP_INDEXFIELD '('		{$$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);}
        NameString
        NameStringItem
        ',' AccessTypeKeyword
        ',' LockRuleKeyword
        ',' UpdateRuleKeyword
        ')' '{'
            FieldUnitList '}'       {$$ = TrLinkChildren ($3,6,$4,$5,$7,$9,$11,$14);}
    | PARSEOP_INDEXFIELD '('
        error ')' '{' error '}'     {$$ = AslDoError(); yyclearin;}
    ;
 
MethodTerm
    : PARSEOP_METHOD  '('			{$$ = TrCreateLeafNode (PARSEOP_METHOD);}
        NameString
        OptionalByteConstExpr       {UtCheckIntegerRange ($5, 0, 7);}
        OptionalSerializeRuleKeyword
        OptionalByteConstExpr
        OptionalParameterTypePackage
        OptionalParameterTypesPackage
        ')' '{'
            TermList '}'            {$$ = TrLinkChildren ($3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$7,$8,$9,$10,$13);}
    | PARSEOP_METHOD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
MutexTerm
    : PARSEOP_MUTEX '('				{$$ = TrCreateLeafNode (PARSEOP_MUTEX);}
        NameString
        ',' ByteConstExpr
        ')'                         {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
    | PARSEOP_MUTEX '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
OpRegionTerm
    : PARSEOP_OPERATIONREGION '('	{$$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);}
        NameString
        ',' OpRegionSpaceIdTerm
        TermArgItem
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8);}
    | PARSEOP_OPERATIONREGION '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
OpRegionSpaceIdTerm
    : RegionSpaceKeyword            {}
    | ByteConst                     {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
    ;
 
PowerResTerm
    : PARSEOP_POWERRESOURCE '('		{$$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);}
        NameString
        ',' ByteConstExpr
        ',' WordConstExpr
        ')' '{'
            ObjectList '}'          {$$ = TrLinkChildren ($3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$8,$11);}
    | PARSEOP_POWERRESOURCE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ProcessorTerm
    : PARSEOP_PROCESSOR '('			{$$ = TrCreateLeafNode (PARSEOP_PROCESSOR);}
        NameString
        ',' ByteConstExpr
        OptionalDWordConstExpr
        OptionalByteConstExpr
        ')' '{'
            ObjectList '}'          {$$ = TrLinkChildren ($3,5,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8,$11);}
    | PARSEOP_PROCESSOR '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ThermalZoneTerm
    : PARSEOP_THERMALZONE '('		{$$ = TrCreateLeafNode (PARSEOP_THERMALZONE);}
        NameString
        ')' '{'
            ObjectList '}'          {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
    | PARSEOP_THERMALZONE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
 
/******* Namespace modifiers *************************************************/
 
 
AliasTerm
    : PARSEOP_ALIAS '('				{$$ = TrCreateLeafNode (PARSEOP_ALIAS);}
        NameString
        NameStringItem
        ')'                         {$$ = TrLinkChildren ($3,2,$4,TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));}
    | PARSEOP_ALIAS '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
NameTerm
    : PARSEOP_NAME '('				{$$ = TrCreateLeafNode (PARSEOP_NAME);}
        NameString
        ',' DataObject
        ')'                         {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
    | PARSEOP_NAME '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ScopeTerm
    : PARSEOP_SCOPE '('				{$$ = TrCreateLeafNode (PARSEOP_SCOPE);}
        NameString
        ')' '{'
            ObjectList '}'          {$$ = TrLinkChildren ($3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
    | PARSEOP_SCOPE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
 
/******* Type 1 opcodes *******************************************************/
 
 
BreakTerm
    : PARSEOP_BREAK					{$$ = TrCreateNode (PARSEOP_BREAK, 0);}
    ;
 
BreakPointTerm
    : PARSEOP_BREAKPOINT			{$$ = TrCreateNode (PARSEOP_BREAKPOINT, 0);}
    ;
 
ContinueTerm
    : PARSEOP_CONTINUE				{$$ = TrCreateNode (PARSEOP_CONTINUE, 0);}
    ;
 
FatalTerm
    : PARSEOP_FATAL '('				{$$ = TrCreateLeafNode (PARSEOP_FATAL);}
        ByteConstExpr
        ',' DWordConstExpr
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$6,$7);}
    | PARSEOP_FATAL '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
IfElseTerm
    : IfTerm ElseTerm               {$$ = TrLinkPeerNode ($1,$2);}
    ;
 
IfTerm
    : PARSEOP_IF '('				{$$ = TrCreateLeafNode (PARSEOP_IF);}
        TermArg
        ')' '{'
            TermList '}'            {$$ = TrLinkChildren ($3,2,$4,$7);}
 
    | PARSEOP_IF '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ElseTerm
    :                               {$$ = NULL;}
    | PARSEOP_ELSE '{'				{$$ = TrCreateLeafNode (PARSEOP_ELSE);}
        TermList '}'                {$$ = TrLinkChildren ($3,1,$4);}
 
    | PARSEOP_ELSE '{'
        error '}'                   {$$ = AslDoError(); yyclearin;}
 
    | PARSEOP_ELSE
        error                       {$$ = AslDoError(); yyclearin;}
 
    | PARSEOP_ELSEIF '('			{$$ = TrCreateLeafNode (PARSEOP_ELSE);}
        TermArg						{$$ = TrCreateLeafNode (PARSEOP_IF);}
        ')' '{'
            TermList '}'		    {TrLinkChildren ($5,2,$4,$8);}
        ElseTerm                    {TrLinkPeerNode ($5,$11);}
                                    {$$ = TrLinkChildren ($3,1,$5);}
 
    | PARSEOP_ELSEIF '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
 
    | PARSEOP_ELSEIF
        error                       {$$ = AslDoError(); yyclearin;}
    ;
 
LoadTerm
    : PARSEOP_LOAD '('				{$$ = TrCreateLeafNode (PARSEOP_LOAD);}
        NameString
        RequiredTarget
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_LOAD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
NoOpTerm
    : PARSEOP_NOOP					{$$ = TrCreateNode (PARSEOP_NOOP, 0);}
    ;
 
NotifyTerm
    : PARSEOP_NOTIFY '('			{$$ = TrCreateLeafNode (PARSEOP_NOTIFY);}
        SuperName
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_NOTIFY '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ReleaseTerm
    : PARSEOP_RELEASE '('			{$$ = TrCreateLeafNode (PARSEOP_RELEASE);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_RELEASE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ResetTerm
    : PARSEOP_RESET '('				{$$ = TrCreateLeafNode (PARSEOP_RESET);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_RESET '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ReturnTerm
    : PARSEOP_RETURN '('			{$$ = TrCreateLeafNode (PARSEOP_RETURN);}
        OptionalReturnArg
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_RETURN 				{$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_RETURN),1,TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN));}
    | PARSEOP_RETURN '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
SignalTerm
    : PARSEOP_SIGNAL '('			{$$ = TrCreateLeafNode (PARSEOP_SIGNAL);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_SIGNAL '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
SleepTerm
    : PARSEOP_SLEEP '('				{$$ = TrCreateLeafNode (PARSEOP_SLEEP);}
        TermArg
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_SLEEP '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
StallTerm
    : PARSEOP_STALL '('				{$$ = TrCreateLeafNode (PARSEOP_STALL);}
        TermArg
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_STALL '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
SwitchTerm
    : PARSEOP_SWITCH '('			{$$ = TrCreateLeafNode (PARSEOP_SWITCH);}
        TermArg
        ')' '{'
            CaseDefaultTermList '}'
                                    {$$ = TrLinkChildren ($3,2,$4,$7);}
    | PARSEOP_SWITCH '('
        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);}
    ;
*/
 
CaseTerm
    : PARSEOP_CASE '('				{$$ = TrCreateLeafNode (PARSEOP_CASE);}
        DataObject
        ')' '{'
            TermList '}'            {$$ = TrLinkChildren ($3,2,$4,$7);}
    | PARSEOP_CASE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DefaultTerm
    : PARSEOP_DEFAULT '{'			{$$ = TrCreateLeafNode (PARSEOP_DEFAULT);}
        TermList '}'                {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_DEFAULT '{'
        error '}'                   {$$ = AslDoError(); yyclearin;}
    ;
 
UnloadTerm
    : PARSEOP_UNLOAD '('			{$$ = TrCreateLeafNode (PARSEOP_UNLOAD);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_UNLOAD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
WhileTerm
    : PARSEOP_WHILE '('				{$$ = TrCreateLeafNode (PARSEOP_WHILE);}
        TermArg
        ')' '{' TermList '}'
                                    {$$ = TrLinkChildren ($3,2,$4,$7);}
    | PARSEOP_WHILE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
 
/******* Type 2 opcodes *******************************************************/
 
AcquireTerm
    : PARSEOP_ACQUIRE '('			{$$ = TrCreateLeafNode (PARSEOP_ACQUIRE);}
        SuperName
        ',' WordConstExpr
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$6);}
    | PARSEOP_ACQUIRE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
AddTerm
    : PARSEOP_ADD '('				{$$ = TrCreateLeafNode (PARSEOP_ADD);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_ADD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
AndTerm
    : PARSEOP_AND '('				{$$ = TrCreateLeafNode (PARSEOP_AND);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_AND '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ConcatTerm
    : PARSEOP_CONCATENATE '('		{$$ = TrCreateLeafNode (PARSEOP_CONCATENATE);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_CONCATENATE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ConcatResTerm
    : PARSEOP_CONCATENATERESTEMPLATE '('    {$$ = TrCreateLeafNode (PARSEOP_CONCATENATERESTEMPLATE);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_CONCATENATERESTEMPLATE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
CondRefOfTerm
    : PARSEOP_CONDREFOF '('			{$$ = TrCreateLeafNode (PARSEOP_CONDREFOF);}
        SuperName
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_CONDREFOF '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
CopyObjectTerm
    : PARSEOP_COPYOBJECT '('		{$$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);}
        TermArg
        ',' SimpleTarget
        ')'                         {$$ = TrLinkChildren ($3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
    | PARSEOP_COPYOBJECT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DecTerm
    : PARSEOP_DECREMENT '('			{$$ = TrCreateLeafNode (PARSEOP_DECREMENT);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_DECREMENT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DerefOfTerm
    : PARSEOP_DEREFOF '('			{$$ = TrCreateLeafNode (PARSEOP_DEREFOF);}
        TermArg
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_DEREFOF '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DivideTerm
    : PARSEOP_DIVIDE '('			{$$ = TrCreateLeafNode (PARSEOP_DIVIDE);}
        TermArg
        TermArgItem
        Target
        Target
        ')'                         {$$ = TrLinkChildren ($3,4,$4,$5,$6,$7);}
    | PARSEOP_DIVIDE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
FindSetLeftBitTerm
    : PARSEOP_FINDSETLEFTBIT '('	{$$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_FINDSETLEFTBIT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
FindSetRightBitTerm
    : PARSEOP_FINDSETRIGHTBIT '('	{$$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_FINDSETRIGHTBIT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
FromBCDTerm
    : PARSEOP_FROMBCD '('			{$$ = TrCreateLeafNode (PARSEOP_FROMBCD);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_FROMBCD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
IncTerm
    : PARSEOP_INCREMENT '('			{$$ = TrCreateLeafNode (PARSEOP_INCREMENT);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_INCREMENT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
IndexTerm
    : PARSEOP_INDEX '('				{$$ = TrCreateLeafNode (PARSEOP_INDEX);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_INDEX '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LAndTerm
    : PARSEOP_LAND '('				{$$ = TrCreateLeafNode (PARSEOP_LAND);}
        TermArg
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_LAND '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LEqualTerm
    : PARSEOP_LEQUAL '('			{$$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
        TermArg
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_LEQUAL '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LGreaterTerm
    : PARSEOP_LGREATER '('			{$$ = TrCreateLeafNode (PARSEOP_LGREATER);}
        TermArg
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_LGREATER '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LGreaterEqualTerm
    : PARSEOP_LGREATEREQUAL '('		{$$ = TrCreateLeafNode (PARSEOP_LLESS);}
        TermArg
        TermArgItem
        ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($3,2,$4,$5));}
    | PARSEOP_LGREATEREQUAL '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LLessTerm
    : PARSEOP_LLESS '('				{$$ = TrCreateLeafNode (PARSEOP_LLESS);}
        TermArg
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_LLESS '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LLessEqualTerm
    : PARSEOP_LLESSEQUAL '('		{$$ = TrCreateLeafNode (PARSEOP_LGREATER);}
        TermArg
        TermArgItem
        ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($3,2,$4,$5));}
    | PARSEOP_LLESSEQUAL '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LNotTerm
    : PARSEOP_LNOT '('				{$$ = TrCreateLeafNode (PARSEOP_LNOT);}
        TermArg
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_LNOT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LNotEqualTerm
    : PARSEOP_LNOTEQUAL '('			{$$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
        TermArg
        TermArgItem
        ')'                         {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($3,2,$4,$5));}
    | PARSEOP_LNOTEQUAL '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LoadTableTerm
    : PARSEOP_LOADTABLE '('			{$$ = TrCreateLeafNode (PARSEOP_LOADTABLE);}
        TermArg
        TermArgItem
        TermArgItem
        OptionalListString
        OptionalListString
        OptionalReference
        ')'                         {$$ = TrLinkChildren ($3,6,$4,$5,$6,$7,$8,$9);}
    | PARSEOP_LOADTABLE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
LOrTerm
    : PARSEOP_LOR '('				{$$ = TrCreateLeafNode (PARSEOP_LOR);}
        TermArg
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_LOR '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
MatchTerm
    : PARSEOP_MATCH '('				{$$ = TrCreateLeafNode (PARSEOP_MATCH);}
        TermArg
        ',' MatchOpKeyword
        TermArgItem
        ',' MatchOpKeyword
        TermArgItem
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,6,$4,$6,$7,$9,$10,$11);}
    | PARSEOP_MATCH '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
MidTerm
    : PARSEOP_MID '('				{$$ = TrCreateLeafNode (PARSEOP_MID);}
        TermArg
        TermArgItem
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,4,$4,$5,$6,$7);}
    | PARSEOP_MID '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ModTerm
    : PARSEOP_MOD '('				{$$ = TrCreateLeafNode (PARSEOP_MOD);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_MOD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
MultiplyTerm
    : PARSEOP_MULTIPLY '('			{$$ = TrCreateLeafNode (PARSEOP_MULTIPLY);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_MULTIPLY '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
NAndTerm
    : PARSEOP_NAND '('				{$$ = TrCreateLeafNode (PARSEOP_NAND);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_NAND '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
NOrTerm
    : PARSEOP_NOR '('				{$$ = TrCreateLeafNode (PARSEOP_NOR);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_NOR '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
NotTerm
    : PARSEOP_NOT '('				{$$ = TrCreateLeafNode (PARSEOP_NOT);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_NOT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ObjectTypeTerm
    : PARSEOP_OBJECTTYPE '('		{$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_OBJECTTYPE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
OrTerm
    : PARSEOP_OR '('				{$$ = TrCreateLeafNode (PARSEOP_OR);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_OR '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
/*
 * In RefOf, the node isn't really a target, but we can't keep track of it after
 * we've taken a pointer to it. (hard to tell if a local becomes initialized this way.)
 */
RefOfTerm
    : PARSEOP_REFOF '('				{$$ = TrCreateLeafNode (PARSEOP_REFOF);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));}
    | PARSEOP_REFOF '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ShiftLeftTerm
    : PARSEOP_SHIFTLEFT '('			{$$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_SHIFTLEFT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ShiftRightTerm
    : PARSEOP_SHIFTRIGHT '('		{$$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_SHIFTRIGHT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
SizeOfTerm
    : PARSEOP_SIZEOF '('			{$$ = TrCreateLeafNode (PARSEOP_SIZEOF);}
        SuperName
        ')'                         {$$ = TrLinkChildren ($3,1,$4);}
    | PARSEOP_SIZEOF '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
StoreTerm
    : PARSEOP_STORE '('				{$$ = TrCreateLeafNode (PARSEOP_STORE);}
        TermArg
        ',' SuperName
        ')'                         {$$ = TrLinkChildren ($3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
    | PARSEOP_STORE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
SubtractTerm
    : PARSEOP_SUBTRACT '('			{$$ = TrCreateLeafNode (PARSEOP_SUBTRACT);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_SUBTRACT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
TimerTerm
    : PARSEOP_TIMER '('			    {$$ = TrCreateLeafNode (PARSEOP_TIMER);}
        ')'                         {$$ = TrLinkChildren ($3,0);}
    | PARSEOP_TIMER		            {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_TIMER),0);}
    | PARSEOP_TIMER '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ToBCDTerm
    : PARSEOP_TOBCD '('				{$$ = TrCreateLeafNode (PARSEOP_TOBCD);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_TOBCD '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ToBufferTerm
    : PARSEOP_TOBUFFER '('			{$$ = TrCreateLeafNode (PARSEOP_TOBUFFER);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_TOBUFFER '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ToDecimalStringTerm
    : PARSEOP_TODECIMALSTRING '('	{$$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_TODECIMALSTRING '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ToHexStringTerm
    : PARSEOP_TOHEXSTRING '('		{$$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_TOHEXSTRING '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ToIntegerTerm
    : PARSEOP_TOINTEGER '('			{$$ = TrCreateLeafNode (PARSEOP_TOINTEGER);}
        TermArg
        Target
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_TOINTEGER '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ToStringTerm
    : PARSEOP_TOSTRING '('			{$$ = TrCreateLeafNode (PARSEOP_TOSTRING);}
        TermArg
        OptionalCount
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_TOSTRING '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ToUUIDTerm
    : PARSEOP_TOUUID '('
        StringData ')'              {$$ = TrUpdateNode (PARSEOP_TOUUID, $3);}
    | PARSEOP_TOUUID '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
WaitTerm
    : PARSEOP_WAIT '('				{$$ = TrCreateLeafNode (PARSEOP_WAIT);}
        SuperName
        TermArgItem
        ')'                         {$$ = TrLinkChildren ($3,2,$4,$5);}
    | PARSEOP_WAIT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
XOrTerm
    : PARSEOP_XOR '('				{$$ = TrCreateLeafNode (PARSEOP_XOR);}
        TermArg
        TermArgItem
        Target
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$5,$6);}
    | PARSEOP_XOR '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
 
/******* Keywords *************************************************************/
 
 
ObjectTypeKeyword
    : PARSEOP_OBJECTTYPE_UNK                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
    | PARSEOP_OBJECTTYPE_INT                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_INT);}
    | PARSEOP_OBJECTTYPE_STR                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_STR);}
    | PARSEOP_OBJECTTYPE_BUF                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BUF);}
    | PARSEOP_OBJECTTYPE_PKG                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PKG);}
    | PARSEOP_OBJECTTYPE_FLD                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_FLD);}
    | PARSEOP_OBJECTTYPE_DEV                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DEV);}
    | PARSEOP_OBJECTTYPE_EVT                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_EVT);}
    | PARSEOP_OBJECTTYPE_MTH                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTH);}
    | PARSEOP_OBJECTTYPE_MTX                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTX);}
    | PARSEOP_OBJECTTYPE_OPR                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_OPR);}
    | PARSEOP_OBJECTTYPE_POW                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_POW);}
    | PARSEOP_OBJECTTYPE_PRO                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PRO);}
    | PARSEOP_OBJECTTYPE_THZ                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_THZ);}
    | PARSEOP_OBJECTTYPE_BFF                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BFF);}
    | PARSEOP_OBJECTTYPE_DDB                {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DDB);}
    ;
 
AccessTypeKeyword
    : PARSEOP_ACCESSTYPE_ANY                {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_ANY);}
    | PARSEOP_ACCESSTYPE_BYTE               {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BYTE);}
    | PARSEOP_ACCESSTYPE_WORD               {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_WORD);}
    | PARSEOP_ACCESSTYPE_DWORD              {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_DWORD);}
    | PARSEOP_ACCESSTYPE_QWORD              {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_QWORD);}
    | PARSEOP_ACCESSTYPE_BUF                {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BUF);}
    ;
 
AccessAttribKeyword
    : PARSEOP_ACCESSATTRIB_QUICK            {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_QUICK );}
    | PARSEOP_ACCESSATTRIB_SND_RCV          {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_SND_RCV);}
    | PARSEOP_ACCESSATTRIB_BYTE             {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BYTE);}
    | PARSEOP_ACCESSATTRIB_WORD             {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD);}
    | PARSEOP_ACCESSATTRIB_BLOCK            {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK);}
    | PARSEOP_ACCESSATTRIB_WORD_CALL        {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD_CALL);}
    | PARSEOP_ACCESSATTRIB_BLOCK_CALL       {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK_CALL);}
    ;
 
LockRuleKeyword
    : PARSEOP_LOCKRULE_LOCK                 {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_LOCK);}
    | PARSEOP_LOCKRULE_NOLOCK               {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_NOLOCK);}
    ;
 
UpdateRuleKeyword
    : PARSEOP_UPDATERULE_PRESERVE           {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_PRESERVE);}
    | PARSEOP_UPDATERULE_ONES               {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ONES);}
    | PARSEOP_UPDATERULE_ZEROS              {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ZEROS);}
    ;
 
 
RegionSpaceKeyword
    : PARSEOP_REGIONSPACE_IO                {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IO);}
    | PARSEOP_REGIONSPACE_MEM               {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_MEM);}
    | PARSEOP_REGIONSPACE_PCI               {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCI);}
    | PARSEOP_REGIONSPACE_EC                {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_EC);}
    | PARSEOP_REGIONSPACE_SMBUS             {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_SMBUS);}
    | PARSEOP_REGIONSPACE_CMOS              {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_CMOS);}
    | PARSEOP_REGIONSPACE_PCIBAR            {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCIBAR);}
    | PARSEOP_REGIONSPACE_IPMI              {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IPMI);}
    ;
 
AddressSpaceKeyword
    : ByteConst								{$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
    | RegionSpaceKeyword					{}
    | PARSEOP_ADDRESSSPACE_FFIXEDHW         {$$ = TrCreateLeafNode (PARSEOP_ADDRESSSPACE_FFIXEDHW);}
    ;
 
 
SerializeRuleKeyword
    : PARSEOP_SERIALIZERULE_SERIAL          {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_SERIAL);}
    | PARSEOP_SERIALIZERULE_NOTSERIAL       {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL);}
    ;
 
MatchOpKeyword
    : PARSEOP_MATCHTYPE_MTR                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MTR);}
    | PARSEOP_MATCHTYPE_MEQ                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MEQ);}
    | PARSEOP_MATCHTYPE_MLE                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLE);}
    | PARSEOP_MATCHTYPE_MLT                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLT);}
    | PARSEOP_MATCHTYPE_MGE                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGE);}
    | PARSEOP_MATCHTYPE_MGT                 {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGT);}
    ;
 
DMATypeKeyword
    : PARSEOP_DMATYPE_A                     {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_A);}
    | PARSEOP_DMATYPE_COMPATIBILITY         {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_COMPATIBILITY);}
    | PARSEOP_DMATYPE_B                     {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_B);}
    | PARSEOP_DMATYPE_F                     {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_F);}
    ;
 
XferTypeKeyword
    : PARSEOP_XFERTYPE_8                    {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8);}
    | PARSEOP_XFERTYPE_8_16                 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8_16);}
    | PARSEOP_XFERTYPE_16                   {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_16);}
    ;
 
ResourceTypeKeyword
    : PARSEOP_RESOURCETYPE_CONSUMER         {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
    | PARSEOP_RESOURCETYPE_PRODUCER         {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_PRODUCER);}
    ;
 
MinKeyword
    : PARSEOP_MINTYPE_FIXED                 {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_FIXED);}
    | PARSEOP_MINTYPE_NOTFIXED              {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_NOTFIXED);}
    ;
 
MaxKeyword
    : PARSEOP_MAXTYPE_FIXED                 {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_FIXED);}
    | PARSEOP_MAXTYPE_NOTFIXED              {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_NOTFIXED);}
    ;
 
DecodeKeyword
    : PARSEOP_DECODETYPE_POS                {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_POS);}
    | PARSEOP_DECODETYPE_SUB                {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_SUB);}
    ;
 
RangeTypeKeyword
    : PARSEOP_RANGETYPE_ISAONLY             {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ISAONLY);}
    | PARSEOP_RANGETYPE_NONISAONLY          {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_NONISAONLY);}
    | PARSEOP_RANGETYPE_ENTIRE              {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ENTIRE);}
    ;
 
MemTypeKeyword
    : PARSEOP_MEMTYPE_CACHEABLE             {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_CACHEABLE);}
    | PARSEOP_MEMTYPE_WRITECOMBINING        {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_WRITECOMBINING);}
    | PARSEOP_MEMTYPE_PREFETCHABLE          {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_PREFETCHABLE);}
    | PARSEOP_MEMTYPE_NONCACHEABLE          {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_NONCACHEABLE);}
    ;
 
OptionalReadWriteKeyword
    :                                       {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
    | PARSEOP_READWRITETYPE_BOTH            {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
    | PARSEOP_READWRITETYPE_READONLY        {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_READONLY);}
    ;
 
InterruptTypeKeyword
    : PARSEOP_INTTYPE_EDGE                  {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_EDGE);}
    | PARSEOP_INTTYPE_LEVEL                 {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_LEVEL);}
    ;
 
InterruptLevel
    : PARSEOP_INTLEVEL_ACTIVEHIGH           {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEHIGH);}
    | PARSEOP_INTLEVEL_ACTIVELOW            {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVELOW);}
    ;
 
ShareTypeKeyword
    : PARSEOP_SHARETYPE_SHARED              {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHARED);}
    | PARSEOP_SHARETYPE_EXCLUSIVE           {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVE);}
    ;
 
IODecodeKeyword
    : PARSEOP_IODECODETYPE_16               {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_16);}
    | PARSEOP_IODECODETYPE_10               {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_10);}
    ;
 
TypeKeyword
    : PARSEOP_TYPE_TRANSLATION              {$$ = TrCreateLeafNode (PARSEOP_TYPE_TRANSLATION);}
    | PARSEOP_TYPE_STATIC                   {$$ = TrCreateLeafNode (PARSEOP_TYPE_STATIC);}
    ;
 
TranslationKeyword
    : PARSEOP_TRANSLATIONTYPE_SPARSE        {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_SPARSE);}
    | PARSEOP_TRANSLATIONTYPE_DENSE         {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_DENSE);}
    ;
 
AddressKeyword
    : PARSEOP_ADDRESSTYPE_MEMORY            {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_MEMORY);}
    | PARSEOP_ADDRESSTYPE_RESERVED          {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_RESERVED);}
    | PARSEOP_ADDRESSTYPE_NVS               {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_NVS);}
    | PARSEOP_ADDRESSTYPE_ACPI              {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_ACPI);}
    ;
 
 
/******* Miscellaneous Types **************************************************/
 
 
SuperName
    : NameString                    {}
    | ArgTerm                       {}
    | LocalTerm                     {}
    | DebugTerm                     {}
    | Type6Opcode                   {}
/*    | UserTerm                      {} */  /* Caused reduce/reduce with Type6Opcode->UserTerm */
    ;
 
ArgTerm
    : PARSEOP_ARG0                  {$$ = TrCreateLeafNode (PARSEOP_ARG0);}
    | PARSEOP_ARG1                  {$$ = TrCreateLeafNode (PARSEOP_ARG1);}
    | PARSEOP_ARG2                  {$$ = TrCreateLeafNode (PARSEOP_ARG2);}
    | PARSEOP_ARG3                  {$$ = TrCreateLeafNode (PARSEOP_ARG3);}
    | PARSEOP_ARG4                  {$$ = TrCreateLeafNode (PARSEOP_ARG4);}
    | PARSEOP_ARG5                  {$$ = TrCreateLeafNode (PARSEOP_ARG5);}
    | PARSEOP_ARG6                  {$$ = TrCreateLeafNode (PARSEOP_ARG6);}
    ;
 
LocalTerm
    : PARSEOP_LOCAL0                {$$ = TrCreateLeafNode (PARSEOP_LOCAL0);}
    | PARSEOP_LOCAL1                {$$ = TrCreateLeafNode (PARSEOP_LOCAL1);}
    | PARSEOP_LOCAL2                {$$ = TrCreateLeafNode (PARSEOP_LOCAL2);}
    | PARSEOP_LOCAL3                {$$ = TrCreateLeafNode (PARSEOP_LOCAL3);}
    | PARSEOP_LOCAL4                {$$ = TrCreateLeafNode (PARSEOP_LOCAL4);}
    | PARSEOP_LOCAL5                {$$ = TrCreateLeafNode (PARSEOP_LOCAL5);}
    | PARSEOP_LOCAL6                {$$ = TrCreateLeafNode (PARSEOP_LOCAL6);}
    | PARSEOP_LOCAL7                {$$ = TrCreateLeafNode (PARSEOP_LOCAL7);}
    ;
 
DebugTerm
    : PARSEOP_DEBUG                 {$$ = TrCreateLeafNode (PARSEOP_DEBUG);}
    ;
 
 
ByteConst
    : Integer                       {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
    ;
 
WordConst
    : Integer                       {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
    ;
 
DWordConst
    : Integer                       {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
    ;
 
QWordConst
    : Integer                       {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
    ;
 
Integer
    : PARSEOP_INTEGER               {$$ = TrCreateValuedLeafNode (PARSEOP_INTEGER, AslCompilerlval.i);}
    ;
 
String
    : PARSEOP_STRING_LITERAL        {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, (ACPI_NATIVE_INT) AslCompilerlval.s);}
    ;
 
ConstTerm
    : ConstExprTerm                 {}
    | PARSEOP_REVISION              {$$ = TrCreateLeafNode (PARSEOP_REVISION);}
    ;
 
ByteConstExpr
    : Type3Opcode                   {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
    | Type2IntegerOpcode            {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
    | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
    | ByteConst                     {}
    ;
 
WordConstExpr
    : Type3Opcode                   {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
    | Type2IntegerOpcode            {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
    | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
    | WordConst                     {}
    ;
 
DWordConstExpr
    : Type3Opcode                   {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
    | Type2IntegerOpcode            {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
    | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
    | DWordConst                    {}
    ;
 
QWordConstExpr
    : Type3Opcode                   {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
    | Type2IntegerOpcode            {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
    | ConstExprTerm                 {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
    | QWordConst                    {}
    ;
 
ConstExprTerm
    : PARSEOP_ZERO                  {$$ = TrCreateValuedLeafNode (PARSEOP_ZERO, 0);}
    | PARSEOP_ONE                   {$$ = TrCreateValuedLeafNode (PARSEOP_ONE, 1);}
    | PARSEOP_ONES                  {$$ = TrCreateValuedLeafNode (PARSEOP_ONES, ACPI_UINT64_MAX);}
    | PARSEOP___DATE__              {$$ = TrCreateConstantLeafNode (PARSEOP___DATE__);}
    | PARSEOP___FILE__              {$$ = TrCreateConstantLeafNode (PARSEOP___FILE__);}
    | PARSEOP___LINE__              {$$ = TrCreateConstantLeafNode (PARSEOP___LINE__);}
    ;
 
/* OptionalCount must appear before ByteList or an incorrect reduction will result */
 
OptionalCount
    :                               {$$ = TrCreateLeafNode (PARSEOP_ONES);}       /* Placeholder is a OnesOp object */
    | ','                           {$$ = TrCreateLeafNode (PARSEOP_ONES);}       /* Placeholder is a OnesOp object */
    | ',' TermArg                   {$$ = $2;}
    ;
 
 
BufferTerm
    : PARSEOP_BUFFER '('            {$$ = TrCreateLeafNode (PARSEOP_BUFFER);}
        OptionalTermArg
        ')' '{'
            BufferTermData '}'      {$$ = TrLinkChildren ($3,2,$4,$7);}
    | PARSEOP_BUFFER '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
BufferTermData
    : ByteList                      {}
    | StringData                    {}
    ;
 
ByteList
    :                               {$$ = NULL;}
    | ByteConstExpr
    | 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);}
    ;
 
PackageTerm
    : PARSEOP_PACKAGE '('           {$$ = TrCreateLeafNode (PARSEOP_VAR_PACKAGE);}
        VarPackageLengthTerm
        ')' '{'
            PackageList '}'         {$$ = TrLinkChildren ($3,2,$4,$7);}
    | PARSEOP_PACKAGE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
VarPackageLengthTerm
    :                               {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
    | TermArg                       {$$ = $1;}
    ;
 
PackageList
    :                               {$$ = NULL;}
    | PackageElement
    | PackageList ','               /* Allows a trailing comma at list end */
    | PackageList ','
        PackageElement              {$$ = TrLinkPeerNode ($1,$3);}
    ;
 
PackageElement
    : DataObject                    {}
    | NameString                    {}
    ;
 
EISAIDTerm
    : PARSEOP_EISAID '('
        StringData ')'              {$$ = TrUpdateNode (PARSEOP_EISAID, $3);}
    | PARSEOP_EISAID '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
 
/******* Resources and Memory ***********************************************/
 
 
/*
 * Note: Create two default nodes to allow conversion to a Buffer AML opcode
 * Also, insert the EndTag at the end of the template.
 */
ResourceTemplateTerm
    : PARSEOP_RESOURCETEMPLATE '(' ')'
        '{'
        ResourceMacroList '}'       {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,4,
                                          TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
                                          TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
                                          $5,
                                          TrCreateLeafNode (PARSEOP_ENDTAG));}
    ;
 
UnicodeTerm
    : PARSEOP_UNICODE '('           {$$ = TrCreateLeafNode (PARSEOP_UNICODE);}
        StringData
        ')'                         {$$ = TrLinkChildren ($3,2,0,$4);}
    | PARSEOP_UNICODE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ResourceMacroList
    :                               {$$ = NULL;}
    | ResourceMacroList
        ResourceMacroTerm           {$$ = TrLinkPeerNode ($1,$2);}
    ;
 
ResourceMacroTerm
    : DMATerm                       {}
    | DWordIOTerm                   {}
    | DWordMemoryTerm               {}
    | DWordSpaceTerm                {}
    | EndDependentFnTerm            {}
    | ExtendedIOTerm                {}
    | ExtendedMemoryTerm            {}
    | ExtendedSpaceTerm             {}
    | FixedIOTerm                   {}
    | InterruptTerm                 {}
    | IOTerm                        {}
    | IRQNoFlagsTerm                {}
    | IRQTerm                       {}
    | Memory24Term                  {}
    | Memory32FixedTerm             {}
    | Memory32Term                  {}
    | QWordIOTerm                   {}
    | QWordMemoryTerm               {}
    | QWordSpaceTerm                {}
    | RegisterTerm                  {}
    | StartDependentFnTerm          {}
    | StartDependentFnNoPriTerm     {}
    | VendorLongTerm                {}
    | VendorShortTerm               {}
    | WordBusNumberTerm             {}
    | WordIOTerm                    {}
    | WordSpaceTerm                 {}
    ;
 
DMATerm
    : PARSEOP_DMA '('               {$$ = TrCreateLeafNode (PARSEOP_DMA);}
        DMATypeKeyword
        OptionalBusMasterKeyword
        ',' XferTypeKeyword
        OptionalNameString_Last
        ')' '{'
            ByteList '}'            {$$ = TrLinkChildren ($3,5,$4,$5,$7,$8,$11);}
    | PARSEOP_DMA '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DWordIOTerm
    : PARSEOP_DWORDIO '('           {$$ = TrCreateLeafNode (PARSEOP_DWORDIO);}
        OptionalResourceType_First
        OptionalMinType
        OptionalMaxType
        OptionalDecodeType
        OptionalRangeType
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString
        OptionalType
        OptionalTranslationType_Last
        ')'                         {$$ = TrLinkChildren ($3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
    | PARSEOP_DWORDIO '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DWordMemoryTerm
    : PARSEOP_DWORDMEMORY '('       {$$ = TrCreateLeafNode (PARSEOP_DWORDMEMORY);}
        OptionalResourceType_First
        OptionalDecodeType
        OptionalMinType
        OptionalMaxType
        OptionalMemType
        ',' OptionalReadWriteKeyword
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString
        OptionalAddressRange
        OptionalType_Last
        ')'                         {$$ = TrLinkChildren ($3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
    | PARSEOP_DWORDMEMORY '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
DWordSpaceTerm
    : PARSEOP_DWORDSPACE '('        {$$ = TrCreateLeafNode (PARSEOP_DWORDSPACE);}
        ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
        OptionalResourceType
        OptionalDecodeType
        OptionalMinType
        OptionalMaxType
        ',' ByteConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
    | PARSEOP_DWORDSPACE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
 
EndDependentFnTerm
    : PARSEOP_ENDDEPENDENTFN '('
        ')'                         {$$ = TrCreateLeafNode (PARSEOP_ENDDEPENDENTFN);}
    | PARSEOP_ENDDEPENDENTFN '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ExtendedIOTerm
    : PARSEOP_EXTENDEDIO '('        {$$ = TrCreateLeafNode (PARSEOP_EXTENDEDIO);}
        OptionalResourceType_First
        OptionalMinType
        OptionalMaxType
        OptionalDecodeType
        OptionalRangeType
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        OptionalQWordConstExpr
        OptionalNameString
        OptionalType
        OptionalTranslationType_Last
        ')'                         {$$ = TrLinkChildren ($3,14,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22);}
    | PARSEOP_EXTENDEDIO '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ExtendedMemoryTerm
    : PARSEOP_EXTENDEDMEMORY '('    {$$ = TrCreateLeafNode (PARSEOP_EXTENDEDMEMORY);}
        OptionalResourceType_First
        OptionalDecodeType
        OptionalMinType
        OptionalMaxType
        OptionalMemType
        ',' OptionalReadWriteKeyword
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        OptionalQWordConstExpr
        OptionalNameString
        OptionalAddressRange
        OptionalType_Last
        ')'                         {$$ = TrLinkChildren ($3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24);}
    | PARSEOP_EXTENDEDMEMORY '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
ExtendedSpaceTerm
    : PARSEOP_EXTENDEDSPACE '('     {$$ = TrCreateLeafNode (PARSEOP_EXTENDEDSPACE);}
        ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
        OptionalResourceType
        OptionalDecodeType
        OptionalMinType
        OptionalMaxType
        ',' ByteConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        OptionalQWordConstExpr
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,13,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23);}
    | PARSEOP_EXTENDEDSPACE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
FixedIOTerm
    : PARSEOP_FIXEDIO '('           {$$ = TrCreateLeafNode (PARSEOP_FIXEDIO);}
        WordConstExpr
        ',' ByteConstExpr
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,3,$4,$6,$7);}
    | PARSEOP_FIXEDIO '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
InterruptTerm
    : PARSEOP_INTERRUPT '('         {$$ = TrCreateLeafNode (PARSEOP_INTERRUPT);}
        OptionalResourceType_First
        ',' InterruptTypeKeyword
        ',' InterruptLevel
        OptionalShareType
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString_Last
        ')' '{'
            DWordList '}'           {$$ = TrLinkChildren ($3,8,$4,$6,$8,$9,$10,$11,$12,$15);}
    | PARSEOP_INTERRUPT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
IOTerm
    : PARSEOP_IO '('                {$$ = TrCreateLeafNode (PARSEOP_IO);}
        IODecodeKeyword
        ',' WordConstExpr
        ',' WordConstExpr
        ',' ByteConstExpr
        ',' ByteConstExpr
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);}
    | PARSEOP_IO '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
IRQNoFlagsTerm
    : PARSEOP_IRQNOFLAGS '('        {$$ = TrCreateLeafNode (PARSEOP_IRQNOFLAGS);}
        OptionalNameString_First
        ')' '{'
            ByteList '}'            {$$ = TrLinkChildren ($3,2,$4,$7);}
    | PARSEOP_IRQNOFLAGS '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
IRQTerm
    : PARSEOP_IRQ '('               {$$ = TrCreateLeafNode (PARSEOP_IRQ);}
        InterruptTypeKeyword
        ',' InterruptLevel
        OptionalShareType
        OptionalNameString_Last
        ')' '{'
            ByteList '}'            {$$ = TrLinkChildren ($3,5,$4,$6,$7,$8,$11);}
    | PARSEOP_IRQ '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
Memory24Term
    : PARSEOP_MEMORY24 '('          {$$ = TrCreateLeafNode (PARSEOP_MEMORY24);}
        OptionalReadWriteKeyword
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);}
    | PARSEOP_MEMORY24 '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
Memory32FixedTerm
    : PARSEOP_MEMORY32FIXED '('     {$$ = TrCreateLeafNode (PARSEOP_MEMORY32FIXED);}
        OptionalReadWriteKeyword
        ',' DWordConstExpr
        ',' DWordConstExpr
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,4,$4,$6,$8,$9);}
    | PARSEOP_MEMORY32FIXED '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
Memory32Term
    : PARSEOP_MEMORY32 '('          {$$ = TrCreateLeafNode (PARSEOP_MEMORY32);}
        OptionalReadWriteKeyword
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        ',' DWordConstExpr
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$12,$13);}
    | PARSEOP_MEMORY32 '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
QWordIOTerm
    : PARSEOP_QWORDIO '('           {$$ = TrCreateLeafNode (PARSEOP_QWORDIO);}
        OptionalResourceType_First
        OptionalMinType
        OptionalMaxType
        OptionalDecodeType
        OptionalRangeType
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString
        OptionalType
        OptionalTranslationType_Last
        ')'                         {$$ = TrLinkChildren ($3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
    | PARSEOP_QWORDIO '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
QWordMemoryTerm
    : PARSEOP_QWORDMEMORY '('       {$$ = TrCreateLeafNode (PARSEOP_QWORDMEMORY);}
        OptionalResourceType_First
        OptionalDecodeType
        OptionalMinType
        OptionalMaxType
        OptionalMemType
        ',' OptionalReadWriteKeyword
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString
        OptionalAddressRange
        OptionalType_Last
        ')'                         {$$ = TrLinkChildren ($3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
    | PARSEOP_QWORDMEMORY '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
QWordSpaceTerm
    : PARSEOP_QWORDSPACE '('        {$$ = TrCreateLeafNode (PARSEOP_QWORDSPACE);}
        ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
        OptionalResourceType
        OptionalDecodeType
        OptionalMinType
        OptionalMaxType
        ',' ByteConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        ',' QWordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
    | PARSEOP_QWORDSPACE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
RegisterTerm
    : PARSEOP_REGISTER '('          {$$ = TrCreateLeafNode (PARSEOP_REGISTER);}
        AddressSpaceKeyword
        ',' ByteConstExpr
        ',' ByteConstExpr
        ',' QWordConstExpr
        OptionalAccessSize
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,6,$4,$6,$8,$10,$11,$12);}
    | PARSEOP_REGISTER '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
StartDependentFnTerm
    : PARSEOP_STARTDEPENDENTFN '('  {$$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN);}
        ByteConstExpr
        ',' ByteConstExpr
        ')' '{'
        ResourceMacroList '}'       {$$ = TrLinkChildren ($3,3,$4,$6,$9);}
    | PARSEOP_STARTDEPENDENTFN '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
StartDependentFnNoPriTerm
    : PARSEOP_STARTDEPENDENTFN_NOPRI '('    {$$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);}
        ')' '{'
        ResourceMacroList '}'       {$$ = TrLinkChildren ($3,1,$6);}
    | PARSEOP_STARTDEPENDENTFN_NOPRI '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
VendorLongTerm
    : PARSEOP_VENDORLONG '('        {$$ = TrCreateLeafNode (PARSEOP_VENDORLONG);}
        OptionalNameString_First
        ')' '{'
            ByteList '}'            {$$ = TrLinkChildren ($3,2,$4,$7);}
    | PARSEOP_VENDORLONG '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
VendorShortTerm
    : PARSEOP_VENDORSHORT '('       {$$ = TrCreateLeafNode (PARSEOP_VENDORSHORT);}
        OptionalNameString_First
        ')' '{'
            ByteList '}'            {$$ = TrLinkChildren ($3,2,$4,$7);}
    | PARSEOP_VENDORSHORT '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
WordBusNumberTerm
    : PARSEOP_WORDBUSNUMBER '('     {$$ = TrCreateLeafNode (PARSEOP_WORDBUSNUMBER);}
        OptionalResourceType_First
        OptionalMinType
        OptionalMaxType
        OptionalDecodeType
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,12,$4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);}
    | PARSEOP_WORDBUSNUMBER '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
WordIOTerm
    : PARSEOP_WORDIO '('            {$$ = TrCreateLeafNode (PARSEOP_WORDIO);}
        OptionalResourceType_First
        OptionalMinType
        OptionalMaxType
        OptionalDecodeType
        OptionalRangeType
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString
        OptionalType
        OptionalTranslationType_Last
        ')'                         {$$ = TrLinkChildren ($3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
    | PARSEOP_WORDIO '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
WordSpaceTerm
    : PARSEOP_WORDSPACE '('         {$$ = TrCreateLeafNode (PARSEOP_WORDSPACE);}
        ByteConstExpr               {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
        OptionalResourceType
        OptionalDecodeType
        OptionalMinType
        OptionalMaxType
        ',' ByteConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        ',' WordConstExpr
        OptionalByteConstExpr
        OptionalStringData
        OptionalNameString_Last
        ')'                         {$$ = TrLinkChildren ($3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
    | PARSEOP_WORDSPACE '('
        error ')'                   {$$ = AslDoError(); yyclearin;}
    ;
 
 
/******* Object References ***********************************************/
 
/* Allow IO, DMA, IRQ Resource macro names to also be used as identifiers */
 
NameString
    : NameSeg                       {}
    | PARSEOP_NAMESTRING            {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) AslCompilerlval.s);}
    | PARSEOP_IO                    {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IO");}
    | PARSEOP_DMA                   {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "DMA");}
    | PARSEOP_IRQ                   {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IRQ");}
    ;
 
NameSeg
    : PARSEOP_NAMESEG               {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESEG, (ACPI_NATIVE_INT) AslCompilerlval.s);}
    ;
 
 
/******* Helper rules ****************************************************/
 
 
AmlPackageLengthTerm
    : Integer                       {$$ = TrUpdateNode (PARSEOP_PACKAGE_LENGTH,(ACPI_PARSE_OBJECT *) $1);}
    ;
 
OptionalBusMasterKeyword
    : ','                                       {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
    | ',' PARSEOP_BUSMASTERTYPE_MASTER          {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
    | ',' PARSEOP_BUSMASTERTYPE_NOTMASTER       {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_NOTMASTER);}
    ;
 
OptionalAccessAttribTerm
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' ByteConstExpr             {$$ = $2;}
    | ',' AccessAttribKeyword       {$$ = $2;}
    ;
 
OptionalAccessSize
    :                               {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);}
    | ','                           {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);}
    | ',' ByteConstExpr             {$$ = $2;}
    ;
 
OptionalAddressRange
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' AddressKeyword            {$$ = $2;}
    ;
 
OptionalByteConstExpr
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' ByteConstExpr             {$$ = $2;}
    ;
 
OptionalDecodeType
    : ','                           {$$ = NULL;}
    | ',' DecodeKeyword             {$$ = $2;}
    ;
 
OptionalDWordConstExpr
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' DWordConstExpr            {$$ = $2;}
    ;
 
OptionalListString
    :                               {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));}   /* Placeholder is a NULL string */
    | ','                           {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));}   /* Placeholder is a NULL string */
    | ',' TermArg                   {$$ = $2;}
    ;
 
OptionalMaxType
    : ','                           {$$ = NULL;}
    | ',' MaxKeyword                {$$ = $2;}
    ;
 
OptionalMemType
    : ','                           {$$ = NULL;}
    | ',' MemTypeKeyword            {$$ = $2;}
    ;
 
OptionalMinType
    : ','                           {$$ = NULL;}
    | ',' MinKeyword                {$$ = $2;}
    ;
 
OptionalNameString
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' NameString                {$$ = $2;}
    ;
 
OptionalNameString_Last
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' NameString                {$$ = $2;}
    ;
 
OptionalNameString_First
    :                               {$$ = TrCreateLeafNode (PARSEOP_ZERO);}
    | NameString                    {$$ = $1;}
    ;
 
OptionalObjectTypeKeyword
    :                               {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
    | ',' ObjectTypeKeyword         {$$ = $2;}
    ;
 
OptionalQWordConstExpr
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' QWordConstExpr            {$$ = $2;}
    ;
 
OptionalRangeType
    : ','                           {$$ = NULL;}
    | ',' RangeTypeKeyword          {$$ = $2;}
    ;
 
OptionalReference
    :                               {$$ = TrCreateLeafNode (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
    | ','                           {$$ = TrCreateLeafNode (PARSEOP_ZERO);}       /* Placeholder is a ZeroOp object */
    | ',' TermArg                   {$$ = $2;}
    ;
 
OptionalResourceType_First
    :                               {$$ = NULL;}
    | ResourceTypeKeyword           {$$ = $1;}
    ;
 
OptionalResourceType
    : ','                           {$$ = NULL;}
    | ',' ResourceTypeKeyword       {$$ = $2;}
    ;
 
OptionalSerializeRuleKeyword
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' SerializeRuleKeyword      {$$ = $2;}
    ;
 
OptionalShareType
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' ShareTypeKeyword          {$$ = $2;}
    ;
 
OptionalStringData
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' StringData                {$$ = $2;}
    ;
 
OptionalTermArg
    :                               {$$ = NULL;}
    | TermArg                       {$$ = $1;}
    ;
 
OptionalReturnArg
    :                               {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN);}       /* Placeholder is a ZeroOp object */
    | TermArg                       {$$ = $1;}
    ;
 
OptionalType
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' TypeKeyword               {$$ = $2;}
    ;
 
OptionalType_Last
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' TypeKeyword               {$$ = $2;}
    ;
 
OptionalTranslationType_Last
    :                               {$$ = NULL;}
    | ','                           {$$ = NULL;}
    | ',' TranslationKeyword        {$$ = $2;}
    ;
 
 
TermArgItem
    : ',' TermArg                   {$$ = $2;}
    | ',' error                     {$$ = AslDoError (); yyclearin;}
    ;
 
NameStringItem
    : ',' NameString                {$$ = $2;}
    | ',' error                     {$$ = AslDoError (); yyclearin;}
    ;
 
 
%%
 
 
/*
 * Local support functions
 */
 
int
AslCompilerwrap(void)
{
  return 1;
}
 
/*! [End] no source code translation !*/
 
void *
AslLocalAllocate (unsigned int Size)
{
    void                *Mem;
 
 
    DbgPrint (ASL_PARSE_OUTPUT, "\nAslLocalAllocate: Expanding Stack to %u\n\n", Size);
 
    Mem = ACPI_ALLOCATE_ZEROED (Size);
    if (!Mem)
    {
        AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
                        Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
                        Gbl_InputByteCount, Gbl_CurrentColumn,
                        Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
        exit (1);
    }
 
    return (Mem);
}
 
ACPI_PARSE_OBJECT *
AslDoError (void)
{
 
 
    return (TrCreateLeafNode (PARSEOP_ERRORNODE));
 
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    UtGetOpName
 *
 * PARAMETERS:  ParseOpcode         - Parser keyword ID
 *
 * RETURN:      Pointer to the opcode name
 *
 * DESCRIPTION: Get the ascii name of the parse opcode
 *
 ******************************************************************************/
 
char *
UtGetOpName (
    UINT32                  ParseOpcode)
{
#ifdef ASL_YYTNAME_START
    /*
     * First entries (ASL_YYTNAME_START) in yytname are special reserved names.
     * Ignore first 8 characters of the name
     */
    return ((char *) yytname
        [(ParseOpcode - ASL_FIRST_PARSE_OPCODE) + ASL_YYTNAME_START] + 8);
#else
    return ("[Unknown parser generator]");
#endif
}


Rev 1498	Rev 2216
1	%{	1	%{
2	/******************************************************************************	2	/******************************************************************************
3	*	3	*
4	* Module Name: aslcompiler.y - Bison input file (ASL grammar and actions)	4	* Module Name: aslcompiler.y - Bison input file (ASL grammar and actions)
5	*	5	*
6	*****************************************************************************/	6	*****************************************************************************/
7		7
8	/******************************************************************************	8	/******************************************************************************
9	*	9	*
10	* 1. Copyright Notice	10	* 1. Copyright Notice
11	*	11	*
12	* Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.	12	* Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
13	* All rights reserved.	13	* All rights reserved.
14	*	14	*
15	* 2. License	15	* 2. License
16	*	16	*
17	* 2.1. This is your license from Intel Corp. under its intellectual property	17	* 2.1. This is your license from Intel Corp. under its intellectual property
18	* rights. You may have additional license terms from the party that provided	18	* rights. You may have additional license terms from the party that provided
19	* you this software, covering your right to use that party's intellectual	19	* you this software, covering your right to use that party's intellectual
20	* property rights.	20	* property rights.
21	*	21	*
22	* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a	22	* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23	* copy of the source code appearing in this file ("Covered Code") an	23	* copy of the source code appearing in this file ("Covered Code") an
24	* irrevocable, perpetual, worldwide license under Intel's copyrights in the	24	* irrevocable, perpetual, worldwide license under Intel's copyrights in the
25	* base code distributed originally by Intel ("Original Intel Code") to copy,	25	* base code distributed originally by Intel ("Original Intel Code") to copy,
26	* make derivatives, distribute, use and display any portion of the Covered	26	* make derivatives, distribute, use and display any portion of the Covered
27	* Code in any form, with the right to sublicense such rights; and	27	* Code in any form, with the right to sublicense such rights; and
28	*	28	*
29	* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent	29	* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30	* license (with the right to sublicense), under only those claims of Intel	30	* license (with the right to sublicense), under only those claims of Intel
31	* patents that are infringed by the Original Intel Code, to make, use, sell,	31	* patents that are infringed by the Original Intel Code, to make, use, sell,
32	* offer to sell, and import the Covered Code and derivative works thereof	32	* offer to sell, and import the Covered Code and derivative works thereof
33	* solely to the minimum extent necessary to exercise the above copyright	33	* solely to the minimum extent necessary to exercise the above copyright
34	* license, and in no event shall the patent license extend to any additions	34	* license, and in no event shall the patent license extend to any additions
35	* to or modifications of the Original Intel Code. No other license or right	35	* to or modifications of the Original Intel Code. No other license or right
36	* is granted directly or by implication, estoppel or otherwise;	36	* is granted directly or by implication, estoppel or otherwise;
37	*	37	*
38	* The above copyright and patent license is granted only if the following	38	* The above copyright and patent license is granted only if the following
39	* conditions are met:	39	* conditions are met:
40	*	40	*
41	* 3. Conditions	41	* 3. Conditions
42	*	42	*
43	* 3.1. Redistribution of Source with Rights to Further Distribute Source.	43	* 3.1. Redistribution of Source with Rights to Further Distribute Source.
44	* Redistribution of source code of any substantial portion of the Covered	44	* Redistribution of source code of any substantial portion of the Covered
45	* Code or modification with rights to further distribute source must include	45	* Code or modification with rights to further distribute source must include
46	* the above Copyright Notice, the above License, this list of Conditions,	46	* the above Copyright Notice, the above License, this list of Conditions,
47	* and the following Disclaimer and Export Compliance provision. In addition,	47	* and the following Disclaimer and Export Compliance provision. In addition,
48	* Licensee must cause all Covered Code to which Licensee contributes to	48	* Licensee must cause all Covered Code to which Licensee contributes to
49	* contain a file documenting the changes Licensee made to create that Covered	49	* contain a file documenting the changes Licensee made to create that Covered
50	* Code and the date of any change. Licensee must include in that file the	50	* Code and the date of any change. Licensee must include in that file the
51	* documentation of any changes made by any predecessor Licensee. Licensee	51	* documentation of any changes made by any predecessor Licensee. Licensee
52	* must include a prominent statement that the modification is derived,	52	* must include a prominent statement that the modification is derived,
53	* directly or indirectly, from Original Intel Code.	53	* directly or indirectly, from Original Intel Code.
54	*	54	*
55	* 3.2. Redistribution of Source with no Rights to Further Distribute Source.	55	* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56	* Redistribution of source code of any substantial portion of the Covered	56	* Redistribution of source code of any substantial portion of the Covered
57	* Code or modification without rights to further distribute source must	57	* Code or modification without rights to further distribute source must
58	* include the following Disclaimer and Export Compliance provision in the	58	* include the following Disclaimer and Export Compliance provision in the
59	* documentation and/or other materials provided with distribution. In	59	* documentation and/or other materials provided with distribution. In
60	* addition, Licensee may not authorize further sublicense of source of any	60	* addition, Licensee may not authorize further sublicense of source of any
61	* portion of the Covered Code, and must include terms to the effect that the	61	* portion of the Covered Code, and must include terms to the effect that the
62	* license from Licensee to its licensee is limited to the intellectual	62	* license from Licensee to its licensee is limited to the intellectual
63	* property embodied in the software Licensee provides to its licensee, and	63	* property embodied in the software Licensee provides to its licensee, and
64	* not to intellectual property embodied in modifications its licensee may	64	* not to intellectual property embodied in modifications its licensee may
65	* make.	65	* make.
66	*	66	*
67	* 3.3. Redistribution of Executable. Redistribution in executable form of any	67	* 3.3. Redistribution of Executable. Redistribution in executable form of any
68	* substantial portion of the Covered Code or modification must reproduce the	68	* substantial portion of the Covered Code or modification must reproduce the
69	* above Copyright Notice, and the following Disclaimer and Export Compliance	69	* above Copyright Notice, and the following Disclaimer and Export Compliance
70	* provision in the documentation and/or other materials provided with the	70	* provision in the documentation and/or other materials provided with the
71	* distribution.	71	* distribution.
72	*	72	*
73	* 3.4. Intel retains all right, title, and interest in and to the Original	73	* 3.4. Intel retains all right, title, and interest in and to the Original
74	* Intel Code.	74	* Intel Code.
75	*	75	*
76	* 3.5. Neither the name Intel nor any other trademark owned or controlled by	76	* 3.5. Neither the name Intel nor any other trademark owned or controlled by
77	* Intel shall be used in advertising or otherwise to promote the sale, use or	77	* Intel shall be used in advertising or otherwise to promote the sale, use or
78	* other dealings in products derived from or relating to the Covered Code	78	* other dealings in products derived from or relating to the Covered Code
79	* without prior written authorization from Intel.	79	* without prior written authorization from Intel.
80	*	80	*
81	* 4. Disclaimer and Export Compliance	81	* 4. Disclaimer and Export Compliance
82	*	82	*
83	* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED	83	* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84	* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE	84	* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85	* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,	85	* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86	* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY	86	* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87	* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY	87	* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88	* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A	88	* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89	* PARTICULAR PURPOSE.	89	* PARTICULAR PURPOSE.
90	*	90	*
91	* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES	91	* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92	* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR	92	* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93	* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,	93	* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94	* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY	94	* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95	* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL	95	* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96	* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS	96	* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97	* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY	97	* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98	* LIMITED REMEDY.	98	* LIMITED REMEDY.
99	*	99	*
100	* 4.3. Licensee shall not export, either directly or indirectly, any of this	100	* 4.3. Licensee shall not export, either directly or indirectly, any of this
101	* software or system incorporating such software without first obtaining any	101	* software or system incorporating such software without first obtaining any
102	* required license or other approval from the U. S. Department of Commerce or	102	* required license or other approval from the U. S. Department of Commerce or
103	* any other agency or department of the United States Government. In the	103	* any other agency or department of the United States Government. In the
104	* event Licensee exports any such software from the United States or	104	* event Licensee exports any such software from the United States or
105	* re-exports any such software from a foreign destination, Licensee shall	105	* re-exports any such software from a foreign destination, Licensee shall
106	* ensure that the distribution and export/re-export of the software is in	106	* ensure that the distribution and export/re-export of the software is in
107	* compliance with all laws, regulations, orders, or other restrictions of the	107	* compliance with all laws, regulations, orders, or other restrictions of the
108	* U.S. Export Administration Regulations. Licensee agrees that neither it nor	108	* U.S. Export Administration Regulations. Licensee agrees that neither it nor
109	* any of its subsidiaries will export/re-export any technical data, process,	109	* any of its subsidiaries will export/re-export any technical data, process,
110	* software, or service, directly or indirectly, to any country for which the	110	* software, or service, directly or indirectly, to any country for which the
111	* United States government or any agency thereof requires an export license,	111	* United States government or any agency thereof requires an export license,
112	* other governmental approval, or letter of assurance, without first obtaining	112	* other governmental approval, or letter of assurance, without first obtaining
113	* such license, approval or letter.	113	* such license, approval or letter.
114	*	114	*
115	*****************************************************************************/	115	*****************************************************************************/
116		116
117	#define YYDEBUG 1	-
118	#define YYERROR_VERBOSE 1	-
119		-
120	/*	-
121	* State stack - compiler will fault if it overflows. (Default was 200)	-
122	*/	-
123	#define YYINITDEPTH 600	-
124		-
125	#include "aslcompiler.h"	117	#include "aslcompiler.h"
126	#include	118	#include
127	#include	119	#include
128	#include	120	#include
129	#include "acpi.h"	121	#include "acpi.h"
130	#include "accommon.h"	122	#include "accommon.h"
131		123
132	#define _COMPONENT ACPI_COMPILER	124	#define _COMPONENT ACPI_COMPILER
133	ACPI_MODULE_NAME ("aslparse")	125	ACPI_MODULE_NAME ("aslparse")
134		126
135	/*	127	/*
136	* Global Notes:	128	* Global Notes:
137	*	129	*
138	* October 2005: The following list terms have been optimized (from the	130	* October 2005: The following list terms have been optimized (from the
139	* original ASL grammar in the ACPI specification) to force the immediate	131	* original ASL grammar in the ACPI specification) to force the immediate
140	* reduction of each list item so that the parse stack use doesn't increase on	132	* reduction of each list item so that the parse stack use doesn't increase on
141	* each list element and possibly overflow on very large lists (>4000 items).	133	* each list element and possibly overflow on very large lists (>4000 items).
142	* This dramatically reduces use of the parse stack overall.	134	* This dramatically reduces use of the parse stack overall.
143	*	135	*
144	* ArgList, TermList, Objectlist, ByteList, DWordList, PackageList,	136	* ArgList, TermList, Objectlist, ByteList, DWordList, PackageList,
145	* ResourceMacroList, and FieldUnitList	137	* ResourceMacroList, and FieldUnitList
146	*/	138	*/
147		139
-		140	void * AslLocalAllocate (unsigned int Size);
-		141
-		142	/* Bison/yacc configuration */
148		-
149	/*	-
150	* Next statement is important - this makes everything public so that	-
151	* we can access some of the parser tables from other modules	-
152	*/	143
153	#define static	144	#define static
154	#undef alloca	145	#undef alloca
155	#define alloca AslLocalAllocate	146	#define alloca AslLocalAllocate
156	#define YYERROR_VERBOSE 1	147	#define yytname AslCompilername
157		148
158	void *	-
159	AslLocalAllocate (unsigned int Size);	149	#define YYINITDEPTH 600 /* State stack depth */
-		150	#define YYDEBUG 1 /* Enable debug output */
-		151	#define YYERROR_VERBOSE 1 /* Verbose error messages */
160		152
161	/*	153	/*
162	* The windows version of bison defines this incorrectly as "32768" (Not negative).	154	* The windows version of bison defines this incorrectly as "32768" (Not negative).
163	* Using a custom (edited binary) version of bison that defines YYFLAG as YYFBAD	155	* We use a custom (edited binary) version of bison that defines YYFLAG as YYFBAD
164	* instead (#define YYFBAD 32768), so we can define it correctly here.	156	* instead (#define YYFBAD 32768), so we can define it correctly here.
165	*	157	*
166	* The problem is that if YYFLAG is positive, the extended syntax error messages	158	* The problem is that if YYFLAG is positive, the extended syntax error messages
167	* are disabled.	159	* are disabled.
168	*/	160	*/
169		161	#define YYFLAG -32768
170	#define YYFLAG -32768	-
171		162
172		-
173	%}	163	%}
174		-
175		164
176	/*	165	/*
177	* Declare the type of values in the grammar	166	* Declare the type of values in the grammar
178	*/	167	*/
179		168	%union {
180	%union {	-
181	UINT64 i;	169	UINT64 i;
182	char *s;	170	char *s;
183	ACPI_PARSE_OBJECT *n;	171	ACPI_PARSE_OBJECT *n;
184	}	172	}
185		173
186		-
187	/! [Begin] no source code translation /	174	/! [Begin] no source code translation /
188		175
189	/*	176	/*
190	* These shift/reduce conflicts are expected. There should be zero	177	* These shift/reduce conflicts are expected. There should be zero
191	* reduce/reduce conflicts.	178	* reduce/reduce conflicts.
192	*/	179	*/
193	%expect 60	180	%expect 60
194		181
195		-
196	/*	182	/*
197	* Token types: These are returned by the lexer	183	* Token types: These are returned by the lexer
198	*	184	*
199	* NOTE: This list MUST match the AslKeywordMapping table found	185	* NOTE: This list MUST match the AslKeywordMapping table found
200	* in aslmap.c EXACTLY! Double check any changes!	186	* in aslmap.c EXACTLY! Double check any changes!
201	*/	187	*/
202		188	%token PARSEOP_ACCESSAS
203	%token PARSEOP_ACCESSAS	-
204	%token PARSEOP_ACCESSATTRIB_BLOCK	189	%token PARSEOP_ACCESSATTRIB_BLOCK
205	%token PARSEOP_ACCESSATTRIB_BLOCK_CALL	190	%token PARSEOP_ACCESSATTRIB_BLOCK_CALL
206	%token PARSEOP_ACCESSATTRIB_BYTE	191	%token PARSEOP_ACCESSATTRIB_BYTE
207	%token PARSEOP_ACCESSATTRIB_WORD_CALL	192	%token PARSEOP_ACCESSATTRIB_WORD_CALL
208	%token PARSEOP_ACCESSATTRIB_QUICK	193	%token PARSEOP_ACCESSATTRIB_QUICK
209	%token PARSEOP_ACCESSATTRIB_SND_RCV	194	%token PARSEOP_ACCESSATTRIB_SND_RCV
210	%token PARSEOP_ACCESSATTRIB_WORD	195	%token PARSEOP_ACCESSATTRIB_WORD
211	%token PARSEOP_ACCESSTYPE_ANY	196	%token PARSEOP_ACCESSTYPE_ANY
212	%token PARSEOP_ACCESSTYPE_BUF	197	%token PARSEOP_ACCESSTYPE_BUF
213	%token PARSEOP_ACCESSTYPE_BYTE	198	%token PARSEOP_ACCESSTYPE_BYTE
214	%token PARSEOP_ACCESSTYPE_DWORD	199	%token PARSEOP_ACCESSTYPE_DWORD
215	%token PARSEOP_ACCESSTYPE_QWORD	200	%token PARSEOP_ACCESSTYPE_QWORD
216	%token PARSEOP_ACCESSTYPE_WORD	201	%token PARSEOP_ACCESSTYPE_WORD
217	%token PARSEOP_ACQUIRE	202	%token PARSEOP_ACQUIRE
218	%token PARSEOP_ADD	203	%token PARSEOP_ADD
219	%token PARSEOP_ADDRESSSPACE_FFIXEDHW	204	%token PARSEOP_ADDRESSSPACE_FFIXEDHW
220	%token PARSEOP_ADDRESSTYPE_ACPI	205	%token PARSEOP_ADDRESSTYPE_ACPI
221	%token PARSEOP_ADDRESSTYPE_MEMORY	206	%token PARSEOP_ADDRESSTYPE_MEMORY
222	%token PARSEOP_ADDRESSTYPE_NVS	207	%token PARSEOP_ADDRESSTYPE_NVS
223	%token PARSEOP_ADDRESSTYPE_RESERVED	208	%token PARSEOP_ADDRESSTYPE_RESERVED
224	%token PARSEOP_ALIAS	209	%token PARSEOP_ALIAS
225	%token PARSEOP_AND	210	%token PARSEOP_AND
226	%token PARSEOP_ARG0	211	%token PARSEOP_ARG0
227	%token PARSEOP_ARG1	212	%token PARSEOP_ARG1
228	%token PARSEOP_ARG2	213	%token PARSEOP_ARG2
229	%token PARSEOP_ARG3	214	%token PARSEOP_ARG3
230	%token PARSEOP_ARG4	215	%token PARSEOP_ARG4
231	%token PARSEOP_ARG5	216	%token PARSEOP_ARG5
232	%token PARSEOP_ARG6	217	%token PARSEOP_ARG6
233	%token PARSEOP_BANKFIELD	218	%token PARSEOP_BANKFIELD
234	%token PARSEOP_BREAK	219	%token PARSEOP_BREAK
235	%token PARSEOP_BREAKPOINT	220	%token PARSEOP_BREAKPOINT
236	%token PARSEOP_BUFFER	221	%token PARSEOP_BUFFER
237	%token PARSEOP_BUSMASTERTYPE_MASTER	222	%token PARSEOP_BUSMASTERTYPE_MASTER
238	%token PARSEOP_BUSMASTERTYPE_NOTMASTER	223	%token PARSEOP_BUSMASTERTYPE_NOTMASTER
239	%token PARSEOP_BYTECONST	224	%token PARSEOP_BYTECONST
240	%token PARSEOP_CASE	225	%token PARSEOP_CASE
241	%token PARSEOP_CONCATENATE	226	%token PARSEOP_CONCATENATE
242	%token PARSEOP_CONCATENATERESTEMPLATE	227	%token PARSEOP_CONCATENATERESTEMPLATE
243	%token PARSEOP_CONDREFOF	228	%token PARSEOP_CONDREFOF
244	%token PARSEOP_CONTINUE	229	%token PARSEOP_CONTINUE
245	%token PARSEOP_COPYOBJECT	230	%token PARSEOP_COPYOBJECT
246	%token PARSEOP_CREATEBITFIELD	231	%token PARSEOP_CREATEBITFIELD
247	%token PARSEOP_CREATEBYTEFIELD	232	%token PARSEOP_CREATEBYTEFIELD
248	%token PARSEOP_CREATEDWORDFIELD	233	%token PARSEOP_CREATEDWORDFIELD
249	%token PARSEOP_CREATEFIELD	234	%token PARSEOP_CREATEFIELD
250	%token PARSEOP_CREATEQWORDFIELD	235	%token PARSEOP_CREATEQWORDFIELD
251	%token PARSEOP_CREATEWORDFIELD	236	%token PARSEOP_CREATEWORDFIELD
252	%token PARSEOP_DATATABLEREGION	237	%token PARSEOP_DATATABLEREGION
253	%token PARSEOP_DEBUG	238	%token PARSEOP_DEBUG
254	%token PARSEOP_DECODETYPE_POS	239	%token PARSEOP_DECODETYPE_POS
255	%token PARSEOP_DECODETYPE_SUB	240	%token PARSEOP_DECODETYPE_SUB
256	%token PARSEOP_DECREMENT	241	%token PARSEOP_DECREMENT
257	%token PARSEOP_DEFAULT	242	%token PARSEOP_DEFAULT
258	%token PARSEOP_DEFAULT_ARG	243	%token PARSEOP_DEFAULT_ARG
259	%token PARSEOP_DEFINITIONBLOCK	244	%token PARSEOP_DEFINITIONBLOCK
260	%token PARSEOP_DEREFOF	245	%token PARSEOP_DEREFOF
261	%token PARSEOP_DEVICE	246	%token PARSEOP_DEVICE
262	%token PARSEOP_DIVIDE	247	%token PARSEOP_DIVIDE
263	%token PARSEOP_DMA	248	%token PARSEOP_DMA
264	%token PARSEOP_DMATYPE_A	249	%token PARSEOP_DMATYPE_A
265	%token PARSEOP_DMATYPE_COMPATIBILITY	250	%token PARSEOP_DMATYPE_COMPATIBILITY
266	%token PARSEOP_DMATYPE_B	251	%token PARSEOP_DMATYPE_B
267	%token PARSEOP_DMATYPE_F	252	%token PARSEOP_DMATYPE_F
268	%token PARSEOP_DWORDCONST	253	%token PARSEOP_DWORDCONST
269	%token PARSEOP_DWORDIO	254	%token PARSEOP_DWORDIO
270	%token PARSEOP_DWORDMEMORY	255	%token PARSEOP_DWORDMEMORY
271	%token PARSEOP_DWORDSPACE	256	%token PARSEOP_DWORDSPACE
272	%token PARSEOP_EISAID	257	%token PARSEOP_EISAID
273	%token PARSEOP_ELSE	258	%token PARSEOP_ELSE
274	%token PARSEOP_ELSEIF	259	%token PARSEOP_ELSEIF
275	%token PARSEOP_ENDDEPENDENTFN	260	%token PARSEOP_ENDDEPENDENTFN
276	%token PARSEOP_ENDTAG	261	%token PARSEOP_ENDTAG
277	%token PARSEOP_ERRORNODE	262	%token PARSEOP_ERRORNODE
278	%token PARSEOP_EVENT	263	%token PARSEOP_EVENT
279	%token PARSEOP_EXTENDEDIO	264	%token PARSEOP_EXTENDEDIO
280	%token PARSEOP_EXTENDEDMEMORY	265	%token PARSEOP_EXTENDEDMEMORY
281	%token PARSEOP_EXTENDEDSPACE	266	%token PARSEOP_EXTENDEDSPACE
282	%token PARSEOP_EXTERNAL	267	%token PARSEOP_EXTERNAL
283	%token PARSEOP_FATAL	268	%token PARSEOP_FATAL
284	%token PARSEOP_FIELD	269	%token PARSEOP_FIELD
285	%token PARSEOP_FINDSETLEFTBIT	270	%token PARSEOP_FINDSETLEFTBIT
286	%token PARSEOP_FINDSETRIGHTBIT	271	%token PARSEOP_FINDSETRIGHTBIT
287	%token PARSEOP_FIXEDIO	272	%token PARSEOP_FIXEDIO
288	%token PARSEOP_FROMBCD	273	%token PARSEOP_FROMBCD
289	%token PARSEOP_FUNCTION	274	%token PARSEOP_FUNCTION
290	%token PARSEOP_IF	275	%token PARSEOP_IF
291	%token PARSEOP_INCLUDE	276	%token PARSEOP_INCLUDE
292	%token PARSEOP_INCLUDE_CSTYLE	277	%token PARSEOP_INCLUDE_CSTYLE
293	%token PARSEOP_INCLUDE_END	278	%token PARSEOP_INCLUDE_END
294	%token PARSEOP_INCREMENT	279	%token PARSEOP_INCREMENT
295	%token PARSEOP_INDEX	280	%token PARSEOP_INDEX
296	%token PARSEOP_INDEXFIELD	281	%token PARSEOP_INDEXFIELD
297	%token PARSEOP_INTEGER	282	%token PARSEOP_INTEGER
298	%token PARSEOP_INTERRUPT	283	%token PARSEOP_INTERRUPT
299	%token PARSEOP_INTLEVEL_ACTIVEHIGH	284	%token PARSEOP_INTLEVEL_ACTIVEHIGH
300	%token PARSEOP_INTLEVEL_ACTIVELOW	285	%token PARSEOP_INTLEVEL_ACTIVELOW
301	%token PARSEOP_INTTYPE_EDGE	286	%token PARSEOP_INTTYPE_EDGE
302	%token PARSEOP_INTTYPE_LEVEL	287	%token PARSEOP_INTTYPE_LEVEL
303	%token PARSEOP_IO	288	%token PARSEOP_IO
304	%token PARSEOP_IODECODETYPE_10	289	%token PARSEOP_IODECODETYPE_10
305	%token PARSEOP_IODECODETYPE_16	290	%token PARSEOP_IODECODETYPE_16
306	%token PARSEOP_IRQ	291	%token PARSEOP_IRQ
307	%token PARSEOP_IRQNOFLAGS	292	%token PARSEOP_IRQNOFLAGS
308	%token PARSEOP_LAND	293	%token PARSEOP_LAND
309	%token PARSEOP_LEQUAL	294	%token PARSEOP_LEQUAL
310	%token PARSEOP_LGREATER	295	%token PARSEOP_LGREATER
311	%token PARSEOP_LGREATEREQUAL	296	%token PARSEOP_LGREATEREQUAL
312	%token PARSEOP_LINE_CSTYLE	297	%token PARSEOP_LINE_CSTYLE
313	%token PARSEOP_LLESS	298	%token PARSEOP_LLESS
314	%token PARSEOP_LLESSEQUAL	299	%token PARSEOP_LLESSEQUAL
315	%token PARSEOP_LNOT	300	%token PARSEOP_LNOT
316	%token PARSEOP_LNOTEQUAL	301	%token PARSEOP_LNOTEQUAL
317	%token PARSEOP_LOAD	302	%token PARSEOP_LOAD
318	%token PARSEOP_LOADTABLE	303	%token PARSEOP_LOADTABLE
319	%token PARSEOP_LOCAL0	304	%token PARSEOP_LOCAL0
320	%token PARSEOP_LOCAL1	305	%token PARSEOP_LOCAL1
321	%token PARSEOP_LOCAL2	306	%token PARSEOP_LOCAL2
322	%token PARSEOP_LOCAL3	307	%token PARSEOP_LOCAL3
323	%token PARSEOP_LOCAL4	308	%token PARSEOP_LOCAL4
324	%token PARSEOP_LOCAL5	309	%token PARSEOP_LOCAL5
325	%token PARSEOP_LOCAL6	310	%token PARSEOP_LOCAL6
326	%token PARSEOP_LOCAL7	311	%token PARSEOP_LOCAL7
327	%token PARSEOP_LOCKRULE_LOCK	312	%token PARSEOP_LOCKRULE_LOCK
328	%token PARSEOP_LOCKRULE_NOLOCK	313	%token PARSEOP_LOCKRULE_NOLOCK
329	%token PARSEOP_LOR	314	%token PARSEOP_LOR
330	%token PARSEOP_MATCH	315	%token PARSEOP_MATCH
331	%token PARSEOP_MATCHTYPE_MEQ	316	%token PARSEOP_MATCHTYPE_MEQ
332	%token PARSEOP_MATCHTYPE_MGE	317	%token PARSEOP_MATCHTYPE_MGE
333	%token PARSEOP_MATCHTYPE_MGT	318	%token PARSEOP_MATCHTYPE_MGT
334	%token PARSEOP_MATCHTYPE_MLE	319	%token PARSEOP_MATCHTYPE_MLE
335	%token PARSEOP_MATCHTYPE_MLT	320	%token PARSEOP_MATCHTYPE_MLT
336	%token PARSEOP_MATCHTYPE_MTR	321	%token PARSEOP_MATCHTYPE_MTR
337	%token PARSEOP_MAXTYPE_FIXED	322	%token PARSEOP_MAXTYPE_FIXED
338	%token PARSEOP_MAXTYPE_NOTFIXED	323	%token PARSEOP_MAXTYPE_NOTFIXED
339	%token PARSEOP_MEMORY24	324	%token PARSEOP_MEMORY24
340	%token PARSEOP_MEMORY32	325	%token PARSEOP_MEMORY32
341	%token PARSEOP_MEMORY32FIXED	326	%token PARSEOP_MEMORY32FIXED
342	%token PARSEOP_MEMTYPE_CACHEABLE	327	%token PARSEOP_MEMTYPE_CACHEABLE
343	%token PARSEOP_MEMTYPE_NONCACHEABLE	328	%token PARSEOP_MEMTYPE_NONCACHEABLE
344	%token PARSEOP_MEMTYPE_PREFETCHABLE	329	%token PARSEOP_MEMTYPE_PREFETCHABLE
345	%token PARSEOP_MEMTYPE_WRITECOMBINING	330	%token PARSEOP_MEMTYPE_WRITECOMBINING
346	%token PARSEOP_METHOD	331	%token PARSEOP_METHOD
347	%token PARSEOP_METHODCALL	332	%token PARSEOP_METHODCALL
348	%token PARSEOP_MID	333	%token PARSEOP_MID
349	%token PARSEOP_MINTYPE_FIXED	334	%token PARSEOP_MINTYPE_FIXED
350	%token PARSEOP_MINTYPE_NOTFIXED	335	%token PARSEOP_MINTYPE_NOTFIXED
351	%token PARSEOP_MOD	336	%token PARSEOP_MOD
352	%token PARSEOP_MULTIPLY	337	%token PARSEOP_MULTIPLY
353	%token PARSEOP_MUTEX	338	%token PARSEOP_MUTEX
354	%token PARSEOP_NAME	339	%token PARSEOP_NAME
355	%token ~~PARSEOP_NAMESEG~~	340	%token ~~PARSEOP_NAMESEG~~
356	%token ~~PARSEOP_NAMESTRING~~	341	%token ~~PARSEOP_NAMESTRING~~
357	%token PARSEOP_NAND	342	%token PARSEOP_NAND
358	%token PARSEOP_NOOP	343	%token PARSEOP_NOOP
359	%token PARSEOP_NOR	344	%token PARSEOP_NOR
360	%token PARSEOP_NOT	345	%token PARSEOP_NOT
361	%token PARSEOP_NOTIFY	346	%token PARSEOP_NOTIFY
362	%token PARSEOP_OBJECTTYPE	347	%token PARSEOP_OBJECTTYPE
363	%token PARSEOP_OBJECTTYPE_BFF	348	%token PARSEOP_OBJECTTYPE_BFF
364	%token PARSEOP_OBJECTTYPE_BUF	349	%token PARSEOP_OBJECTTYPE_BUF
365	%token PARSEOP_OBJECTTYPE_DDB	350	%token PARSEOP_OBJECTTYPE_DDB
366	%token PARSEOP_OBJECTTYPE_DEV	351	%token PARSEOP_OBJECTTYPE_DEV
367	%token PARSEOP_OBJECTTYPE_EVT	352	%token PARSEOP_OBJECTTYPE_EVT
368	%token PARSEOP_OBJECTTYPE_FLD	353	%token PARSEOP_OBJECTTYPE_FLD
369	%token PARSEOP_OBJECTTYPE_INT	354	%token PARSEOP_OBJECTTYPE_INT
370	%token PARSEOP_OBJECTTYPE_MTH	355	%token PARSEOP_OBJECTTYPE_MTH
371	%token PARSEOP_OBJECTTYPE_MTX	356	%token PARSEOP_OBJECTTYPE_MTX
372	%token PARSEOP_OBJECTTYPE_OPR	357	%token PARSEOP_OBJECTTYPE_OPR
373	%token PARSEOP_OBJECTTYPE_PKG	358	%token PARSEOP_OBJECTTYPE_PKG
374	%token PARSEOP_OBJECTTYPE_POW	359	%token PARSEOP_OBJECTTYPE_POW
375	%token PARSEOP_OBJECTTYPE_PRO	360	%token PARSEOP_OBJECTTYPE_PRO
376	%token PARSEOP_OBJECTTYPE_STR	361	%token PARSEOP_OBJECTTYPE_STR
377	%token PARSEOP_OBJECTTYPE_THZ	362	%token PARSEOP_OBJECTTYPE_THZ
378	%token PARSEOP_OBJECTTYPE_UNK	363	%token PARSEOP_OBJECTTYPE_UNK
379	%token PARSEOP_OFFSET	364	%token PARSEOP_OFFSET
380	%token PARSEOP_ONE	365	%token PARSEOP_ONE
381	%token PARSEOP_ONES	366	%token PARSEOP_ONES
382	%token PARSEOP_OPERATIONREGION	367	%token PARSEOP_OPERATIONREGION
383	%token PARSEOP_OR	368	%token PARSEOP_OR
384	%token PARSEOP_PACKAGE	369	%token PARSEOP_PACKAGE
385	%token PARSEOP_PACKAGE_LENGTH	370	%token PARSEOP_PACKAGE_LENGTH
386	%token PARSEOP_POWERRESOURCE	371	%token PARSEOP_POWERRESOURCE
387	%token PARSEOP_PROCESSOR	372	%token PARSEOP_PROCESSOR
388	%token PARSEOP_QWORDCONST	373	%token PARSEOP_QWORDCONST
389	%token PARSEOP_QWORDIO	374	%token PARSEOP_QWORDIO
390	%token PARSEOP_QWORDMEMORY	375	%token PARSEOP_QWORDMEMORY
391	%token PARSEOP_QWORDSPACE	376	%token PARSEOP_QWORDSPACE
392	%token PARSEOP_RANGETYPE_ENTIRE	377	%token PARSEOP_RANGETYPE_ENTIRE
393	%token PARSEOP_RANGETYPE_ISAONLY	378	%token PARSEOP_RANGETYPE_ISAONLY
394	%token PARSEOP_RANGETYPE_NONISAONLY	379	%token PARSEOP_RANGETYPE_NONISAONLY
395	%token PARSEOP_RAW_DATA	380	%token PARSEOP_RAW_DATA
396	%token PARSEOP_READWRITETYPE_BOTH	381	%token PARSEOP_READWRITETYPE_BOTH
397	%token PARSEOP_READWRITETYPE_READONLY	382	%token PARSEOP_READWRITETYPE_READONLY
398	%token PARSEOP_REFOF	383	%token PARSEOP_REFOF
399	%token PARSEOP_REGIONSPACE_CMOS	384	%token PARSEOP_REGIONSPACE_CMOS
400	%token PARSEOP_REGIONSPACE_EC	385	%token PARSEOP_REGIONSPACE_EC
401	%token PARSEOP_REGIONSPACE_IO	386	%token PARSEOP_REGIONSPACE_IO
402	%token PARSEOP_REGIONSPACE_IPMI	387	%token PARSEOP_REGIONSPACE_IPMI
403	%token PARSEOP_REGIONSPACE_MEM	388	%token PARSEOP_REGIONSPACE_MEM
404	%token PARSEOP_REGIONSPACE_PCI	389	%token PARSEOP_REGIONSPACE_PCI
405	%token PARSEOP_REGIONSPACE_PCIBAR	390	%token PARSEOP_REGIONSPACE_PCIBAR
406	%token PARSEOP_REGIONSPACE_SMBUS	391	%token PARSEOP_REGIONSPACE_SMBUS
407	%token PARSEOP_REGISTER	392	%token PARSEOP_REGISTER
408	%token PARSEOP_RELEASE	393	%token PARSEOP_RELEASE
409	%token PARSEOP_RESERVED_BYTES	394	%token PARSEOP_RESERVED_BYTES
410	%token PARSEOP_RESET	395	%token PARSEOP_RESET
411	%token PARSEOP_RESOURCETEMPLATE	396	%token PARSEOP_RESOURCETEMPLATE
412	%token PARSEOP_RESOURCETYPE_CONSUMER	397	%token PARSEOP_RESOURCETYPE_CONSUMER
413	%token PARSEOP_RESOURCETYPE_PRODUCER	398	%token PARSEOP_RESOURCETYPE_PRODUCER
414	%token PARSEOP_RETURN	399	%token PARSEOP_RETURN
415	%token PARSEOP_REVISION	400	%token PARSEOP_REVISION
416	%token PARSEOP_SCOPE	401	%token PARSEOP_SCOPE
417	%token PARSEOP_SERIALIZERULE_NOTSERIAL	402	%token PARSEOP_SERIALIZERULE_NOTSERIAL
418	%token PARSEOP_SERIALIZERULE_SERIAL	403	%token PARSEOP_SERIALIZERULE_SERIAL
419	%token PARSEOP_SHARETYPE_EXCLUSIVE	404	%token PARSEOP_SHARETYPE_EXCLUSIVE
420	%token PARSEOP_SHARETYPE_SHARED	405	%token PARSEOP_SHARETYPE_SHARED
421	%token PARSEOP_SHIFTLEFT	406	%token PARSEOP_SHIFTLEFT
422	%token PARSEOP_SHIFTRIGHT	407	%token PARSEOP_SHIFTRIGHT
423	%token PARSEOP_SIGNAL	408	%token PARSEOP_SIGNAL
424	%token PARSEOP_SIZEOF	409	%token PARSEOP_SIZEOF
425	%token PARSEOP_SLEEP	410	%token PARSEOP_SLEEP
426	%token PARSEOP_STALL	411	%token PARSEOP_STALL
427	%token PARSEOP_STARTDEPENDENTFN	412	%token PARSEOP_STARTDEPENDENTFN
428	%token PARSEOP_STARTDEPENDENTFN_NOPRI	413	%token PARSEOP_STARTDEPENDENTFN_NOPRI
429	%token PARSEOP_STORE	414	%token PARSEOP_STORE
430	%token ~~PARSEOP_STRING_LITERAL~~	415	%token ~~PARSEOP_STRING_LITERAL~~
431	%token PARSEOP_SUBTRACT	416	%token PARSEOP_SUBTRACT
432	%token PARSEOP_SWITCH	417	%token PARSEOP_SWITCH
433	%token PARSEOP_THERMALZONE	418	%token PARSEOP_THERMALZONE
434	%token PARSEOP_TIMER	419	%token PARSEOP_TIMER
435	%token PARSEOP_TOBCD	420	%token PARSEOP_TOBCD
436	%token PARSEOP_TOBUFFER	421	%token PARSEOP_TOBUFFER
437	%token PARSEOP_TODECIMALSTRING	422	%token PARSEOP_TODECIMALSTRING
438	%token PARSEOP_TOHEXSTRING	423	%token PARSEOP_TOHEXSTRING
439	%token PARSEOP_TOINTEGER	424	%token PARSEOP_TOINTEGER
440	%token PARSEOP_TOSTRING	425	%token PARSEOP_TOSTRING
441	%token PARSEOP_TOUUID	426	%token PARSEOP_TOUUID
442	%token PARSEOP_TRANSLATIONTYPE_DENSE	427	%token PARSEOP_TRANSLATIONTYPE_DENSE
443	%token PARSEOP_TRANSLATIONTYPE_SPARSE	428	%token PARSEOP_TRANSLATIONTYPE_SPARSE
444	%token PARSEOP_TYPE_STATIC	429	%token PARSEOP_TYPE_STATIC
445	%token PARSEOP_TYPE_TRANSLATION	430	%token PARSEOP_TYPE_TRANSLATION
446	%token PARSEOP_UNICODE	431	%token PARSEOP_UNICODE
447	%token PARSEOP_UNLOAD	432	%token PARSEOP_UNLOAD
448	%token PARSEOP_UPDATERULE_ONES	433	%token PARSEOP_UPDATERULE_ONES
449	%token PARSEOP_UPDATERULE_PRESERVE	434	%token PARSEOP_UPDATERULE_PRESERVE
450	%token PARSEOP_UPDATERULE_ZEROS	435	%token PARSEOP_UPDATERULE_ZEROS
451	%token PARSEOP_VAR_PACKAGE	436	%token PARSEOP_VAR_PACKAGE
452	%token PARSEOP_VENDORLONG	437	%token PARSEOP_VENDORLONG
453	%token PARSEOP_VENDORSHORT	438	%token PARSEOP_VENDORSHORT
454	%token PARSEOP_WAIT	439	%token PARSEOP_WAIT
455	%token PARSEOP_WHILE	440	%token PARSEOP_WHILE
456	%token PARSEOP_WORDBUSNUMBER	441	%token PARSEOP_WORDBUSNUMBER
457	%token PARSEOP_WORDCONST	442	%token PARSEOP_WORDCONST
458	%token PARSEOP_WORDIO	443	%token PARSEOP_WORDIO
459	%token PARSEOP_WORDSPACE	444	%token PARSEOP_WORDSPACE
460	%token PARSEOP_XFERTYPE_8	445	%token PARSEOP_XFERTYPE_8
461	%token PARSEOP_XFERTYPE_8_16	446	%token PARSEOP_XFERTYPE_8_16
462	%token PARSEOP_XFERTYPE_16	447	%token PARSEOP_XFERTYPE_16
463	%token PARSEOP_XOR	448	%token PARSEOP_XOR
464	%token PARSEOP_ZERO	449	%token PARSEOP_ZERO
465		450
-		451	/*
-		452	* Special functions. These should probably stay at the end of this
-		453	* table.
-		454	*/
-		455	%token PARSEOP___DATE__
-		456	%token PARSEOP___FILE__
-		457	%token PARSEOP___LINE__
466		458
467	/*	459	/*
468	* Production names	460	* Production names
469	*/	461	*/
470		462
471	%type ASLCode	463	%type ASLCode
472	%type DefinitionBlockTerm	464	%type DefinitionBlockTerm
473	%type TermList	465	%type TermList
474	%type Term	466	%type Term
475	%type CompilerDirective	467	%type CompilerDirective
476	%type ObjectList	468	%type ObjectList
477	%type Object	469	%type Object
478	%type DataObject	470	%type DataObject
479	%type BufferData	471	%type BufferData
480	%type PackageData	472	%type PackageData
481	%type IntegerData	473	%type IntegerData
482	%type StringData	474	%type StringData
483	%type NamedObject	475	%type NamedObject
484	%type NameSpaceModifier	476	%type NameSpaceModifier
485	%type UserTerm	477	%type UserTerm
486	%type ArgList	478	%type ArgList
487	%type TermArg	479	%type TermArg
488	%type Target	480	%type Target

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpica/compiler/aslcompiler.y – Rev 1498 → 2216