aslcompiler.l revision 151937
1 2%{ 3/****************************************************************************** 4 * 5 * Module Name: aslcompiler.l - Flex input file 6 * $Revision: 1.74 $ 7 * 8 *****************************************************************************/ 9 10/****************************************************************************** 11 * 12 * 1. Copyright Notice 13 * 14 * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp. 15 * All rights reserved. 16 * 17 * 2. License 18 * 19 * 2.1. This is your license from Intel Corp. under its intellectual property 20 * rights. You may have additional license terms from the party that provided 21 * you this software, covering your right to use that party's intellectual 22 * property rights. 23 * 24 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 25 * copy of the source code appearing in this file ("Covered Code") an 26 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 27 * base code distributed originally by Intel ("Original Intel Code") to copy, 28 * make derivatives, distribute, use and display any portion of the Covered 29 * Code in any form, with the right to sublicense such rights; and 30 * 31 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 32 * license (with the right to sublicense), under only those claims of Intel 33 * patents that are infringed by the Original Intel Code, to make, use, sell, 34 * offer to sell, and import the Covered Code and derivative works thereof 35 * solely to the minimum extent necessary to exercise the above copyright 36 * license, and in no event shall the patent license extend to any additions 37 * to or modifications of the Original Intel Code. No other license or right 38 * is granted directly or by implication, estoppel or otherwise; 39 * 40 * The above copyright and patent license is granted only if the following 41 * conditions are met: 42 * 43 * 3. Conditions 44 * 45 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 46 * Redistribution of source code of any substantial portion of the Covered 47 * Code or modification with rights to further distribute source must include 48 * the above Copyright Notice, the above License, this list of Conditions, 49 * and the following Disclaimer and Export Compliance provision. In addition, 50 * Licensee must cause all Covered Code to which Licensee contributes to 51 * contain a file documenting the changes Licensee made to create that Covered 52 * Code and the date of any change. Licensee must include in that file the 53 * documentation of any changes made by any predecessor Licensee. Licensee 54 * must include a prominent statement that the modification is derived, 55 * directly or indirectly, from Original Intel Code. 56 * 57 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 58 * Redistribution of source code of any substantial portion of the Covered 59 * Code or modification without rights to further distribute source must 60 * include the following Disclaimer and Export Compliance provision in the 61 * documentation and/or other materials provided with distribution. In 62 * addition, Licensee may not authorize further sublicense of source of any 63 * portion of the Covered Code, and must include terms to the effect that the 64 * license from Licensee to its licensee is limited to the intellectual 65 * property embodied in the software Licensee provides to its licensee, and 66 * not to intellectual property embodied in modifications its licensee may 67 * make. 68 * 69 * 3.3. Redistribution of Executable. Redistribution in executable form of any 70 * substantial portion of the Covered Code or modification must reproduce the 71 * above Copyright Notice, and the following Disclaimer and Export Compliance 72 * provision in the documentation and/or other materials provided with the 73 * distribution. 74 * 75 * 3.4. Intel retains all right, title, and interest in and to the Original 76 * Intel Code. 77 * 78 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 79 * Intel shall be used in advertising or otherwise to promote the sale, use or 80 * other dealings in products derived from or relating to the Covered Code 81 * without prior written authorization from Intel. 82 * 83 * 4. Disclaimer and Export Compliance 84 * 85 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 86 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 87 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 88 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 89 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 90 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 91 * PARTICULAR PURPOSE. 92 * 93 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 94 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 95 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 96 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 97 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 98 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 99 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 100 * LIMITED REMEDY. 101 * 102 * 4.3. Licensee shall not export, either directly or indirectly, any of this 103 * software or system incorporating such software without first obtaining any 104 * required license or other approval from the U. S. Department of Commerce or 105 * any other agency or department of the United States Government. In the 106 * event Licensee exports any such software from the United States or 107 * re-exports any such software from a foreign destination, Licensee shall 108 * ensure that the distribution and export/re-export of the software is in 109 * compliance with all laws, regulations, orders, or other restrictions of the 110 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 111 * any of its subsidiaries will export/re-export any technical data, process, 112 * software, or service, directly or indirectly, to any country for which the 113 * United States government or any agency thereof requires an export license, 114 * other governmental approval, or letter of assurance, without first obtaining 115 * such license, approval or letter. 116 * 117 *****************************************************************************/ 118 119 120#include <stdlib.h> 121#include <string.h> 122#include <contrib/dev/acpica/compiler/aslcompiler.h> 123#include "aslcompiler.y.h" 124YYSTYPE AslCompilerlval; 125 126/* 127 * Generation: Use the following command line: 128 * 129 * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath) 130 * 131 * -i: Scanner must be case-insensitive 132 */ 133 134#define _COMPONENT ACPI_COMPILER 135 ACPI_MODULE_NAME ("aslscan") 136char 137comment (void); 138char 139comment2 (void); 140void 141count (int type); 142char 143literal (void); 144void 145copy (void); 146 147/*! [Begin] no source code translation */ 148 149%} 150 151 152LeadNameChar [A-Za-z_] 153DigitChar [0-9] 154HexDigitChar [A-Fa-f0-9] 155RootChar [\\] 156Nothing [] 157 158NameChar [A-Za-z_0-9] 159NameSeg1 {LeadNameChar}{NameChar} 160NameSeg2 {LeadNameChar}{NameChar}{NameChar} 161NameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar} 162NameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3} 163 164NameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath} 165NamePath {NonEmptyNamePath}? 166NonEmptyNamePath {NameSeg}{NamePathTail}* 167NamePathTail [.]{NameSeg} 168 169%% 170 171[ ] { count (0); } 172[\n] { count (0); } 173[ \t] { count (0); } 174 175 176"/*" { if (!comment ()) yyterminate (); } 177"//" { if (!comment2 ()) yyterminate (); } 178 179"\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); } 180 181 1820[xX]{HexDigitChar}+ | 183{DigitChar}+ { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext); 184 count (1); return (PARSEOP_INTEGER); } 185 186"Include" { count (1); return (PARSEOP_INCLUDE); } 187"#include" { count (1); return (PARSEOP_INCLUDE_CSTYLE); } 188"#line" { count (1); return (PARSEOP_LINE_CSTYLE); } 189"External" { count (1); return (PARSEOP_EXTERNAL); } 190 191 192"Ones" { count (1); return (PARSEOP_ONES); } 193"One" { count (1); return (PARSEOP_ONE); } 194"Zero" { count (1); return (PARSEOP_ZERO); } 195"Revision" { count (1); return (PARSEOP_REVISION); } 196 197"Offset" { count (1); return (PARSEOP_OFFSET); } 198"AccessAs" { count (1); return (PARSEOP_ACCESSAS); } 199"BankField" { count (2); return (PARSEOP_BANKFIELD); } 200"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); } 201"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); } 202"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); } 203"CreateField" { count (2); return (PARSEOP_CREATEFIELD); } 204"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); } 205"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); } 206"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); } 207"Device" { count (2); return (PARSEOP_DEVICE); } 208"Event" { count (2); return (PARSEOP_EVENT); } 209"Field" { count (2); return (PARSEOP_FIELD); } 210"Function" { count (2); return (PARSEOP_FUNCTION); } 211"IndexField" { count (2); return (PARSEOP_INDEXFIELD); } 212"Method" { count (2); return (PARSEOP_METHOD); } 213"Mutex" { count (2); return (PARSEOP_MUTEX); } 214"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); } 215"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); } 216"Processor" { count (2); return (PARSEOP_PROCESSOR); } 217"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); } 218"Alias" { count (2); return (PARSEOP_ALIAS); } 219"Name" { count (2); return (PARSEOP_NAME); } 220"Scope" { count (2); return (PARSEOP_SCOPE); } 221"Break" { count (3); return (PARSEOP_BREAK); } 222"BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); } 223"Continue" { count (3); return (PARSEOP_CONTINUE); } 224"Fatal" { count (3); return (PARSEOP_FATAL); } 225"If" { count (3); return (PARSEOP_IF); } 226"Else" { count (3); return (PARSEOP_ELSE); } 227"ElseIf" { count (3); return (PARSEOP_ELSEIF); } 228"Load" { count (3); return (PARSEOP_LOAD); } 229"Noop" { count (3); return (PARSEOP_NOOP); } 230"Notify" { count (3); return (PARSEOP_NOTIFY); } 231"Release" { count (3); return (PARSEOP_RELEASE); } 232"Reset" { count (3); return (PARSEOP_RESET); } 233"Return" { count (3); return (PARSEOP_RETURN); } 234"Signal" { count (3); return (PARSEOP_SIGNAL); } 235"Sleep" { count (3); return (PARSEOP_SLEEP); } 236"Stall" { count (3); return (PARSEOP_STALL); } 237"Switch" { count (3); return (PARSEOP_SWITCH); } 238"Case" { count (3); return (PARSEOP_CASE); } 239"Default" { count (3); return (PARSEOP_DEFAULT); } 240"Unload" { count (3); return (PARSEOP_UNLOAD); } 241"While" { count (3); return (PARSEOP_WHILE); } 242 243"Acquire" { count (3); return (PARSEOP_ACQUIRE); } 244"Add" { count (3); return (PARSEOP_ADD); } 245"And" { count (3); return (PARSEOP_AND); } 246"Concatenate" { count (3); return (PARSEOP_CONCATENATE); } 247"ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); } 248"CondRefOf" { count (3); return (PARSEOP_CONDREFOF); } 249"CopyObject" { count (3); return (PARSEOP_COPYOBJECT); } 250"Decrement" { count (3); return (PARSEOP_DECREMENT); } 251"DeRefOf" { count (3); return (PARSEOP_DEREFOF); } 252"Divide" { count (3); return (PARSEOP_DIVIDE); } 253"FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); } 254"FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); } 255"FromBCD" { count (3); return (PARSEOP_FROMBCD); } 256"Increment" { count (3); return (PARSEOP_INCREMENT); } 257"Index" { count (3); return (PARSEOP_INDEX); } 258"LAnd" { count (3); return (PARSEOP_LAND); } 259"LEqual" { count (3); return (PARSEOP_LEQUAL); } 260"LGreater" { count (3); return (PARSEOP_LGREATER); } 261"LGreaterEqual" { count (3); return (PARSEOP_LGREATEREQUAL); } 262"LLess" { count (3); return (PARSEOP_LLESS); } 263"LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); } 264"LNot" { count (3); return (PARSEOP_LNOT); } 265"LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); } 266"LoadTable" { count (3); return (PARSEOP_LOADTABLE); } 267"LOr" { count (3); return (PARSEOP_LOR); } 268"Match" { count (3); return (PARSEOP_MATCH); } 269"Mid" { count (3); return (PARSEOP_MID); } 270"Mod" { count (3); return (PARSEOP_MOD); } 271"Multiply" { count (3); return (PARSEOP_MULTIPLY); } 272"NAnd" { count (3); return (PARSEOP_NAND); } 273"NOr" { count (3); return (PARSEOP_NOR); } 274"Not" { count (3); return (PARSEOP_NOT); } 275"ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); } 276"Or" { count (3); return (PARSEOP_OR); } 277"RefOf" { count (3); return (PARSEOP_REFOF); } 278"ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); } 279"ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); } 280"SizeOf" { count (3); return (PARSEOP_SIZEOF); } 281"Store" { count (3); return (PARSEOP_STORE); } 282"Subtract" { count (3); return (PARSEOP_SUBTRACT); } 283"Timer" { count (3); return (PARSEOP_TIMER); } 284"ToBCD" { count (3); return (PARSEOP_TOBCD); } 285"ToBuffer" { count (3); return (PARSEOP_TOBUFFER); } 286"ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); } 287"ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); } 288"ToInteger" { count (3); return (PARSEOP_TOINTEGER); } 289"ToString" { count (3); return (PARSEOP_TOSTRING); } 290"Wait" { count (3); return (PARSEOP_WAIT); } 291"XOr" { count (3); return (PARSEOP_XOR); } 292 293"Arg0" { count (1); return (PARSEOP_ARG0); } 294"Arg1" { count (1); return (PARSEOP_ARG1); } 295"Arg2" { count (1); return (PARSEOP_ARG2); } 296"Arg3" { count (1); return (PARSEOP_ARG3); } 297"Arg4" { count (1); return (PARSEOP_ARG4); } 298"Arg5" { count (1); return (PARSEOP_ARG5); } 299"Arg6" { count (1); return (PARSEOP_ARG6); } 300 301"Local0" { count (1); return (PARSEOP_LOCAL0); } 302"Local1" { count (1); return (PARSEOP_LOCAL1); } 303"Local2" { count (1); return (PARSEOP_LOCAL2); } 304"Local3" { count (1); return (PARSEOP_LOCAL3); } 305"Local4" { count (1); return (PARSEOP_LOCAL4); } 306"Local5" { count (1); return (PARSEOP_LOCAL5); } 307"Local6" { count (1); return (PARSEOP_LOCAL6); } 308"Local7" { count (1); return (PARSEOP_LOCAL7); } 309 310"Debug" { count (1); return (PARSEOP_DEBUG); } 311 312"DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); } 313"Buffer" { count (1); return (PARSEOP_BUFFER); } 314"Package" { count (1); return (PARSEOP_PACKAGE); } 315 316"EISAID" { count (1); return (PARSEOP_EISAID); } 317"ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); } 318"ToUUID" { count (1); return (PARSEOP_TOUUID); } 319"Unicode" { count (1); return (PARSEOP_UNICODE); } 320"DMA" { count (1); return (PARSEOP_DMA); } 321"DWordIO" { count (1); return (PARSEOP_DWORDIO); } 322"DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); } 323"DWordSpace" { count (1); return (PARSEOP_DWORDSPACE); } 324"EndDependentFn" { count (1); return (PARSEOP_ENDDEPENDENTFN); } 325"ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); } 326"ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); } 327"ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); } 328"FixedIO" { count (1); return (PARSEOP_FIXEDIO); } 329"Interrupt" { count (1); return (PARSEOP_INTERRUPT); } 330"IO" { count (1); return (PARSEOP_IO); } 331"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); } 332"IRQ" { count (1); return (PARSEOP_IRQ); } 333"Memory24" { count (1); return (PARSEOP_MEMORY24); } 334"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); } 335"Memory32" { count (1); return (PARSEOP_MEMORY32); } 336"QWordIO" { count (1); return (PARSEOP_QWORDIO); } 337"QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); } 338"QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); } 339"Register" { count (1); return (PARSEOP_REGISTER); } 340"StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); } 341"StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); } 342"VendorLong" { count (1); return (PARSEOP_VENDORLONG); } 343"VendorShort" { count (1); return (PARSEOP_VENDORSHORT); } 344"WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); } 345"WordIO" { count (1); return (PARSEOP_WORDIO); } 346"WordSpace" { count (1); return (PARSEOP_WORDSPACE); } 347 348"UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); } 349"IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); } 350"StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); } 351"BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); } 352"PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); } 353"FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); } 354"DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); } 355"EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); } 356"MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); } 357"MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); } 358"OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); } 359"PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); } 360"ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); } 361"ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); } 362"BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); } 363"DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); } 364 365"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); } 366"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); } 367"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); } 368"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); } 369"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); } 370"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); } 371 372"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); } 373"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); } 374 375"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); } 376"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); } 377"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); } 378 379"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); } 380"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); } 381 382"SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); } 383"SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); } 384"PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); } 385"EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); } 386"SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); } 387"SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); } 388"PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); } 389 390"FFixedHW" { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); } 391 392"SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 393"SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 394"SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 395"SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 396"SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 397"SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 398"SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 399 400"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); } 401"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); } 402"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); } 403"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); } 404"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); } 405"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); } 406 407"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); } 408"TypeA" { count (0); return (PARSEOP_DMATYPE_A); } 409"TypeB" { count (0); return (PARSEOP_DMATYPE_B); } 410"TypeF" { count (0); return (PARSEOP_DMATYPE_F); } 411 412"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); } 413"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); } 414 415"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); } 416"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); } 417"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); } 418 419"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); } 420"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); } 421 422"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); } 423"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); } 424 425"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); } 426"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); } 427 428"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); } 429"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); } 430 431"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); } 432"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); } 433"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); } 434 435"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); } 436"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); } 437"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); } 438"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); } 439 440"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); } 441"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); } 442 443"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); } 444"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); } 445 446"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); } 447"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); } 448 449"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); } 450"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); } 451 452"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); } 453"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); } 454 455"TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); } 456"TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); } 457 458"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); } 459"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); } 460 461"AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); } 462"AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); } 463"AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); } 464"AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); } 465 466 467"{" { count (0); return('{'); } 468"}" { count (0); return('}'); } 469"," { count (0); return(','); } 470"(" { count (0); return('('); } 471")" { count (0); return(')'); } 472 473 474{NameSeg} { char *s; 475 count (0); 476 s=malloc (ACPI_NAME_SIZE + 1); 477 if (strcmp (AslCompilertext, "\\")) 478 { 479 strcpy (s, "____"); 480 AcpiUtStrupr (AslCompilertext); 481 } 482 memcpy (s, AslCompilertext, strlen (AslCompilertext)); 483 AslCompilerlval.s = s; 484 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s); 485 return (PARSEOP_NAMESEG); } 486 487{NameString} { char *s; 488 count (0); 489 s=malloc (strlen (AslCompilertext)+1); 490 AcpiUtStrupr (AslCompilertext); 491 strcpy (s, AslCompilertext); 492 s[strlen (AslCompilertext)] = 0; 493 AslCompilerlval.s = s; 494 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s); 495 return (PARSEOP_NAMESTRING); } 496 497"*" | 498"/" { count (1); 499 AslCompilererror ("Parse error, expecting ASL keyword or name");} 500 501. { count (1); 502 sprintf (MsgBuffer, 503 "Invalid character (0x%2.2X), expecting ASL keyword or name", 504 *AslCompilertext); 505 AslCompilererror (MsgBuffer);} 506 507<<EOF>> { if (AslPopInputFileStack ()) 508 yyterminate(); 509 else 510 return (PARSEOP_INCLUDE_END);}; 511 512%% 513 514/*! [End] no source code translation !*/ 515 516typedef struct asl_file_node 517{ 518 FILE *File; 519 UINT32 CurrentLineNumber; 520 YY_BUFFER_STATE State; 521 char *Filename; 522 struct asl_file_node *Next; 523 524} ASL_FILE_NODE; 525 526ASL_FILE_NODE *InputStack = NULL; 527 528 529/******************************************************************************* 530 * 531 * FUNCTION: AslPopInputFileStack 532 * 533 * PARAMETERS: None 534 * 535 * RETURN: 0 if a node was popped, -1 otherwise 536 * 537 * DESCRIPTION: Pop the top of the input file stack and point the parser to 538 * the saved parse buffer contained in the fnode. Also, set the 539 * global line counters to the saved values. This function is 540 * called when an include file reaches EOF. 541 * 542 ******************************************************************************/ 543 544int 545AslPopInputFileStack ( 546 void) 547{ 548 ASL_FILE_NODE *Fnode; 549 FILE *InputFile = NULL; 550 551 552 Fnode = InputStack; 553 DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode); 554 555 556 if (!Fnode) 557 { 558 return -1; 559 } 560 561 /* Close the current include file */ 562 563 fclose (yyin); 564 565 /* Update the top-of-stack */ 566 567 InputStack = Fnode->Next; 568 InputFile = Fnode->File; 569 570 /* Reset global line counter and filename */ 571 572 Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename; 573 Gbl_CurrentLineNumber = Fnode->CurrentLineNumber; 574 575 /* Point the parser to the popped file */ 576 577 yy_delete_buffer (YY_CURRENT_BUFFER); 578 yy_switch_to_buffer (Fnode->State); 579 580 /* All done with this node */ 581 582 ACPI_MEM_FREE (Fnode); 583 return 0; 584} 585 586 587/******************************************************************************* 588 * 589 * FUNCTION: AslPushInputFileStack 590 * 591 * PARAMETERS: InputFile - Open file pointer 592 * Filename - Name of the file 593 * 594 * RETURN: None 595 * 596 * DESCRIPTION: Push the InputFile onto the file stack, and point the parser 597 * to this file. Called when an include file is successfully 598 * opened. 599 * 600 ******************************************************************************/ 601 602void 603AslPushInputFileStack ( 604 FILE *InputFile, 605 char *Filename) 606{ 607 ASL_FILE_NODE *Fnode; 608 YY_BUFFER_STATE State; 609 610 611 /* Save the current state in an Fnode */ 612 613 Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE)); 614 615 Fnode->File = yyin; 616 Fnode->Next = InputStack; 617 Fnode->State = YY_CURRENT_BUFFER; 618 Fnode->CurrentLineNumber = Gbl_CurrentLineNumber; 619 Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename; 620 621 /* Push it on the stack */ 622 623 InputStack = Fnode; 624 625 /* Point the parser to this file */ 626 627 State = yy_create_buffer (InputFile, YY_BUF_SIZE); 628 yy_switch_to_buffer (State); 629 630 DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile); 631 632 /* Reset the global line count and filename */ 633 634 Gbl_Files[ASL_FILE_INPUT].Filename = Filename; 635 Gbl_CurrentLineNumber = 1; 636 yyin = InputFile; 637} 638 639 640/******************************************************************************* 641 * 642 * FUNCTION: ResetCurrentLineBuffer 643 * 644 * PARAMETERS: None 645 * 646 * RETURN: None 647 * 648 * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers. 649 * 650 ******************************************************************************/ 651 652void 653ResetCurrentLineBuffer ( 654 void) 655{ 656 657 if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle) 658 { 659 FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer, 660 Gbl_LineBufPtr - Gbl_CurrentLineBuffer); 661 } 662 663 Gbl_CurrentLineOffset += Gbl_CurrentColumn; 664 Gbl_CurrentColumn = 0; 665 666 Gbl_CurrentLineNumber++; 667 Gbl_LogicalLineNumber++; 668 Gbl_LineBufPtr = Gbl_CurrentLineBuffer; 669} 670 671 672/******************************************************************************* 673 * 674 * FUNCTION: InsertLineBuffer 675 * 676 * PARAMETERS: SourceChar - One char from the input ASL source file 677 * 678 * RETURN: None 679 * 680 * DESCRIPTION: Put one character of the source file into the temp line buffer 681 * 682 ******************************************************************************/ 683 684#define ASL_SPACES_PER_TAB 4 685 686void 687InsertLineBuffer ( 688 int SourceChar) 689{ 690 UINT32 i; 691 UINT32 Count = 1; 692 693 694 if (SourceChar == EOF) 695 { 696 return; 697 } 698 699 Gbl_InputByteCount++; 700 701 /* Handle tabs. Convert to spaces */ 702 703 if (SourceChar == '\t') 704 { 705 SourceChar = ' '; 706 Count = ASL_SPACES_PER_TAB - 707 (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1)); 708 } 709 710 711 for (i = 0; i < Count; i++) 712 { 713 Gbl_CurrentColumn++; 714 715 /* Insert the character into the line buffer */ 716 717 *Gbl_LineBufPtr = (UINT8) SourceChar; 718 Gbl_LineBufPtr++; 719 720 if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1))) 721 { 722#if 0 723 /* 724 * Warning if we have split a long source line. 725 * <Probably overkill> 726 */ 727 sprintf (MsgBuffer, "Max %d", ASL_LINE_BUFFER_SIZE); 728 AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE, 729 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 730 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 731 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer); 732#endif 733 734 ResetCurrentLineBuffer (); 735 } 736 else if (SourceChar == '\n') 737 { 738 /* End of line */ 739 740 ResetCurrentLineBuffer (); 741 } 742 } 743} 744 745 746/******************************************************************************* 747 * 748 * FUNCTION: count 749 * 750 * PARAMETERS: yytext - Contains the matched keyword. 751 * Type - Keyword/Character type: 752 * 0 = anything except a keyword 753 * 1 = pseudo-keywords 754 * 2 = non-executable ASL keywords 755 * 3 = executable ASL keywords 756 * 757 * RETURN: None 758 * 759 * DESCRIPTION: Count keywords and put them into the line buffer 760 * 761 ******************************************************************************/ 762 763void 764count ( 765 int Type) 766{ 767 int i; 768 769 770 switch (Type) 771 { 772 case 2: 773 TotalKeywords++; 774 TotalNamedObjects++; 775 break; 776 777 case 3: 778 TotalKeywords++; 779 TotalExecutableOpcodes++; 780 break; 781 } 782 783 for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++) 784 { 785 InsertLineBuffer (yytext[i]); 786 *Gbl_LineBufPtr = 0; 787 } 788} 789 790 791/******************************************************************************* 792 * 793 * FUNCTION: comment 794 * 795 * PARAMETERS: none 796 * 797 * RETURN: none 798 * 799 * DESCRIPTION: Process a standard comment. 800 * 801 ******************************************************************************/ 802 803char 804comment (void) 805{ 806 char c; 807 char c1 = 0; 808 809 810 InsertLineBuffer ('/'); 811 InsertLineBuffer ('*'); 812 813loop: 814 815 /* Eat chars until end-of-comment */ 816 817 while ((c = (char) input()) != '*' && c != EOF) 818 { 819 InsertLineBuffer (c); 820 c1 = c; 821 } 822 823 if (c == EOF) 824 { 825 goto EarlyEOF; 826 } 827 828 /* 829 * Check for nested comment -- can help catch cases where a previous 830 * comment was accidently left unterminated 831 */ 832 if ((c1 == '/') && (c == '*')) 833 { 834 AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT, 835 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 836 Gbl_InputByteCount, Gbl_CurrentColumn, 837 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 838 } 839 840 /* Comment is closed only if the NEXT character is a slash */ 841 842 InsertLineBuffer (c); 843 844 if ((c1 = (char) input()) != '/' && c1 != EOF) 845 { 846 unput(c1); 847 goto loop; 848 } 849 850 if (c1 == EOF) 851 { 852 goto EarlyEOF; 853 } 854 855 InsertLineBuffer (c1); 856 return TRUE; 857 858 859EarlyEOF: 860 /* 861 * Premature End-Of-File 862 */ 863 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF, 864 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 865 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 866 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 867 return (FALSE); 868} 869 870 871/******************************************************************************* 872 * 873 * FUNCTION: comment 874 * 875 * PARAMETERS: none 876 * 877 * RETURN: none 878 * 879 * DESCRIPTION: Process a new "//" comment. 880 * 881 ******************************************************************************/ 882 883char 884comment2 (void) 885{ 886 char c; 887 888 889 InsertLineBuffer ('/'); 890 InsertLineBuffer ('/'); 891 892 while ((c = (char) input()) != '\n' && c != EOF) 893 { 894 InsertLineBuffer (c); 895 } 896 897 if (c == EOF) 898 { 899 /* End of file is OK, change to newline. Let parser detect EOF later */ 900 901 c = '\n'; 902 } 903 904 InsertLineBuffer (c); 905 return (TRUE); 906} 907 908 909/******************************************************************************* 910 * 911 * FUNCTION: literal 912 * 913 * PARAMETERS: none 914 * 915 * RETURN: none 916 * 917 * DESCRIPTION: Process a string literal (surrounded by quotes) 918 * 919 ******************************************************************************/ 920 921#define ASL_NORMAL_CHAR 0 922#define ASL_ESCAPE_SEQUENCE 1 923#define ASL_OCTAL_CONSTANT 2 924#define ASL_HEX_CONSTANT 3 925 926char 927literal (void) 928{ 929 char *s = MsgBuffer; 930 char *CleanString; 931 char StringChar; 932 UINT32 State = ASL_NORMAL_CHAR; 933 UINT32 i = 0; 934 UINT8 Digit; 935 UINT8 StringLength = 0; 936 char ConvertBuffer[4]; 937 938 939 /* 940 * Eat chars until end-of-literal. 941 * NOTE: Put back the original surrounding quotes into the 942 * source line buffer. 943 */ 944 InsertLineBuffer ('\"'); 945 while ((StringChar = (char) input()) != EOF) 946 { 947 StringLength++; 948 if (StringLength == ACPI_MAX_STRING_CONVERSION) 949 { 950 /* Emit error only once, but keep going */ 951 952 AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH, 953 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 954 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 955 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 956 } 957 958 InsertLineBuffer (StringChar); 959 960DoCharacter: 961 962 switch (State) 963 { 964 case ASL_NORMAL_CHAR: 965 966 switch (StringChar) 967 { 968 case '\\': 969 /* 970 * Special handling for backslash-escape sequence. We will 971 * toss the backslash and translate the escape char(s). 972 */ 973 State = ASL_ESCAPE_SEQUENCE; 974 continue; 975 976 case '\"': 977 978 /* String terminator */ 979 980 goto CompletedString; 981 } 982 break; 983 984 985 case ASL_ESCAPE_SEQUENCE: 986 987 State = ASL_NORMAL_CHAR; 988 switch (StringChar) 989 { 990 case 'a': 991 StringChar = 0x07; /* BELL */ 992 break; 993 994 case 'b': 995 StringChar = 0x08; /* BACKSPACE */ 996 break; 997 998 case 'f': 999 StringChar = 0x0C; /* FORMFEED */ 1000 break; 1001 1002 case 'n': 1003 StringChar = 0x0A; /* LINEFEED */ 1004 break; 1005 1006 case 'r': 1007 StringChar = 0x0D; /* CARRIAGE RETURN*/ 1008 break; 1009 1010 case 't': 1011 StringChar = 0x09; /* HORIZONTAL TAB */ 1012 break; 1013 1014 case 'v': 1015 StringChar = 0x0B; /* VERTICAL TAB */ 1016 break; 1017 1018 case 'x': 1019 State = ASL_HEX_CONSTANT; 1020 i = 0; 1021 continue; 1022 1023 case '\'': /* Single Quote */ 1024 case '\"': /* Double Quote */ 1025 case '\\': /* Backslash */ 1026 break; 1027 1028 default: 1029 1030 /* Check for an octal digit (0-7) */ 1031 1032 if (ACPI_IS_OCTAL_DIGIT (StringChar)) 1033 { 1034 State = ASL_OCTAL_CONSTANT; 1035 ConvertBuffer[0] = StringChar; 1036 i = 1; 1037 continue; 1038 } 1039 1040 /* Unknown escape sequence issue warning, but use the character */ 1041 1042 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE, 1043 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1044 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1045 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1046 break; 1047 } 1048 break; 1049 1050 1051 case ASL_OCTAL_CONSTANT: 1052 1053 /* Up to three octal digits allowed */ 1054 1055 if (!ACPI_IS_OCTAL_DIGIT (StringChar) || 1056 (i > 2)) 1057 { 1058 /* 1059 * Reached end of the constant. Convert the assembled ASCII 1060 * string and resume processing of the next character 1061 */ 1062 ConvertBuffer[i] = 0; 1063 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8); 1064 1065 /* Check for NULL or non-ascii character (ignore if so) */ 1066 1067 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX)) 1068 { 1069 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING, 1070 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1071 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1072 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1073 } 1074 else 1075 { 1076 *s = (char) Digit; 1077 s++; 1078 } 1079 1080 State = ASL_NORMAL_CHAR; 1081 goto DoCharacter; 1082 break; 1083 } 1084 1085 /* Append another digit of the constant */ 1086 1087 ConvertBuffer[i] = StringChar; 1088 i++; 1089 continue; 1090 1091 1092 case ASL_HEX_CONSTANT: 1093 1094 /* Up to two hex digits allowed */ 1095 1096 if (!ACPI_IS_XDIGIT (StringChar) || 1097 (i > 1)) 1098 { 1099 /* 1100 * Reached end of the constant. Convert the assembled ASCII 1101 * string and resume processing of the next character 1102 */ 1103 ConvertBuffer[i] = 0; 1104 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16); 1105 1106 /* Check for NULL or non-ascii character (ignore if so) */ 1107 1108 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX)) 1109 { 1110 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING, 1111 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1112 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1113 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1114 } 1115 else 1116 { 1117 *s = (char) Digit; 1118 s++; 1119 } 1120 1121 State = ASL_NORMAL_CHAR; 1122 goto DoCharacter; 1123 break; 1124 } 1125 1126 /* Append another digit of the constant */ 1127 1128 ConvertBuffer[i] = StringChar; 1129 i++; 1130 continue; 1131 } 1132 1133 /* Save the finished character */ 1134 1135 *s = StringChar; 1136 s++; 1137 } 1138 1139 /* 1140 * Premature End-Of-File 1141 */ 1142 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF, 1143 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1144 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1145 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1146 return (FALSE); 1147 1148 1149CompletedString: 1150 /* 1151 * Null terminate the input string and copy string to a new buffer 1152 */ 1153 *s = 0; 1154 1155 CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1); 1156 if (!CleanString) 1157 { 1158 AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION, 1159 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1160 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1161 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1162 return (FALSE); 1163 } 1164 1165 ACPI_STRCPY (CleanString, MsgBuffer); 1166 AslCompilerlval.s = CleanString; 1167 return (TRUE); 1168} 1169 1170 1171