drivers/acpi/compiler/aslcompiler.l

   1 %{
   2 /******************************************************************************
   3  *
   4  * Module Name: aslcompiler.l - Flex/lex input file
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2015, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights. You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code. No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision. In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change. Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee. Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution. In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government. In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #include "aslcompiler.h"
 118 #include "aslcompiler.y.h"
 119
 120 #include <stdlib.h>
 121 #include <string.h>
 122 YYSTYPE AslCompilerlval;
 123
 124 /*
 125  * Generation:  Use the following command line:
 126  *
 127  * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath)
 128  *
 129  * -i: Scanner must be case-insensitive
 130  */
 131
 132 #define _COMPONENT          ACPI_COMPILER
 133         ACPI_MODULE_NAME    ("aslscanner")
 134
 135
 136 /* Local prototypes */
 137
 138 static void
 139 AslDoLineDirective (void);
 140
 141 static char
 142 AslDoComment (void);
 143
 144 static char
 145 AslDoCommentType2 (void);
 146
 147 static char
 148 AslDoStringLiteral (void);
 149
 150 static void
 151 count (int type);
 152
 153
 154 /*! [Begin] no source code translation */
 155
 156 %}
 157     /* Definitions */
 158
 159 LeadNameChar                [A-Za-z_]
 160 DigitChar                   [0-9]
 161 HexDigitChar                [A-Fa-f0-9]
 162 RootChar                    [\\]
 163 Nothing                     []
 164
 165 NameChar                    [A-Za-z_0-9]
 166 NameSeg1                    {LeadNameChar}{NameChar}
 167 NameSeg2                    {LeadNameChar}{NameChar}{NameChar}
 168 NameSeg3                    {LeadNameChar}{NameChar}{NameChar}{NameChar}
 169 NameSeg                     {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3}
 170
 171 NameString                  {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath}
 172 NamePath                    {NonEmptyNamePath}?
 173 NonEmptyNamePath            {NameSeg}{NamePathTail}*
 174 NamePathTail                [.]{NameSeg}
 175
 176 %%
 177     /* Rules */
 178
 179 [ ]                         { count (0); }
 180 [\n]                        { count (0); } /* Handle files with both LF and CR/LF */
 181 [\r]                        { count (0); } /* termination on both Unix and Windows */
 182 [ \t]                       { count (0); }
 183
 184
 185 "/*"                        { if (!AslDoComment ()) {yyterminate ();} }
 186 "//"                        { if (!AslDoCommentType2 ()) {yyterminate ();} }
 187
 188 "\""                        { if (AslDoStringLiteral ()) {return (PARSEOP_STRING_LITERAL);}
 189                               else {yyterminate ();} }
 190 ";"                         { count (0); return(';'); }
 191
 192     /* ASL Extension: Standard C operators */
 193
 194 "~"                         { count (3); return (PARSEOP_EXP_NOT); }
 195 "!"                         { count (3); return (PARSEOP_EXP_LOGICAL_NOT); }
 196 "*"                         { count (3); return (PARSEOP_EXP_MULTIPLY); }
 197 "/"                         { count (3); return (PARSEOP_EXP_DIVIDE); }
 198 "%"                         { count (3); return (PARSEOP_EXP_MODULO); }
 199 "+"                         { count (3); return (PARSEOP_EXP_ADD); }
 200 "-"                         { count (3); return (PARSEOP_EXP_SUBTRACT); }
 201 ">>"                        { count (3); return (PARSEOP_EXP_SHIFT_RIGHT); }
 202 "<<"                        { count (3); return (PARSEOP_EXP_SHIFT_LEFT); }
 203 "<"                         { count (3); return (PARSEOP_EXP_LESS); }
 204 ">"                         { count (3); return (PARSEOP_EXP_GREATER); }
 205 "&"                         { count (3); return (PARSEOP_EXP_AND); }
 206 "<="                        { count (3); return (PARSEOP_EXP_LESS_EQUAL); }
 207 ">="                        { count (3); return (PARSEOP_EXP_GREATER_EQUAL); }
 208 "=="                        { count (3); return (PARSEOP_EXP_EQUAL); }
 209 "!="                        { count (3); return (PARSEOP_EXP_NOT_EQUAL); }
 210 "|"                         { count (3); return (PARSEOP_EXP_OR); }
 211 "&&"                        { count (3); return (PARSEOP_EXP_LOGICAL_AND); }
 212 "||"                        { count (3); return (PARSEOP_EXP_LOGICAL_OR); }
 213 "++"                        { count (3); return (PARSEOP_EXP_INCREMENT); }
 214 "--"                        { count (3); return (PARSEOP_EXP_DECREMENT); }
 215 "^ "                        { count (3); return (PARSEOP_EXP_XOR); }
 216
 217     /* ASL Extension: Standard C assignment operators */
 218
 219 "="                         { count (3); return (PARSEOP_EXP_EQUALS); }
 220 "+="                        { count (3); return (PARSEOP_EXP_ADD_EQ); }
 221 "-="                        { count (3); return (PARSEOP_EXP_SUB_EQ); }
 222 "*="                        { count (3); return (PARSEOP_EXP_MUL_EQ); }
 223 "/="                        { count (3); return (PARSEOP_EXP_DIV_EQ); }
 224 "%="                        { count (3); return (PARSEOP_EXP_MOD_EQ); }
 225 "<<="                       { count (3); return (PARSEOP_EXP_SHL_EQ); }
 226 ">>="                       { count (3); return (PARSEOP_EXP_SHR_EQ); }
 227 "&="                        { count (3); return (PARSEOP_EXP_AND_EQ); }
 228 "^="                        { count (3); return (PARSEOP_EXP_XOR_EQ); }
 229 "|="                        { count (3); return (PARSEOP_EXP_OR_EQ); }
 230
 231
 232     /*
 233      * Begin standard ASL grammar
 234      */
 235 0[xX]{HexDigitChar}+ |
 236 {DigitChar}+                { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext);
 237                                 count (1); return (PARSEOP_INTEGER); }
 238
 239 "Include"                   { count (1); return (PARSEOP_INCLUDE); }
 240 "External"                  { count (1); return (PARSEOP_EXTERNAL); }
 241
 242  /*
 243   * The #line directive is emitted by the preprocessor and handled
 244   * here in the main iASL lexer - simply set the line number and
 245   * optionally the current filename.
 246   */
 247 "#line"                     { AslDoLineDirective ();}
 248
 249
 250  /****************************************************************************
 251   *
 252   * Main ASL operators
 253   *
 254   ****************************************************************************/
 255
 256 "AccessAs"                  { count (1); return (PARSEOP_ACCESSAS); }
 257 "Acquire"                   { count (3); return (PARSEOP_ACQUIRE); }
 258 "Add"                       { count (3); return (PARSEOP_ADD); }
 259 "Alias"                     { count (2); return (PARSEOP_ALIAS); }
 260 "And"                       { count (3); return (PARSEOP_AND); }
 261 "BankField"                 { count (2); return (PARSEOP_BANKFIELD); }
 262 "Break"                     { count (3); return (PARSEOP_BREAK); }
 263 "BreakPoint"                { count (3); return (PARSEOP_BREAKPOINT); }
 264 "Buffer"                    { count (1); return (PARSEOP_BUFFER); }
 265 "Case"                      { count (3); return (PARSEOP_CASE); }
 266 "Concatenate"               { count (3); return (PARSEOP_CONCATENATE); }
 267 "ConcatenateResTemplate"    { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); }
 268 "CondRefOf"                 { count (3); return (PARSEOP_CONDREFOF); }
 269 "Connection"                { count (2); return (PARSEOP_CONNECTION); }
 270 "Continue"                  { count (3); return (PARSEOP_CONTINUE); }
 271 "CopyObject"                { count (3); return (PARSEOP_COPYOBJECT); }
 272 "CreateBitField"            { count (2); return (PARSEOP_CREATEBITFIELD); }
 273 "CreateByteField"           { count (2); return (PARSEOP_CREATEBYTEFIELD); }
 274 "CreateDWordField"          { count (2); return (PARSEOP_CREATEDWORDFIELD); }
 275 "CreateField"               { count (2); return (PARSEOP_CREATEFIELD); }
 276 "CreateQWordField"          { count (2); return (PARSEOP_CREATEQWORDFIELD); }
 277 "CreateWordField"           { count (2); return (PARSEOP_CREATEWORDFIELD); }
 278 "DataTableRegion"           { count (2); return (PARSEOP_DATATABLEREGION); }
 279 "Debug"                     { count (1); return (PARSEOP_DEBUG); }
 280 "Decrement"                 { count (3); return (PARSEOP_DECREMENT); }
 281 "Default"                   { count (3); return (PARSEOP_DEFAULT); }
 282 "DefinitionBlock"           { count (1); return (PARSEOP_DEFINITIONBLOCK); }
 283 "DeRefOf"                   { count (3); return (PARSEOP_DEREFOF); }
 284 "Device"                    { count (2); return (PARSEOP_DEVICE); }
 285 "Divide"                    { count (3); return (PARSEOP_DIVIDE); }
 286 "Eisaid"                    { count (1); return (PARSEOP_EISAID); }
 287 "Else"                      { count (3); return (PARSEOP_ELSE); }
 288 "ElseIf"                    { count (3); return (PARSEOP_ELSEIF); }
 289 "Event"                     { count (2); return (PARSEOP_EVENT); }
 290 "Fatal"                     { count (3); return (PARSEOP_FATAL); }
 291 "Field"                     { count (2); return (PARSEOP_FIELD); }
 292 "FindSetLeftBit"            { count (3); return (PARSEOP_FINDSETLEFTBIT); }
 293 "FindSetRightBit"           { count (3); return (PARSEOP_FINDSETRIGHTBIT); }
 294 "FromBcd"                   { count (3); return (PARSEOP_FROMBCD); }
 295 "Function"                  { count (2); return (PARSEOP_FUNCTION); }
 296 "If"                        { count (3); return (PARSEOP_IF); }
 297 "Increment"                 { count (3); return (PARSEOP_INCREMENT); }
 298 "Index"                     { count (3); return (PARSEOP_INDEX); }
 299 "IndexField"                { count (2); return (PARSEOP_INDEXFIELD); }
 300 "LAnd"                      { count (3); return (PARSEOP_LAND); }
 301 "LEqual"                    { count (3); return (PARSEOP_LEQUAL); }
 302 "LGreater"                  { count (3); return (PARSEOP_LGREATER); }
 303 "LGreaterEqual"             { count (3); return (PARSEOP_LGREATEREQUAL); }
 304 "LLess"                     { count (3); return (PARSEOP_LLESS); }
 305 "LLessEqual"                { count (3); return (PARSEOP_LLESSEQUAL); }
 306 "LNot"                      { count (3); return (PARSEOP_LNOT); }
 307 "LNotEqual"                 { count (3); return (PARSEOP_LNOTEQUAL); }
 308 "Load"                      { count (3); return (PARSEOP_LOAD); }
 309 "LoadTable"                 { count (3); return (PARSEOP_LOADTABLE); }
 310 "LOr"                       { count (3); return (PARSEOP_LOR); }
 311 "Match"                     { count (3); return (PARSEOP_MATCH); }
 312 "Method"                    { count (2); return (PARSEOP_METHOD); }
 313 "Mid"                       { count (3); return (PARSEOP_MID); }
 314 "Mod"                       { count (3); return (PARSEOP_MOD); }
 315 "Multiply"                  { count (3); return (PARSEOP_MULTIPLY); }
 316 "Mutex"                     { count (2); return (PARSEOP_MUTEX); }
 317 "Name"                      { count (2); return (PARSEOP_NAME); }
 318 "NAnd"                      { count (3); return (PARSEOP_NAND); }
 319 "Noop"                      { if (!AcpiGbl_IgnoreNoopOperator) {count (3); return (PARSEOP_NOOP);} }
 320 "NOr"                       { count (3); return (PARSEOP_NOR); }
 321 "Not"                       { count (3); return (PARSEOP_NOT); }
 322 "Notify"                    { count (3); return (PARSEOP_NOTIFY); }
 323 "ObjectType"                { count (3); return (PARSEOP_OBJECTTYPE); }
 324 "Offset"                    { count (1); return (PARSEOP_OFFSET); }
 325 "One"                       { count (1); return (PARSEOP_ONE); }
 326 "Ones"                      { count (1); return (PARSEOP_ONES); }
 327 "OperationRegion"           { count (2); return (PARSEOP_OPERATIONREGION); }
 328 "Or"                        { count (3); return (PARSEOP_OR); }
 329 "Package"                   { count (1); return (PARSEOP_PACKAGE); }
 330 "PowerResource"             { count (2); return (PARSEOP_POWERRESOURCE); }
 331 "Processor"                 { count (2); return (PARSEOP_PROCESSOR); }
 332 "RefOf"                     { count (3); return (PARSEOP_REFOF); }
 333 "Release"                   { count (3); return (PARSEOP_RELEASE); }
 334 "Reset"                     { count (3); return (PARSEOP_RESET); }
 335 "Return"                    { count (3); return (PARSEOP_RETURN); }
 336 "Revision"                  { count (1); return (PARSEOP_REVISION); }
 337 "Scope"                     { count (2); return (PARSEOP_SCOPE); }
 338 "ShiftLeft"                 { count (3); return (PARSEOP_SHIFTLEFT); }
 339 "ShiftRight"                { count (3); return (PARSEOP_SHIFTRIGHT); }
 340 "Signal"                    { count (3); return (PARSEOP_SIGNAL); }
 341 "SizeOf"                    { count (3); return (PARSEOP_SIZEOF); }
 342 "Sleep"                     { count (3); return (PARSEOP_SLEEP); }
 343 "Stall"                     { count (3); return (PARSEOP_STALL); }
 344 "Store"                     { count (3); return (PARSEOP_STORE); }
 345 "Subtract"                  { count (3); return (PARSEOP_SUBTRACT); }
 346 "Switch"                    { count (3); return (PARSEOP_SWITCH); }
 347 "ThermalZone"               { count (2); return (PARSEOP_THERMALZONE); }
 348 "Timer"                     { count (3); return (PARSEOP_TIMER); }
 349 "ToBcd"                     { count (3); return (PARSEOP_TOBCD); }
 350 "ToBuffer"                  { count (3); return (PARSEOP_TOBUFFER); }
 351 "ToDecimalString"           { count (3); return (PARSEOP_TODECIMALSTRING); }
 352 "ToHexString"               { count (3); return (PARSEOP_TOHEXSTRING); }
 353 "ToInteger"                 { count (3); return (PARSEOP_TOINTEGER); }
 354 "ToString"                  { count (3); return (PARSEOP_TOSTRING); }
 355 "ToUuid"                    { count (1); return (PARSEOP_TOUUID); }
 356 "Unicode"                   { count (1); return (PARSEOP_UNICODE); }
 357 "Unload"                    { count (3); return (PARSEOP_UNLOAD); }
 358 "Wait"                      { count (3); return (PARSEOP_WAIT); }
 359 "While"                     { count (3); return (PARSEOP_WHILE); }
 360 "XOr"                       { count (3); return (PARSEOP_XOR); }
 361 "Zero"                      { count (1); return (PARSEOP_ZERO); }
 362
 363     /* Control method arguments and locals */
 364
 365 "Arg0"                      { count (1); return (PARSEOP_ARG0); }
 366 "Arg1"                      { count (1); return (PARSEOP_ARG1); }
 367 "Arg2"                      { count (1); return (PARSEOP_ARG2); }
 368 "Arg3"                      { count (1); return (PARSEOP_ARG3); }
 369 "Arg4"                      { count (1); return (PARSEOP_ARG4); }
 370 "Arg5"                      { count (1); return (PARSEOP_ARG5); }
 371 "Arg6"                      { count (1); return (PARSEOP_ARG6); }
 372 "Local0"                    { count (1); return (PARSEOP_LOCAL0); }
 373 "Local1"                    { count (1); return (PARSEOP_LOCAL1); }
 374 "Local2"                    { count (1); return (PARSEOP_LOCAL2); }
 375 "Local3"                    { count (1); return (PARSEOP_LOCAL3); }
 376 "Local4"                    { count (1); return (PARSEOP_LOCAL4); }
 377 "Local5"                    { count (1); return (PARSEOP_LOCAL5); }
 378 "Local6"                    { count (1); return (PARSEOP_LOCAL6); }
 379 "Local7"                    { count (1); return (PARSEOP_LOCAL7); }
 380
 381
 382  /****************************************************************************
 383   *
 384   * Resource Descriptor macros
 385   *
 386   ****************************************************************************/
 387
 388 "ResourceTemplate"          { count (1); return (PARSEOP_RESOURCETEMPLATE); }
 389 "RawDataBuffer"             { count (1); return (PARSEOP_DATABUFFER); }
 390
 391 "DMA"                       { count (1); return (PARSEOP_DMA); }
 392 "DWordIO"                   { count (1); return (PARSEOP_DWORDIO); }
 393 "DWordMemory"               { count (1); return (PARSEOP_DWORDMEMORY); }
 394 "DWordSpace"                { count (1); return (PARSEOP_DWORDSPACE); }
 395 "EndDependentFn"            { count (1); return (PARSEOP_ENDDEPENDENTFN); }
 396 "ExtendedIO"                { count (1); return (PARSEOP_EXTENDEDIO); }
 397 "ExtendedMemory"            { count (1); return (PARSEOP_EXTENDEDMEMORY); }
 398 "ExtendedSpace"             { count (1); return (PARSEOP_EXTENDEDSPACE); }
 399 "FixedDma"                  { count (1); return (PARSEOP_FIXEDDMA); }
 400 "FixedIO"                   { count (1); return (PARSEOP_FIXEDIO); }
 401 "GpioInt"                   { count (1); return (PARSEOP_GPIO_INT); }
 402 "GpioIo"                    { count (1); return (PARSEOP_GPIO_IO); }
 403 "I2cSerialBus"              { count (1); return (PARSEOP_I2C_SERIALBUS); }
 404 "Interrupt"                 { count (1); return (PARSEOP_INTERRUPT); }
 405 "IO"                        { count (1); return (PARSEOP_IO); }
 406 "IRQ"                       { count (1); return (PARSEOP_IRQ); }
 407 "IRQNoFlags"                { count (1); return (PARSEOP_IRQNOFLAGS); }
 408 "Memory24"                  { count (1); return (PARSEOP_MEMORY24); }
 409 "Memory32"                  { count (1); return (PARSEOP_MEMORY32); }
 410 "Memory32Fixed"             { count (1); return (PARSEOP_MEMORY32FIXED); }
 411 "QWordIO"                   { count (1); return (PARSEOP_QWORDIO); }
 412 "QWordMemory"               { count (1); return (PARSEOP_QWORDMEMORY); }
 413 "QWordSpace"                { count (1); return (PARSEOP_QWORDSPACE); }
 414 "Register"                  { count (1); return (PARSEOP_REGISTER); }
 415 "SpiSerialBus"              { count (1); return (PARSEOP_SPI_SERIALBUS); }
 416 "StartDependentFn"          { count (1); return (PARSEOP_STARTDEPENDENTFN); }
 417 "StartDependentFnNoPri"     { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); }
 418 "UartSerialBus"             { count (1); return (PARSEOP_UART_SERIALBUS); }
 419 "VendorLong"                { count (1); return (PARSEOP_VENDORLONG); }
 420 "VendorShort"               { count (1); return (PARSEOP_VENDORSHORT); }
 421 "WordBusNumber"             { count (1); return (PARSEOP_WORDBUSNUMBER); }
 422 "WordIO"                    { count (1); return (PARSEOP_WORDIO); }
 423 "WordSpace"                 { count (1); return (PARSEOP_WORDSPACE); }
 424
 425
 426  /****************************************************************************
 427   *
 428   * Keywords used as arguments to ASL operators and macros
 429   *
 430   ****************************************************************************/
 431
 432     /*  AccessAttribKeyword: Serial Bus Attributes (ACPI 5.0) */
 433
 434 "AttribQuick"               { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
 435 "AttribSendReceive"         { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
 436 "AttribByte"                { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
 437 "AttribWord"                { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
 438 "AttribBlock"               { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
 439 "AttribProcessCall"         { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
 440 "AttribBlockProcessCall"    { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
 441
 442     /* AccessAttribKeyword: Legacy synonyms for above (pre-ACPI 5.0) */
 443
 444 "SMBQuick"                  { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
 445 "SMBSendReceive"            { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
 446 "SMBByte"                   { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
 447 "SMBWord"                   { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
 448 "SMBBlock"                  { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
 449 "SMBProcessCall"            { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
 450 "SMBBlockProcessCall"       { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
 451
 452     /* AccessTypeKeyword: Field Access Types */
 453
 454 "AnyAcc"                    { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
 455 "ByteAcc"                   { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
 456 "WordAcc"                   { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
 457 "DWordAcc"                  { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
 458 "QWordAcc"                  { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
 459 "BufferAcc"                 { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
 460
 461     /* AddressingModeKeyword: Mode - Resource Descriptors (ACPI 5.0) */
 462
 463 "AddressingMode7Bit"        { count (0); return (PARSEOP_ADDRESSINGMODE_7BIT); }
 464 "AddressingMode10Bit"       { count (0); return (PARSEOP_ADDRESSINGMODE_10BIT); }
 465
 466     /* AddressKeyword: ACPI memory range types */
 467
 468 "AddressRangeMemory"        { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
 469 "AddressRangeReserved"      { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
 470 "AddressRangeNVS"           { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
 471 "AddressRangeACPI"          { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
 472
 473     /* BusMasterKeyword: DMA Bus Mastering */
 474
 475 "BusMaster"                 { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
 476 "NotBusMaster"              { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
 477
 478     /* ByteLengthKeyword: Bits per Byte - Resource Descriptors (ACPI 5.0) */
 479
 480 "DataBitsFive"              { count (0); return (PARSEOP_BITSPERBYTE_FIVE); }
 481 "DataBitsSix"               { count (0); return (PARSEOP_BITSPERBYTE_SIX); }
 482 "DataBitsSeven"             { count (0); return (PARSEOP_BITSPERBYTE_SEVEN); }
 483 "DataBitsEight"             { count (0); return (PARSEOP_BITSPERBYTE_EIGHT); }
 484 "DataBitsNine"              { count (0); return (PARSEOP_BITSPERBYTE_NINE); }
 485
 486     /* ClockPhaseKeyword: Resource Descriptors (ACPI 5.0) */
 487
 488 "ClockPhaseFirst"           { count (0); return (PARSEOP_CLOCKPHASE_FIRST); }
 489 "ClockPhaseSecond"          { count (0); return (PARSEOP_CLOCKPHASE_SECOND); }
 490
 491     /* ClockPolarityKeyword: Resource Descriptors (ACPI 5.0) */
 492
 493 "ClockPolarityLow"          { count (0); return (PARSEOP_CLOCKPOLARITY_LOW); }
 494 "ClockPolarityHigh"         { count (0); return (PARSEOP_CLOCKPOLARITY_HIGH); }
 495
 496     /* DecodeKeyword: Type of Memory Decoding - Resource Descriptors */
 497
 498 "PosDecode"                 { count (0); return (PARSEOP_DECODETYPE_POS); }
 499 "SubDecode"                 { count (0); return (PARSEOP_DECODETYPE_SUB); }
 500
 501     /* DmaTypeKeyword: DMA Types - DMA Resource Descriptor */
 502
 503 "Compatibility"             { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
 504 "TypeA"                     { count (0); return (PARSEOP_DMATYPE_A); }
 505 "TypeB"                     { count (0); return (PARSEOP_DMATYPE_B); }
 506 "TypeF"                     { count (0); return (PARSEOP_DMATYPE_F); }
 507
 508     /* EndianKeyword: Endian type - Resource Descriptor (ACPI 5.0) */
 509
 510 "LittleEndian"              { count (0); return (PARSEOP_ENDIAN_LITTLE); }
 511 "BigEndian"                 { count (0); return (PARSEOP_ENDIAN_BIG); }
 512
 513     /* ExtendedAttribKeyword: Bus attributes, AccessAs operator (ACPI 5.0) */
 514
 515 "AttribBytes"               { count (0); return (PARSEOP_ACCESSATTRIB_MULTIBYTE); }
 516 "AttribRawBytes"            { count (0); return (PARSEOP_ACCESSATTRIB_RAW_BYTES); }
 517 "AttribRawProcessBytes"     { count (0); return (PARSEOP_ACCESSATTRIB_RAW_PROCESS); }
 518
 519     /* FlowControlKeyword: Resource Descriptors (ACPI 5.0) */
 520
 521 "FlowControlHardware"       { count (0); return (PARSEOP_FLOWCONTROL_HW); }
 522 "FlowControlNone"           { count (0); return (PARSEOP_FLOWCONTROL_NONE); }
 523 "FlowControlXon"            { count (0); return (PARSEOP_FLOWCONTROL_SW); }
 524
 525     /* InterruptLevelKeyword: Interrupt Active Types */
 526
 527 "ActiveBoth"                { count (0); return (PARSEOP_INTLEVEL_ACTIVEBOTH); }
 528 "ActiveHigh"                { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
 529 "ActiveLow"                 { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
 530
 531     /* InterruptTypeKeyword: Interrupt Types */
 532
 533 "Edge"                      { count (0); return (PARSEOP_INTTYPE_EDGE); }
 534 "Level"                     { count (0); return (PARSEOP_INTTYPE_LEVEL); }
 535
 536     /* IoDecodeKeyword: Type of Memory Decoding - Resource Descriptors */
 537
 538 "Decode10"                  { count (0); return (PARSEOP_IODECODETYPE_10); }
 539 "Decode16"                  { count (0); return (PARSEOP_IODECODETYPE_16); }
 540
 541     /* IoRestrictionKeyword: I/O Restriction - GPIO Resource Descriptors (ACPI 5.0) */
 542
 543 "IoRestrictionNone"         { count (0); return (PARSEOP_IORESTRICT_NONE); }
 544 "IoRestrictionInputOnly"    { count (0); return (PARSEOP_IORESTRICT_IN); }
 545 "IoRestrictionOutputOnly"   { count (0); return (PARSEOP_IORESTRICT_OUT); }
 546 "IoRestrictionNoneAndPreserve"   { count (0); return (PARSEOP_IORESTRICT_PRESERVE); }
 547
 548     /* LockRuleKeyword: Global Lock use for Field Operator */
 549
 550 "Lock"                      { count (0); return (PARSEOP_LOCKRULE_LOCK); }
 551 "NoLock"                    { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
 552
 553     /* MatchOpKeyword: Types for Match Operator */
 554
 555 "MTR"                       { count (0); return (PARSEOP_MATCHTYPE_MTR); }
 556 "MEQ"                       { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
 557 "MLE"                       { count (0); return (PARSEOP_MATCHTYPE_MLE); }
 558 "MLT"                       { count (0); return (PARSEOP_MATCHTYPE_MLT); }
 559 "MGE"                       { count (0); return (PARSEOP_MATCHTYPE_MGE); }
 560 "MGT"                       { count (0); return (PARSEOP_MATCHTYPE_MGT); }
 561
 562     /* MaxKeyword: Max Range Type - Resource Descriptors */
 563
 564 "MaxFixed"                  { count (0); return (PARSEOP_MAXTYPE_FIXED); }
 565 "MaxNotFixed"               { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
 566
 567     /* MemTypeKeyword: Memory Types - Resource Descriptors */
 568
 569 "Cacheable"                 { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
 570 "WriteCombining"            { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
 571 "Prefetchable"              { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
 572 "NonCacheable"              { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
 573
 574     /* MinKeyword: Min Range Type - Resource Descriptors */
 575
 576 "MinFixed"                  { count (0); return (PARSEOP_MINTYPE_FIXED); }
 577 "MinNotFixed"               { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
 578
 579     /* ObjectTypeKeyword: ACPI Object Types */
 580
 581 "UnknownObj"                { count (0); return (PARSEOP_OBJECTTYPE_UNK); }
 582 "IntObj"                    { count (0); return (PARSEOP_OBJECTTYPE_INT); }
 583 "StrObj"                    { count (0); return (PARSEOP_OBJECTTYPE_STR); }
 584 "BuffObj"                   { count (0); return (PARSEOP_OBJECTTYPE_BUF); }
 585 "PkgObj"                    { count (0); return (PARSEOP_OBJECTTYPE_PKG); }
 586 "FieldUnitObj"              { count (0); return (PARSEOP_OBJECTTYPE_FLD); }
 587 "DeviceObj"                 { count (0); return (PARSEOP_OBJECTTYPE_DEV); }
 588 "EventObj"                  { count (0); return (PARSEOP_OBJECTTYPE_EVT); }
 589 "MethodObj"                 { count (0); return (PARSEOP_OBJECTTYPE_MTH); }
 590 "MutexObj"                  { count (0); return (PARSEOP_OBJECTTYPE_MTX); }
 591 "OpRegionObj"               { count (0); return (PARSEOP_OBJECTTYPE_OPR); }
 592 "PowerResObj"               { count (0); return (PARSEOP_OBJECTTYPE_POW); }
 593 "ProcessorObj"              { count (0); return (PARSEOP_OBJECTTYPE_PRO); }
 594 "ThermalZoneObj"            { count (0); return (PARSEOP_OBJECTTYPE_THZ); }
 595 "BuffFieldObj"              { count (0); return (PARSEOP_OBJECTTYPE_BFF); }
 596 "DDBHandleObj"              { count (0); return (PARSEOP_OBJECTTYPE_DDB); }
 597
 598     /* ParityKeyword: Resource Descriptors (ACPI 5.0) */
 599
 600 "ParityTypeSpace"           { count (0); return (PARSEOP_PARITYTYPE_SPACE); }
 601 "ParityTypeMark"            { count (0); return (PARSEOP_PARITYTYPE_MARK); }
 602 "ParityTypeOdd"             { count (0); return (PARSEOP_PARITYTYPE_ODD); }
 603 "ParityTypeEven"            { count (0); return (PARSEOP_PARITYTYPE_EVEN); }
 604 "ParityTypeNone"            { count (0); return (PARSEOP_PARITYTYPE_NONE); }
 605
 606     /* PinConfigKeyword: Pin Configuration - GPIO Resource Descriptors (ACPI 5.0) */
 607
 608 "PullDefault"               { count (0); return (PARSEOP_PIN_PULLDEFAULT); }
 609 "PullUp"                    { count (0); return (PARSEOP_PIN_PULLUP); }
 610 "PullDown"                  { count (0); return (PARSEOP_PIN_PULLDOWN); }
 611 "PullNone"                  { count (0); return (PARSEOP_PIN_NOPULL); }
 612
 613     /* PolarityKeyword: Resource Descriptors (ACPI 5.0) */
 614
 615 "PolarityLow"               { count (0); return (PARSEOP_DEVICEPOLARITY_LOW); }
 616 "PolarityHigh"              { count (0); return (PARSEOP_DEVICEPOLARITY_HIGH); }
 617
 618     /* RangeTypeKeyword: I/O Range Types - Resource Descriptors */
 619
 620 "ISAOnlyRanges"             { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
 621 "NonISAOnlyRanges"          { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
 622 "EntireRange"               { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
 623
 624     /* ReadWriteKeyword: Memory Access Types - Resource Descriptors */
 625
 626 "ReadWrite"                 { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
 627 "ReadOnly"                  { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
 628
 629     /* RegionSpaceKeyword: Operation Region Address Space Types */
 630
 631 "SystemIO"                  { count (0); return (PARSEOP_REGIONSPACE_IO); }
 632 "SystemMemory"              { count (0); return (PARSEOP_REGIONSPACE_MEM); }
 633 "PCI_Config"                { count (0); return (PARSEOP_REGIONSPACE_PCI); }
 634 "EmbeddedControl"           { count (0); return (PARSEOP_REGIONSPACE_EC); }
 635 "SMBus"                     { count (0); return (PARSEOP_REGIONSPACE_SMBUS); }
 636 "SystemCMOS"                { count (0); return (PARSEOP_REGIONSPACE_CMOS); }
 637 "PciBarTarget"              { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); }
 638 "IPMI"                      { count (0); return (PARSEOP_REGIONSPACE_IPMI); }
 639 "GeneralPurposeIo"          { count (0); return (PARSEOP_REGIONSPACE_GPIO); }       /* ACPI 5.0 */
 640 "GenericSerialBus"          { count (0); return (PARSEOP_REGIONSPACE_GSBUS); }      /* ACPI 5.0 */
 641 "PCC"                       { count (0); return (PARSEOP_REGIONSPACE_PCC); }        /* ACPI 5.0 */
 642 "FFixedHW"                  { count (0); return (PARSEOP_REGIONSPACE_FFIXEDHW); }
 643
 644     /* ResourceTypeKeyword: Resource Usage - Resource Descriptors */
 645
 646 "ResourceConsumer"          { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
 647 "ResourceProducer"          { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
 648
 649     /* SerializeRuleKeyword: Control Method Serialization */
 650
 651 "Serialized"                { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
 652 "NotSerialized"             { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
 653
 654     /* ShareTypeKeyword: Interrupt Sharing - Resource Descriptors */
 655
 656 "Shared"                    { count (0); return (PARSEOP_SHARETYPE_SHARED); }
 657 "Exclusive"                 { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
 658 "SharedAndWake"             { count (0); return (PARSEOP_SHARETYPE_SHAREDWAKE); }       /* ACPI 5.0 */
 659 "ExclusiveAndWake"          { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVEWAKE); }    /* ACPI 5.0 */
 660
 661     /* SlaveModeKeyword: Resource Descriptors (ACPI 5.0) */
 662
 663 "ControllerInitiated"       { count (0); return (PARSEOP_SLAVEMODE_CONTROLLERINIT); }
 664 "DeviceInitiated"           { count (0); return (PARSEOP_SLAVEMODE_DEVICEINIT); }
 665
 666     /* StopBitsKeyword: Resource Descriptors (ACPI 5.0) */
 667
 668 "StopBitsOne"               { count (0); return (PARSEOP_STOPBITS_ONE); }
 669 "StopBitsOnePlusHalf"       { count (0); return (PARSEOP_STOPBITS_ONEPLUSHALF); }
 670 "StopBitsTwo"               { count (0); return (PARSEOP_STOPBITS_TWO); }
 671 "StopBitsZero"              { count (0); return (PARSEOP_STOPBITS_ZERO); }
 672
 673     /* TransferWidthKeyword: DMA Widths - Fixed DMA Resource Descriptor (ACPI 5.0) */
 674
 675 "Width8bit"                 { count (0); return (PARSEOP_XFERSIZE_8); }
 676 "Width16bit"                { count (0); return (PARSEOP_XFERSIZE_16); }
 677 "Width32bit"                { count (0); return (PARSEOP_XFERSIZE_32); }
 678 "Width64bit"                { count (0); return (PARSEOP_XFERSIZE_64); }
 679 "Width128bit"               { count (0); return (PARSEOP_XFERSIZE_128); }
 680 "Width256bit"               { count (0); return (PARSEOP_XFERSIZE_256); }
 681
 682     /* TranslationKeyword: Translation Density Types - Resource Descriptors */
 683
 684 "SparseTranslation"         { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
 685 "DenseTranslation"          { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
 686
 687     /* TypeKeyword: Translation Types - Resource Descriptors */
 688
 689 "TypeTranslation"           { count (0); return (PARSEOP_TYPE_TRANSLATION); }
 690 "TypeStatic"                { count (0); return (PARSEOP_TYPE_STATIC); }
 691
 692     /* UpdateRuleKeyword: Field Update Rules */
 693
 694 "Preserve"                  { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
 695 "WriteAsOnes"               { count (0); return (PARSEOP_UPDATERULE_ONES); }
 696 "WriteAsZeros"              { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
 697
 698     /* WireModeKeyword: SPI Wire Mode - Resource Descriptors (ACPI 5.0) */
 699
 700 "FourWireMode"              { count (0); return (PARSEOP_WIREMODE_FOUR); }
 701 "ThreeWireMode"             { count (0); return (PARSEOP_WIREMODE_THREE); }
 702
 703     /* XferTypeKeyword: DMA Transfer Types */
 704
 705 "Transfer8"                 { count (0); return (PARSEOP_XFERTYPE_8); }
 706 "Transfer8_16"              { count (0); return (PARSEOP_XFERTYPE_8_16); }
 707 "Transfer16"                { count (0); return (PARSEOP_XFERTYPE_16); }
 708
 709     /* ToPld macro */
 710
 711 "ToPLD"                     { count (0); return (PARSEOP_TOPLD); }
 712
 713 "PLD_Revision"              { count (0); return (PARSEOP_PLD_REVISION); }
 714 "PLD_IgnoreColor"           { count (0); return (PARSEOP_PLD_IGNORECOLOR); }
 715 "PLD_Red"                   { count (0); return (PARSEOP_PLD_RED); }
 716 "PLD_Green"                 { count (0); return (PARSEOP_PLD_GREEN); }
 717 "PLD_Blue"                  { count (0); return (PARSEOP_PLD_BLUE); }
 718 "PLD_Width"                 { count (0); return (PARSEOP_PLD_WIDTH); }
 719 "PLD_Height"                { count (0); return (PARSEOP_PLD_HEIGHT); }
 720 "PLD_UserVisible"           { count (0); return (PARSEOP_PLD_USERVISIBLE); }
 721 "PLD_Dock"                  { count (0); return (PARSEOP_PLD_DOCK); }
 722 "PLD_Lid"                   { count (0); return (PARSEOP_PLD_LID); }
 723 "PLD_Panel"                 { count (0); return (PARSEOP_PLD_PANEL); }
 724 "PLD_VerticalPosition"      { count (0); return (PARSEOP_PLD_VERTICALPOSITION); }
 725 "PLD_HorizontalPosition"    { count (0); return (PARSEOP_PLD_HORIZONTALPOSITION); }
 726 "PLD_Shape"                 { count (0); return (PARSEOP_PLD_SHAPE); }
 727 "PLD_GroupOrientation"      { count (0); return (PARSEOP_PLD_GROUPORIENTATION); }
 728 "PLD_GroupToken"            { count (0); return (PARSEOP_PLD_GROUPTOKEN); }
 729 "PLD_GroupPosition"         { count (0); return (PARSEOP_PLD_GROUPPOSITION); }
 730 "PLD_Bay"                   { count (0); return (PARSEOP_PLD_BAY); }
 731 "PLD_Ejectable"             { count (0); return (PARSEOP_PLD_EJECTABLE); }
 732 "PLD_EjectRequired"         { count (0); return (PARSEOP_PLD_EJECTREQUIRED); }
 733 "PLD_CabinetNumber"         { count (0); return (PARSEOP_PLD_CABINETNUMBER); }
 734 "PLD_CardCageNumber"        { count (0); return (PARSEOP_PLD_CARDCAGENUMBER); }
 735 "PLD_Reference"             { count (0); return (PARSEOP_PLD_REFERENCE); }
 736 "PLD_Rotation"              { count (0); return (PARSEOP_PLD_ROTATION); }
 737 "PLD_Order"                 { count (0); return (PARSEOP_PLD_ORDER); }
 738 "PLD_Reserved"              { count (0); return (PARSEOP_PLD_RESERVED); }
 739 "PLD_VerticalOffset"        { count (0); return (PARSEOP_PLD_VERTICALOFFSET); }
 740 "PLD_HorizontalOffset"      { count (0); return (PARSEOP_PLD_HORIZONTALOFFSET); }
 741
 742
 743     /* printf debug macros */
 744 "printf"                    { count (0); return (PARSEOP_PRINTF); }
 745 "fprintf"                   { count (0); return (PARSEOP_FPRINTF); }
 746
 747     /* Predefined compiler names */
 748
 749 "__DATE__"                  { count (0); return (PARSEOP___DATE__); }
 750 "__FILE__"                  { count (0); return (PARSEOP___FILE__); }
 751 "__LINE__"                  { count (0); return (PARSEOP___LINE__); }
 752 "__PATH__"                  { count (0); return (PARSEOP___PATH__); }
 753
 754
 755 "{"                         { count (0); return('{'); }
 756 "}"                         { count (0); return('}'); }
 757 ","                         { count (0); return(','); }
 758 "("                         { count (0); return('('); }
 759 ")"                         { count (0); return(')'); }
 760
 761 {NameSeg}                   { char *s;
 762                                 count (0);
 763                                 s=UtStringCacheCalloc (ACPI_NAME_SIZE + 1);
 764                                 if (strcmp (AslCompilertext, "\\"))
 765                                 {
 766                                     strcpy (s, "____");
 767                                     AcpiUtStrupr (AslCompilertext);
 768                                 }
 769                                 memcpy (s, AslCompilertext, strlen (AslCompilertext));
 770                                 AslCompilerlval.s = s;
 771                                 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s);
 772                                 return (PARSEOP_NAMESEG); }
 773
 774 {NameString}                { char *s;
 775                                 count (0);
 776                                 s=UtStringCacheCalloc (strlen (AslCompilertext)+1);
 777                                 AcpiUtStrupr (AslCompilertext);
 778                                 strcpy (s, AslCompilertext);
 779                                 AslCompilerlval.s = s;
 780                                 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s);
 781                                 return (PARSEOP_NAMESTRING); }
 782
 783 .                           { count (1);
 784                                 if (ACPI_IS_PRINT (*AslCompilertext))
 785                                 {
 786                                     sprintf (MsgBuffer,
 787                                         "Invalid character (%c), expecting ASL keyword or name",
 788                                         *AslCompilertext);
 789                                 }
 790                                 else
 791                                 {
 792                                     sprintf (MsgBuffer,
 793                                         "Invalid character (0x%2.2X), expecting ASL keyword or name",
 794                                         *AslCompilertext);
 795                                 }
 796                                 AslCompilererror (MsgBuffer);}
 797
 798 <<EOF>>                     { if (AslPopInputFileStack ())
 799                                 {yyterminate();}
 800                               else
 801                                 {return (PARSEOP_INCLUDE_END);} };
 802
 803 %%
 804
 805 /*! [End] no source code translation !*/
 806
 807 /*
 808  * Bring in the scanner support routines
 809  */
 810 #include "aslsupport.l"