aslcompiler.l revision 1.1
1 2 %{ 3 /****************************************************************************** 4 * 5 * Module Name: aslcompiler.l - Flex input file 6 * 7 *****************************************************************************/ 8 9 /****************************************************************************** 10 * 11 * 1. Copyright Notice 12 * 13 * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. 14 * All rights reserved. 15 * 16 * 2. License 17 * 18 * 2.1. This is your license from Intel Corp. under its intellectual property 19 * rights. You may have additional license terms from the party that provided 20 * you this software, covering your right to use that party's intellectual 21 * property rights. 22 * 23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 24 * copy of the source code appearing in this file ("Covered Code") an 25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 26 * base code distributed originally by Intel ("Original Intel Code") to copy, 27 * make derivatives, distribute, use and display any portion of the Covered 28 * Code in any form, with the right to sublicense such rights; and 29 * 30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 31 * license (with the right to sublicense), under only those claims of Intel 32 * patents that are infringed by the Original Intel Code, to make, use, sell, 33 * offer to sell, and import the Covered Code and derivative works thereof 34 * solely to the minimum extent necessary to exercise the above copyright 35 * license, and in no event shall the patent license extend to any additions 36 * to or modifications of the Original Intel Code. No other license or right 37 * is granted directly or by implication, estoppel or otherwise; 38 * 39 * The above copyright and patent license is granted only if the following 40 * conditions are met: 41 * 42 * 3. Conditions 43 * 44 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 45 * Redistribution of source code of any substantial portion of the Covered 46 * Code or modification with rights to further distribute source must include 47 * the above Copyright Notice, the above License, this list of Conditions, 48 * and the following Disclaimer and Export Compliance provision. In addition, 49 * Licensee must cause all Covered Code to which Licensee contributes to 50 * contain a file documenting the changes Licensee made to create that Covered 51 * Code and the date of any change. Licensee must include in that file the 52 * documentation of any changes made by any predecessor Licensee. Licensee 53 * must include a prominent statement that the modification is derived, 54 * directly or indirectly, from Original Intel Code. 55 * 56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 57 * Redistribution of source code of any substantial portion of the Covered 58 * Code or modification without rights to further distribute source must 59 * include the following Disclaimer and Export Compliance provision in the 60 * documentation and/or other materials provided with distribution. In 61 * addition, Licensee may not authorize further sublicense of source of any 62 * portion of the Covered Code, and must include terms to the effect that the 63 * license from Licensee to its licensee is limited to the intellectual 64 * property embodied in the software Licensee provides to its licensee, and 65 * not to intellectual property embodied in modifications its licensee may 66 * make. 67 * 68 * 3.3. Redistribution of Executable. Redistribution in executable form of any 69 * substantial portion of the Covered Code or modification must reproduce the 70 * above Copyright Notice, and the following Disclaimer and Export Compliance 71 * provision in the documentation and/or other materials provided with the 72 * distribution. 73 * 74 * 3.4. Intel retains all right, title, and interest in and to the Original 75 * Intel Code. 76 * 77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 78 * Intel shall be used in advertising or otherwise to promote the sale, use or 79 * other dealings in products derived from or relating to the Covered Code 80 * without prior written authorization from Intel. 81 * 82 * 4. Disclaimer and Export Compliance 83 * 84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 85 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 87 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 88 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 90 * PARTICULAR PURPOSE. 91 * 92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 99 * LIMITED REMEDY. 100 * 101 * 4.3. Licensee shall not export, either directly or indirectly, any of this 102 * software or system incorporating such software without first obtaining any 103 * required license or other approval from the U. S. Department of Commerce or 104 * any other agency or department of the United States Government. In the 105 * event Licensee exports any such software from the United States or 106 * re-exports any such software from a foreign destination, Licensee shall 107 * ensure that the distribution and export/re-export of the software is in 108 * compliance with all laws, regulations, orders, or other restrictions of the 109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 110 * any of its subsidiaries will export/re-export any technical data, process, 111 * software, or service, directly or indirectly, to any country for which the 112 * United States government or any agency thereof requires an export license, 113 * other governmental approval, or letter of assurance, without first obtaining 114 * such license, approval or letter. 115 * 116 *****************************************************************************/ 117 118 119 #include <stdlib.h> 120 #include <string.h> 121 #include "aslcompiler.h" 122 #include "aslcompiler.y.h" 123 YYSTYPE AslCompilerlval; 124 125 /* 126 * Generation: Use the following command line: 127 * 128 * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath) 129 * 130 * -i: Scanner must be case-insensitive 131 */ 132 133 #define _COMPONENT ACPI_COMPILER 134 ACPI_MODULE_NAME ("aslscan") 135 char 136 comment (void); 137 char 138 comment2 (void); 139 void 140 count (int type); 141 char 142 literal (void); 143 void 144 copy (void); 145 146 /*! [Begin] no source code translation */ 147 148 %} 149 150 151 LeadNameChar [A-Za-z_] 152 DigitChar [0-9] 153 HexDigitChar [A-Fa-f0-9] 154 RootChar [\\] 155 Nothing [] 156 157 NameChar [A-Za-z_0-9] 158 NameSeg1 {LeadNameChar}{NameChar} 159 NameSeg2 {LeadNameChar}{NameChar}{NameChar} 160 NameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar} 161 NameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3} 162 163 NameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath} 164 NamePath {NonEmptyNamePath}? 165 NonEmptyNamePath {NameSeg}{NamePathTail}* 166 NamePathTail [.]{NameSeg} 167 168 %% 169 170 [ ] { count (0); } 171 [\n] { count (0); } /* Handle files with both LF and CR/LF */ 172 [\r] { count (0); } /* termination on both Unix and Windows */ 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 182 0[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 "IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); } 390 391 "FFixedHW" { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); } 392 393 "SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 394 "SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 395 "SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 396 "SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 397 "SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 398 "SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 399 "SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 400 401 "MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); } 402 "MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); } 403 "MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); } 404 "MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); } 405 "MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); } 406 "MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); } 407 408 "Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); } 409 "TypeA" { count (0); return (PARSEOP_DMATYPE_A); } 410 "TypeB" { count (0); return (PARSEOP_DMATYPE_B); } 411 "TypeF" { count (0); return (PARSEOP_DMATYPE_F); } 412 413 "BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); } 414 "NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); } 415 416 "Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); } 417 "Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); } 418 "Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); } 419 420 "ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); } 421 "ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); } 422 423 "MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); } 424 "MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); } 425 426 "MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); } 427 "MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); } 428 429 "PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); } 430 "SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); } 431 432 "ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); } 433 "NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); } 434 "EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); } 435 436 "Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); } 437 "WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); } 438 "Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); } 439 "NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); } 440 441 "ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); } 442 "ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); } 443 444 "Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); } 445 "Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); } 446 447 "ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); } 448 "ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); } 449 450 "Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); } 451 "Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); } 452 453 "Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); } 454 "Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); } 455 456 "TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); } 457 "TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); } 458 459 "SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); } 460 "DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); } 461 462 "AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); } 463 "AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); } 464 "AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); } 465 "AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); } 466 467 468 "{" { count (0); return('{'); } 469 "}" { count (0); return('}'); } 470 "," { count (0); return(','); } 471 "(" { count (0); return('('); } 472 ")" { count (0); return(')'); } 473 474 475 {NameSeg} { char *s; 476 count (0); 477 s=malloc (ACPI_NAME_SIZE + 1); 478 if (strcmp (AslCompilertext, "\\")) 479 { 480 strcpy (s, "____"); 481 AcpiUtStrupr (AslCompilertext); 482 } 483 memcpy (s, AslCompilertext, strlen (AslCompilertext)); 484 AslCompilerlval.s = s; 485 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s); 486 return (PARSEOP_NAMESEG); } 487 488 {NameString} { char *s; 489 count (0); 490 s=malloc (strlen (AslCompilertext)+1); 491 AcpiUtStrupr (AslCompilertext); 492 strcpy (s, AslCompilertext); 493 s[strlen (AslCompilertext)] = 0; 494 AslCompilerlval.s = s; 495 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s); 496 return (PARSEOP_NAMESTRING); } 497 498 "*" | 499 "/" { count (1); 500 AslCompilererror ("Parse error, expecting ASL keyword or name");} 501 502 . { count (1); 503 sprintf (MsgBuffer, 504 "Invalid character (0x%2.2X), expecting ASL keyword or name", 505 *AslCompilertext); 506 AslCompilererror (MsgBuffer);} 507 508 <<EOF>> { if (AslPopInputFileStack ()) 509 yyterminate(); 510 else 511 return (PARSEOP_INCLUDE_END);}; 512 513 %% 514 515 /*! [End] no source code translation !*/ 516 517 typedef struct asl_file_node 518 { 519 FILE *File; 520 UINT32 CurrentLineNumber; 521 YY_BUFFER_STATE State; 522 char *Filename; 523 struct asl_file_node *Next; 524 525 } ASL_FILE_NODE; 526 527 ASL_FILE_NODE *InputStack = NULL; 528 529 530 /******************************************************************************* 531 * 532 * FUNCTION: AslPopInputFileStack 533 * 534 * PARAMETERS: None 535 * 536 * RETURN: 0 if a node was popped, -1 otherwise 537 * 538 * DESCRIPTION: Pop the top of the input file stack and point the parser to 539 * the saved parse buffer contained in the fnode. Also, set the 540 * global line counters to the saved values. This function is 541 * called when an include file reaches EOF. 542 * 543 ******************************************************************************/ 544 545 int 546 AslPopInputFileStack ( 547 void) 548 { 549 ASL_FILE_NODE *Fnode; 550 FILE *InputFile = NULL; 551 552 553 Fnode = InputStack; 554 DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode); 555 556 557 if (!Fnode) 558 { 559 return -1; 560 } 561 562 /* Close the current include file */ 563 564 fclose (yyin); 565 566 /* Update the top-of-stack */ 567 568 InputStack = Fnode->Next; 569 InputFile = Fnode->File; 570 571 /* Reset global line counter and filename */ 572 573 Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename; 574 Gbl_CurrentLineNumber = Fnode->CurrentLineNumber; 575 576 /* Point the parser to the popped file */ 577 578 yy_delete_buffer (YY_CURRENT_BUFFER); 579 yy_switch_to_buffer (Fnode->State); 580 581 /* All done with this node */ 582 583 ACPI_FREE (Fnode); 584 return 0; 585 } 586 587 588 /******************************************************************************* 589 * 590 * FUNCTION: AslPushInputFileStack 591 * 592 * PARAMETERS: InputFile - Open file pointer 593 * Filename - Name of the file 594 * 595 * RETURN: None 596 * 597 * DESCRIPTION: Push the InputFile onto the file stack, and point the parser 598 * to this file. Called when an include file is successfully 599 * opened. 600 * 601 ******************************************************************************/ 602 603 void 604 AslPushInputFileStack ( 605 FILE *InputFile, 606 char *Filename) 607 { 608 ASL_FILE_NODE *Fnode; 609 YY_BUFFER_STATE State; 610 611 612 /* Save the current state in an Fnode */ 613 614 Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE)); 615 616 Fnode->File = yyin; 617 Fnode->Next = InputStack; 618 Fnode->State = YY_CURRENT_BUFFER; 619 Fnode->CurrentLineNumber = Gbl_CurrentLineNumber; 620 Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename; 621 622 /* Push it on the stack */ 623 624 InputStack = Fnode; 625 626 /* Point the parser to this file */ 627 628 State = yy_create_buffer (InputFile, YY_BUF_SIZE); 629 yy_switch_to_buffer (State); 630 631 DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile); 632 633 /* Reset the global line count and filename */ 634 635 Gbl_Files[ASL_FILE_INPUT].Filename = Filename; 636 Gbl_CurrentLineNumber = 1; 637 yyin = InputFile; 638 } 639 640 641 /******************************************************************************* 642 * 643 * FUNCTION: ResetCurrentLineBuffer 644 * 645 * PARAMETERS: None 646 * 647 * RETURN: None 648 * 649 * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers. 650 * 651 ******************************************************************************/ 652 653 void 654 ResetCurrentLineBuffer ( 655 void) 656 { 657 658 if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle) 659 { 660 FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer, 661 Gbl_LineBufPtr - Gbl_CurrentLineBuffer); 662 } 663 664 Gbl_CurrentLineOffset += Gbl_CurrentColumn; 665 Gbl_CurrentColumn = 0; 666 667 Gbl_CurrentLineNumber++; 668 Gbl_LogicalLineNumber++; 669 Gbl_LineBufPtr = Gbl_CurrentLineBuffer; 670 } 671 672 673 /******************************************************************************* 674 * 675 * FUNCTION: InsertLineBuffer 676 * 677 * PARAMETERS: SourceChar - One char from the input ASL source file 678 * 679 * RETURN: None 680 * 681 * DESCRIPTION: Put one character of the source file into the temp line buffer 682 * 683 ******************************************************************************/ 684 685 #define ASL_SPACES_PER_TAB 4 686 687 void 688 InsertLineBuffer ( 689 int SourceChar) 690 { 691 UINT32 i; 692 UINT32 Count = 1; 693 694 695 if (SourceChar == EOF) 696 { 697 return; 698 } 699 700 Gbl_InputByteCount++; 701 702 /* Handle tabs. Convert to spaces */ 703 704 if (SourceChar == '\t') 705 { 706 SourceChar = ' '; 707 Count = ASL_SPACES_PER_TAB - 708 (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1)); 709 } 710 711 712 for (i = 0; i < Count; i++) 713 { 714 Gbl_CurrentColumn++; 715 716 /* Insert the character into the line buffer */ 717 718 *Gbl_LineBufPtr = (UINT8) SourceChar; 719 Gbl_LineBufPtr++; 720 721 if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1))) 722 { 723 #if 0 724 /* 725 * Warning if we have split a long source line. 726 * <Probably overkill> 727 */ 728 sprintf (MsgBuffer, "Max %u", ASL_LINE_BUFFER_SIZE); 729 AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE, 730 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 731 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 732 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer); 733 #endif 734 735 ResetCurrentLineBuffer (); 736 } 737 else if (SourceChar == '\n') 738 { 739 /* End of line */ 740 741 ResetCurrentLineBuffer (); 742 } 743 } 744 } 745 746 747 /******************************************************************************* 748 * 749 * FUNCTION: count 750 * 751 * PARAMETERS: yytext - Contains the matched keyword. 752 * Type - Keyword/Character type: 753 * 0 = anything except a keyword 754 * 1 = pseudo-keywords 755 * 2 = non-executable ASL keywords 756 * 3 = executable ASL keywords 757 * 758 * RETURN: None 759 * 760 * DESCRIPTION: Count keywords and put them into the line buffer 761 * 762 ******************************************************************************/ 763 764 void 765 count ( 766 int Type) 767 { 768 int i; 769 770 771 switch (Type) 772 { 773 case 2: 774 TotalKeywords++; 775 TotalNamedObjects++; 776 break; 777 778 case 3: 779 TotalKeywords++; 780 TotalExecutableOpcodes++; 781 break; 782 } 783 784 for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++) 785 { 786 InsertLineBuffer (yytext[i]); 787 *Gbl_LineBufPtr = 0; 788 } 789 } 790 791 792 /******************************************************************************* 793 * 794 * FUNCTION: comment 795 * 796 * PARAMETERS: none 797 * 798 * RETURN: none 799 * 800 * DESCRIPTION: Process a standard comment. 801 * 802 ******************************************************************************/ 803 804 char 805 comment (void) 806 { 807 char c; 808 char c1 = 0; 809 810 811 InsertLineBuffer ('/'); 812 InsertLineBuffer ('*'); 813 814 loop: 815 816 /* Eat chars until end-of-comment */ 817 818 while ((c = (char) input()) != '*' && c != EOF) 819 { 820 InsertLineBuffer (c); 821 c1 = c; 822 } 823 824 if (c == EOF) 825 { 826 goto EarlyEOF; 827 } 828 829 /* 830 * Check for nested comment -- can help catch cases where a previous 831 * comment was accidently left unterminated 832 */ 833 if ((c1 == '/') && (c == '*')) 834 { 835 AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT, 836 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 837 Gbl_InputByteCount, Gbl_CurrentColumn, 838 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 839 } 840 841 /* Comment is closed only if the NEXT character is a slash */ 842 843 InsertLineBuffer (c); 844 845 if ((c1 = (char) input()) != '/' && c1 != EOF) 846 { 847 unput(c1); 848 goto loop; 849 } 850 851 if (c1 == EOF) 852 { 853 goto EarlyEOF; 854 } 855 856 InsertLineBuffer (c1); 857 return TRUE; 858 859 860 EarlyEOF: 861 /* 862 * Premature End-Of-File 863 */ 864 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF, 865 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 866 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 867 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 868 return (FALSE); 869 } 870 871 872 /******************************************************************************* 873 * 874 * FUNCTION: comment 875 * 876 * PARAMETERS: none 877 * 878 * RETURN: none 879 * 880 * DESCRIPTION: Process a new "//" comment. 881 * 882 ******************************************************************************/ 883 884 char 885 comment2 (void) 886 { 887 char c; 888 889 890 InsertLineBuffer ('/'); 891 InsertLineBuffer ('/'); 892 893 while ((c = (char) input()) != '\n' && c != EOF) 894 { 895 InsertLineBuffer (c); 896 } 897 898 if (c == EOF) 899 { 900 /* End of file is OK, change to newline. Let parser detect EOF later */ 901 902 c = '\n'; 903 } 904 905 InsertLineBuffer (c); 906 return (TRUE); 907 } 908 909 910 /******************************************************************************* 911 * 912 * FUNCTION: literal 913 * 914 * PARAMETERS: none 915 * 916 * RETURN: none 917 * 918 * DESCRIPTION: Process a string literal (surrounded by quotes) 919 * 920 ******************************************************************************/ 921 922 #define ASL_NORMAL_CHAR 0 923 #define ASL_ESCAPE_SEQUENCE 1 924 #define ASL_OCTAL_CONSTANT 2 925 #define ASL_HEX_CONSTANT 3 926 927 char 928 literal (void) 929 { 930 char *StringBuffer = MsgBuffer; 931 char *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE; 932 char *CleanString; 933 char StringChar; 934 UINT32 State = ASL_NORMAL_CHAR; 935 UINT32 i = 0; 936 UINT8 Digit; 937 char ConvertBuffer[4]; 938 939 940 /* 941 * Eat chars until end-of-literal. 942 * NOTE: Put back the original surrounding quotes into the 943 * source line buffer. 944 */ 945 InsertLineBuffer ('\"'); 946 while ((StringChar = (char) input()) != EOF) 947 { 948 InsertLineBuffer (StringChar); 949 950 DoCharacter: 951 952 switch (State) 953 { 954 case ASL_NORMAL_CHAR: 955 956 switch (StringChar) 957 { 958 case '\\': 959 /* 960 * Special handling for backslash-escape sequence. We will 961 * toss the backslash and translate the escape char(s). 962 */ 963 State = ASL_ESCAPE_SEQUENCE; 964 continue; 965 966 case '\"': 967 968 /* String terminator */ 969 970 goto CompletedString; 971 } 972 break; 973 974 975 case ASL_ESCAPE_SEQUENCE: 976 977 State = ASL_NORMAL_CHAR; 978 switch (StringChar) 979 { 980 case 'a': 981 StringChar = 0x07; /* BELL */ 982 break; 983 984 case 'b': 985 StringChar = 0x08; /* BACKSPACE */ 986 break; 987 988 case 'f': 989 StringChar = 0x0C; /* FORMFEED */ 990 break; 991 992 case 'n': 993 StringChar = 0x0A; /* LINEFEED */ 994 break; 995 996 case 'r': 997 StringChar = 0x0D; /* CARRIAGE RETURN*/ 998 break; 999 1000 case 't': 1001 StringChar = 0x09; /* HORIZONTAL TAB */ 1002 break; 1003 1004 case 'v': 1005 StringChar = 0x0B; /* VERTICAL TAB */ 1006 break; 1007 1008 case 'x': 1009 State = ASL_HEX_CONSTANT; 1010 i = 0; 1011 continue; 1012 1013 case '\'': /* Single Quote */ 1014 case '\"': /* Double Quote */ 1015 case '\\': /* Backslash */ 1016 break; 1017 1018 default: 1019 1020 /* Check for an octal digit (0-7) */ 1021 1022 if (ACPI_IS_OCTAL_DIGIT (StringChar)) 1023 { 1024 State = ASL_OCTAL_CONSTANT; 1025 ConvertBuffer[0] = StringChar; 1026 i = 1; 1027 continue; 1028 } 1029 1030 /* Unknown escape sequence issue warning, but use the character */ 1031 1032 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE, 1033 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1034 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1035 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1036 break; 1037 } 1038 break; 1039 1040 1041 case ASL_OCTAL_CONSTANT: 1042 1043 /* Up to three octal digits allowed */ 1044 1045 if (!ACPI_IS_OCTAL_DIGIT (StringChar) || 1046 (i > 2)) 1047 { 1048 /* 1049 * Reached end of the constant. Convert the assembled ASCII 1050 * string and resume processing of the next character 1051 */ 1052 ConvertBuffer[i] = 0; 1053 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8); 1054 1055 /* Check for NULL or non-ascii character (ignore if so) */ 1056 1057 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX)) 1058 { 1059 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING, 1060 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1061 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1062 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1063 } 1064 else 1065 { 1066 *StringBuffer = (char) Digit; 1067 StringBuffer++; 1068 if (StringBuffer >= EndBuffer) 1069 { 1070 goto BufferOverflow; 1071 } 1072 } 1073 1074 State = ASL_NORMAL_CHAR; 1075 goto DoCharacter; 1076 break; 1077 } 1078 1079 /* Append another digit of the constant */ 1080 1081 ConvertBuffer[i] = StringChar; 1082 i++; 1083 continue; 1084 1085 1086 case ASL_HEX_CONSTANT: 1087 1088 /* Up to two hex digits allowed */ 1089 1090 if (!ACPI_IS_XDIGIT (StringChar) || 1091 (i > 1)) 1092 { 1093 /* 1094 * Reached end of the constant. Convert the assembled ASCII 1095 * string and resume processing of the next character 1096 */ 1097 ConvertBuffer[i] = 0; 1098 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16); 1099 1100 /* Check for NULL or non-ascii character (ignore if so) */ 1101 1102 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX)) 1103 { 1104 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING, 1105 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1106 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1107 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1108 } 1109 else 1110 { 1111 *StringBuffer = (char) Digit; 1112 StringBuffer++; 1113 if (StringBuffer >= EndBuffer) 1114 { 1115 goto BufferOverflow; 1116 } 1117 } 1118 1119 State = ASL_NORMAL_CHAR; 1120 goto DoCharacter; 1121 break; 1122 } 1123 1124 /* Append another digit of the constant */ 1125 1126 ConvertBuffer[i] = StringChar; 1127 i++; 1128 continue; 1129 } 1130 1131 /* Save the finished character */ 1132 1133 *StringBuffer = StringChar; 1134 StringBuffer++; 1135 if (StringBuffer >= EndBuffer) 1136 { 1137 goto BufferOverflow; 1138 } 1139 } 1140 1141 /* 1142 * Premature End-Of-File 1143 */ 1144 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF, 1145 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1146 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1147 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1148 return (FALSE); 1149 1150 1151 CompletedString: 1152 /* 1153 * Null terminate the input string and copy string to a new buffer 1154 */ 1155 *StringBuffer = 0; 1156 1157 CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1); 1158 if (!CleanString) 1159 { 1160 AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION, 1161 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1162 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1163 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1164 return (FALSE); 1165 } 1166 1167 ACPI_STRCPY (CleanString, MsgBuffer); 1168 AslCompilerlval.s = CleanString; 1169 return (TRUE); 1170 1171 1172 BufferOverflow: 1173 1174 /* Literal was too long */ 1175 1176 AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH, 1177 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1178 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1179 Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096"); 1180 return (FALSE); 1181 } 1182 1183 1184
Indexes created Sat Sep 27 22:09:54 GMT 2025