aslcompiler.l revision 197104
1234285Sdim 2234285Sdim%{ 3234285Sdim/****************************************************************************** 4234285Sdim * 5234285Sdim * Module Name: aslcompiler.l - Flex input file 6234285Sdim * 7234285Sdim *****************************************************************************/ 8234285Sdim 9234285Sdim/****************************************************************************** 10234285Sdim * 11234285Sdim * 1. Copyright Notice 12234285Sdim * 13234285Sdim * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp. 14234285Sdim * All rights reserved. 15249423Sdim * 16234285Sdim * 2. License 17234285Sdim * 18234285Sdim * 2.1. This is your license from Intel Corp. under its intellectual property 19234285Sdim * rights. You may have additional license terms from the party that provided 20234285Sdim * you this software, covering your right to use that party's intellectual 21249423Sdim * property rights. 22234285Sdim * 23249423Sdim * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 24234285Sdim * copy of the source code appearing in this file ("Covered Code") an 25234285Sdim * irrevocable, perpetual, worldwide license under Intel's copyrights in the 26251662Sdim * base code distributed originally by Intel ("Original Intel Code") to copy, 27234285Sdim * make derivatives, distribute, use and display any portion of the Covered 28251662Sdim * Code in any form, with the right to sublicense such rights; and 29263508Sdim * 30243830Sdim * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 31234285Sdim * license (with the right to sublicense), under only those claims of Intel 32234285Sdim * patents that are infringed by the Original Intel Code, to make, use, sell, 33234285Sdim * offer to sell, and import the Covered Code and derivative works thereof 34234285Sdim * solely to the minimum extent necessary to exercise the above copyright 35234285Sdim * license, and in no event shall the patent license extend to any additions 36234285Sdim * to or modifications of the Original Intel Code. No other license or right 37234285Sdim * is granted directly or by implication, estoppel or otherwise; 38234285Sdim * 39234285Sdim * The above copyright and patent license is granted only if the following 40239462Sdim * conditions are met: 41234285Sdim * 42239462Sdim * 3. Conditions 43234285Sdim * 44239462Sdim * 3.1. Redistribution of Source with Rights to Further Distribute Source. 45234285Sdim * Redistribution of source code of any substantial portion of the Covered 46239462Sdim * Code or modification with rights to further distribute source must include 47234285Sdim * the above Copyright Notice, the above License, this list of Conditions, 48239462Sdim * and the following Disclaimer and Export Compliance provision. In addition, 49234285Sdim * Licensee must cause all Covered Code to which Licensee contributes to 50239462Sdim * contain a file documenting the changes Licensee made to create that Covered 51234285Sdim * Code and the date of any change. Licensee must include in that file the 52239462Sdim * documentation of any changes made by any predecessor Licensee. Licensee 53234285Sdim * must include a prominent statement that the modification is derived, 54239462Sdim * directly or indirectly, from Original Intel Code. 55234285Sdim * 56239462Sdim * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 57234285Sdim * Redistribution of source code of any substantial portion of the Covered 58263508Sdim * Code or modification without rights to further distribute source must 59263508Sdim * include the following Disclaimer and Export Compliance provision in the 60234285Sdim * documentation and/or other materials provided with distribution. In 61234285Sdim * addition, Licensee may not authorize further sublicense of source of any 62234285Sdim * portion of the Covered Code, and must include terms to the effect that the 63263508Sdim * license from Licensee to its licensee is limited to the intellectual 64234285Sdim * property embodied in the software Licensee provides to its licensee, and 65234285Sdim * not to intellectual property embodied in modifications its licensee may 66234285Sdim * make. 67234285Sdim * 68234285Sdim * 3.3. Redistribution of Executable. Redistribution in executable form of any 69234285Sdim * substantial portion of the Covered Code or modification must reproduce the 70234285Sdim * above Copyright Notice, and the following Disclaimer and Export Compliance 71234285Sdim * provision in the documentation and/or other materials provided with the 72234285Sdim * distribution. 73234285Sdim * 74234285Sdim * 3.4. Intel retains all right, title, and interest in and to the Original 75234285Sdim * Intel Code. 76234285Sdim * 77239462Sdim * 3.5. Neither the name Intel nor any other trademark owned or controlled by 78234285Sdim * Intel shall be used in advertising or otherwise to promote the sale, use or 79234285Sdim * other dealings in products derived from or relating to the Covered Code 80234285Sdim * without prior written authorization from Intel. 81234285Sdim * 82234285Sdim * 4. Disclaimer and Export Compliance 83234285Sdim * 84234285Sdim * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 85234285Sdim * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 86234285Sdim * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 87234285Sdim * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 88234285Sdim * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 89234285Sdim * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 90234285Sdim * PARTICULAR PURPOSE. 91234285Sdim * 92234285Sdim * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 93234285Sdim * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 94234285Sdim * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 95234285Sdim * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 96234285Sdim * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 97234285Sdim * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 98234285Sdim * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 99234285Sdim * LIMITED REMEDY. 100234285Sdim * 101234285Sdim * 4.3. Licensee shall not export, either directly or indirectly, any of this 102239462Sdim * software or system incorporating such software without first obtaining any 103234285Sdim * required license or other approval from the U. S. Department of Commerce or 104234285Sdim * any other agency or department of the United States Government. In the 105234285Sdim * event Licensee exports any such software from the United States or 106234285Sdim * re-exports any such software from a foreign destination, Licensee shall 107234285Sdim * ensure that the distribution and export/re-export of the software is in 108234285Sdim * compliance with all laws, regulations, orders, or other restrictions of the 109239462Sdim * U.S. Export Administration Regulations. Licensee agrees that neither it nor 110239462Sdim * any of its subsidiaries will export/re-export any technical data, process, 111234285Sdim * software, or service, directly or indirectly, to any country for which the 112234285Sdim * United States government or any agency thereof requires an export license, 113234285Sdim * other governmental approval, or letter of assurance, without first obtaining 114234285Sdim * such license, approval or letter. 115234285Sdim * 116234285Sdim *****************************************************************************/ 117234285Sdim 118234285Sdim 119234285Sdim#include <stdlib.h> 120234285Sdim#include <string.h> 121234285Sdim#include <contrib/dev/acpica/compiler/aslcompiler.h> 122234285Sdim#include "aslcompiler.y.h" 123234285SdimYYSTYPE AslCompilerlval; 124234285Sdim 125251662Sdim/* 126234285Sdim * Generation: Use the following command line: 127234285Sdim * 128234285Sdim * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath) 129234285Sdim * 130234285Sdim * -i: Scanner must be case-insensitive 131234285Sdim */ 132251662Sdim 133234285Sdim#define _COMPONENT ACPI_COMPILER 134251662Sdim ACPI_MODULE_NAME ("aslscan") 135234285Sdimchar 136234285Sdimcomment (void); 137234285Sdimchar 138234285Sdimcomment2 (void); 139234285Sdimvoid 140234285Sdimcount (int type); 141234285Sdimchar 142234285Sdimliteral (void); 143234285Sdimvoid 144234285Sdimcopy (void); 145234285Sdim 146234285Sdim/*! [Begin] no source code translation */ 147234285Sdim 148234285Sdim%} 149234285Sdim 150234285Sdim 151234285SdimLeadNameChar [A-Za-z_] 152234285SdimDigitChar [0-9] 153234285SdimHexDigitChar [A-Fa-f0-9] 154234285SdimRootChar [\\] 155234285SdimNothing [] 156234285Sdim 157234285SdimNameChar [A-Za-z_0-9] 158234285SdimNameSeg1 {LeadNameChar}{NameChar} 159234285SdimNameSeg2 {LeadNameChar}{NameChar}{NameChar} 160234285SdimNameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar} 161234285SdimNameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3} 162234285Sdim 163234285SdimNameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath} 164234285SdimNamePath {NonEmptyNamePath}? 165234285SdimNonEmptyNamePath {NameSeg}{NamePathTail}* 166234285SdimNamePathTail [.]{NameSeg} 167234285Sdim 168234285Sdim%% 169234285Sdim 170234285Sdim[ ] { count (0); } 171234285Sdim[\n] { count (0); } /* Handle files with both LF and CR/LF */ 172234285Sdim[\r] { count (0); } /* termination on both Unix and Windows */ 173234285Sdim[ \t] { count (0); } 174234285Sdim 175234285Sdim 176234285Sdim"/*" { if (!comment ()) yyterminate (); } 177239462Sdim"//" { if (!comment2 ()) yyterminate (); } 178234285Sdim 179234285Sdim"\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); } 180234285Sdim 181251662Sdim 182251662Sdim0[xX]{HexDigitChar}+ | 183234285Sdim{DigitChar}+ { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext); 184234285Sdim count (1); return (PARSEOP_INTEGER); } 185234285Sdim 186234285Sdim"Include" { count (1); return (PARSEOP_INCLUDE); } 187234285Sdim"#include" { count (1); return (PARSEOP_INCLUDE_CSTYLE); } 188234285Sdim"#line" { count (1); return (PARSEOP_LINE_CSTYLE); } 189234285Sdim"External" { count (1); return (PARSEOP_EXTERNAL); } 190234285Sdim 191234285Sdim 192234285Sdim"Ones" { count (1); return (PARSEOP_ONES); } 193234285Sdim"One" { count (1); return (PARSEOP_ONE); } 194234285Sdim"Zero" { count (1); return (PARSEOP_ZERO); } 195234285Sdim"Revision" { count (1); return (PARSEOP_REVISION); } 196234285Sdim 197234285Sdim"Offset" { count (1); return (PARSEOP_OFFSET); } 198234285Sdim"AccessAs" { count (1); return (PARSEOP_ACCESSAS); } 199234285Sdim"BankField" { count (2); return (PARSEOP_BANKFIELD); } 200234285Sdim"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); } 201251662Sdim"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); } 202234285Sdim"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); } 203251662Sdim"CreateField" { count (2); return (PARSEOP_CREATEFIELD); } 204234285Sdim"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); } 205234285Sdim"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); } 206234285Sdim"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); } 207251662Sdim"Device" { count (2); return (PARSEOP_DEVICE); } 208234285Sdim"Event" { count (2); return (PARSEOP_EVENT); } 209234285Sdim"Field" { count (2); return (PARSEOP_FIELD); } 210234285Sdim"Function" { count (2); return (PARSEOP_FUNCTION); } 211251662Sdim"IndexField" { count (2); return (PARSEOP_INDEXFIELD); } 212251662Sdim"Method" { count (2); return (PARSEOP_METHOD); } 213251662Sdim"Mutex" { count (2); return (PARSEOP_MUTEX); } 214251662Sdim"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); } 215251662Sdim"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); } 216251662Sdim"Processor" { count (2); return (PARSEOP_PROCESSOR); } 217251662Sdim"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); } 218251662Sdim"Alias" { count (2); return (PARSEOP_ALIAS); } 219251662Sdim"Name" { count (2); return (PARSEOP_NAME); } 220251662Sdim"Scope" { count (2); return (PARSEOP_SCOPE); } 221251662Sdim"Break" { count (3); return (PARSEOP_BREAK); } 222234285Sdim"BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); } 223234285Sdim"Continue" { count (3); return (PARSEOP_CONTINUE); } 224234285Sdim"Fatal" { count (3); return (PARSEOP_FATAL); } 225234285Sdim"If" { count (3); return (PARSEOP_IF); } 226234285Sdim"Else" { count (3); return (PARSEOP_ELSE); } 227251662Sdim"ElseIf" { count (3); return (PARSEOP_ELSEIF); } 228251662Sdim"Load" { count (3); return (PARSEOP_LOAD); } 229251662Sdim"Noop" { count (3); return (PARSEOP_NOOP); } 230251662Sdim"Notify" { count (3); return (PARSEOP_NOTIFY); } 231251662Sdim"Release" { count (3); return (PARSEOP_RELEASE); } 232251662Sdim"Reset" { count (3); return (PARSEOP_RESET); } 233251662Sdim"Return" { count (3); return (PARSEOP_RETURN); } 234251662Sdim"Signal" { count (3); return (PARSEOP_SIGNAL); } 235251662Sdim"Sleep" { count (3); return (PARSEOP_SLEEP); } 236251662Sdim"Stall" { count (3); return (PARSEOP_STALL); } 237251662Sdim"Switch" { count (3); return (PARSEOP_SWITCH); } 238251662Sdim"Case" { count (3); return (PARSEOP_CASE); } 239251662Sdim"Default" { count (3); return (PARSEOP_DEFAULT); } 240251662Sdim"Unload" { count (3); return (PARSEOP_UNLOAD); } 241234285Sdim"While" { count (3); return (PARSEOP_WHILE); } 242251662Sdim 243251662Sdim"Acquire" { count (3); return (PARSEOP_ACQUIRE); } 244251662Sdim"Add" { count (3); return (PARSEOP_ADD); } 245251662Sdim"And" { count (3); return (PARSEOP_AND); } 246251662Sdim"Concatenate" { count (3); return (PARSEOP_CONCATENATE); } 247234285Sdim"ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); } 248251662Sdim"CondRefOf" { count (3); return (PARSEOP_CONDREFOF); } 249251662Sdim"CopyObject" { count (3); return (PARSEOP_COPYOBJECT); } 250234285Sdim"Decrement" { count (3); return (PARSEOP_DECREMENT); } 251234285Sdim"DeRefOf" { count (3); return (PARSEOP_DEREFOF); } 252234285Sdim"Divide" { count (3); return (PARSEOP_DIVIDE); } 253251662Sdim"FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); } 254251662Sdim"FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); } 255234285Sdim"FromBCD" { count (3); return (PARSEOP_FROMBCD); } 256234285Sdim"Increment" { count (3); return (PARSEOP_INCREMENT); } 257234285Sdim"Index" { count (3); return (PARSEOP_INDEX); } 258251662Sdim"LAnd" { count (3); return (PARSEOP_LAND); } 259234285Sdim"LEqual" { count (3); return (PARSEOP_LEQUAL); } 260251662Sdim"LGreater" { count (3); return (PARSEOP_LGREATER); } 261251662Sdim"LGreaterEqual" { count (3); return (PARSEOP_LGREATEREQUAL); } 262251662Sdim"LLess" { count (3); return (PARSEOP_LLESS); } 263234285Sdim"LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); } 264234285Sdim"LNot" { count (3); return (PARSEOP_LNOT); } 265234285Sdim"LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); } 266234285Sdim"LoadTable" { count (3); return (PARSEOP_LOADTABLE); } 267234285Sdim"LOr" { count (3); return (PARSEOP_LOR); } 268234285Sdim"Match" { count (3); return (PARSEOP_MATCH); } 269234285Sdim"Mid" { count (3); return (PARSEOP_MID); } 270251662Sdim"Mod" { count (3); return (PARSEOP_MOD); } 271234285Sdim"Multiply" { count (3); return (PARSEOP_MULTIPLY); } 272251662Sdim"NAnd" { count (3); return (PARSEOP_NAND); } 273251662Sdim"NOr" { count (3); return (PARSEOP_NOR); } 274251662Sdim"Not" { count (3); return (PARSEOP_NOT); } 275234285Sdim"ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); } 276251662Sdim"Or" { count (3); return (PARSEOP_OR); } 277251662Sdim"RefOf" { count (3); return (PARSEOP_REFOF); } 278234285Sdim"ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); } 279234285Sdim"ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); } 280234285Sdim"SizeOf" { count (3); return (PARSEOP_SIZEOF); } 281234285Sdim"Store" { count (3); return (PARSEOP_STORE); } 282234285Sdim"Subtract" { count (3); return (PARSEOP_SUBTRACT); } 283234285Sdim"Timer" { count (3); return (PARSEOP_TIMER); } 284234285Sdim"ToBCD" { count (3); return (PARSEOP_TOBCD); } 285251662Sdim"ToBuffer" { count (3); return (PARSEOP_TOBUFFER); } 286234285Sdim"ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); } 287234285Sdim"ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); } 288234285Sdim"ToInteger" { count (3); return (PARSEOP_TOINTEGER); } 289234285Sdim"ToString" { count (3); return (PARSEOP_TOSTRING); } 290234285Sdim"Wait" { count (3); return (PARSEOP_WAIT); } 291234285Sdim"XOr" { count (3); return (PARSEOP_XOR); } 292234285Sdim 293251662Sdim"Arg0" { count (1); return (PARSEOP_ARG0); } 294251662Sdim"Arg1" { count (1); return (PARSEOP_ARG1); } 295251662Sdim"Arg2" { count (1); return (PARSEOP_ARG2); } 296251662Sdim"Arg3" { count (1); return (PARSEOP_ARG3); } 297251662Sdim"Arg4" { count (1); return (PARSEOP_ARG4); } 298251662Sdim"Arg5" { count (1); return (PARSEOP_ARG5); } 299251662Sdim"Arg6" { count (1); return (PARSEOP_ARG6); } 300251662Sdim 301251662Sdim"Local0" { count (1); return (PARSEOP_LOCAL0); } 302234285Sdim"Local1" { count (1); return (PARSEOP_LOCAL1); } 303234285Sdim"Local2" { count (1); return (PARSEOP_LOCAL2); } 304234285Sdim"Local3" { count (1); return (PARSEOP_LOCAL3); } 305234285Sdim"Local4" { count (1); return (PARSEOP_LOCAL4); } 306234285Sdim"Local5" { count (1); return (PARSEOP_LOCAL5); } 307234285Sdim"Local6" { count (1); return (PARSEOP_LOCAL6); } 308234285Sdim"Local7" { count (1); return (PARSEOP_LOCAL7); } 309251662Sdim 310251662Sdim"Debug" { count (1); return (PARSEOP_DEBUG); } 311234285Sdim 312234285Sdim"DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); } 313234285Sdim"Buffer" { count (1); return (PARSEOP_BUFFER); } 314234285Sdim"Package" { count (1); return (PARSEOP_PACKAGE); } 315234285Sdim 316234285Sdim"EISAID" { count (1); return (PARSEOP_EISAID); } 317234285Sdim"ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); } 318234285Sdim"ToUUID" { count (1); return (PARSEOP_TOUUID); } 319234285Sdim"Unicode" { count (1); return (PARSEOP_UNICODE); } 320234285Sdim"DMA" { count (1); return (PARSEOP_DMA); } 321234285Sdim"DWordIO" { count (1); return (PARSEOP_DWORDIO); } 322234285Sdim"DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); } 323234285Sdim"DWordSpace" { count (1); return (PARSEOP_DWORDSPACE); } 324234285Sdim"EndDependentFn" { count (1); return (PARSEOP_ENDDEPENDENTFN); } 325234285Sdim"ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); } 326234285Sdim"ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); } 327234285Sdim"ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); } 328234285Sdim"FixedIO" { count (1); return (PARSEOP_FIXEDIO); } 329234285Sdim"Interrupt" { count (1); return (PARSEOP_INTERRUPT); } 330234285Sdim"IO" { count (1); return (PARSEOP_IO); } 331234285Sdim"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); } 332234285Sdim"IRQ" { count (1); return (PARSEOP_IRQ); } 333234285Sdim"Memory24" { count (1); return (PARSEOP_MEMORY24); } 334234285Sdim"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); } 335249423Sdim"Memory32" { count (1); return (PARSEOP_MEMORY32); } 336249423Sdim"QWordIO" { count (1); return (PARSEOP_QWORDIO); } 337249423Sdim"QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); } 338249423Sdim"QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); } 339249423Sdim"Register" { count (1); return (PARSEOP_REGISTER); } 340249423Sdim"StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); } 341249423Sdim"StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); } 342249423Sdim"VendorLong" { count (1); return (PARSEOP_VENDORLONG); } 343249423Sdim"VendorShort" { count (1); return (PARSEOP_VENDORSHORT); } 344249423Sdim"WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); } 345249423Sdim"WordIO" { count (1); return (PARSEOP_WORDIO); } 346249423Sdim"WordSpace" { count (1); return (PARSEOP_WORDSPACE); } 347249423Sdim 348249423Sdim"UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); } 349249423Sdim"IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); } 350249423Sdim"StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); } 351249423Sdim"BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); } 352249423Sdim"PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); } 353249423Sdim"FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); } 354249423Sdim"DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); } 355249423Sdim"EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); } 356249423Sdim"MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); } 357249423Sdim"MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); } 358249423Sdim"OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); } 359249423Sdim"PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); } 360249423Sdim"ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); } 361249423Sdim"ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); } 362249423Sdim"BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); } 363249423Sdim"DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); } 364249423Sdim 365249423Sdim"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); } 366249423Sdim"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); } 367249423Sdim"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); } 368249423Sdim"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); } 369249423Sdim"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); } 370249423Sdim"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); } 371249423Sdim 372249423Sdim"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); } 373249423Sdim"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); } 374249423Sdim 375249423Sdim"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); } 376249423Sdim"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); } 377249423Sdim"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); } 378249423Sdim 379249423Sdim"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); } 380249423Sdim"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); } 381249423Sdim 382249423Sdim"SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); } 383249423Sdim"SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); } 384249423Sdim"PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); } 385249423Sdim"EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); } 386249423Sdim"SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); } 387249423Sdim"SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); } 388249423Sdim"PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); } 389249423Sdim"IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); } 390249423Sdim 391249423Sdim"FFixedHW" { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); } 392249423Sdim 393249423Sdim"SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 394249423Sdim"SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 395249423Sdim"SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 396249423Sdim"SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 397249423Sdim"SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 398249423Sdim"SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 399249423Sdim"SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 400249423Sdim 401249423Sdim"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); } 402249423Sdim"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); } 403249423Sdim"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); } 404249423Sdim"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); } 405249423Sdim"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); } 406249423Sdim"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); } 407249423Sdim 408249423Sdim"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); } 409249423Sdim"TypeA" { count (0); return (PARSEOP_DMATYPE_A); } 410249423Sdim"TypeB" { count (0); return (PARSEOP_DMATYPE_B); } 411249423Sdim"TypeF" { count (0); return (PARSEOP_DMATYPE_F); } 412249423Sdim 413234285Sdim"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); } 414234285Sdim"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); } 415234285Sdim 416234285Sdim"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); } 417234285Sdim"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); } 418234285Sdim"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); } 419234285Sdim 420234285Sdim"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); } 421234285Sdim"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); } 422249423Sdim 423234285Sdim"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); } 424234285Sdim"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); } 425234285Sdim 426234285Sdim"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); } 427234285Sdim"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); } 428234285Sdim 429234285Sdim"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); } 430234285Sdim"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); } 431239462Sdim 432239462Sdim"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); } 433234285Sdim"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); } 434234285Sdim"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); } 435234285Sdim 436234285Sdim"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); } 437234285Sdim"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); } 438234285Sdim"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); } 439234285Sdim"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); } 440234285Sdim 441234285Sdim"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); } 442234285Sdim"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); } 443234285Sdim 444234285Sdim"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); } 445234285Sdim"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); } 446234285Sdim 447239462Sdim"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); } 448239462Sdim"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); } 449234285Sdim 450234285Sdim"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); } 451234285Sdim"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); } 452249423Sdim 453249423Sdim"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); } 454249423Sdim"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); } 455249423Sdim 456249423Sdim"TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); } 457249423Sdim"TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); } 458249423Sdim 459249423Sdim"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); } 460249423Sdim"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); } 461249423Sdim 462249423Sdim"AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); } 463249423Sdim"AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); } 464234285Sdim"AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); } 465234285Sdim"AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); } 466234285Sdim 467234285Sdim 468234285Sdim"{" { count (0); return('{'); } 469234285Sdim"}" { count (0); return('}'); } 470234285Sdim"," { count (0); return(','); } 471234285Sdim"(" { count (0); return('('); } 472234285Sdim")" { count (0); return(')'); } 473234285Sdim 474234285Sdim 475234285Sdim{NameSeg} { char *s; 476234285Sdim count (0); 477234285Sdim s=malloc (ACPI_NAME_SIZE + 1); 478234285Sdim if (strcmp (AslCompilertext, "\\")) 479234285Sdim { 480234285Sdim strcpy (s, "____"); 481234285Sdim AcpiUtStrupr (AslCompilertext); 482234285Sdim } 483234285Sdim memcpy (s, AslCompilertext, strlen (AslCompilertext)); 484234285Sdim AslCompilerlval.s = s; 485234285Sdim DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s); 486234285Sdim return (PARSEOP_NAMESEG); } 487239462Sdim 488234285Sdim{NameString} { char *s; 489234285Sdim count (0); 490234285Sdim s=malloc (strlen (AslCompilertext)+1); 491239462Sdim AcpiUtStrupr (AslCompilertext); 492234285Sdim strcpy (s, AslCompilertext); 493234285Sdim s[strlen (AslCompilertext)] = 0; 494234285Sdim AslCompilerlval.s = s; 495239462Sdim DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s); 496234285Sdim return (PARSEOP_NAMESTRING); } 497234285Sdim 498234285Sdim"*" | 499234285Sdim"/" { count (1); 500234285Sdim AslCompilererror ("Parse error, expecting ASL keyword or name");} 501234285Sdim 502234285Sdim. { count (1); 503234285Sdim sprintf (MsgBuffer, 504234285Sdim "Invalid character (0x%2.2X), expecting ASL keyword or name", 505234285Sdim *AslCompilertext); 506234285Sdim AslCompilererror (MsgBuffer);} 507234285Sdim 508234285Sdim<<EOF>> { if (AslPopInputFileStack ()) 509234285Sdim yyterminate(); 510234285Sdim else 511234285Sdim return (PARSEOP_INCLUDE_END);}; 512234285Sdim 513234285Sdim%% 514234285Sdim 515234285Sdim/*! [End] no source code translation !*/ 516234285Sdim 517234285Sdimtypedef struct asl_file_node 518234285Sdim{ 519234285Sdim FILE *File; 520234285Sdim UINT32 CurrentLineNumber; 521234285Sdim YY_BUFFER_STATE State; 522234285Sdim char *Filename; 523234285Sdim struct asl_file_node *Next; 524234285Sdim 525234285Sdim} ASL_FILE_NODE; 526234285Sdim 527234285SdimASL_FILE_NODE *InputStack = NULL; 528234285Sdim 529234285Sdim 530234285Sdim/******************************************************************************* 531234285Sdim * 532239462Sdim * FUNCTION: AslPopInputFileStack 533234285Sdim * 534234285Sdim * PARAMETERS: None 535239462Sdim * 536234285Sdim * RETURN: 0 if a node was popped, -1 otherwise 537234285Sdim * 538239462Sdim * DESCRIPTION: Pop the top of the input file stack and point the parser to 539234285Sdim * the saved parse buffer contained in the fnode. Also, set the 540234285Sdim * global line counters to the saved values. This function is 541234285Sdim * called when an include file reaches EOF. 542234285Sdim * 543234285Sdim ******************************************************************************/ 544234285Sdim 545234285Sdimint 546234285SdimAslPopInputFileStack ( 547234285Sdim void) 548234285Sdim{ 549234285Sdim ASL_FILE_NODE *Fnode; 550234285Sdim FILE *InputFile = NULL; 551234285Sdim 552234285Sdim 553234285Sdim Fnode = InputStack; 554234285Sdim DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode); 555234285Sdim 556234285Sdim 557234285Sdim if (!Fnode) 558234285Sdim { 559234285Sdim return -1; 560234285Sdim } 561234285Sdim 562234285Sdim /* Close the current include file */ 563234285Sdim 564234285Sdim fclose (yyin); 565234285Sdim 566234285Sdim /* Update the top-of-stack */ 567234285Sdim 568239462Sdim InputStack = Fnode->Next; 569239462Sdim InputFile = Fnode->File; 570239462Sdim 571239462Sdim /* Reset global line counter and filename */ 572239462Sdim 573234285Sdim Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename; 574234285Sdim Gbl_CurrentLineNumber = Fnode->CurrentLineNumber; 575234285Sdim 576234285Sdim /* Point the parser to the popped file */ 577234285Sdim 578234285Sdim yy_delete_buffer (YY_CURRENT_BUFFER); 579234285Sdim yy_switch_to_buffer (Fnode->State); 580234285Sdim 581239462Sdim /* All done with this node */ 582249423Sdim 583249423Sdim ACPI_FREE (Fnode); 584249423Sdim return 0; 585234285Sdim} 586249423Sdim 587249423Sdim 588249423Sdim/******************************************************************************* 589249423Sdim * 590234285Sdim * FUNCTION: AslPushInputFileStack 591249423Sdim * 592249423Sdim * PARAMETERS: InputFile - Open file pointer 593249423Sdim * Filename - Name of the file 594249423Sdim * 595239462Sdim * RETURN: None 596239462Sdim * 597249423Sdim * DESCRIPTION: Push the InputFile onto the file stack, and point the parser 598249423Sdim * to this file. Called when an include file is successfully 599239462Sdim * opened. 600249423Sdim * 601239462Sdim ******************************************************************************/ 602239462Sdim 603249423Sdimvoid 604249423SdimAslPushInputFileStack ( 605249423Sdim FILE *InputFile, 606239462Sdim char *Filename) 607249423Sdim{ 608249423Sdim ASL_FILE_NODE *Fnode; 609249423Sdim YY_BUFFER_STATE State; 610249423Sdim 611249423Sdim 612249423Sdim /* Save the current state in an Fnode */ 613249423Sdim 614249423Sdim Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE)); 615249423Sdim 616239462Sdim Fnode->File = yyin; 617239462Sdim Fnode->Next = InputStack; 618249423Sdim Fnode->State = YY_CURRENT_BUFFER; 619239462Sdim Fnode->CurrentLineNumber = Gbl_CurrentLineNumber; 620239462Sdim Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename; 621251662Sdim 622251662Sdim /* Push it on the stack */ 623239462Sdim 624239462Sdim InputStack = Fnode; 625249423Sdim 626249423Sdim /* Point the parser to this file */ 627249423Sdim 628249423Sdim State = yy_create_buffer (InputFile, YY_BUF_SIZE); 629249423Sdim yy_switch_to_buffer (State); 630249423Sdim 631249423Sdim DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile); 632249423Sdim 633249423Sdim /* Reset the global line count and filename */ 634249423Sdim 635239462Sdim Gbl_Files[ASL_FILE_INPUT].Filename = Filename; 636239462Sdim Gbl_CurrentLineNumber = 1; 637239462Sdim yyin = InputFile; 638239462Sdim} 639234285Sdim 640234285Sdim 641234285Sdim/******************************************************************************* 642234285Sdim * 643234285Sdim * FUNCTION: ResetCurrentLineBuffer 644234285Sdim * 645234285Sdim * PARAMETERS: None 646234285Sdim * 647234285Sdim * RETURN: None 648234285Sdim * 649234285Sdim * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers. 650234285Sdim * 651234285Sdim ******************************************************************************/ 652234285Sdim 653234285Sdimvoid 654234285SdimResetCurrentLineBuffer ( 655234285Sdim void) 656234285Sdim{ 657234285Sdim 658234285Sdim if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle) 659234285Sdim { 660234285Sdim FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer, 661234285Sdim Gbl_LineBufPtr - Gbl_CurrentLineBuffer); 662234285Sdim } 663234285Sdim 664234285Sdim Gbl_CurrentLineOffset += Gbl_CurrentColumn; 665234285Sdim Gbl_CurrentColumn = 0; 666234285Sdim 667234285Sdim Gbl_CurrentLineNumber++; 668234285Sdim Gbl_LogicalLineNumber++; 669234285Sdim Gbl_LineBufPtr = Gbl_CurrentLineBuffer; 670234285Sdim} 671234285Sdim 672234285Sdim 673234285Sdim/******************************************************************************* 674234285Sdim * 675234285Sdim * FUNCTION: InsertLineBuffer 676234285Sdim * 677234285Sdim * PARAMETERS: SourceChar - One char from the input ASL source file 678234285Sdim * 679234285Sdim * RETURN: None 680234285Sdim * 681234285Sdim * DESCRIPTION: Put one character of the source file into the temp line buffer 682234285Sdim * 683234285Sdim ******************************************************************************/ 684234285Sdim 685234285Sdim#define ASL_SPACES_PER_TAB 4 686234285Sdim 687234285Sdimvoid 688234285SdimInsertLineBuffer ( 689234285Sdim int SourceChar) 690234285Sdim{ 691234285Sdim UINT32 i; 692234285Sdim UINT32 Count = 1; 693234285Sdim 694234285Sdim 695234285Sdim if (SourceChar == EOF) 696234285Sdim { 697234285Sdim return; 698234285Sdim } 699234285Sdim 700234285Sdim Gbl_InputByteCount++; 701234285Sdim 702234285Sdim /* Handle tabs. Convert to spaces */ 703234285Sdim 704234285Sdim if (SourceChar == '\t') 705234285Sdim { 706234285Sdim SourceChar = ' '; 707234285Sdim Count = ASL_SPACES_PER_TAB - 708234285Sdim (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1)); 709234285Sdim } 710234285Sdim 711234285Sdim 712234285Sdim for (i = 0; i < Count; i++) 713234285Sdim { 714234285Sdim Gbl_CurrentColumn++; 715234285Sdim 716234285Sdim /* Insert the character into the line buffer */ 717234285Sdim 718234285Sdim *Gbl_LineBufPtr = (UINT8) SourceChar; 719239462Sdim Gbl_LineBufPtr++; 720234285Sdim 721234285Sdim if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1))) 722234285Sdim { 723234285Sdim#if 0 724234285Sdim /* 725239462Sdim * Warning if we have split a long source line. 726239462Sdim * <Probably overkill> 727239462Sdim */ 728239462Sdim sprintf (MsgBuffer, "Max %d", ASL_LINE_BUFFER_SIZE); 729239462Sdim AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE, 730234285Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 731251662Sdim Gbl_CurrentLineOffset, Gbl_CurrentColumn, 732251662Sdim Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer); 733251662Sdim#endif 734251662Sdim 735251662Sdim ResetCurrentLineBuffer (); 736251662Sdim } 737234285Sdim else if (SourceChar == '\n') 738239462Sdim { 739234285Sdim /* End of line */ 740234285Sdim 741234285Sdim ResetCurrentLineBuffer (); 742234285Sdim } 743234285Sdim } 744263508Sdim} 745234285Sdim 746234285Sdim 747234285Sdim/******************************************************************************* 748234285Sdim * 749234285Sdim * FUNCTION: count 750234285Sdim * 751234285Sdim * PARAMETERS: yytext - Contains the matched keyword. 752263508Sdim * Type - Keyword/Character type: 753263508Sdim * 0 = anything except a keyword 754263508Sdim * 1 = pseudo-keywords 755234285Sdim * 2 = non-executable ASL keywords 756263508Sdim * 3 = executable ASL keywords 757263508Sdim * 758263508Sdim * RETURN: None 759263508Sdim * 760263508Sdim * DESCRIPTION: Count keywords and put them into the line buffer 761263508Sdim * 762263508Sdim ******************************************************************************/ 763263508Sdim 764263508Sdimvoid 765234285Sdimcount ( 766234285Sdim int Type) 767243830Sdim{ 768243830Sdim int i; 769243830Sdim 770243830Sdim 771243830Sdim switch (Type) 772243830Sdim { 773243830Sdim case 2: 774243830Sdim TotalKeywords++; 775243830Sdim TotalNamedObjects++; 776234285Sdim break; 777239462Sdim 778239462Sdim case 3: 779239462Sdim TotalKeywords++; 780234285Sdim TotalExecutableOpcodes++; 781234285Sdim break; 782234285Sdim } 783234285Sdim 784234285Sdim for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++) 785263508Sdim { 786234285Sdim InsertLineBuffer (yytext[i]); 787234285Sdim *Gbl_LineBufPtr = 0; 788263508Sdim } 789234285Sdim} 790234285Sdim 791239462Sdim 792234285Sdim/******************************************************************************* 793234285Sdim * 794234285Sdim * FUNCTION: comment 795234285Sdim * 796234285Sdim * PARAMETERS: none 797234285Sdim * 798234285Sdim * RETURN: none 799234285Sdim * 800234285Sdim * DESCRIPTION: Process a standard comment. 801234285Sdim * 802234285Sdim ******************************************************************************/ 803234285Sdim 804234285Sdimchar 805234285Sdimcomment (void) 806234285Sdim{ 807234285Sdim char c; 808249423Sdim char c1 = 0; 809249423Sdim 810249423Sdim 811249423Sdim InsertLineBuffer ('/'); 812234285Sdim InsertLineBuffer ('*'); 813234285Sdim 814249423Sdimloop: 815249423Sdim 816249423Sdim /* Eat chars until end-of-comment */ 817249423Sdim 818249423Sdim while ((c = (char) input()) != '*' && c != EOF) 819249423Sdim { 820249423Sdim InsertLineBuffer (c); 821249423Sdim c1 = c; 822249423Sdim } 823249423Sdim 824249423Sdim if (c == EOF) 825249423Sdim { 826249423Sdim goto EarlyEOF; 827249423Sdim } 828249423Sdim 829249423Sdim /* 830249423Sdim * Check for nested comment -- can help catch cases where a previous 831249423Sdim * comment was accidently left unterminated 832249423Sdim */ 833249423Sdim if ((c1 == '/') && (c == '*')) 834249423Sdim { 835249423Sdim AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT, 836249423Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 837249423Sdim Gbl_InputByteCount, Gbl_CurrentColumn, 838249423Sdim Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 839249423Sdim } 840249423Sdim 841249423Sdim /* Comment is closed only if the NEXT character is a slash */ 842249423Sdim 843249423Sdim InsertLineBuffer (c); 844249423Sdim 845249423Sdim if ((c1 = (char) input()) != '/' && c1 != EOF) 846249423Sdim { 847249423Sdim unput(c1); 848249423Sdim goto loop; 849249423Sdim } 850249423Sdim 851249423Sdim if (c1 == EOF) 852249423Sdim { 853249423Sdim goto EarlyEOF; 854249423Sdim } 855249423Sdim 856249423Sdim InsertLineBuffer (c1); 857249423Sdim return TRUE; 858249423Sdim 859249423Sdim 860249423SdimEarlyEOF: 861249423Sdim /* 862249423Sdim * Premature End-Of-File 863249423Sdim */ 864249423Sdim AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF, 865249423Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 866249423Sdim Gbl_CurrentLineOffset, Gbl_CurrentColumn, 867249423Sdim Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 868249423Sdim return (FALSE); 869249423Sdim} 870249423Sdim 871249423Sdim 872249423Sdim/******************************************************************************* 873249423Sdim * 874249423Sdim * FUNCTION: comment 875249423Sdim * 876249423Sdim * PARAMETERS: none 877249423Sdim * 878249423Sdim * RETURN: none 879249423Sdim * 880249423Sdim * DESCRIPTION: Process a new "//" comment. 881249423Sdim * 882249423Sdim ******************************************************************************/ 883249423Sdim 884249423Sdimchar 885249423Sdimcomment2 (void) 886249423Sdim{ 887249423Sdim char c; 888249423Sdim 889249423Sdim 890249423Sdim InsertLineBuffer ('/'); 891249423Sdim InsertLineBuffer ('/'); 892249423Sdim 893249423Sdim while ((c = (char) input()) != '\n' && c != EOF) 894249423Sdim { 895249423Sdim InsertLineBuffer (c); 896249423Sdim } 897249423Sdim 898249423Sdim if (c == EOF) 899249423Sdim { 900249423Sdim /* End of file is OK, change to newline. Let parser detect EOF later */ 901249423Sdim 902249423Sdim c = '\n'; 903234285Sdim } 904234285Sdim 905234285Sdim InsertLineBuffer (c); 906234285Sdim return (TRUE); 907234285Sdim} 908249423Sdim 909249423Sdim 910249423Sdim/******************************************************************************* 911249423Sdim * 912249423Sdim * FUNCTION: literal 913249423Sdim * 914249423Sdim * PARAMETERS: none 915249423Sdim * 916251662Sdim * RETURN: none 917234285Sdim * 918251662Sdim * DESCRIPTION: Process a string literal (surrounded by quotes) 919234285Sdim * 920234285Sdim ******************************************************************************/ 921234285Sdim 922251662Sdim#define ASL_NORMAL_CHAR 0 923251662Sdim#define ASL_ESCAPE_SEQUENCE 1 924251662Sdim#define ASL_OCTAL_CONSTANT 2 925249423Sdim#define ASL_HEX_CONSTANT 3 926249423Sdim 927249423Sdimchar 928249423Sdimliteral (void) 929249423Sdim{ 930249423Sdim char *StringBuffer = MsgBuffer; 931249423Sdim char *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE; 932249423Sdim char *CleanString; 933249423Sdim char StringChar; 934249423Sdim UINT32 State = ASL_NORMAL_CHAR; 935249423Sdim UINT32 i = 0; 936249423Sdim UINT8 Digit; 937249423Sdim char ConvertBuffer[4]; 938249423Sdim 939249423Sdim 940249423Sdim /* 941249423Sdim * Eat chars until end-of-literal. 942249423Sdim * NOTE: Put back the original surrounding quotes into the 943249423Sdim * source line buffer. 944249423Sdim */ 945249423Sdim InsertLineBuffer ('\"'); 946249423Sdim while ((StringChar = (char) input()) != EOF) 947234285Sdim { 948234285Sdim InsertLineBuffer (StringChar); 949234285Sdim 950234285SdimDoCharacter: 951234285Sdim 952234285Sdim switch (State) 953234285Sdim { 954239462Sdim case ASL_NORMAL_CHAR: 955234285Sdim 956234285Sdim switch (StringChar) 957234285Sdim { 958234285Sdim case '\\': 959234285Sdim /* 960234285Sdim * Special handling for backslash-escape sequence. We will 961234285Sdim * toss the backslash and translate the escape char(s). 962234285Sdim */ 963234285Sdim State = ASL_ESCAPE_SEQUENCE; 964234285Sdim continue; 965234285Sdim 966234285Sdim case '\"': 967234285Sdim 968234285Sdim /* String terminator */ 969234285Sdim 970234285Sdim goto CompletedString; 971234285Sdim } 972234285Sdim break; 973251662Sdim 974251662Sdim 975251662Sdim case ASL_ESCAPE_SEQUENCE: 976251662Sdim 977251662Sdim State = ASL_NORMAL_CHAR; 978251662Sdim switch (StringChar) 979234285Sdim { 980234285Sdim case 'a': 981234285Sdim StringChar = 0x07; /* BELL */ 982234285Sdim break; 983234285Sdim 984234285Sdim case 'b': 985251662Sdim StringChar = 0x08; /* BACKSPACE */ 986251662Sdim break; 987251662Sdim 988251662Sdim case 'f': 989251662Sdim StringChar = 0x0C; /* FORMFEED */ 990251662Sdim break; 991251662Sdim 992251662Sdim case 'n': 993251662Sdim StringChar = 0x0A; /* LINEFEED */ 994251662Sdim break; 995251662Sdim 996251662Sdim case 'r': 997251662Sdim StringChar = 0x0D; /* CARRIAGE RETURN*/ 998251662Sdim break; 999251662Sdim 1000251662Sdim case 't': 1001251662Sdim StringChar = 0x09; /* HORIZONTAL TAB */ 1002251662Sdim break; 1003251662Sdim 1004251662Sdim case 'v': 1005251662Sdim StringChar = 0x0B; /* VERTICAL TAB */ 1006251662Sdim break; 1007251662Sdim 1008249423Sdim case 'x': 1009249423Sdim State = ASL_HEX_CONSTANT; 1010249423Sdim i = 0; 1011249423Sdim continue; 1012249423Sdim 1013249423Sdim case '\'': /* Single Quote */ 1014249423Sdim case '\"': /* Double Quote */ 1015251662Sdim case '\\': /* Backslash */ 1016251662Sdim break; 1017251662Sdim 1018251662Sdim default: 1019251662Sdim 1020251662Sdim /* Check for an octal digit (0-7) */ 1021251662Sdim 1022263508Sdim if (ACPI_IS_OCTAL_DIGIT (StringChar)) 1023263508Sdim { 1024263508Sdim State = ASL_OCTAL_CONSTANT; 1025263508Sdim ConvertBuffer[0] = StringChar; 1026263508Sdim i = 1; 1027263508Sdim continue; 1028263508Sdim } 1029263508Sdim 1030263508Sdim /* Unknown escape sequence issue warning, but use the character */ 1031263508Sdim 1032234285Sdim AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE, 1033234285Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1034234285Sdim Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1035234285Sdim Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1036234285Sdim break; 1037234285Sdim } 1038234285Sdim break; 1039239462Sdim 1040234285Sdim 1041234285Sdim case ASL_OCTAL_CONSTANT: 1042234285Sdim 1043234285Sdim /* Up to three octal digits allowed */ 1044234285Sdim 1045234285Sdim if (!ACPI_IS_OCTAL_DIGIT (StringChar) || 1046234285Sdim (i > 2)) 1047234285Sdim { 1048234285Sdim /* 1049234285Sdim * Reached end of the constant. Convert the assembled ASCII 1050234285Sdim * string and resume processing of the next character 1051234285Sdim */ 1052234285Sdim ConvertBuffer[i] = 0; 1053234285Sdim Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8); 1054234285Sdim 1055234285Sdim /* Check for NULL or non-ascii character (ignore if so) */ 1056234285Sdim 1057234285Sdim if ((Digit == 0) || (Digit > ACPI_ASCII_MAX)) 1058234285Sdim { 1059234285Sdim AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING, 1060234285Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1061234285Sdim Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1062234285Sdim Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1063234285Sdim } 1064234285Sdim else 1065234285Sdim { 1066234285Sdim *StringBuffer = (char) Digit; 1067234285Sdim StringBuffer++; 1068234285Sdim if (StringBuffer >= EndBuffer) 1069234285Sdim { 1070234285Sdim goto BufferOverflow; 1071234285Sdim } 1072234285Sdim } 1073234285Sdim 1074234285Sdim State = ASL_NORMAL_CHAR; 1075234285Sdim goto DoCharacter; 1076234285Sdim break; 1077234285Sdim } 1078234285Sdim 1079234285Sdim /* Append another digit of the constant */ 1080234285Sdim 1081239462Sdim ConvertBuffer[i] = StringChar; 1082234285Sdim i++; 1083234285Sdim continue; 1084234285Sdim 1085234285Sdim 1086234285Sdim case ASL_HEX_CONSTANT: 1087234285Sdim 1088234285Sdim /* Up to two hex digits allowed */ 1089234285Sdim 1090234285Sdim if (!ACPI_IS_XDIGIT (StringChar) || 1091234285Sdim (i > 1)) 1092234285Sdim { 1093234285Sdim /* 1094234285Sdim * Reached end of the constant. Convert the assembled ASCII 1095234285Sdim * string and resume processing of the next character 1096234285Sdim */ 1097234285Sdim ConvertBuffer[i] = 0; 1098234285Sdim Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16); 1099234285Sdim 1100249423Sdim /* Check for NULL or non-ascii character (ignore if so) */ 1101249423Sdim 1102249423Sdim if ((Digit == 0) || (Digit > ACPI_ASCII_MAX)) 1103249423Sdim { 1104234285Sdim AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING, 1105234285Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1106234285Sdim Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1107234285Sdim Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1108249423Sdim } 1109239462Sdim else 1110249423Sdim { 1111234285Sdim *StringBuffer = (char) Digit; 1112239462Sdim StringBuffer++; 1113234285Sdim if (StringBuffer >= EndBuffer) 1114234285Sdim { 1115234285Sdim goto BufferOverflow; 1116234285Sdim } 1117249423Sdim } 1118239462Sdim 1119234285Sdim State = ASL_NORMAL_CHAR; 1120249423Sdim goto DoCharacter; 1121239462Sdim break; 1122234285Sdim } 1123234285Sdim 1124234285Sdim /* Append another digit of the constant */ 1125234285Sdim 1126234285Sdim ConvertBuffer[i] = StringChar; 1127234285Sdim i++; 1128234285Sdim continue; 1129234285Sdim } 1130234285Sdim 1131234285Sdim /* Save the finished character */ 1132234285Sdim 1133234285Sdim *StringBuffer = StringChar; 1134234285Sdim StringBuffer++; 1135234285Sdim if (StringBuffer >= EndBuffer) 1136234285Sdim { 1137234285Sdim goto BufferOverflow; 1138234285Sdim } 1139234285Sdim } 1140234285Sdim 1141234285Sdim /* 1142249423Sdim * Premature End-Of-File 1143249423Sdim */ 1144249423Sdim AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF, 1145249423Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1146249423Sdim Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1147249423Sdim Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1148234285Sdim return (FALSE); 1149234285Sdim 1150249423Sdim 1151249423SdimCompletedString: 1152249423Sdim /* 1153249423Sdim * Null terminate the input string and copy string to a new buffer 1154249423Sdim */ 1155249423Sdim *StringBuffer = 0; 1156234285Sdim 1157234285Sdim CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1); 1158249423Sdim if (!CleanString) 1159249423Sdim { 1160249423Sdim AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION, 1161249423Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1162249423Sdim Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1163249423Sdim Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1164234285Sdim return (FALSE); 1165234285Sdim } 1166234285Sdim 1167234285Sdim ACPI_STRCPY (CleanString, MsgBuffer); 1168234285Sdim AslCompilerlval.s = CleanString; 1169234285Sdim return (TRUE); 1170234285Sdim 1171234285Sdim 1172249423SdimBufferOverflow: 1173249423Sdim 1174249423Sdim /* Literal was too long */ 1175234285Sdim 1176234285Sdim AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH, 1177234285Sdim Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1178234285Sdim Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1179234285Sdim Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096"); 1180234285Sdim return (FALSE); 1181234285Sdim} 1182234285Sdim 1183234285Sdim 1184234285Sdim