1 %{ 2 /****************************************************************************** 3 * 4 * Module Name: aslcompiler.l - Flex/lex input file 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2012, Intel Corp. 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions, and the following disclaimer, 17 * without modification. 18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 19 * substantially similar to the "NO WARRANTY" disclaimer below 20 * ("Disclaimer") and any redistribution must be conditioned upon 21 * including a substantially similar Disclaimer requirement for further 22 * binary redistribution. 23 * 3. Neither the names of the above-listed copyright holders nor the names 24 * of any contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * Alternatively, this software may be distributed under the terms of the 28 * GNU General Public License ("GPL") version 2 as published by the Free 29 * Software Foundation. 30 * 31 * NO WARRANTY 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 42 * POSSIBILITY OF SUCH DAMAGES. 43 */ 44 45 #include <contrib/dev/acpica/compiler/aslcompiler.h> 46 #include "aslcompiler.y.h" 47 48 #include <stdlib.h> 49 #include <string.h> 50 YYSTYPE AslCompilerlval; 51 52 /* 53 * Generation: Use the following command line: 54 * 55 * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath) 56 * 57 * -i: Scanner must be case-insensitive 58 */ 59 60 #define _COMPONENT ACPI_COMPILER 61 ACPI_MODULE_NAME ("aslscan") 62 63 /* Local prototypes */ 64 65 char 66 comment (void); 67 char 68 comment2 (void); 69 void 70 count (int type); 71 char 72 literal (void); 73 void 74 copy (void); 75 76 /*! [Begin] no source code translation */ 77 78 %} 79 /* Definitions */ 80 81 LeadNameChar [A-Za-z_] 82 DigitChar [0-9] 83 HexDigitChar [A-Fa-f0-9] 84 RootChar [\\] 85 Nothing [] 86 87 NameChar [A-Za-z_0-9] 88 NameSeg1 {LeadNameChar}{NameChar} 89 NameSeg2 {LeadNameChar}{NameChar}{NameChar} 90 NameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar} 91 NameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3} 92 93 NameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath} 94 NamePath {NonEmptyNamePath}? 95 NonEmptyNamePath {NameSeg}{NamePathTail}* 96 NamePathTail [.]{NameSeg} 97 98 %% 99 /* Rules */ 100 101 [ ] { count (0); } 102 [\n] { count (0); } /* Handle files with both LF and CR/LF */ 103 [\r] { count (0); } /* termination on both Unix and Windows */ 104 [ \t] { count (0); } 105 106 107 "/*" { if (!comment ()) yyterminate (); } 108 "//" { if (!comment2 ()) yyterminate (); } 109 110 "\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); } 111 ";" { count (0); return(';'); } 112 113 114 0[xX]{HexDigitChar}+ | 115 {DigitChar}+ { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext); 116 count (1); return (PARSEOP_INTEGER); } 117 118 "Include" { count (1); return (PARSEOP_INCLUDE); } 119 "#include" { count (1); return (PARSEOP_INCLUDE_CSTYLE); } 120 "#line" { count (1); return (PARSEOP_LINE_CSTYLE); } 121 "External" { count (1); return (PARSEOP_EXTERNAL); } 122 123 /**************************************************************************** 124 * 125 * Main ASL operators 126 * 127 ****************************************************************************/ 128 129 "AccessAs" { count (1); return (PARSEOP_ACCESSAS); } 130 "Acquire" { count (3); return (PARSEOP_ACQUIRE); } 131 "Add" { count (3); return (PARSEOP_ADD); } 132 "Alias" { count (2); return (PARSEOP_ALIAS); } 133 "And" { count (3); return (PARSEOP_AND); } 134 "BankField" { count (2); return (PARSEOP_BANKFIELD); } 135 "Break" { count (3); return (PARSEOP_BREAK); } 136 "BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); } 137 "Buffer" { count (1); return (PARSEOP_BUFFER); } 138 "Case" { count (3); return (PARSEOP_CASE); } 139 "Concatenate" { count (3); return (PARSEOP_CONCATENATE); } 140 "ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); } 141 "CondRefOf" { count (3); return (PARSEOP_CONDREFOF); } 142 "Connection" { count (2); return (PARSEOP_CONNECTION); } 143 "Continue" { count (3); return (PARSEOP_CONTINUE); } 144 "CopyObject" { count (3); return (PARSEOP_COPYOBJECT); } 145 "CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); } 146 "CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); } 147 "CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); } 148 "CreateField" { count (2); return (PARSEOP_CREATEFIELD); } 149 "CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); } 150 "CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); } 151 "DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); } 152 "Debug" { count (1); return (PARSEOP_DEBUG); } 153 "Decrement" { count (3); return (PARSEOP_DECREMENT); } 154 "Default" { count (3); return (PARSEOP_DEFAULT); } 155 "DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); } 156 "DeRefOf" { count (3); return (PARSEOP_DEREFOF); } 157 "Device" { count (2); return (PARSEOP_DEVICE); } 158 "Divide" { count (3); return (PARSEOP_DIVIDE); } 159 "Eisaid" { count (1); return (PARSEOP_EISAID); } 160 "Else" { count (3); return (PARSEOP_ELSE); } 161 "ElseIf" { count (3); return (PARSEOP_ELSEIF); } 162 "Event" { count (2); return (PARSEOP_EVENT); } 163 "Fatal" { count (3); return (PARSEOP_FATAL); } 164 "Field" { count (2); return (PARSEOP_FIELD); } 165 "FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); } 166 "FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); } 167 "FromBcd" { count (3); return (PARSEOP_FROMBCD); } 168 "Function" { count (2); return (PARSEOP_FUNCTION); } 169 "If" { count (3); return (PARSEOP_IF); } 170 "Increment" { count (3); return (PARSEOP_INCREMENT); } 171 "Index" { count (3); return (PARSEOP_INDEX); } 172 "IndexField" { count (2); return (PARSEOP_INDEXFIELD); } 173 "LAnd" { count (3); return (PARSEOP_LAND); } 174 "LEqual" { count (3); return (PARSEOP_LEQUAL); } 175 "LGreater" { count (3); return (PARSEOP_LGREATER); } 176 "LGreaterEqual" { count (3); return (PARSEOP_LGREATEREQUAL); } 177 "LLess" { count (3); return (PARSEOP_LLESS); } 178 "LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); } 179 "LNot" { count (3); return (PARSEOP_LNOT); } 180 "LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); } 181 "Load" { count (3); return (PARSEOP_LOAD); } 182 "LoadTable" { count (3); return (PARSEOP_LOADTABLE); } 183 "LOr" { count (3); return (PARSEOP_LOR); } 184 "Match" { count (3); return (PARSEOP_MATCH); } 185 "Method" { count (2); return (PARSEOP_METHOD); } 186 "Mid" { count (3); return (PARSEOP_MID); } 187 "Mod" { count (3); return (PARSEOP_MOD); } 188 "Multiply" { count (3); return (PARSEOP_MULTIPLY); } 189 "Mutex" { count (2); return (PARSEOP_MUTEX); } 190 "Name" { count (2); return (PARSEOP_NAME); } 191 "NAnd" { count (3); return (PARSEOP_NAND); } 192 "Noop" { count (3); return (PARSEOP_NOOP); } 193 "NOr" { count (3); return (PARSEOP_NOR); } 194 "Not" { count (3); return (PARSEOP_NOT); } 195 "Notify" { count (3); return (PARSEOP_NOTIFY); } 196 "ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); } 197 "Offset" { count (1); return (PARSEOP_OFFSET); } 198 "One" { count (1); return (PARSEOP_ONE); } 199 "Ones" { count (1); return (PARSEOP_ONES); } 200 "OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); } 201 "Or" { count (3); return (PARSEOP_OR); } 202 "Package" { count (1); return (PARSEOP_PACKAGE); } 203 "PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); } 204 "Processor" { count (2); return (PARSEOP_PROCESSOR); } 205 "RefOf" { count (3); return (PARSEOP_REFOF); } 206 "Release" { count (3); return (PARSEOP_RELEASE); } 207 "Reset" { count (3); return (PARSEOP_RESET); } 208 "Return" { count (3); return (PARSEOP_RETURN); } 209 "Revision" { count (1); return (PARSEOP_REVISION); } 210 "Scope" { count (2); return (PARSEOP_SCOPE); } 211 "ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); } 212 "ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); } 213 "Signal" { count (3); return (PARSEOP_SIGNAL); } 214 "SizeOf" { count (3); return (PARSEOP_SIZEOF); } 215 "Sleep" { count (3); return (PARSEOP_SLEEP); } 216 "Stall" { count (3); return (PARSEOP_STALL); } 217 "Store" { count (3); return (PARSEOP_STORE); } 218 "Subtract" { count (3); return (PARSEOP_SUBTRACT); } 219 "Switch" { count (3); return (PARSEOP_SWITCH); } 220 "ThermalZone" { count (2); return (PARSEOP_THERMALZONE); } 221 "Timer" { count (3); return (PARSEOP_TIMER); } 222 "ToBcd" { count (3); return (PARSEOP_TOBCD); } 223 "ToBuffer" { count (3); return (PARSEOP_TOBUFFER); } 224 "ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); } 225 "ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); } 226 "ToInteger" { count (3); return (PARSEOP_TOINTEGER); } 227 "ToString" { count (3); return (PARSEOP_TOSTRING); } 228 "ToUuid" { count (1); return (PARSEOP_TOUUID); } 229 "Unicode" { count (1); return (PARSEOP_UNICODE); } 230 "Unload" { count (3); return (PARSEOP_UNLOAD); } 231 "Wait" { count (3); return (PARSEOP_WAIT); } 232 "While" { count (3); return (PARSEOP_WHILE); } 233 "XOr" { count (3); return (PARSEOP_XOR); } 234 "Zero" { count (1); return (PARSEOP_ZERO); } 235 236 /* Control method arguments and locals */ 237 238 "Arg0" { count (1); return (PARSEOP_ARG0); } 239 "Arg1" { count (1); return (PARSEOP_ARG1); } 240 "Arg2" { count (1); return (PARSEOP_ARG2); } 241 "Arg3" { count (1); return (PARSEOP_ARG3); } 242 "Arg4" { count (1); return (PARSEOP_ARG4); } 243 "Arg5" { count (1); return (PARSEOP_ARG5); } 244 "Arg6" { count (1); return (PARSEOP_ARG6); } 245 "Local0" { count (1); return (PARSEOP_LOCAL0); } 246 "Local1" { count (1); return (PARSEOP_LOCAL1); } 247 "Local2" { count (1); return (PARSEOP_LOCAL2); } 248 "Local3" { count (1); return (PARSEOP_LOCAL3); } 249 "Local4" { count (1); return (PARSEOP_LOCAL4); } 250 "Local5" { count (1); return (PARSEOP_LOCAL5); } 251 "Local6" { count (1); return (PARSEOP_LOCAL6); } 252 "Local7" { count (1); return (PARSEOP_LOCAL7); } 253 254 255 /**************************************************************************** 256 * 257 * Resource Descriptor macros 258 * 259 ****************************************************************************/ 260 261 "ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); } 262 "RawDataBuffer" { count (1); return (PARSEOP_DATABUFFER); } 263 264 "DMA" { count (1); return (PARSEOP_DMA); } 265 "DWordIO" { count (1); return (PARSEOP_DWORDIO); } 266 "DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); } 267 "DWordSpace" { count (1); return (PARSEOP_DWORDSPACE); } 268 "EndDependentFn" { count (1); return (PARSEOP_ENDDEPENDENTFN); } 269 "ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); } 270 "ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); } 271 "ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); } 272 "FixedDma" { count (1); return (PARSEOP_FIXEDDMA); } 273 "FixedIO" { count (1); return (PARSEOP_FIXEDIO); } 274 "GpioInt" { count (1); return (PARSEOP_GPIO_INT); } 275 "GpioIo" { count (1); return (PARSEOP_GPIO_IO); } 276 "I2cSerialBus" { count (1); return (PARSEOP_I2C_SERIALBUS); } 277 "Interrupt" { count (1); return (PARSEOP_INTERRUPT); } 278 "IO" { count (1); return (PARSEOP_IO); } 279 "IRQ" { count (1); return (PARSEOP_IRQ); } 280 "IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); } 281 "Memory24" { count (1); return (PARSEOP_MEMORY24); } 282 "Memory32" { count (1); return (PARSEOP_MEMORY32); } 283 "Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); } 284 "QWordIO" { count (1); return (PARSEOP_QWORDIO); } 285 "QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); } 286 "QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); } 287 "Register" { count (1); return (PARSEOP_REGISTER); } 288 "SpiSerialBus" { count (1); return (PARSEOP_SPI_SERIALBUS); } 289 "StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); } 290 "StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); } 291 "UartSerialBus" { count (1); return (PARSEOP_UART_SERIALBUS); } 292 "VendorLong" { count (1); return (PARSEOP_VENDORLONG); } 293 "VendorShort" { count (1); return (PARSEOP_VENDORSHORT); } 294 "WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); } 295 "WordIO" { count (1); return (PARSEOP_WORDIO); } 296 "WordSpace" { count (1); return (PARSEOP_WORDSPACE); } 297 298 299 /**************************************************************************** 300 * 301 * Keywords used as arguments to ASL operators and macros 302 * 303 ****************************************************************************/ 304 305 /* AccessAttribKeyword: Serial Bus Attributes (ACPI 5.0) */ 306 307 "AttribQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 308 "AttribSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 309 "AttribByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 310 "AttribWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 311 "AttribBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 312 "AttribProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 313 "AttribBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 314 315 /* AccessAttribKeyword: Legacy synonyms for above (pre-ACPI 5.0) */ 316 317 "SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 318 "SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 319 "SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 320 "SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 321 "SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 322 "SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 323 "SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 324 325 /* AccessTypeKeyword: Field Access Types */ 326 327 "AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); } 328 "ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); } 329 "WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); } 330 "DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); } 331 "QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); } 332 "BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); } 333 334 /* AddressingModeKeyword: Mode - Resource Descriptors (ACPI 5.0) */ 335 336 "AddressingMode7Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_7BIT); } 337 "AddressingMode10Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_10BIT); } 338 339 /* AddressKeyword: ACPI memory range types */ 340 341 "AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); } 342 "AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); } 343 "AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); } 344 "AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); } 345 346 /* BusMasterKeyword: DMA Bus Mastering */ 347 348 "BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); } 349 "NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); } 350 351 /* ByteLengthKeyword: Bits per Byte - Resource Descriptors (ACPI 5.0) */ 352 353 "DataBitsFive" { count (0); return (PARSEOP_BITSPERBYTE_FIVE); } 354 "DataBitsSix" { count (0); return (PARSEOP_BITSPERBYTE_SIX); } 355 "DataBitsSeven" { count (0); return (PARSEOP_BITSPERBYTE_SEVEN); } 356 "DataBitsEight" { count (0); return (PARSEOP_BITSPERBYTE_EIGHT); } 357 "DataBitsNine" { count (0); return (PARSEOP_BITSPERBYTE_NINE); } 358 359 /* ClockPhaseKeyword: Resource Descriptors (ACPI 5.0) */ 360 361 "ClockPhaseFirst" { count (0); return (PARSEOP_CLOCKPHASE_FIRST); } 362 "ClockPhaseSecond" { count (0); return (PARSEOP_CLOCKPHASE_SECOND); } 363 364 /* ClockPolarityKeyword: Resource Descriptors (ACPI 5.0) */ 365 366 "ClockPolarityLow" { count (0); return (PARSEOP_CLOCKPOLARITY_LOW); } 367 "ClockPolarityHigh" { count (0); return (PARSEOP_CLOCKPOLARITY_HIGH); } 368 369 /* DecodeKeyword: Type of Memory Decoding - Resource Descriptors */ 370 371 "PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); } 372 "SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); } 373 374 /* DmaTypeKeyword: DMA Types - DMA Resource Descriptor */ 375 376 "Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); } 377 "TypeA" { count (0); return (PARSEOP_DMATYPE_A); } 378 "TypeB" { count (0); return (PARSEOP_DMATYPE_B); } 379 "TypeF" { count (0); return (PARSEOP_DMATYPE_F); } 380 381 /* EndianKeyword: Endian type - Resource Descriptor (ACPI 5.0) */ 382 383 "LittleEndian" { count (0); return (PARSEOP_ENDIAN_LITTLE); } 384 "BigEndian" { count (0); return (PARSEOP_ENDIAN_BIG); } 385 386 /* ExtendedAttribKeyword: Bus attributes, AccessAs operator (ACPI 5.0) */ 387 388 "AttribBytes" { count (0); return (PARSEOP_ACCESSATTRIB_MULTIBYTE); } 389 "AttribRawBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_BYTES); } 390 "AttribRawProcessBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_PROCESS); } 391 392 /* FlowControlKeyword: Resource Descriptors (ACPI 5.0) */ 393 394 "FlowControlHardware" { count (0); return (PARSEOP_FLOWCONTROL_HW); } 395 "FlowControlNone" { count (0); return (PARSEOP_FLOWCONTROL_NONE); } 396 "FlowControlXon" { count (0); return (PARSEOP_FLOWCONTROL_SW); } 397 398 /* InterruptLevelKeyword: Interrupt Active Types */ 399 400 "ActiveBoth" { count (0); return (PARSEOP_INTLEVEL_ACTIVEBOTH); } 401 "ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); } 402 "ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); } 403 404 /* InterruptTypeKeyword: Interrupt Types */ 405 406 "Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); } 407 "Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); } 408 409 /* IoDecodeKeyword: Type of Memory Decoding - Resource Descriptors */ 410 411 "Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); } 412 "Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); } 413 414 /* IoRestrictionKeyword: I/O Restriction - GPIO Resource Descriptors (ACPI 5.0) */ 415 416 "IoRestrictionNone" { count (0); return (PARSEOP_IORESTRICT_NONE); } 417 "IoRestrictionInputOnly" { count (0); return (PARSEOP_IORESTRICT_IN); } 418 "IoRestrictionOutputOnly" { count (0); return (PARSEOP_IORESTRICT_OUT); } 419 "IoRestrictionNoneAndPreserve" { count (0); return (PARSEOP_IORESTRICT_PRESERVE); } 420 421 /* LockRuleKeyword: Global Lock use for Field Operator */ 422 423 "Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); } 424 "NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); } 425 426 /* MatchOpKeyword: Types for Match Operator */ 427 428 "MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); } 429 "MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); } 430 "MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); } 431 "MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); } 432 "MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); } 433 "MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); } 434 435 /* MaxKeyword: Max Range Type - Resource Descriptors */ 436 437 "MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); } 438 "MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); } 439 440 /* MemTypeKeyword: Memory Types - Resource Descriptors */ 441 442 "Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); } 443 "WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); } 444 "Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); } 445 "NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); } 446 447 /* MinKeyword: Min Range Type - Resource Descriptors */ 448 449 "MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); } 450 "MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); } 451 452 /* ObjectTypeKeyword: ACPI Object Types */ 453 454 "UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); } 455 "IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); } 456 "StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); } 457 "BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); } 458 "PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); } 459 "FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); } 460 "DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); } 461 "EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); } 462 "MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); } 463 "MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); } 464 "OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); } 465 "PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); } 466 "ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); } 467 "ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); } 468 "BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); } 469 "DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); } 470 471 /* ParityKeyword: Resource Descriptors (ACPI 5.0) */ 472 473 "ParityTypeSpace" { count (0); return (PARSEOP_PARITYTYPE_SPACE); } 474 "ParityTypeMark" { count (0); return (PARSEOP_PARITYTYPE_MARK); } 475 "ParityTypeOdd" { count (0); return (PARSEOP_PARITYTYPE_ODD); } 476 "ParityTypeEven" { count (0); return (PARSEOP_PARITYTYPE_EVEN); } 477 "ParityTypeNone" { count (0); return (PARSEOP_PARITYTYPE_NONE); } 478 479 /* PinConfigKeyword: Pin Configuration - GPIO Resource Descriptors (ACPI 5.0) */ 480 481 "PullDefault" { count (0); return (PARSEOP_PIN_PULLDEFAULT); } 482 "PullUp" { count (0); return (PARSEOP_PIN_PULLUP); } 483 "PullDown" { count (0); return (PARSEOP_PIN_PULLDOWN); } 484 "PullNone" { count (0); return (PARSEOP_PIN_NOPULL); } 485 486 /* PolarityKeyword: Resource Descriptors (ACPI 5.0) */ 487 488 "PolarityLow" { count (0); return (PARSEOP_DEVICEPOLARITY_LOW); } 489 "PolarityHigh" { count (0); return (PARSEOP_DEVICEPOLARITY_HIGH); } 490 491 /* RangeTypeKeyword: I/O Range Types - Resource Descriptors */ 492 493 "ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); } 494 "NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); } 495 "EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); } 496 497 /* ReadWriteKeyword: Memory Access Types - Resource Descriptors */ 498 499 "ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); } 500 "ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); } 501 502 /* RegionSpaceKeyword: Operation Region Address Space Types */ 503 504 "SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); } 505 "SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); } 506 "PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); } 507 "EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); } 508 "SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); } 509 "SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); } 510 "PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); } 511 "IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); } 512 "GeneralPurposeIo" { count (0); return (PARSEOP_REGIONSPACE_GPIO); } /* ACPI 5.0 */ 513 "GenericSerialBus" { count (0); return (PARSEOP_REGIONSPACE_GSBUS); } /* ACPI 5.0 */ 514 "FFixedHW" { count (0); return (PARSEOP_REGIONSPACE_FFIXEDHW); } 515 516 /* ResourceTypeKeyword: Resource Usage - Resource Descriptors */ 517 518 "ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); } 519 "ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); } 520 521 /* SerializeRuleKeyword: Control Method Serialization */ 522 523 "Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); } 524 "NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); } 525 526 /* ShareTypeKeyword: Interrupt Sharing - Resource Descriptors */ 527 528 "Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); } 529 "Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); } 530 "SharedAndWake" { count (0); return (PARSEOP_SHARETYPE_SHAREDWAKE); } /* ACPI 5.0 */ 531 "ExclusiveAndWake" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVEWAKE); } /* ACPI 5.0 */ 532 533 /* SlaveModeKeyword: Resource Descriptors (ACPI 5.0) */ 534 535 "ControllerInitiated" { count (0); return (PARSEOP_SLAVEMODE_CONTROLLERINIT); } 536 "DeviceInitiated" { count (0); return (PARSEOP_SLAVEMODE_DEVICEINIT); } 537 538 /* StopBitsKeyword: Resource Descriptors (ACPI 5.0) */ 539 540 "StopBitsOne" { count (0); return (PARSEOP_STOPBITS_ONE); } 541 "StopBitsOnePlusHalf" { count (0); return (PARSEOP_STOPBITS_ONEPLUSHALF); } 542 "StopBitsTwo" { count (0); return (PARSEOP_STOPBITS_TWO); } 543 "StopBitsZero" { count (0); return (PARSEOP_STOPBITS_ZERO); } 544 545 /* TransferWidthKeyword: DMA Widths - Fixed DMA Resource Descriptor (ACPI 5.0) */ 546 547 "Width8bit" { count (0); return (PARSEOP_XFERSIZE_8); } 548 "Width16bit" { count (0); return (PARSEOP_XFERSIZE_16); } 549 "Width32bit" { count (0); return (PARSEOP_XFERSIZE_32); } 550 "Width64bit" { count (0); return (PARSEOP_XFERSIZE_64); } 551 "Width128bit" { count (0); return (PARSEOP_XFERSIZE_128); } 552 "Width256bit" { count (0); return (PARSEOP_XFERSIZE_256); } 553 554 /* TranslationKeyword: Translation Density Types - Resource Descriptors */ 555 556 "SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); } 557 "DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); } 558 559 /* TypeKeyword: Translation Types - Resource Descriptors */ 560 561 "TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); } 562 "TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); } 563 564 /* UpdateRuleKeyword: Field Update Rules */ 565 566 "Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); } 567 "WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); } 568 "WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); } 569 570 /* WireModeKeyword: SPI Wire Mode - Resource Descriptors (ACPI 5.0) */ 571 572 "FourWireMode" { count (0); return (PARSEOP_WIREMODE_FOUR); } 573 "ThreeWireMode" { count (0); return (PARSEOP_WIREMODE_THREE); } 574 575 /* XferTypeKeyword: DMA Transfer Types */ 576 577 "Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); } 578 "Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); } 579 "Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); } 580 581 /* Predefined compiler names */ 582 583 "__DATE__" { count (0); return (PARSEOP___DATE__); } 584 "__FILE__" { count (0); return (PARSEOP___FILE__); } 585 "__LINE__" { count (0); return (PARSEOP___LINE__); } 586 "__PATH__" { count (0); return (PARSEOP___PATH__); } 587 588 589 "{" { count (0); return('{'); } 590 "}" { count (0); return('}'); } 591 "," { count (0); return(','); } 592 "(" { count (0); return('('); } 593 ")" { count (0); return(')'); } 594 595 {NameSeg} { char *s; 596 count (0); 597 s=malloc (ACPI_NAME_SIZE + 1); 598 if (strcmp (AslCompilertext, "\\")) 599 { 600 strcpy (s, "____"); 601 AcpiUtStrupr (AslCompilertext); 602 } 603 memcpy (s, AslCompilertext, strlen (AslCompilertext)); 604 AslCompilerlval.s = s; 605 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s); 606 return (PARSEOP_NAMESEG); } 607 608 {NameString} { char *s; 609 count (0); 610 s=malloc (strlen (AslCompilertext)+1); 611 AcpiUtStrupr (AslCompilertext); 612 strcpy (s, AslCompilertext); 613 s[strlen (AslCompilertext)] = 0; 614 AslCompilerlval.s = s; 615 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s); 616 return (PARSEOP_NAMESTRING); } 617 618 "*" | 619 "/" { count (1); 620 AslCompilererror ("Parse error, expecting ASL keyword or name");} 621 622 . { count (1); 623 sprintf (MsgBuffer, 624 "Invalid character (0x%2.2X), expecting ASL keyword or name", 625 *AslCompilertext); 626 AslCompilererror (MsgBuffer);} 627 628 <<EOF>> { if (AslPopInputFileStack ()) 629 yyterminate(); 630 else 631 return (PARSEOP_INCLUDE_END);}; 632 633 %% 634 635 /*! [End] no source code translation !*/ 636 637 typedef struct asl_file_node 638 { 639 FILE *File; 640 UINT32 CurrentLineNumber; 641 YY_BUFFER_STATE State; 642 char *Filename; 643 struct asl_file_node *Next; 644 645 } ASL_FILE_NODE; 646 647 ASL_FILE_NODE *InputStack = NULL; 648 649 650 /******************************************************************************* 651 * 652 * FUNCTION: AslPopInputFileStack 653 * 654 * PARAMETERS: None 655 * 656 * RETURN: 0 if a node was popped, -1 otherwise 657 * 658 * DESCRIPTION: Pop the top of the input file stack and point the parser to 659 * the saved parse buffer contained in the fnode. Also, set the 660 * global line counters to the saved values. This function is 661 * called when an include file reaches EOF. 662 * 663 ******************************************************************************/ 664 665 int 666 AslPopInputFileStack ( 667 void) 668 { 669 ASL_FILE_NODE *Fnode; 670 671 672 Fnode = InputStack; 673 DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode); 674 675 676 if (!Fnode) 677 { 678 return -1; 679 } 680 681 /* Close the current include file */ 682 683 fclose (yyin); 684 685 /* Update the top-of-stack */ 686 687 InputStack = Fnode->Next; 688 689 /* Reset global line counter and filename */ 690 691 Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename; 692 Gbl_CurrentLineNumber = Fnode->CurrentLineNumber; 693 694 /* Point the parser to the popped file */ 695 696 yy_delete_buffer (YY_CURRENT_BUFFER); 697 yy_switch_to_buffer (Fnode->State); 698 699 /* All done with this node */ 700 701 ACPI_FREE (Fnode); 702 return 0; 703 } 704 705 706 /******************************************************************************* 707 * 708 * FUNCTION: AslPushInputFileStack 709 * 710 * PARAMETERS: InputFile - Open file pointer 711 * Filename - Name of the file 712 * 713 * RETURN: None 714 * 715 * DESCRIPTION: Push the InputFile onto the file stack, and point the parser 716 * to this file. Called when an include file is successfully 717 * opened. 718 * 719 ******************************************************************************/ 720 721 void 722 AslPushInputFileStack ( 723 FILE *InputFile, 724 char *Filename) 725 { 726 ASL_FILE_NODE *Fnode; 727 YY_BUFFER_STATE State; 728 729 730 /* Save the current state in an Fnode */ 731 732 Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE)); 733 734 Fnode->File = yyin; 735 Fnode->Next = InputStack; 736 Fnode->State = YY_CURRENT_BUFFER; 737 Fnode->CurrentLineNumber = Gbl_CurrentLineNumber; 738 Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename; 739 740 /* Push it on the stack */ 741 742 InputStack = Fnode; 743 744 /* Point the parser to this file */ 745 746 State = yy_create_buffer (InputFile, YY_BUF_SIZE); 747 yy_switch_to_buffer (State); 748 749 DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile); 750 751 /* Reset the global line count and filename */ 752 753 Gbl_Files[ASL_FILE_INPUT].Filename = Filename; 754 Gbl_CurrentLineNumber = 1; 755 yyin = InputFile; 756 } 757 758 759 /******************************************************************************* 760 * 761 * FUNCTION: ResetCurrentLineBuffer 762 * 763 * PARAMETERS: None 764 * 765 * RETURN: None 766 * 767 * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers. 768 * 769 ******************************************************************************/ 770 771 void 772 ResetCurrentLineBuffer ( 773 void) 774 { 775 776 if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle) 777 { 778 FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer, 779 Gbl_LineBufPtr - Gbl_CurrentLineBuffer); 780 } 781 782 Gbl_CurrentLineOffset += Gbl_CurrentColumn; 783 Gbl_CurrentColumn = 0; 784 785 Gbl_CurrentLineNumber++; 786 Gbl_LogicalLineNumber++; 787 Gbl_LineBufPtr = Gbl_CurrentLineBuffer; 788 } 789 790 791 /******************************************************************************* 792 * 793 * FUNCTION: InsertLineBuffer 794 * 795 * PARAMETERS: SourceChar - One char from the input ASL source file 796 * 797 * RETURN: None 798 * 799 * DESCRIPTION: Put one character of the source file into the temp line buffer 800 * 801 ******************************************************************************/ 802 803 #define ASL_SPACES_PER_TAB 4 804 805 void 806 InsertLineBuffer ( 807 int SourceChar) 808 { 809 UINT32 i; 810 UINT32 Count = 1; 811 812 813 if (SourceChar == EOF) 814 { 815 return; 816 } 817 818 Gbl_InputByteCount++; 819 820 /* Handle tabs. Convert to spaces */ 821 822 if (SourceChar == '\t') 823 { 824 SourceChar = ' '; 825 Count = ASL_SPACES_PER_TAB - 826 (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1)); 827 } 828 829 830 for (i = 0; i < Count; i++) 831 { 832 Gbl_CurrentColumn++; 833 834 /* Insert the character into the line buffer */ 835 836 *Gbl_LineBufPtr = (UINT8) SourceChar; 837 Gbl_LineBufPtr++; 838 839 if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1))) 840 { 841 #if 0 842 /* 843 * Warning if we have split a long source line. 844 * <Probably overkill> 845 */ 846 sprintf (MsgBuffer, "Max %u", ASL_LINE_BUFFER_SIZE); 847 AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE, 848 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 849 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 850 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer); 851 #endif 852 853 ResetCurrentLineBuffer (); 854 } 855 else if (SourceChar == '\n') 856 { 857 /* End of line */ 858 859 ResetCurrentLineBuffer (); 860 } 861 } 862 } 863 864 865 /******************************************************************************* 866 * 867 * FUNCTION: count 868 * 869 * PARAMETERS: yytext - Contains the matched keyword. 870 * Type - Keyword/Character type: 871 * 0 = anything except a keyword 872 * 1 = pseudo-keywords 873 * 2 = non-executable ASL keywords 874 * 3 = executable ASL keywords 875 * 876 * RETURN: None 877 * 878 * DESCRIPTION: Count keywords and put them into the line buffer 879 * 880 ******************************************************************************/ 881 882 void 883 count ( 884 int Type) 885 { 886 int i; 887 888 889 switch (Type) 890 { 891 case 2: 892 TotalKeywords++; 893 TotalNamedObjects++; 894 break; 895 896 case 3: 897 TotalKeywords++; 898 TotalExecutableOpcodes++; 899 break; 900 } 901 902 for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++) 903 { 904 InsertLineBuffer (yytext[i]); 905 *Gbl_LineBufPtr = 0; 906 } 907 } 908 909 910 /******************************************************************************* 911 * 912 * FUNCTION: comment 913 * 914 * PARAMETERS: none 915 * 916 * RETURN: none 917 * 918 * DESCRIPTION: Process a standard comment. 919 * 920 ******************************************************************************/ 921 922 char 923 comment (void) 924 { 925 char c; 926 char c1 = 0; 927 928 929 InsertLineBuffer ('/'); 930 InsertLineBuffer ('*'); 931 932 loop: 933 934 /* Eat chars until end-of-comment */ 935 936 while ((c = (char) input()) != '*' && c != EOF) 937 { 938 InsertLineBuffer (c); 939 c1 = c; 940 } 941 942 if (c == EOF) 943 { 944 goto EarlyEOF; 945 } 946 947 /* 948 * Check for nested comment -- can help catch cases where a previous 949 * comment was accidently left unterminated 950 */ 951 if ((c1 == '/') && (c == '*')) 952 { 953 AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT, 954 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 955 Gbl_InputByteCount, Gbl_CurrentColumn, 956 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 957 } 958 959 /* Comment is closed only if the NEXT character is a slash */ 960 961 InsertLineBuffer (c); 962 963 if ((c1 = (char) input()) != '/' && c1 != EOF) 964 { 965 unput(c1); 966 goto loop; 967 } 968 969 if (c1 == EOF) 970 { 971 goto EarlyEOF; 972 } 973 974 InsertLineBuffer (c1); 975 return TRUE; 976 977 978 EarlyEOF: 979 /* 980 * Premature End-Of-File 981 */ 982 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF, 983 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 984 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 985 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 986 return (FALSE); 987 } 988 989 990 /******************************************************************************* 991 * 992 * FUNCTION: comment 993 * 994 * PARAMETERS: none 995 * 996 * RETURN: none 997 * 998 * DESCRIPTION: Process a new "//" comment. 999 * 1000 ******************************************************************************/ 1001 1002 char 1003 comment2 (void) 1004 { 1005 char c; 1006 1007 1008 InsertLineBuffer ('/'); 1009 InsertLineBuffer ('/'); 1010 1011 while ((c = (char) input()) != '\n' && c != EOF) 1012 { 1013 InsertLineBuffer (c); 1014 } 1015 1016 if (c == EOF) 1017 { 1018 /* End of file is OK, change to newline. Let parser detect EOF later */ 1019 1020 c = '\n'; 1021 } 1022 1023 InsertLineBuffer (c); 1024 return (TRUE); 1025 } 1026 1027 1028 /******************************************************************************* 1029 * 1030 * FUNCTION: literal 1031 * 1032 * PARAMETERS: none 1033 * 1034 * RETURN: none 1035 * 1036 * DESCRIPTION: Process a string literal (surrounded by quotes) 1037 * 1038 ******************************************************************************/ 1039 1040 #define ASL_NORMAL_CHAR 0 1041 #define ASL_ESCAPE_SEQUENCE 1 1042 #define ASL_OCTAL_CONSTANT 2 1043 #define ASL_HEX_CONSTANT 3 1044 1045 char 1046 literal (void) 1047 { 1048 char *StringBuffer = MsgBuffer; 1049 char *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE; 1050 char *CleanString; 1051 char StringChar; 1052 UINT32 State = ASL_NORMAL_CHAR; 1053 UINT32 i = 0; 1054 UINT8 Digit; 1055 char ConvertBuffer[4]; 1056 1057 1058 /* 1059 * Eat chars until end-of-literal. 1060 * NOTE: Put back the original surrounding quotes into the 1061 * source line buffer. 1062 */ 1063 InsertLineBuffer ('\"'); 1064 while ((StringChar = (char) input()) != EOF) 1065 { 1066 InsertLineBuffer (StringChar); 1067 1068 DoCharacter: 1069 1070 switch (State) 1071 { 1072 case ASL_NORMAL_CHAR: 1073 1074 switch (StringChar) 1075 { 1076 case '\\': 1077 /* 1078 * Special handling for backslash-escape sequence. We will 1079 * toss the backslash and translate the escape char(s). 1080 */ 1081 State = ASL_ESCAPE_SEQUENCE; 1082 continue; 1083 1084 case '\"': 1085 1086 /* String terminator */ 1087 1088 goto CompletedString; 1089 } 1090 break; 1091 1092 1093 case ASL_ESCAPE_SEQUENCE: 1094 1095 State = ASL_NORMAL_CHAR; 1096 switch (StringChar) 1097 { 1098 case 'a': 1099 StringChar = 0x07; /* BELL */ 1100 break; 1101 1102 case 'b': 1103 StringChar = 0x08; /* BACKSPACE */ 1104 break; 1105 1106 case 'f': 1107 StringChar = 0x0C; /* FORMFEED */ 1108 break; 1109 1110 case 'n': 1111 StringChar = 0x0A; /* LINEFEED */ 1112 break; 1113 1114 case 'r': 1115 StringChar = 0x0D; /* CARRIAGE RETURN*/ 1116 break; 1117 1118 case 't': 1119 StringChar = 0x09; /* HORIZONTAL TAB */ 1120 break; 1121 1122 case 'v': 1123 StringChar = 0x0B; /* VERTICAL TAB */ 1124 break; 1125 1126 case 'x': 1127 State = ASL_HEX_CONSTANT; 1128 i = 0; 1129 continue; 1130 1131 case '\'': /* Single Quote */ 1132 case '\"': /* Double Quote */ 1133 case '\\': /* Backslash */ 1134 break; 1135 1136 default: 1137 1138 /* Check for an octal digit (0-7) */ 1139 1140 if (ACPI_IS_OCTAL_DIGIT (StringChar)) 1141 { 1142 State = ASL_OCTAL_CONSTANT; 1143 ConvertBuffer[0] = StringChar; 1144 i = 1; 1145 continue; 1146 } 1147 1148 /* Unknown escape sequence issue warning, but use the character */ 1149 1150 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE, 1151 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1152 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1153 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1154 break; 1155 } 1156 break; 1157 1158 1159 case ASL_OCTAL_CONSTANT: 1160 1161 /* Up to three octal digits allowed */ 1162 1163 if (!ACPI_IS_OCTAL_DIGIT (StringChar) || 1164 (i > 2)) 1165 { 1166 /* 1167 * Reached end of the constant. Convert the assembled ASCII 1168 * string and resume processing of the next character 1169 */ 1170 ConvertBuffer[i] = 0; 1171 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8); 1172 1173 /* Check for NULL or non-ascii character (ignore if so) */ 1174 1175 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX)) 1176 { 1177 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING, 1178 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1179 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1180 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1181 } 1182 else 1183 { 1184 *StringBuffer = (char) Digit; 1185 StringBuffer++; 1186 if (StringBuffer >= EndBuffer) 1187 { 1188 goto BufferOverflow; 1189 } 1190 } 1191 1192 State = ASL_NORMAL_CHAR; 1193 goto DoCharacter; 1194 break; 1195 } 1196 1197 /* Append another digit of the constant */ 1198 1199 ConvertBuffer[i] = StringChar; 1200 i++; 1201 continue; 1202 1203 1204 case ASL_HEX_CONSTANT: 1205 1206 /* Up to two hex digits allowed */ 1207 1208 if (!ACPI_IS_XDIGIT (StringChar) || 1209 (i > 1)) 1210 { 1211 /* 1212 * Reached end of the constant. Convert the assembled ASCII 1213 * string and resume processing of the next character 1214 */ 1215 ConvertBuffer[i] = 0; 1216 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16); 1217 1218 /* Check for NULL or non-ascii character (ignore if so) */ 1219 1220 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX)) 1221 { 1222 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING, 1223 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1224 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1225 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1226 } 1227 else 1228 { 1229 *StringBuffer = (char) Digit; 1230 StringBuffer++; 1231 if (StringBuffer >= EndBuffer) 1232 { 1233 goto BufferOverflow; 1234 } 1235 } 1236 1237 State = ASL_NORMAL_CHAR; 1238 goto DoCharacter; 1239 break; 1240 } 1241 1242 /* Append another digit of the constant */ 1243 1244 ConvertBuffer[i] = StringChar; 1245 i++; 1246 continue; 1247 } 1248 1249 /* Save the finished character */ 1250 1251 *StringBuffer = StringChar; 1252 StringBuffer++; 1253 if (StringBuffer >= EndBuffer) 1254 { 1255 goto BufferOverflow; 1256 } 1257 } 1258 1259 /* 1260 * Premature End-Of-File 1261 */ 1262 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF, 1263 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1264 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1265 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1266 return (FALSE); 1267 1268 1269 CompletedString: 1270 /* 1271 * Null terminate the input string and copy string to a new buffer 1272 */ 1273 *StringBuffer = 0; 1274 1275 CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1); 1276 if (!CleanString) 1277 { 1278 AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION, 1279 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1280 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1281 Gbl_Files[ASL_FILE_INPUT].Filename, NULL); 1282 return (FALSE); 1283 } 1284 1285 ACPI_STRCPY (CleanString, MsgBuffer); 1286 AslCompilerlval.s = CleanString; 1287 return (TRUE); 1288 1289 1290 BufferOverflow: 1291 1292 /* Literal was too long */ 1293 1294 AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH, 1295 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 1296 Gbl_CurrentLineOffset, Gbl_CurrentColumn, 1297 Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096"); 1298 return (FALSE); 1299 } 1300 1301 1302