aslcompiler.l revision 1.1.1.23
1 %{ 2 /****************************************************************************** 3 * 4 * Module Name: aslcompiler.l - Flex/lex input file 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2023, 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 MERCHANTABILITY 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 "aslcompiler.h" 46 #include "aslcompiler.y.h" 47 #include "acconvert.h" 48 49 #include <stdlib.h> 50 #include <string.h> 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 ("aslscanner") 62 63 64 /* Local prototypes */ 65 66 static void 67 AslDoLineDirective (void); 68 69 static BOOLEAN 70 AslDoComment (void); 71 72 static BOOLEAN 73 AslDoCommentType2 (void); 74 75 static char 76 AslDoStringLiteral (void); 77 78 static void 79 count (int type); 80 81 82 /*! [Begin] no source code translation */ 83 84 %} 85 /* Definitions */ 86 87 LeadNameChar [A-Za-z_] 88 DigitChar [0-9] 89 ErrorCode [(][ ]*[1-9][0-9][0-9][0-9][ ]*[)] 90 OctalChar [0-7] 91 HexDigitChar [A-Fa-f0-9] 92 RootChar [\\] 93 Nothing [] 94 95 NameChar [A-Za-z_0-9] 96 NameSeg1 {LeadNameChar}{NameChar} 97 NameSeg2 {LeadNameChar}{NameChar}{NameChar} 98 NameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar} 99 NameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3} 100 101 NameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath} 102 NamePath {NonEmptyNamePath}? 103 NonEmptyNamePath {NameSeg}{NamePathTail}* 104 NamePathTail [.]{NameSeg} 105 106 %% 107 /* Rules */ 108 109 [ ] { count (0); } 110 [\n] { count (0); } /* Handle files with both LF and CR/LF */ 111 [\r] { count (0); } /* termination on both Unix and Windows */ 112 [ \t] { count (0); } 113 114 115 "/*" { if (!AslDoComment ()) {yyterminate ();} } 116 "//" { if (!AslDoCommentType2 ()) {yyterminate ();} } 117 118 "\"" { if (AslDoStringLiteral ()) {return (PARSEOP_STRING_LITERAL);} 119 else {yyterminate ();} } 120 ";" { count (0); return(';'); } 121 122 /* ASL Extension: Standard C operators */ 123 124 "~" { count (3); return (PARSEOP_EXP_NOT); } 125 "!" { count (3); return (PARSEOP_EXP_LOGICAL_NOT); } 126 "*" { count (3); return (PARSEOP_EXP_MULTIPLY); } 127 "/" { count (3); return (PARSEOP_EXP_DIVIDE); } 128 "%" { count (3); return (PARSEOP_EXP_MODULO); } 129 "+" { count (3); return (PARSEOP_EXP_ADD); } 130 "-" { count (3); return (PARSEOP_EXP_SUBTRACT); } 131 ">>" { count (3); return (PARSEOP_EXP_SHIFT_RIGHT); } 132 "<<" { count (3); return (PARSEOP_EXP_SHIFT_LEFT); } 133 "<" { count (3); return (PARSEOP_EXP_LESS); } 134 ">" { count (3); return (PARSEOP_EXP_GREATER); } 135 "&" { count (3); return (PARSEOP_EXP_AND); } 136 "<=" { count (3); return (PARSEOP_EXP_LESS_EQUAL); } 137 ">=" { count (3); return (PARSEOP_EXP_GREATER_EQUAL); } 138 "==" { count (3); return (PARSEOP_EXP_EQUAL); } 139 "!=" { count (3); return (PARSEOP_EXP_NOT_EQUAL); } 140 "|" { count (3); return (PARSEOP_EXP_OR); } 141 "&&" { count (3); return (PARSEOP_EXP_LOGICAL_AND); } 142 "||" { count (3); return (PARSEOP_EXP_LOGICAL_OR); } 143 "++" { count (3); return (PARSEOP_EXP_INCREMENT); } 144 "--" { count (3); return (PARSEOP_EXP_DECREMENT); } 145 "^ " { count (3); return (PARSEOP_EXP_XOR); } 146 147 /* ASL Extension: Standard C assignment operators */ 148 149 "=" { count (3); return (PARSEOP_EXP_EQUALS); } 150 "+=" { count (3); return (PARSEOP_EXP_ADD_EQ); } 151 "-=" { count (3); return (PARSEOP_EXP_SUB_EQ); } 152 "*=" { count (3); return (PARSEOP_EXP_MUL_EQ); } 153 "/=" { count (3); return (PARSEOP_EXP_DIV_EQ); } 154 "%=" { count (3); return (PARSEOP_EXP_MOD_EQ); } 155 "<<=" { count (3); return (PARSEOP_EXP_SHL_EQ); } 156 ">>=" { count (3); return (PARSEOP_EXP_SHR_EQ); } 157 "&=" { count (3); return (PARSEOP_EXP_AND_EQ); } 158 "^=" { count (3); return (PARSEOP_EXP_XOR_EQ); } 159 "|=" { count (3); return (PARSEOP_EXP_OR_EQ); } 160 161 "[" { count (3); return (PARSEOP_EXP_INDEX_LEFT); } 162 "]" { count (0); return (PARSEOP_EXP_INDEX_RIGHT); } 163 "(" { count (0); return (PARSEOP_OPEN_PAREN); } 164 ")" { count (0); return (PARSEOP_CLOSE_PAREN); } 165 166 "{" { count (0); return ('{'); } 167 "}" { count (0); return ('}'); } 168 "," { count (0); return (','); } 169 170 171 /* 172 * Begin standard ASL grammar 173 */ 174 [0-9][a-zA-Z0-9]* { count (1); AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext); 175 return (PARSEOP_INTEGER); } 176 177 "Include" { count (1); return (PARSEOP_INCLUDE); } 178 "External" { count (1); return (PARSEOP_EXTERNAL); } 179 180 /* 181 * The #line directive is emitted by the preprocessor and handled 182 * here in the main iASL lexer - simply set the line number and 183 * optionally the current filename. 184 */ 185 "#line" { AslDoLineDirective ();} 186 187 188 /**************************************************************************** 189 * 190 * Main ASL operators 191 * 192 ****************************************************************************/ 193 194 "AccessAs" { count (1); return (PARSEOP_ACCESSAS); } 195 "Acquire" { count (3); return (PARSEOP_ACQUIRE); } 196 "Add" { count (3); return (PARSEOP_ADD); } 197 "Alias" { count (2); return (PARSEOP_ALIAS); } 198 "And" { count (3); return (PARSEOP_AND); } 199 "BankField" { count (2); return (PARSEOP_BANKFIELD); } 200 "Break" { count (3); return (PARSEOP_BREAK); } 201 "BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); } 202 "Buffer" { count (1); return (PARSEOP_BUFFER); } 203 "Case" { count (3); return (PARSEOP_CASE); } 204 "Concatenate" { count (3); return (PARSEOP_CONCATENATE); } 205 "ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); } 206 "CondRefOf" { count (3); return (PARSEOP_CONDREFOF); } 207 "Connection" { count (2); return (PARSEOP_CONNECTION); } 208 "Continue" { count (3); return (PARSEOP_CONTINUE); } 209 "CopyObject" { count (3); return (PARSEOP_COPYOBJECT); } 210 "CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); } 211 "CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); } 212 "CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); } 213 "CreateField" { count (2); return (PARSEOP_CREATEFIELD); } 214 "CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); } 215 "CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); } 216 "DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); } 217 "Debug" { count (1); return (PARSEOP_DEBUG); } 218 "Decrement" { count (3); return (PARSEOP_DECREMENT); } 219 "Default" { count (3); return (PARSEOP_DEFAULT); } 220 "DefinitionBlock" { count (1); return (PARSEOP_DEFINITION_BLOCK); } 221 "DeRefOf" { count (3); return (PARSEOP_DEREFOF); } 222 "Device" { count (2); return (PARSEOP_DEVICE); } 223 "Divide" { count (3); return (PARSEOP_DIVIDE); } 224 "Eisaid" { count (1); return (PARSEOP_EISAID); } 225 "Else" { count (3); return (PARSEOP_ELSE); } 226 "ElseIf" { count (3); return (PARSEOP_ELSEIF); } 227 "Event" { count (2); return (PARSEOP_EVENT); } 228 "Fatal" { count (3); return (PARSEOP_FATAL); } 229 "Field" { count (2); return (PARSEOP_FIELD); } 230 "FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); } 231 "FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); } 232 "FromBcd" { count (3); return (PARSEOP_FROMBCD); } 233 "Function" { count (2); return (PARSEOP_FUNCTION); } 234 "If" { count (3); return (PARSEOP_IF); } 235 "Increment" { count (3); return (PARSEOP_INCREMENT); } 236 "Index" { count (3); return (PARSEOP_INDEX); } 237 "IndexField" { count (2); return (PARSEOP_INDEXFIELD); } 238 "LAnd" { count (3); return (PARSEOP_LAND); } 239 "LEqual" { count (3); return (PARSEOP_LEQUAL); } 240 "LGreater" { count (3); return (PARSEOP_LGREATER); } 241 "LGreaterEqual" { count (3); return (PARSEOP_LGREATEREQUAL); } 242 "LLess" { count (3); return (PARSEOP_LLESS); } 243 "LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); } 244 "LNot" { count (3); return (PARSEOP_LNOT); } 245 "LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); } 246 "Load" { count (3); return (PARSEOP_LOAD); } 247 "LoadTable" { count (3); return (PARSEOP_LOADTABLE); } 248 "LOr" { count (3); return (PARSEOP_LOR); } 249 "Match" { count (3); return (PARSEOP_MATCH); } 250 "Method" { count (2); return (PARSEOP_METHOD); } 251 "Mid" { count (3); return (PARSEOP_MID); } 252 "Mod" { count (3); return (PARSEOP_MOD); } 253 "Multiply" { count (3); return (PARSEOP_MULTIPLY); } 254 "Mutex" { count (2); return (PARSEOP_MUTEX); } 255 "Name" { count (2); return (PARSEOP_NAME); } 256 "NAnd" { count (3); return (PARSEOP_NAND); } 257 "Noop" { if (!AcpiGbl_IgnoreNoopOperator) {count (3); return (PARSEOP_NOOP);} } 258 "NOr" { count (3); return (PARSEOP_NOR); } 259 "Not" { count (3); return (PARSEOP_NOT); } 260 "Notify" { count (3); return (PARSEOP_NOTIFY); } 261 "ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); } 262 "Offset" { count (1); return (PARSEOP_OFFSET); } 263 "One" { count (1); return (PARSEOP_ONE); } 264 "Ones" { count (1); return (PARSEOP_ONES); } 265 "OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); } 266 "Or" { count (3); return (PARSEOP_OR); } 267 "Package" { count (1); return (PARSEOP_PACKAGE); } 268 "PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); } 269 "Processor" { count (2); return (PARSEOP_PROCESSOR); } 270 "RefOf" { count (3); return (PARSEOP_REFOF); } 271 "Release" { count (3); return (PARSEOP_RELEASE); } 272 "Reset" { count (3); return (PARSEOP_RESET); } 273 "Return" { count (3); return (PARSEOP_RETURN); } 274 "Revision" { count (1); return (PARSEOP_REVISION); } 275 "Scope" { count (2); return (PARSEOP_SCOPE); } 276 "ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); } 277 "ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); } 278 "Signal" { count (3); return (PARSEOP_SIGNAL); } 279 "SizeOf" { count (3); return (PARSEOP_SIZEOF); } 280 "Sleep" { count (3); return (PARSEOP_SLEEP); } 281 "Stall" { count (3); return (PARSEOP_STALL); } 282 "Store" { count (3); return (PARSEOP_STORE); } 283 "Subtract" { count (3); return (PARSEOP_SUBTRACT); } 284 "Switch" { count (3); return (PARSEOP_SWITCH); } 285 "ThermalZone" { count (2); return (PARSEOP_THERMALZONE); } 286 "Timer" { count (3); return (PARSEOP_TIMER); } 287 "ToBcd" { count (3); return (PARSEOP_TOBCD); } 288 "ToBuffer" { count (3); return (PARSEOP_TOBUFFER); } 289 "ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); } 290 "ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); } 291 "ToInteger" { count (3); return (PARSEOP_TOINTEGER); } 292 "ToString" { count (3); return (PARSEOP_TOSTRING); } 293 "ToUuid" { count (1); return (PARSEOP_TOUUID); } 294 "Unicode" { count (1); return (PARSEOP_UNICODE); } 295 "Unload" { count (3); return (PARSEOP_UNLOAD); } 296 "Wait" { count (3); return (PARSEOP_WAIT); } 297 "While" { count (3); return (PARSEOP_WHILE); } 298 "XOr" { count (3); return (PARSEOP_XOR); } 299 "Zero" { count (1); return (PARSEOP_ZERO); } 300 301 /* Control method arguments and locals */ 302 303 "Arg0" { count (1); return (PARSEOP_ARG0); } 304 "Arg1" { count (1); return (PARSEOP_ARG1); } 305 "Arg2" { count (1); return (PARSEOP_ARG2); } 306 "Arg3" { count (1); return (PARSEOP_ARG3); } 307 "Arg4" { count (1); return (PARSEOP_ARG4); } 308 "Arg5" { count (1); return (PARSEOP_ARG5); } 309 "Arg6" { count (1); return (PARSEOP_ARG6); } 310 "Local0" { count (1); return (PARSEOP_LOCAL0); } 311 "Local1" { count (1); return (PARSEOP_LOCAL1); } 312 "Local2" { count (1); return (PARSEOP_LOCAL2); } 313 "Local3" { count (1); return (PARSEOP_LOCAL3); } 314 "Local4" { count (1); return (PARSEOP_LOCAL4); } 315 "Local5" { count (1); return (PARSEOP_LOCAL5); } 316 "Local6" { count (1); return (PARSEOP_LOCAL6); } 317 "Local7" { count (1); return (PARSEOP_LOCAL7); } 318 319 320 /**************************************************************************** 321 * 322 * Resource Descriptor macros 323 * 324 ****************************************************************************/ 325 326 "ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); } 327 "RawDataBuffer" { count (1); return (PARSEOP_DATABUFFER); } 328 329 "Csi2Bus" { count (1); return (PARSEOP_CSI2_SERIALBUS); } 330 "DMA" { count (1); return (PARSEOP_DMA); } 331 "DWordIO" { count (1); return (PARSEOP_DWORDIO); } 332 "DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); } 333 "DWordPcc" { count (1); return (PARSEOP_DWORDPCC); } 334 "DWordSpace" { count (1); return (PARSEOP_DWORDSPACE); } 335 "EndDependentFn" { count (1); return (PARSEOP_ENDDEPENDENTFN); } 336 "ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); } 337 "ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); } 338 "ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); } 339 "FixedDma" { count (1); return (PARSEOP_FIXEDDMA); } 340 "FixedIO" { count (1); return (PARSEOP_FIXEDIO); } 341 "GpioInt" { count (1); return (PARSEOP_GPIO_INT); } 342 "GpioIo" { count (1); return (PARSEOP_GPIO_IO); } 343 "I2cSerialBus" { count (1); return (PARSEOP_I2C_SERIALBUS); } 344 "I2cSerialBusV2" { count (1); return (PARSEOP_I2C_SERIALBUS_V2); } 345 "Interrupt" { count (1); return (PARSEOP_INTERRUPT); } 346 "IO" { count (1); return (PARSEOP_IO); } 347 "IRQ" { count (1); return (PARSEOP_IRQ); } 348 "IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); } 349 "Memory24" { count (1); return (PARSEOP_MEMORY24); } 350 "Memory32" { count (1); return (PARSEOP_MEMORY32); } 351 "Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); } 352 "PinConfig" { count (1); return (PARSEOP_PINCONFIG); } 353 "PinFunction" { count (1); return (PARSEOP_PINFUNCTION); } 354 "PinGroup" { count (1); return (PARSEOP_PINGROUP); } 355 "PinGroupConfig" { count (1); return (PARSEOP_PINGROUPCONFIG); } 356 "PinGroupFunction" { count (1); return (PARSEOP_PINGROUPFUNCTION); } 357 "ClockInput" { count (1); return (PARSEOP_CLOCKINPUT); } 358 "QWordIO" { count (1); return (PARSEOP_QWORDIO); } 359 "QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); } 360 "QWordPcc" { count (1); return (PARSEOP_DWORDPCC); } 361 "QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); } 362 "Register" { count (1); return (PARSEOP_REGISTER); } 363 "SpiSerialBus" { count (1); return (PARSEOP_SPI_SERIALBUS); } 364 "SpiSerialBusV2" { count (1); return (PARSEOP_SPI_SERIALBUS_V2); } 365 "StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); } 366 "StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); } 367 "UartSerialBus" { count (1); return (PARSEOP_UART_SERIALBUS); } 368 "UartSerialBusV2" { count (1); return (PARSEOP_UART_SERIALBUS_V2); } 369 "VendorLong" { count (1); return (PARSEOP_VENDORLONG); } 370 "VendorShort" { count (1); return (PARSEOP_VENDORSHORT); } 371 "WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); } 372 "WordIO" { count (1); return (PARSEOP_WORDIO); } 373 "WordPcc" { count (1); return (PARSEOP_DWORDPCC); } 374 "WordSpace" { count (1); return (PARSEOP_WORDSPACE); } 375 376 377 /**************************************************************************** 378 * 379 * Keywords used as arguments to ASL operators and macros 380 * 381 ****************************************************************************/ 382 383 /* AccessAttribKeyword: Serial Bus Attributes (ACPI 5.0) */ 384 385 "AttribQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 386 "AttribSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 387 "AttribByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 388 "AttribWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 389 "AttribBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 390 "AttribProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 391 "AttribBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 392 393 /* AccessAttribKeyword: Legacy synonyms for above (pre-ACPI 5.0) */ 394 395 "SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 396 "SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 397 "SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 398 "SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 399 "SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 400 "SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 401 "SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 402 403 /* AccessTypeKeyword: Field Access Types */ 404 405 "AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); } 406 "ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); } 407 "WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); } 408 "DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); } 409 "QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); } 410 "BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); } 411 412 /* AddressingModeKeyword: Mode - Resource Descriptors (ACPI 5.0) */ 413 414 "AddressingMode7Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_7BIT); } 415 "AddressingMode10Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_10BIT); } 416 417 /* AddressKeyword: ACPI memory range types */ 418 419 "AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); } 420 "AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); } 421 "AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); } 422 "AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); } 423 424 /* BusMasterKeyword: DMA Bus Mastering */ 425 426 "BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); } 427 "NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); } 428 429 /* ByteLengthKeyword: Bits per Byte - Resource Descriptors (ACPI 5.0) */ 430 431 "DataBitsFive" { count (0); return (PARSEOP_BITSPERBYTE_FIVE); } 432 "DataBitsSix" { count (0); return (PARSEOP_BITSPERBYTE_SIX); } 433 "DataBitsSeven" { count (0); return (PARSEOP_BITSPERBYTE_SEVEN); } 434 "DataBitsEight" { count (0); return (PARSEOP_BITSPERBYTE_EIGHT); } 435 "DataBitsNine" { count (0); return (PARSEOP_BITSPERBYTE_NINE); } 436 437 /* ClockPhaseKeyword: Resource Descriptors (ACPI 5.0) */ 438 439 "ClockPhaseFirst" { count (0); return (PARSEOP_CLOCKPHASE_FIRST); } 440 "ClockPhaseSecond" { count (0); return (PARSEOP_CLOCKPHASE_SECOND); } 441 442 /* ClockPolarityKeyword: Resource Descriptors (ACPI 5.0) */ 443 444 "ClockPolarityLow" { count (0); return (PARSEOP_CLOCKPOLARITY_LOW); } 445 "ClockPolarityHigh" { count (0); return (PARSEOP_CLOCKPOLARITY_HIGH); } 446 447 /* DecodeKeyword: Type of Memory Decoding - Resource Descriptors */ 448 449 "PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); } 450 "SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); } 451 452 /* DmaTypeKeyword: DMA Types - DMA Resource Descriptor */ 453 454 "Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); } 455 "TypeA" { count (0); return (PARSEOP_DMATYPE_A); } 456 "TypeB" { count (0); return (PARSEOP_DMATYPE_B); } 457 "TypeF" { count (0); return (PARSEOP_DMATYPE_F); } 458 459 /* EndianKeyword: Endian type - Resource Descriptor (ACPI 5.0) */ 460 461 "LittleEndian" { count (0); return (PARSEOP_ENDIAN_LITTLE); } 462 "BigEndian" { count (0); return (PARSEOP_ENDIAN_BIG); } 463 464 /* ExtendedAttribKeyword: Bus attributes, AccessAs operator (ACPI 5.0) */ 465 466 "AttribBytes" { count (0); return (PARSEOP_ACCESSATTRIB_BYTES); } 467 "AttribRawBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_BYTES); } 468 "AttribRawProcessBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_PROCESS); } 469 470 /* FlowControlKeyword: Resource Descriptors (ACPI 5.0) */ 471 472 "FlowControlHardware" { count (0); return (PARSEOP_FLOWCONTROL_HW); } 473 "FlowControlNone" { count (0); return (PARSEOP_FLOWCONTROL_NONE); } 474 "FlowControlXon" { count (0); return (PARSEOP_FLOWCONTROL_SW); } 475 476 /* InterruptLevelKeyword: Interrupt Active Types */ 477 478 "ActiveBoth" { count (0); return (PARSEOP_INTLEVEL_ACTIVEBOTH); } 479 "ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); } 480 "ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); } 481 482 /* InterruptTypeKeyword: Interrupt Types */ 483 484 "Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); } 485 "Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); } 486 487 /* IoDecodeKeyword: Type of Memory Decoding - Resource Descriptors */ 488 489 "Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); } 490 "Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); } 491 492 /* IoRestrictionKeyword: I/O Restriction - GPIO Resource Descriptors (ACPI 5.0) */ 493 494 "IoRestrictionNone" { count (0); return (PARSEOP_IORESTRICT_NONE); } 495 "IoRestrictionInputOnly" { count (0); return (PARSEOP_IORESTRICT_IN); } 496 "IoRestrictionOutputOnly" { count (0); return (PARSEOP_IORESTRICT_OUT); } 497 "IoRestrictionNoneAndPreserve" { count (0); return (PARSEOP_IORESTRICT_PRESERVE); } 498 499 /* LockRuleKeyword: Global Lock use for Field Operator */ 500 501 "Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); } 502 "NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); } 503 504 /* MatchOpKeyword: Types for Match Operator */ 505 506 "MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); } 507 "MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); } 508 "MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); } 509 "MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); } 510 "MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); } 511 "MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); } 512 513 /* MaxKeyword: Max Range Type - Resource Descriptors */ 514 515 "MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); } 516 "MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); } 517 518 /* MemTypeKeyword: Memory Types - Resource Descriptors */ 519 520 "Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); } 521 "WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); } 522 "Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); } 523 "NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); } 524 525 /* MinKeyword: Min Range Type - Resource Descriptors */ 526 527 "MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); } 528 "MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); } 529 530 /* ObjectTypeKeyword: ACPI Object Types */ 531 532 "UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); } 533 "IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); } 534 "StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); } 535 "BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); } 536 "PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); } 537 "FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); } 538 "DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); } 539 "EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); } 540 "MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); } 541 "MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); } 542 "OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); } 543 "PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); } 544 "ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); } 545 "ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); } 546 "BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); } 547 "DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); } 548 549 /* ParityKeyword: Resource Descriptors (ACPI 5.0) */ 550 551 "ParityTypeSpace" { count (0); return (PARSEOP_PARITYTYPE_SPACE); } 552 "ParityTypeMark" { count (0); return (PARSEOP_PARITYTYPE_MARK); } 553 "ParityTypeOdd" { count (0); return (PARSEOP_PARITYTYPE_ODD); } 554 "ParityTypeEven" { count (0); return (PARSEOP_PARITYTYPE_EVEN); } 555 "ParityTypeNone" { count (0); return (PARSEOP_PARITYTYPE_NONE); } 556 557 /* PinConfigKeyword: Pin Configuration - GPIO Resource Descriptors (ACPI 5.0) */ 558 559 "PullDefault" { count (0); return (PARSEOP_PIN_PULLDEFAULT); } 560 "PullUp" { count (0); return (PARSEOP_PIN_PULLUP); } 561 "PullDown" { count (0); return (PARSEOP_PIN_PULLDOWN); } 562 "PullNone" { count (0); return (PARSEOP_PIN_NOPULL); } 563 564 /* ClockScaleKeyword: Resource Descriptors (ACPI 6.5) */ 565 566 "Hz" { count (0); return (PARSEOP_CLOCK_HZ); } 567 "KHz" { count (0); return (PARSEOP_CLOCK_KHZ); } 568 "MHz" { count (0); return (PARSEOP_CLOCK_MHZ); } 569 570 /* ClockModeKeyword: Resource Descriptors (ACPI 6.5) */ 571 572 "Fixed" { count (0); return (PARSEOP_CLOCK_FIXED); } 573 "Variable" { count (0); return (PARSEOP_CLOCK_VARIABLE); } 574 575 /* PolarityKeyword: Resource Descriptors (ACPI 5.0) */ 576 577 "PolarityLow" { count (0); return (PARSEOP_DEVICEPOLARITY_LOW); } 578 "PolarityHigh" { count (0); return (PARSEOP_DEVICEPOLARITY_HIGH); } 579 580 /* RangeTypeKeyword: I/O Range Types - Resource Descriptors */ 581 582 "ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); } 583 "NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); } 584 "EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); } 585 586 /* ReadWriteKeyword: Memory Access Types - Resource Descriptors */ 587 588 "ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); } 589 "ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); } 590 591 /* RegionSpaceKeyword: Operation Region Address Space Types */ 592 593 "SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); } 594 "SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); } 595 "PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); } 596 "EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); } 597 "SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); } 598 "SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); } 599 "PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); } 600 "IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); } 601 "GeneralPurposeIo" { count (0); return (PARSEOP_REGIONSPACE_GPIO); } /* ACPI 5.0 */ 602 "GenericSerialBus" { count (0); return (PARSEOP_REGIONSPACE_GSBUS); } /* ACPI 5.0 */ 603 "PCC" { count (0); return (PARSEOP_REGIONSPACE_PCC); } /* ACPI 5.0 */ 604 "PlatformRtMechanism" { count (0); return (PARSEOP_REGIONSPACE_PRM); } 605 "FFixedHW" { count (0); return (PARSEOP_REGIONSPACE_FFIXEDHW); } 606 607 /* ResourceTypeKeyword: Resource Usage - Resource Descriptors */ 608 609 "ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); } 610 "ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); } 611 612 /* SerializeRuleKeyword: Control Method Serialization */ 613 614 "Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); } 615 "NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); } 616 617 /* ShareTypeKeyword: Interrupt Sharing - Resource Descriptors */ 618 619 "Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); } 620 "Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); } 621 "SharedAndWake" { count (0); return (PARSEOP_SHARETYPE_SHAREDWAKE); } /* ACPI 5.0 */ 622 "ExclusiveAndWake" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVEWAKE); } /* ACPI 5.0 */ 623 624 /* SlaveModeKeyword: Resource Descriptors (ACPI 5.0) */ 625 626 "ControllerInitiated" { count (0); return (PARSEOP_SLAVEMODE_CONTROLLERINIT); } 627 "DeviceInitiated" { count (0); return (PARSEOP_SLAVEMODE_DEVICEINIT); } 628 629 /* StopBitsKeyword: Resource Descriptors (ACPI 5.0) */ 630 631 "StopBitsOne" { count (0); return (PARSEOP_STOPBITS_ONE); } 632 "StopBitsOnePlusHalf" { count (0); return (PARSEOP_STOPBITS_ONEPLUSHALF); } 633 "StopBitsTwo" { count (0); return (PARSEOP_STOPBITS_TWO); } 634 "StopBitsZero" { count (0); return (PARSEOP_STOPBITS_ZERO); } 635 636 /* TransferWidthKeyword: DMA Widths - Fixed DMA Resource Descriptor (ACPI 5.0) */ 637 638 "Width8bit" { count (0); return (PARSEOP_XFERSIZE_8); } 639 "Width16bit" { count (0); return (PARSEOP_XFERSIZE_16); } 640 "Width32bit" { count (0); return (PARSEOP_XFERSIZE_32); } 641 "Width64bit" { count (0); return (PARSEOP_XFERSIZE_64); } 642 "Width128bit" { count (0); return (PARSEOP_XFERSIZE_128); } 643 "Width256bit" { count (0); return (PARSEOP_XFERSIZE_256); } 644 645 /* TranslationKeyword: Translation Density Types - Resource Descriptors */ 646 647 "SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); } 648 "DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); } 649 650 /* TypeKeyword: Translation Types - Resource Descriptors */ 651 652 "TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); } 653 "TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); } 654 655 /* UpdateRuleKeyword: Field Update Rules */ 656 657 "Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); } 658 "WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); } 659 "WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); } 660 661 /* WireModeKeyword: SPI Wire Mode - Resource Descriptors (ACPI 5.0) */ 662 663 "FourWireMode" { count (0); return (PARSEOP_WIREMODE_FOUR); } 664 "ThreeWireMode" { count (0); return (PARSEOP_WIREMODE_THREE); } 665 666 /* XferTypeKeyword: DMA Transfer Types */ 667 668 "Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); } 669 "Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); } 670 "Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); } 671 672 /* ToPld macro */ 673 674 "ToPLD" { count (0); return (PARSEOP_TOPLD); } 675 676 "PLD_Revision" { count (0); return (PARSEOP_PLD_REVISION); } 677 "PLD_IgnoreColor" { count (0); return (PARSEOP_PLD_IGNORECOLOR); } 678 "PLD_Red" { count (0); return (PARSEOP_PLD_RED); } 679 "PLD_Green" { count (0); return (PARSEOP_PLD_GREEN); } 680 "PLD_Blue" { count (0); return (PARSEOP_PLD_BLUE); } 681 "PLD_Width" { count (0); return (PARSEOP_PLD_WIDTH); } 682 "PLD_Height" { count (0); return (PARSEOP_PLD_HEIGHT); } 683 "PLD_UserVisible" { count (0); return (PARSEOP_PLD_USERVISIBLE); } 684 "PLD_Dock" { count (0); return (PARSEOP_PLD_DOCK); } 685 "PLD_Lid" { count (0); return (PARSEOP_PLD_LID); } 686 "PLD_Panel" { count (0); return (PARSEOP_PLD_PANEL); } 687 "PLD_VerticalPosition" { count (0); return (PARSEOP_PLD_VERTICALPOSITION); } 688 "PLD_HorizontalPosition" { count (0); return (PARSEOP_PLD_HORIZONTALPOSITION); } 689 "PLD_Shape" { count (0); return (PARSEOP_PLD_SHAPE); } 690 "PLD_GroupOrientation" { count (0); return (PARSEOP_PLD_GROUPORIENTATION); } 691 "PLD_GroupToken" { count (0); return (PARSEOP_PLD_GROUPTOKEN); } 692 "PLD_GroupPosition" { count (0); return (PARSEOP_PLD_GROUPPOSITION); } 693 "PLD_Bay" { count (0); return (PARSEOP_PLD_BAY); } 694 "PLD_Ejectable" { count (0); return (PARSEOP_PLD_EJECTABLE); } 695 "PLD_EjectRequired" { count (0); return (PARSEOP_PLD_EJECTREQUIRED); } 696 "PLD_CabinetNumber" { count (0); return (PARSEOP_PLD_CABINETNUMBER); } 697 "PLD_CardCageNumber" { count (0); return (PARSEOP_PLD_CARDCAGENUMBER); } 698 "PLD_Reference" { count (0); return (PARSEOP_PLD_REFERENCE); } 699 "PLD_Rotation" { count (0); return (PARSEOP_PLD_ROTATION); } 700 "PLD_Order" { count (0); return (PARSEOP_PLD_ORDER); } 701 "PLD_Reserved" { count (0); return (PARSEOP_PLD_RESERVED); } 702 "PLD_VerticalOffset" { count (0); return (PARSEOP_PLD_VERTICALOFFSET); } 703 "PLD_HorizontalOffset" { count (0); return (PARSEOP_PLD_HORIZONTALOFFSET); } 704 705 706 /* printf debug macros */ 707 708 "printf" { count (0); return (PARSEOP_PRINTF); } 709 "fprintf" { count (0); return (PARSEOP_FPRINTF); } 710 711 /* Other macros */ 712 713 "For" { count (0); return (PARSEOP_FOR); } 714 715 /* Predefined compiler names */ 716 717 "__DATE__" { count (0); return (PARSEOP___DATE__); } 718 "__FILE__" { count (0); return (PARSEOP___FILE__); } 719 "__LINE__" { count (0); return (PARSEOP___LINE__); } 720 "__PATH__" { count (0); return (PARSEOP___PATH__); } 721 "__METHOD__" { count (0); return (PARSEOP___METHOD__); } 722 "__EXPECT__"{ErrorCode} { char *s; 723 unsigned int index = 0; 724 count (0); 725 while (!isdigit ((int) AslCompilertext[index])) 726 { 727 index++; 728 } 729 730 /* 731 * The error code is contained inside the 732 * {ErrorCode} pattern. Extract it and log it 733 * as the expected error code. 734 */ 735 s = UtLocalCacheCalloc (ASL_ERROR_CODE_LENGTH + 1); 736 memcpy (s, AslCompilertext + index, ASL_ERROR_CODE_LENGTH); 737 AslLogExpectedExceptionByLine (s); } 738 739 {NameSeg} { char *s; 740 count (0); 741 s=UtLocalCacheCalloc (ACPI_NAMESEG_SIZE + 1); 742 if (strcmp (AslCompilertext, "\\")) 743 { 744 /* 745 * According to the ACPI specification, 746 * NameSegments must have length of 4. If 747 * the NameSegment has length less than 4, 748 * they are padded with underscores to meet 749 * the required length. 750 */ 751 strcpy (s, "____"); 752 } 753 memcpy (s, AslCompilertext, strlen (AslCompilertext)); 754 AslCompilerlval.s = s; 755 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s); 756 return (PARSEOP_NAMESEG); } 757 758 {NameString} { char *s; 759 count (0); 760 s=UtLocalCacheCalloc (strlen (AslCompilertext)+1); 761 strcpy (s, AslCompilertext); 762 AslCompilerlval.s = s; 763 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s); 764 return (PARSEOP_NAMESTRING); } 765 766 . { count (1); 767 if (isprint ((int) *AslCompilertext)) 768 { 769 sprintf (AslGbl_MsgBuffer, 770 "Invalid character (%c), expecting ASL keyword or name", 771 *AslCompilertext); 772 } 773 else 774 { 775 sprintf (AslGbl_MsgBuffer, 776 "Invalid character (0x%2.2X), expecting ASL keyword or name", 777 *AslCompilertext); 778 } 779 AslCompilererror (AslGbl_MsgBuffer);} 780 781 <<EOF>> { if (AslPopInputFileStack ()) 782 {yyterminate();} 783 else 784 {return (PARSEOP_INCLUDE_END);} }; 785 786 %% 787 788 /*! [End] no source code translation !*/ 789 790 /* 791 * Bring in the scanner support routines 792 */ 793 #include "aslsupport.l" 794
Indexes created Wed Oct 01 19:09:53 GMT 2025