-
%{
/******************************************************************************
*
- * Module Name: aslcompiler.l - Flex input file
+ * Module Name: aslcompiler.l - Flex/lex input file
*
*****************************************************************************/
*
* 1. Copyright Notice
*
- * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2012, 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
+ * 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.
*
* 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
+ * 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
* 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,
+ * 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
+ * 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.
*
* 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
+ * 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
* 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
+ * 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.
*
* 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
+ * 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
+ * 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
*
*****************************************************************************/
+#include "aslcompiler.h"
+#include "aslcompiler.y.h"
#include <stdlib.h>
#include <string.h>
-#include "aslcompiler.h"
-#include "aslcompiler.y.h"
YYSTYPE AslCompilerlval;
/*
*/
#define _COMPONENT ACPI_COMPILER
- ACPI_MODULE_NAME ("aslscan")
-char
-comment (void);
-char
-comment2 (void);
-void
+ ACPI_MODULE_NAME ("aslscanner")
+
+
+/* Local prototypes */
+
+static void
+AslDoLineDirective (void);
+
+static char
+AslDoComment (void);
+
+static char
+AslDoCommentType2 (void);
+
+static char
+AslDoStringLiteral (void);
+
+static void
count (int type);
-char
-literal (void);
-void
-copy (void);
+
/*! [Begin] no source code translation */
%}
-
+ /* Definitions */
LeadNameChar [A-Za-z_]
DigitChar [0-9]
NamePathTail [.]{NameSeg}
%%
+ /* Rules */
[ ] { count (0); }
[\n] { count (0); } /* Handle files with both LF and CR/LF */
[ \t] { count (0); }
-"/*" { if (!comment ()) yyterminate (); }
-"//" { if (!comment2 ()) yyterminate (); }
+"/*" { if (!AslDoComment ()) yyterminate (); }
+"//" { if (!AslDoCommentType2 ()) yyterminate (); }
-"\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); }
+"\"" { if (AslDoStringLiteral ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); }
+";" { count (0); return(';'); }
0[xX]{HexDigitChar}+ |
count (1); return (PARSEOP_INTEGER); }
"Include" { count (1); return (PARSEOP_INCLUDE); }
-"#include" { count (1); return (PARSEOP_INCLUDE_CSTYLE); }
-"#line" { count (1); return (PARSEOP_LINE_CSTYLE); }
"External" { count (1); return (PARSEOP_EXTERNAL); }
+ /*
+ * The #line directive is emitted by the preprocessor and handled
+ * here in the main iASL lexer - simply set the line number and
+ * optionally the current filename.
+ */
+"#line" { AslDoLineDirective ();}
-"Ones" { count (1); return (PARSEOP_ONES); }
-"One" { count (1); return (PARSEOP_ONE); }
-"Zero" { count (1); return (PARSEOP_ZERO); }
-"Revision" { count (1); return (PARSEOP_REVISION); }
-"Offset" { count (1); return (PARSEOP_OFFSET); }
+ /****************************************************************************
+ *
+ * Main ASL operators
+ *
+ ****************************************************************************/
+
"AccessAs" { count (1); return (PARSEOP_ACCESSAS); }
-"BankField" { count (2); return (PARSEOP_BANKFIELD); }
-"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); }
-"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); }
-"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); }
-"CreateField" { count (2); return (PARSEOP_CREATEFIELD); }
-"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); }
-"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); }
-"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); }
-"Device" { count (2); return (PARSEOP_DEVICE); }
-"Event" { count (2); return (PARSEOP_EVENT); }
-"Field" { count (2); return (PARSEOP_FIELD); }
-"Function" { count (2); return (PARSEOP_FUNCTION); }
-"IndexField" { count (2); return (PARSEOP_INDEXFIELD); }
-"Method" { count (2); return (PARSEOP_METHOD); }
-"Mutex" { count (2); return (PARSEOP_MUTEX); }
-"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); }
-"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); }
-"Processor" { count (2); return (PARSEOP_PROCESSOR); }
-"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); }
+"Acquire" { count (3); return (PARSEOP_ACQUIRE); }
+"Add" { count (3); return (PARSEOP_ADD); }
"Alias" { count (2); return (PARSEOP_ALIAS); }
-"Name" { count (2); return (PARSEOP_NAME); }
-"Scope" { count (2); return (PARSEOP_SCOPE); }
+"And" { count (3); return (PARSEOP_AND); }
+"BankField" { count (2); return (PARSEOP_BANKFIELD); }
"Break" { count (3); return (PARSEOP_BREAK); }
"BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); }
-"Continue" { count (3); return (PARSEOP_CONTINUE); }
-"Fatal" { count (3); return (PARSEOP_FATAL); }
-"If" { count (3); return (PARSEOP_IF); }
-"Else" { count (3); return (PARSEOP_ELSE); }
-"ElseIf" { count (3); return (PARSEOP_ELSEIF); }
-"Load" { count (3); return (PARSEOP_LOAD); }
-"Noop" { count (3); return (PARSEOP_NOOP); }
-"Notify" { count (3); return (PARSEOP_NOTIFY); }
-"Release" { count (3); return (PARSEOP_RELEASE); }
-"Reset" { count (3); return (PARSEOP_RESET); }
-"Return" { count (3); return (PARSEOP_RETURN); }
-"Signal" { count (3); return (PARSEOP_SIGNAL); }
-"Sleep" { count (3); return (PARSEOP_SLEEP); }
-"Stall" { count (3); return (PARSEOP_STALL); }
-"Switch" { count (3); return (PARSEOP_SWITCH); }
+"Buffer" { count (1); return (PARSEOP_BUFFER); }
"Case" { count (3); return (PARSEOP_CASE); }
-"Default" { count (3); return (PARSEOP_DEFAULT); }
-"Unload" { count (3); return (PARSEOP_UNLOAD); }
-"While" { count (3); return (PARSEOP_WHILE); }
-
-"Acquire" { count (3); return (PARSEOP_ACQUIRE); }
-"Add" { count (3); return (PARSEOP_ADD); }
-"And" { count (3); return (PARSEOP_AND); }
"Concatenate" { count (3); return (PARSEOP_CONCATENATE); }
"ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); }
"CondRefOf" { count (3); return (PARSEOP_CONDREFOF); }
+"Connection" { count (2); return (PARSEOP_CONNECTION); }
+"Continue" { count (3); return (PARSEOP_CONTINUE); }
"CopyObject" { count (3); return (PARSEOP_COPYOBJECT); }
+"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); }
+"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); }
+"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); }
+"CreateField" { count (2); return (PARSEOP_CREATEFIELD); }
+"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); }
+"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); }
+"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); }
+"Debug" { count (1); return (PARSEOP_DEBUG); }
"Decrement" { count (3); return (PARSEOP_DECREMENT); }
+"Default" { count (3); return (PARSEOP_DEFAULT); }
+"DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); }
"DeRefOf" { count (3); return (PARSEOP_DEREFOF); }
+"Device" { count (2); return (PARSEOP_DEVICE); }
"Divide" { count (3); return (PARSEOP_DIVIDE); }
+"Eisaid" { count (1); return (PARSEOP_EISAID); }
+"Else" { count (3); return (PARSEOP_ELSE); }
+"ElseIf" { count (3); return (PARSEOP_ELSEIF); }
+"Event" { count (2); return (PARSEOP_EVENT); }
+"Fatal" { count (3); return (PARSEOP_FATAL); }
+"Field" { count (2); return (PARSEOP_FIELD); }
"FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); }
"FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); }
-"FromBCD" { count (3); return (PARSEOP_FROMBCD); }
+"FromBcd" { count (3); return (PARSEOP_FROMBCD); }
+"Function" { count (2); return (PARSEOP_FUNCTION); }
+"If" { count (3); return (PARSEOP_IF); }
"Increment" { count (3); return (PARSEOP_INCREMENT); }
"Index" { count (3); return (PARSEOP_INDEX); }
+"IndexField" { count (2); return (PARSEOP_INDEXFIELD); }
"LAnd" { count (3); return (PARSEOP_LAND); }
"LEqual" { count (3); return (PARSEOP_LEQUAL); }
"LGreater" { count (3); return (PARSEOP_LGREATER); }
"LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); }
"LNot" { count (3); return (PARSEOP_LNOT); }
"LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); }
+"Load" { count (3); return (PARSEOP_LOAD); }
"LoadTable" { count (3); return (PARSEOP_LOADTABLE); }
"LOr" { count (3); return (PARSEOP_LOR); }
"Match" { count (3); return (PARSEOP_MATCH); }
+"Method" { count (2); return (PARSEOP_METHOD); }
"Mid" { count (3); return (PARSEOP_MID); }
"Mod" { count (3); return (PARSEOP_MOD); }
"Multiply" { count (3); return (PARSEOP_MULTIPLY); }
+"Mutex" { count (2); return (PARSEOP_MUTEX); }
+"Name" { count (2); return (PARSEOP_NAME); }
"NAnd" { count (3); return (PARSEOP_NAND); }
+"Noop" { count (3); return (PARSEOP_NOOP); }
"NOr" { count (3); return (PARSEOP_NOR); }
"Not" { count (3); return (PARSEOP_NOT); }
+"Notify" { count (3); return (PARSEOP_NOTIFY); }
"ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); }
+"Offset" { count (1); return (PARSEOP_OFFSET); }
+"One" { count (1); return (PARSEOP_ONE); }
+"Ones" { count (1); return (PARSEOP_ONES); }
+"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); }
"Or" { count (3); return (PARSEOP_OR); }
+"Package" { count (1); return (PARSEOP_PACKAGE); }
+"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); }
+"Processor" { count (2); return (PARSEOP_PROCESSOR); }
"RefOf" { count (3); return (PARSEOP_REFOF); }
+"Release" { count (3); return (PARSEOP_RELEASE); }
+"Reset" { count (3); return (PARSEOP_RESET); }
+"Return" { count (3); return (PARSEOP_RETURN); }
+"Revision" { count (1); return (PARSEOP_REVISION); }
+"Scope" { count (2); return (PARSEOP_SCOPE); }
"ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); }
"ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); }
+"Signal" { count (3); return (PARSEOP_SIGNAL); }
"SizeOf" { count (3); return (PARSEOP_SIZEOF); }
+"Sleep" { count (3); return (PARSEOP_SLEEP); }
+"Stall" { count (3); return (PARSEOP_STALL); }
"Store" { count (3); return (PARSEOP_STORE); }
"Subtract" { count (3); return (PARSEOP_SUBTRACT); }
+"Switch" { count (3); return (PARSEOP_SWITCH); }
+"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); }
"Timer" { count (3); return (PARSEOP_TIMER); }
-"ToBCD" { count (3); return (PARSEOP_TOBCD); }
+"ToBcd" { count (3); return (PARSEOP_TOBCD); }
"ToBuffer" { count (3); return (PARSEOP_TOBUFFER); }
"ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); }
"ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); }
"ToInteger" { count (3); return (PARSEOP_TOINTEGER); }
"ToString" { count (3); return (PARSEOP_TOSTRING); }
+"ToUuid" { count (1); return (PARSEOP_TOUUID); }
+"Unicode" { count (1); return (PARSEOP_UNICODE); }
+"Unload" { count (3); return (PARSEOP_UNLOAD); }
"Wait" { count (3); return (PARSEOP_WAIT); }
+"While" { count (3); return (PARSEOP_WHILE); }
"XOr" { count (3); return (PARSEOP_XOR); }
+"Zero" { count (1); return (PARSEOP_ZERO); }
+
+ /* Control method arguments and locals */
"Arg0" { count (1); return (PARSEOP_ARG0); }
"Arg1" { count (1); return (PARSEOP_ARG1); }
"Arg4" { count (1); return (PARSEOP_ARG4); }
"Arg5" { count (1); return (PARSEOP_ARG5); }
"Arg6" { count (1); return (PARSEOP_ARG6); }
-
"Local0" { count (1); return (PARSEOP_LOCAL0); }
"Local1" { count (1); return (PARSEOP_LOCAL1); }
"Local2" { count (1); return (PARSEOP_LOCAL2); }
"Local6" { count (1); return (PARSEOP_LOCAL6); }
"Local7" { count (1); return (PARSEOP_LOCAL7); }
-"Debug" { count (1); return (PARSEOP_DEBUG); }
-"DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); }
-"Buffer" { count (1); return (PARSEOP_BUFFER); }
-"Package" { count (1); return (PARSEOP_PACKAGE); }
+ /****************************************************************************
+ *
+ * Resource Descriptor macros
+ *
+ ****************************************************************************/
-"EISAID" { count (1); return (PARSEOP_EISAID); }
"ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); }
-"ToUUID" { count (1); return (PARSEOP_TOUUID); }
-"Unicode" { count (1); return (PARSEOP_UNICODE); }
+"RawDataBuffer" { count (1); return (PARSEOP_DATABUFFER); }
+
"DMA" { count (1); return (PARSEOP_DMA); }
"DWordIO" { count (1); return (PARSEOP_DWORDIO); }
"DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); }
"ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); }
"ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); }
"ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); }
+"FixedDma" { count (1); return (PARSEOP_FIXEDDMA); }
"FixedIO" { count (1); return (PARSEOP_FIXEDIO); }
+"GpioInt" { count (1); return (PARSEOP_GPIO_INT); }
+"GpioIo" { count (1); return (PARSEOP_GPIO_IO); }
+"I2cSerialBus" { count (1); return (PARSEOP_I2C_SERIALBUS); }
"Interrupt" { count (1); return (PARSEOP_INTERRUPT); }
"IO" { count (1); return (PARSEOP_IO); }
-"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); }
"IRQ" { count (1); return (PARSEOP_IRQ); }
+"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); }
"Memory24" { count (1); return (PARSEOP_MEMORY24); }
-"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); }
"Memory32" { count (1); return (PARSEOP_MEMORY32); }
+"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); }
"QWordIO" { count (1); return (PARSEOP_QWORDIO); }
"QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); }
"QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); }
"Register" { count (1); return (PARSEOP_REGISTER); }
+"SpiSerialBus" { count (1); return (PARSEOP_SPI_SERIALBUS); }
"StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); }
"StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); }
+"UartSerialBus" { count (1); return (PARSEOP_UART_SERIALBUS); }
"VendorLong" { count (1); return (PARSEOP_VENDORLONG); }
"VendorShort" { count (1); return (PARSEOP_VENDORSHORT); }
"WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); }
"WordIO" { count (1); return (PARSEOP_WORDIO); }
"WordSpace" { count (1); return (PARSEOP_WORDSPACE); }
-"UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); }
-"IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); }
-"StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); }
-"BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); }
-"PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); }
-"FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); }
-"DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); }
-"EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); }
-"MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); }
-"MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); }
-"OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); }
-"PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); }
-"ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); }
-"ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); }
-"BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); }
-"DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); }
-
-"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
-"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
-"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
-"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
-"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
-"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
-
-"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); }
-"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
-"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
-"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); }
-"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
+ /****************************************************************************
+ *
+ * Keywords used as arguments to ASL operators and macros
+ *
+ ****************************************************************************/
-"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
-"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
+ /* AccessAttribKeyword: Serial Bus Attributes (ACPI 5.0) */
-"SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); }
-"SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); }
-"PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); }
-"EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); }
-"SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); }
-"SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); }
-"PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); }
-"IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); }
+"AttribQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
+"AttribSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
+"AttribByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
+"AttribWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
+"AttribBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
+"AttribProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
+"AttribBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
-"FFixedHW" { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); }
+ /* AccessAttribKeyword: Legacy synonyms for above (pre-ACPI 5.0) */
"SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
"SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
"SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
"SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
-"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); }
-"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
-"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); }
-"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); }
-"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); }
-"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); }
-
-"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
-"TypeA" { count (0); return (PARSEOP_DMATYPE_A); }
-"TypeB" { count (0); return (PARSEOP_DMATYPE_B); }
-"TypeF" { count (0); return (PARSEOP_DMATYPE_F); }
-
-"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
-"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
-
-"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); }
-"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); }
-"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); }
-
-"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
-"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
-
-"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); }
-"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
+ /* AccessTypeKeyword: Field Access Types */
-"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); }
-"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
-
-"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); }
-"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); }
-
-"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
-"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
-"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
-
-"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
-"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
-"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
-"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
-
-"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
-"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
-
-"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); }
-"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); }
-
-"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
-"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
-
-"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); }
-"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
+"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
+"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
+"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
+"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
+"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
+"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
-"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); }
-"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); }
+ /* AddressingModeKeyword: Mode - Resource Descriptors (ACPI 5.0) */
-"TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); }
-"TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); }
+"AddressingMode7Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_7BIT); }
+"AddressingMode10Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_10BIT); }
-"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
-"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
+ /* AddressKeyword: ACPI memory range types */
"AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
"AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
"AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
"AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
+ /* BusMasterKeyword: DMA Bus Mastering */
-"{" { count (0); return('{'); }
-"}" { count (0); return('}'); }
-"," { count (0); return(','); }
-"(" { count (0); return('('); }
-")" { count (0); return(')'); }
-
-
-{NameSeg} { char *s;
- count (0);
- s=malloc (ACPI_NAME_SIZE + 1);
- if (strcmp (AslCompilertext, "\\"))
- {
- strcpy (s, "____");
- AcpiUtStrupr (AslCompilertext);
- }
- memcpy (s, AslCompilertext, strlen (AslCompilertext));
- AslCompilerlval.s = s;
- DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s);
- return (PARSEOP_NAMESEG); }
-
-{NameString} { char *s;
- count (0);
- s=malloc (strlen (AslCompilertext)+1);
- AcpiUtStrupr (AslCompilertext);
- strcpy (s, AslCompilertext);
- s[strlen (AslCompilertext)] = 0;
- AslCompilerlval.s = s;
- DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s);
- return (PARSEOP_NAMESTRING); }
-
-"*" |
-"/" { count (1);
- AslCompilererror ("Parse error, expecting ASL keyword or name");}
-
-. { count (1);
- sprintf (MsgBuffer,
- "Invalid character (0x%2.2X), expecting ASL keyword or name",
- *AslCompilertext);
- AslCompilererror (MsgBuffer);}
-
-<<EOF>> { if (AslPopInputFileStack ())
- yyterminate();
- else
- return (PARSEOP_INCLUDE_END);};
-
-%%
-
-/*! [End] no source code translation !*/
-
-typedef struct asl_file_node
-{
- FILE *File;
- UINT32 CurrentLineNumber;
- YY_BUFFER_STATE State;
- char *Filename;
- struct asl_file_node *Next;
-
-} ASL_FILE_NODE;
-
-ASL_FILE_NODE *InputStack = NULL;
-
-
-/*******************************************************************************
- *
- * FUNCTION: AslPopInputFileStack
- *
- * PARAMETERS: None
- *
- * RETURN: 0 if a node was popped, -1 otherwise
- *
- * DESCRIPTION: Pop the top of the input file stack and point the parser to
- * the saved parse buffer contained in the fnode. Also, set the
- * global line counters to the saved values. This function is
- * called when an include file reaches EOF.
- *
- ******************************************************************************/
-
-int
-AslPopInputFileStack (
- void)
-{
- ASL_FILE_NODE *Fnode;
- FILE *InputFile = NULL;
-
-
- Fnode = InputStack;
- DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
-
-
- if (!Fnode)
- {
- return -1;
- }
-
- /* Close the current include file */
+"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
+"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
- fclose (yyin);
+ /* ByteLengthKeyword: Bits per Byte - Resource Descriptors (ACPI 5.0) */
- /* Update the top-of-stack */
+"DataBitsFive" { count (0); return (PARSEOP_BITSPERBYTE_FIVE); }
+"DataBitsSix" { count (0); return (PARSEOP_BITSPERBYTE_SIX); }
+"DataBitsSeven" { count (0); return (PARSEOP_BITSPERBYTE_SEVEN); }
+"DataBitsEight" { count (0); return (PARSEOP_BITSPERBYTE_EIGHT); }
+"DataBitsNine" { count (0); return (PARSEOP_BITSPERBYTE_NINE); }
- InputStack = Fnode->Next;
- InputFile = Fnode->File;
+ /* ClockPhaseKeyword: Resource Descriptors (ACPI 5.0) */
- /* Reset global line counter and filename */
+"ClockPhaseFirst" { count (0); return (PARSEOP_CLOCKPHASE_FIRST); }
+"ClockPhaseSecond" { count (0); return (PARSEOP_CLOCKPHASE_SECOND); }
- Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
- Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
+ /* ClockPolarityKeyword: Resource Descriptors (ACPI 5.0) */
- /* Point the parser to the popped file */
+"ClockPolarityLow" { count (0); return (PARSEOP_CLOCKPOLARITY_LOW); }
+"ClockPolarityHigh" { count (0); return (PARSEOP_CLOCKPOLARITY_HIGH); }
- yy_delete_buffer (YY_CURRENT_BUFFER);
- yy_switch_to_buffer (Fnode->State);
+ /* DecodeKeyword: Type of Memory Decoding - Resource Descriptors */
- /* All done with this node */
+"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); }
+"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); }
- ACPI_FREE (Fnode);
- return 0;
-}
+ /* DmaTypeKeyword: DMA Types - DMA Resource Descriptor */
+"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
+"TypeA" { count (0); return (PARSEOP_DMATYPE_A); }
+"TypeB" { count (0); return (PARSEOP_DMATYPE_B); }
+"TypeF" { count (0); return (PARSEOP_DMATYPE_F); }
-/*******************************************************************************
- *
- * FUNCTION: AslPushInputFileStack
- *
- * PARAMETERS: InputFile - Open file pointer
- * Filename - Name of the file
- *
- * RETURN: None
- *
- * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
- * to this file. Called when an include file is successfully
- * opened.
- *
- ******************************************************************************/
+ /* EndianKeyword: Endian type - Resource Descriptor (ACPI 5.0) */
-void
-AslPushInputFileStack (
- FILE *InputFile,
- char *Filename)
-{
- ASL_FILE_NODE *Fnode;
- YY_BUFFER_STATE State;
+"LittleEndian" { count (0); return (PARSEOP_ENDIAN_LITTLE); }
+"BigEndian" { count (0); return (PARSEOP_ENDIAN_BIG); }
+ /* ExtendedAttribKeyword: Bus attributes, AccessAs operator (ACPI 5.0) */
- /* Save the current state in an Fnode */
+"AttribBytes" { count (0); return (PARSEOP_ACCESSATTRIB_MULTIBYTE); }
+"AttribRawBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_BYTES); }
+"AttribRawProcessBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_PROCESS); }
- Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
+ /* FlowControlKeyword: Resource Descriptors (ACPI 5.0) */
- Fnode->File = yyin;
- Fnode->Next = InputStack;
- Fnode->State = YY_CURRENT_BUFFER;
- Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
- Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
+"FlowControlHardware" { count (0); return (PARSEOP_FLOWCONTROL_HW); }
+"FlowControlNone" { count (0); return (PARSEOP_FLOWCONTROL_NONE); }
+"FlowControlXon" { count (0); return (PARSEOP_FLOWCONTROL_SW); }
- /* Push it on the stack */
+ /* InterruptLevelKeyword: Interrupt Active Types */
- InputStack = Fnode;
+"ActiveBoth" { count (0); return (PARSEOP_INTLEVEL_ACTIVEBOTH); }
+"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
+"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
- /* Point the parser to this file */
+ /* InterruptTypeKeyword: Interrupt Types */
- State = yy_create_buffer (InputFile, YY_BUF_SIZE);
- yy_switch_to_buffer (State);
+"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); }
+"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); }
- DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
+ /* IoDecodeKeyword: Type of Memory Decoding - Resource Descriptors */
- /* Reset the global line count and filename */
+"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); }
+"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); }
- Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
- Gbl_CurrentLineNumber = 1;
- yyin = InputFile;
-}
+ /* IoRestrictionKeyword: I/O Restriction - GPIO Resource Descriptors (ACPI 5.0) */
+"IoRestrictionNone" { count (0); return (PARSEOP_IORESTRICT_NONE); }
+"IoRestrictionInputOnly" { count (0); return (PARSEOP_IORESTRICT_IN); }
+"IoRestrictionOutputOnly" { count (0); return (PARSEOP_IORESTRICT_OUT); }
+"IoRestrictionNoneAndPreserve" { count (0); return (PARSEOP_IORESTRICT_PRESERVE); }
-/*******************************************************************************
- *
- * FUNCTION: ResetCurrentLineBuffer
- *
- * PARAMETERS: None
- *
- * RETURN: None
- *
- * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
- *
- ******************************************************************************/
+ /* LockRuleKeyword: Global Lock use for Field Operator */
-void
-ResetCurrentLineBuffer (
- void)
-{
+"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); }
+"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
- if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
- {
- FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
- Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
- }
+ /* MatchOpKeyword: Types for Match Operator */
- Gbl_CurrentLineOffset += Gbl_CurrentColumn;
- Gbl_CurrentColumn = 0;
+"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); }
+"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
+"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); }
+"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); }
+"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); }
+"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); }
- Gbl_CurrentLineNumber++;
- Gbl_LogicalLineNumber++;
- Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
-}
+ /* MaxKeyword: Max Range Type - Resource Descriptors */
+"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); }
+"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
-/*******************************************************************************
- *
- * FUNCTION: InsertLineBuffer
- *
- * PARAMETERS: SourceChar - One char from the input ASL source file
- *
- * RETURN: None
- *
- * DESCRIPTION: Put one character of the source file into the temp line buffer
- *
- ******************************************************************************/
+ /* MemTypeKeyword: Memory Types - Resource Descriptors */
-#define ASL_SPACES_PER_TAB 4
+"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
+"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
+"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
+"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
-void
-InsertLineBuffer (
- int SourceChar)
-{
- UINT32 i;
- UINT32 Count = 1;
+ /* MinKeyword: Min Range Type - Resource Descriptors */
+"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); }
+"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
- if (SourceChar == EOF)
- {
- return;
- }
+ /* ObjectTypeKeyword: ACPI Object Types */
- Gbl_InputByteCount++;
+"UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); }
+"IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); }
+"StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); }
+"BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); }
+"PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); }
+"FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); }
+"DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); }
+"EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); }
+"MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); }
+"MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); }
+"OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); }
+"PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); }
+"ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); }
+"ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); }
+"BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); }
+"DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); }
- /* Handle tabs. Convert to spaces */
+ /* ParityKeyword: Resource Descriptors (ACPI 5.0) */
- if (SourceChar == '\t')
- {
- SourceChar = ' ';
- Count = ASL_SPACES_PER_TAB -
- (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
- }
+"ParityTypeSpace" { count (0); return (PARSEOP_PARITYTYPE_SPACE); }
+"ParityTypeMark" { count (0); return (PARSEOP_PARITYTYPE_MARK); }
+"ParityTypeOdd" { count (0); return (PARSEOP_PARITYTYPE_ODD); }
+"ParityTypeEven" { count (0); return (PARSEOP_PARITYTYPE_EVEN); }
+"ParityTypeNone" { count (0); return (PARSEOP_PARITYTYPE_NONE); }
+ /* PinConfigKeyword: Pin Configuration - GPIO Resource Descriptors (ACPI 5.0) */
- for (i = 0; i < Count; i++)
- {
- Gbl_CurrentColumn++;
+"PullDefault" { count (0); return (PARSEOP_PIN_PULLDEFAULT); }
+"PullUp" { count (0); return (PARSEOP_PIN_PULLUP); }
+"PullDown" { count (0); return (PARSEOP_PIN_PULLDOWN); }
+"PullNone" { count (0); return (PARSEOP_PIN_NOPULL); }
- /* Insert the character into the line buffer */
+ /* PolarityKeyword: Resource Descriptors (ACPI 5.0) */
- *Gbl_LineBufPtr = (UINT8) SourceChar;
- Gbl_LineBufPtr++;
+"PolarityLow" { count (0); return (PARSEOP_DEVICEPOLARITY_LOW); }
+"PolarityHigh" { count (0); return (PARSEOP_DEVICEPOLARITY_HIGH); }
- if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1)))
- {
-#if 0
- /*
- * Warning if we have split a long source line.
- * <Probably overkill>
- */
- sprintf (MsgBuffer, "Max %d", ASL_LINE_BUFFER_SIZE);
- AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_CurrentLineOffset, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
-#endif
+ /* RangeTypeKeyword: I/O Range Types - Resource Descriptors */
- ResetCurrentLineBuffer ();
- }
- else if (SourceChar == '\n')
- {
- /* End of line */
+"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
+"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
+"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
- ResetCurrentLineBuffer ();
- }
- }
-}
+ /* ReadWriteKeyword: Memory Access Types - Resource Descriptors */
+"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
+"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
-/*******************************************************************************
- *
- * FUNCTION: count
- *
- * PARAMETERS: yytext - Contains the matched keyword.
- * Type - Keyword/Character type:
- * 0 = anything except a keyword
- * 1 = pseudo-keywords
- * 2 = non-executable ASL keywords
- * 3 = executable ASL keywords
- *
- * RETURN: None
- *
- * DESCRIPTION: Count keywords and put them into the line buffer
- *
- ******************************************************************************/
+ /* RegionSpaceKeyword: Operation Region Address Space Types */
-void
-count (
- int Type)
-{
- int i;
+"SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); }
+"SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); }
+"PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); }
+"EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); }
+"SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); }
+"SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); }
+"PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); }
+"IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); }
+"GeneralPurposeIo" { count (0); return (PARSEOP_REGIONSPACE_GPIO); } /* ACPI 5.0 */
+"GenericSerialBus" { count (0); return (PARSEOP_REGIONSPACE_GSBUS); } /* ACPI 5.0 */
+"PCC" { count (0); return (PARSEOP_REGIONSPACE_PCC); } /* ACPI 5.0 */
+"FFixedHW" { count (0); return (PARSEOP_REGIONSPACE_FFIXEDHW); }
+ /* ResourceTypeKeyword: Resource Usage - Resource Descriptors */
- switch (Type)
- {
- case 2:
- TotalKeywords++;
- TotalNamedObjects++;
- break;
+"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
+"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
- case 3:
- TotalKeywords++;
- TotalExecutableOpcodes++;
- break;
- }
+ /* SerializeRuleKeyword: Control Method Serialization */
- for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
- {
- InsertLineBuffer (yytext[i]);
- *Gbl_LineBufPtr = 0;
- }
-}
+"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
+"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
+ /* ShareTypeKeyword: Interrupt Sharing - Resource Descriptors */
-/*******************************************************************************
- *
- * FUNCTION: comment
- *
- * PARAMETERS: none
- *
- * RETURN: none
- *
- * DESCRIPTION: Process a standard comment.
- *
- ******************************************************************************/
+"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); }
+"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
+"SharedAndWake" { count (0); return (PARSEOP_SHARETYPE_SHAREDWAKE); } /* ACPI 5.0 */
+"ExclusiveAndWake" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVEWAKE); } /* ACPI 5.0 */
-char
-comment (void)
-{
- char c;
- char c1 = 0;
+ /* SlaveModeKeyword: Resource Descriptors (ACPI 5.0) */
+"ControllerInitiated" { count (0); return (PARSEOP_SLAVEMODE_CONTROLLERINIT); }
+"DeviceInitiated" { count (0); return (PARSEOP_SLAVEMODE_DEVICEINIT); }
- InsertLineBuffer ('/');
- InsertLineBuffer ('*');
+ /* StopBitsKeyword: Resource Descriptors (ACPI 5.0) */
-loop:
+"StopBitsOne" { count (0); return (PARSEOP_STOPBITS_ONE); }
+"StopBitsOnePlusHalf" { count (0); return (PARSEOP_STOPBITS_ONEPLUSHALF); }
+"StopBitsTwo" { count (0); return (PARSEOP_STOPBITS_TWO); }
+"StopBitsZero" { count (0); return (PARSEOP_STOPBITS_ZERO); }
- /* Eat chars until end-of-comment */
+ /* TransferWidthKeyword: DMA Widths - Fixed DMA Resource Descriptor (ACPI 5.0) */
- while ((c = (char) input()) != '*' && c != EOF)
- {
- InsertLineBuffer (c);
- c1 = c;
- }
+"Width8bit" { count (0); return (PARSEOP_XFERSIZE_8); }
+"Width16bit" { count (0); return (PARSEOP_XFERSIZE_16); }
+"Width32bit" { count (0); return (PARSEOP_XFERSIZE_32); }
+"Width64bit" { count (0); return (PARSEOP_XFERSIZE_64); }
+"Width128bit" { count (0); return (PARSEOP_XFERSIZE_128); }
+"Width256bit" { count (0); return (PARSEOP_XFERSIZE_256); }
- if (c == EOF)
- {
- goto EarlyEOF;
- }
+ /* TranslationKeyword: Translation Density Types - Resource Descriptors */
- /*
- * Check for nested comment -- can help catch cases where a previous
- * comment was accidently left unterminated
- */
- if ((c1 == '/') && (c == '*'))
- {
- AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_InputByteCount, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
- }
+"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
+"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
- /* Comment is closed only if the NEXT character is a slash */
+ /* TypeKeyword: Translation Types - Resource Descriptors */
- InsertLineBuffer (c);
+"TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); }
+"TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); }
- if ((c1 = (char) input()) != '/' && c1 != EOF)
- {
- unput(c1);
- goto loop;
- }
+ /* UpdateRuleKeyword: Field Update Rules */
- if (c1 == EOF)
- {
- goto EarlyEOF;
- }
+"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
+"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); }
+"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
- InsertLineBuffer (c1);
- return TRUE;
+ /* WireModeKeyword: SPI Wire Mode - Resource Descriptors (ACPI 5.0) */
+"FourWireMode" { count (0); return (PARSEOP_WIREMODE_FOUR); }
+"ThreeWireMode" { count (0); return (PARSEOP_WIREMODE_THREE); }
-EarlyEOF:
- /*
- * Premature End-Of-File
- */
- AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_CurrentLineOffset, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
- return (FALSE);
-}
+ /* XferTypeKeyword: DMA Transfer Types */
+"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); }
+"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); }
+"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); }
-/*******************************************************************************
- *
- * FUNCTION: comment
- *
- * PARAMETERS: none
- *
- * RETURN: none
- *
- * DESCRIPTION: Process a new "//" comment.
- *
- ******************************************************************************/
+ /* Predefined compiler names */
-char
-comment2 (void)
-{
- char c;
+"__DATE__" { count (0); return (PARSEOP___DATE__); }
+"__FILE__" { count (0); return (PARSEOP___FILE__); }
+"__LINE__" { count (0); return (PARSEOP___LINE__); }
+"__PATH__" { count (0); return (PARSEOP___PATH__); }
- InsertLineBuffer ('/');
- InsertLineBuffer ('/');
+"{" { count (0); return('{'); }
+"}" { count (0); return('}'); }
+"," { count (0); return(','); }
+"(" { count (0); return('('); }
+")" { count (0); return(')'); }
- while ((c = (char) input()) != '\n' && c != EOF)
- {
- InsertLineBuffer (c);
- }
+{NameSeg} { char *s;
+ count (0);
+ s=malloc (ACPI_NAME_SIZE + 1);
+ if (strcmp (AslCompilertext, "\\"))
+ {
+ strcpy (s, "____");
+ AcpiUtStrupr (AslCompilertext);
+ }
+ memcpy (s, AslCompilertext, strlen (AslCompilertext));
+ AslCompilerlval.s = s;
+ DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s);
+ return (PARSEOP_NAMESEG); }
- if (c == EOF)
- {
- /* End of file is OK, change to newline. Let parser detect EOF later */
+{NameString} { char *s;
+ count (0);
+ s=malloc (strlen (AslCompilertext)+1);
+ AcpiUtStrupr (AslCompilertext);
+ strcpy (s, AslCompilertext);
+ s[strlen (AslCompilertext)] = 0;
+ AslCompilerlval.s = s;
+ DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s);
+ return (PARSEOP_NAMESTRING); }
- c = '\n';
- }
+"*" |
+"/" { count (1);
+ AslCompilererror ("Parse error, expecting ASL keyword or name");}
- InsertLineBuffer (c);
- return (TRUE);
-}
+. { count (1);
+ sprintf (MsgBuffer,
+ "Invalid character (0x%2.2X), expecting ASL keyword or name",
+ *AslCompilertext);
+ AslCompilererror (MsgBuffer);}
+<<EOF>> { if (AslPopInputFileStack ())
+ yyterminate();
+ else
+ return (PARSEOP_INCLUDE_END);};
-/*******************************************************************************
- *
- * FUNCTION: literal
- *
- * PARAMETERS: none
- *
- * RETURN: none
- *
- * DESCRIPTION: Process a string literal (surrounded by quotes)
- *
- ******************************************************************************/
-
-#define ASL_NORMAL_CHAR 0
-#define ASL_ESCAPE_SEQUENCE 1
-#define ASL_OCTAL_CONSTANT 2
-#define ASL_HEX_CONSTANT 3
-
-char
-literal (void)
-{
- char *StringBuffer = MsgBuffer;
- char *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
- char *CleanString;
- char StringChar;
- UINT32 State = ASL_NORMAL_CHAR;
- UINT32 i = 0;
- UINT8 Digit;
- char ConvertBuffer[4];
-
-
- /*
- * Eat chars until end-of-literal.
- * NOTE: Put back the original surrounding quotes into the
- * source line buffer.
- */
- InsertLineBuffer ('\"');
- while ((StringChar = (char) input()) != EOF)
- {
- InsertLineBuffer (StringChar);
-
-DoCharacter:
-
- switch (State)
- {
- case ASL_NORMAL_CHAR:
-
- switch (StringChar)
- {
- case '\\':
- /*
- * Special handling for backslash-escape sequence. We will
- * toss the backslash and translate the escape char(s).
- */
- State = ASL_ESCAPE_SEQUENCE;
- continue;
-
- case '\"':
-
- /* String terminator */
-
- goto CompletedString;
- }
- break;
-
-
- case ASL_ESCAPE_SEQUENCE:
-
- State = ASL_NORMAL_CHAR;
- switch (StringChar)
- {
- case 'a':
- StringChar = 0x07; /* BELL */
- break;
-
- case 'b':
- StringChar = 0x08; /* BACKSPACE */
- break;
-
- case 'f':
- StringChar = 0x0C; /* FORMFEED */
- break;
-
- case 'n':
- StringChar = 0x0A; /* LINEFEED */
- break;
-
- case 'r':
- StringChar = 0x0D; /* CARRIAGE RETURN*/
- break;
-
- case 't':
- StringChar = 0x09; /* HORIZONTAL TAB */
- break;
-
- case 'v':
- StringChar = 0x0B; /* VERTICAL TAB */
- break;
-
- case 'x':
- State = ASL_HEX_CONSTANT;
- i = 0;
- continue;
-
- case '\'': /* Single Quote */
- case '\"': /* Double Quote */
- case '\\': /* Backslash */
- break;
-
- default:
-
- /* Check for an octal digit (0-7) */
-
- if (ACPI_IS_OCTAL_DIGIT (StringChar))
- {
- State = ASL_OCTAL_CONSTANT;
- ConvertBuffer[0] = StringChar;
- i = 1;
- continue;
- }
-
- /* Unknown escape sequence issue warning, but use the character */
-
- AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_CurrentLineOffset, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
- break;
- }
- break;
-
-
- case ASL_OCTAL_CONSTANT:
-
- /* Up to three octal digits allowed */
-
- if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
- (i > 2))
- {
- /*
- * Reached end of the constant. Convert the assembled ASCII
- * string and resume processing of the next character
- */
- ConvertBuffer[i] = 0;
- Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
-
- /* Check for NULL or non-ascii character (ignore if so) */
-
- if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
- {
- AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_CurrentLineOffset, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
- }
- else
- {
- *StringBuffer = (char) Digit;
- StringBuffer++;
- if (StringBuffer >= EndBuffer)
- {
- goto BufferOverflow;
- }
- }
-
- State = ASL_NORMAL_CHAR;
- goto DoCharacter;
- break;
- }
-
- /* Append another digit of the constant */
-
- ConvertBuffer[i] = StringChar;
- i++;
- continue;
-
-
- case ASL_HEX_CONSTANT:
-
- /* Up to two hex digits allowed */
-
- if (!ACPI_IS_XDIGIT (StringChar) ||
- (i > 1))
- {
- /*
- * Reached end of the constant. Convert the assembled ASCII
- * string and resume processing of the next character
- */
- ConvertBuffer[i] = 0;
- Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
-
- /* Check for NULL or non-ascii character (ignore if so) */
-
- if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
- {
- AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_CurrentLineOffset, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
- }
- else
- {
- *StringBuffer = (char) Digit;
- StringBuffer++;
- if (StringBuffer >= EndBuffer)
- {
- goto BufferOverflow;
- }
- }
-
- State = ASL_NORMAL_CHAR;
- goto DoCharacter;
- break;
- }
-
- /* Append another digit of the constant */
-
- ConvertBuffer[i] = StringChar;
- i++;
- continue;
- }
-
- /* Save the finished character */
-
- *StringBuffer = StringChar;
- StringBuffer++;
- if (StringBuffer >= EndBuffer)
- {
- goto BufferOverflow;
- }
- }
-
- /*
- * Premature End-Of-File
- */
- AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_CurrentLineOffset, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
- return (FALSE);
-
-
-CompletedString:
- /*
- * Null terminate the input string and copy string to a new buffer
- */
- *StringBuffer = 0;
-
- CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
- if (!CleanString)
- {
- AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_CurrentLineOffset, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
- return (FALSE);
- }
-
- ACPI_STRCPY (CleanString, MsgBuffer);
- AslCompilerlval.s = CleanString;
- return (TRUE);
-
-
-BufferOverflow:
-
- /* Literal was too long */
-
- AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
- Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
- Gbl_CurrentLineOffset, Gbl_CurrentColumn,
- Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");
- return (FALSE);
-}
+%%
+/*! [End] no source code translation !*/
+/*
+ * Bring in the scanner support routines
+ */
+#include "aslsupport.l"
projects / l4.git / blobdiff