sys/contrib/dev/acpica-unix-20031203/compiler/aslcompiler.l

   1
   2 %{
   3 /******************************************************************************
   4  *
   5  * Module Name: aslcompiler.l - Flex input file
   6  *              $Revision: $
   7  *
   8  *****************************************************************************/
   9
  10 /******************************************************************************
  11  *
  12  * 1. Copyright Notice
  13  *
  14  * Some or all of this work - Copyright (c) 1999 - 2003, Intel Corp.
  15  * All rights reserved.
  16  *
  17  * 2. License
  18  *
  19  * 2.1. This is your license from Intel Corp. under its intellectual property
  20  * rights.  You may have additional license terms from the party that provided
  21  * you this software, covering your right to use that party's intellectual
  22  * property rights.
  23  *
  24  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  25  * copy of the source code appearing in this file ("Covered Code") an
  26  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  27  * base code distributed originally by Intel ("Original Intel Code") to copy,
  28  * make derivatives, distribute, use and display any portion of the Covered
  29  * Code in any form, with the right to sublicense such rights; and
  30  *
  31  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  32  * license (with the right to sublicense), under only those claims of Intel
  33  * patents that are infringed by the Original Intel Code, to make, use, sell,
  34  * offer to sell, and import the Covered Code and derivative works thereof
  35  * solely to the minimum extent necessary to exercise the above copyright
  36  * license, and in no event shall the patent license extend to any additions
  37  * to or modifications of the Original Intel Code.  No other license or right
  38  * is granted directly or by implication, estoppel or otherwise;
  39  *
  40  * The above copyright and patent license is granted only if the following
  41  * conditions are met:
  42  *
  43  * 3. Conditions
  44  *
  45  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  46  * Redistribution of source code of any substantial portion of the Covered
  47  * Code or modification with rights to further distribute source must include
  48  * the above Copyright Notice, the above License, this list of Conditions,
  49  * and the following Disclaimer and Export Compliance provision.  In addition,
  50  * Licensee must cause all Covered Code to which Licensee contributes to
  51  * contain a file documenting the changes Licensee made to create that Covered
  52  * Code and the date of any change.  Licensee must include in that file the
  53  * documentation of any changes made by any predecessor Licensee.  Licensee
  54  * must include a prominent statement that the modification is derived,
  55  * directly or indirectly, from Original Intel Code.
  56  *
  57  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  58  * Redistribution of source code of any substantial portion of the Covered
  59  * Code or modification without rights to further distribute source must
  60  * include the following Disclaimer and Export Compliance provision in the
  61  * documentation and/or other materials provided with distribution.  In
  62  * addition, Licensee may not authorize further sublicense of source of any
  63  * portion of the Covered Code, and must include terms to the effect that the
  64  * license from Licensee to its licensee is limited to the intellectual
  65  * property embodied in the software Licensee provides to its licensee, and
  66  * not to intellectual property embodied in modifications its licensee may
  67  * make.
  68  *
  69  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  70  * substantial portion of the Covered Code or modification must reproduce the
  71  * above Copyright Notice, and the following Disclaimer and Export Compliance
  72  * provision in the documentation and/or other materials provided with the
  73  * distribution.
  74  *
  75  * 3.4. Intel retains all right, title, and interest in and to the Original
  76  * Intel Code.
  77  *
  78  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  79  * Intel shall be used in advertising or otherwise to promote the sale, use or
  80  * other dealings in products derived from or relating to the Covered Code
  81  * without prior written authorization from Intel.
  82  *
  83  * 4. Disclaimer and Export Compliance
  84  *
  85  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  86  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  87  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  88  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  89  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  90  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  91  * PARTICULAR PURPOSE.
  92  *
  93  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  94  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  95  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  96  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  97  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  98  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  99  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
 100  * LIMITED REMEDY.
 101  *
 102  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 103  * software or system incorporating such software without first obtaining any
 104  * required license or other approval from the U. S. Department of Commerce or
 105  * any other agency or department of the United States Government.  In the
 106  * event Licensee exports any such software from the United States or
 107  * re-exports any such software from a foreign destination, Licensee shall
 108  * ensure that the distribution and export/re-export of the software is in
 109  * compliance with all laws, regulations, orders, or other restrictions of the
 110  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 111  * any of its subsidiaries will export/re-export any technical data, process,
 112  * software, or service, directly or indirectly, to any country for which the
 113  * United States government or any agency thereof requires an export license,
 114  * other governmental approval, or letter of assurance, without first obtaining
 115  * such license, approval or letter.
 116  *
 117  *****************************************************************************/
 118
 119
 120 #include <stdlib.h>
 121 #include <string.h>
 122 #include "aslcompiler.h"
 123 #include "aslcompiler.y.h"
 124 YYSTYPE AslCompilerlval;
 125
 126 /*
 127  * Generation:  Use the following command line:
 128  *
 129  * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath)
 130  *
 131  * -i: Scanner must be case-insensitive
 132  */
 133
 134 #define _COMPONENT          ACPI_COMPILER
 135         ACPI_MODULE_NAME    ("aslscan")
 136 char
 137 comment (void);
 138 char
 139 comment2 (void);
 140 void
 141 count (int type);
 142 char
 143 literal (void);
 144 void
 145 copy (void);
 146
 147 /*! [Begin] no source code translation */
 148
 149 %}
 150
 151
 152 LeadNameChar                [A-Za-z_]
 153 DigitChar                   [0-9]
 154 HexDigitChar                [A-Fa-f0-9]
 155 RootChar                    [\\]
 156 Nothing                     []
 157
 158 NameChar                    [A-Za-z_0-9]
 159 NameSeg1                    {LeadNameChar}{NameChar}
 160 NameSeg2                    {LeadNameChar}{NameChar}{NameChar}
 161 NameSeg3                    {LeadNameChar}{NameChar}{NameChar}{NameChar}
 162 NameSeg                     {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3}
 163
 164 NameString                  {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath}
 165 NamePath                    {NonEmptyNamePath}?
 166 NonEmptyNamePath            {NameSeg}{NamePathTail}*
 167 NamePathTail                [.]{NameSeg}
 168
 169 %%
 170
 171 [ ]                         { count (0); }
 172 [\n]                        { count (0); }
 173 [ \t]                       { count (0); }
 174
 175
 176 "/*"                        { if (!comment ()) yyterminate (); }
 177 "//"                        { if (!comment2 ()) yyterminate (); }
 178
 179 "\""                        { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); }
 180
 181
 182 0[xX]{HexDigitChar}+ |
 183 {DigitChar}+                { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext);
 184                                 count (1); return (PARSEOP_INTEGER); }
 185
 186 "Include"                   { count (1); return (PARSEOP_INCLUDE); }
 187 "#include"                  { count (1); return (PARSEOP_INCLUDE_CSTYLE); }
 188 "#line"                                         { count (1); return (PARSEOP_LINE_CSTYLE); }
 189 "External"                  { count (1); return (PARSEOP_EXTERNAL); }
 190
 191
 192 "Ones"                      { count (1); return (PARSEOP_ONES); }
 193 "One"                       { count (1); return (PARSEOP_ONE); }
 194 "Zero"                      { count (1); return (PARSEOP_ZERO); }
 195 "Revision"                  { count (1); return (PARSEOP_REVISION); }
 196
 197 "Offset"                    { count (1); return (PARSEOP_OFFSET); }
 198 "AccessAs"                  { count (1); return (PARSEOP_ACCESSAS); }
 199 "BankField"                 { count (2); return (PARSEOP_BANKFIELD); }
 200 "CreateBitField"            { count (2); return (PARSEOP_CREATEBITFIELD); }
 201 "CreateByteField"           { count (2); return (PARSEOP_CREATEBYTEFIELD); }
 202 "CreateDWordField"          { count (2); return (PARSEOP_CREATEDWORDFIELD); }
 203 "CreateField"               { count (2); return (PARSEOP_CREATEFIELD); }
 204 "CreateQWordField"          { count (2); return (PARSEOP_CREATEQWORDFIELD); }
 205 "CreateWordField"           { count (2); return (PARSEOP_CREATEWORDFIELD); }
 206 "DataTableRegion"           { count (2); return (PARSEOP_DATATABLEREGION); }
 207 "Device"                    { count (2); return (PARSEOP_DEVICE); }
 208 "Event"                     { count (2); return (PARSEOP_EVENT); }
 209 "Field"                     { count (2); return (PARSEOP_FIELD); }
 210 "IndexField"                { count (2); return (PARSEOP_INDEXFIELD); }
 211 "Method"                    { count (2); return (PARSEOP_METHOD); }
 212 "Mutex"                     { count (2); return (PARSEOP_MUTEX); }
 213 "OperationRegion"           { count (2); return (PARSEOP_OPERATIONREGION); }
 214 "PowerResource"             { count (2); return (PARSEOP_POWERRESOURCE); }
 215 "Processor"                 { count (2); return (PARSEOP_PROCESSOR); }
 216 "ThermalZone"               { count (2); return (PARSEOP_THERMALZONE); }
 217 "Alias"                     { count (2); return (PARSEOP_ALIAS); }
 218 "Name"                      { count (2); return (PARSEOP_NAME); }
 219 "Scope"                     { count (2); return (PARSEOP_SCOPE); }
 220 "Break"                     { count (3); return (PARSEOP_BREAK); }
 221 "BreakPoint"                { count (3); return (PARSEOP_BREAKPOINT); }
 222 "Continue"                  { count (3); return (PARSEOP_CONTINUE); }
 223 "Fatal"                     { count (3); return (PARSEOP_FATAL); }
 224 "If"                        { count (3); return (PARSEOP_IF); }
 225 "Else"                      { count (3); return (PARSEOP_ELSE); }
 226 "ElseIf"                    { count (3); return (PARSEOP_ELSEIF); }
 227 "Load"                      { count (3); return (PARSEOP_LOAD); }
 228 "Noop"                      { count (3); return (PARSEOP_NOOP); }
 229 "Notify"                    { count (3); return (PARSEOP_NOTIFY); }
 230 "Release"                   { count (3); return (PARSEOP_RELEASE); }
 231 "Reset"                     { count (3); return (PARSEOP_RESET); }
 232 "Return"                    { count (3); return (PARSEOP_RETURN); }
 233 "Signal"                    { count (3); return (PARSEOP_SIGNAL); }
 234 "Sleep"                     { count (3); return (PARSEOP_SLEEP); }
 235 "Stall"                     { count (3); return (PARSEOP_STALL); }
 236 "Switch"                    { count (3); return (PARSEOP_SWITCH); }
 237 "Case"                      { count (3); return (PARSEOP_CASE); }
 238 "Default"                   { count (3); return (PARSEOP_DEFAULT); }
 239 "Unload"                    { count (3); return (PARSEOP_UNLOAD); }
 240 "While"                     { count (3); return (PARSEOP_WHILE); }
 241
 242 "Acquire"                   { count (3); return (PARSEOP_ACQUIRE); }
 243 "Add"                       { count (3); return (PARSEOP_ADD); }
 244 "And"                       { count (3); return (PARSEOP_AND); }
 245 "Concatenate"               { count (3); return (PARSEOP_CONCATENATE); }
 246 "ConcatenateResTemplate"    { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); }
 247 "CondRefOf"                 { count (3); return (PARSEOP_CONDREFOF); }
 248 "CopyObject"                { count (3); return (PARSEOP_COPYOBJECT); }
 249 "Decrement"                 { count (3); return (PARSEOP_DECREMENT); }
 250 "DeRefOf"                   { count (3); return (PARSEOP_DEREFOF); }
 251 "Divide"                    { count (3); return (PARSEOP_DIVIDE); }
 252 "FindSetLeftBit"            { count (3); return (PARSEOP_FINDSETLEFTBIT); }
 253 "FindSetRightBit"           { count (3); return (PARSEOP_FINDSETRIGHTBIT); }
 254 "FromBCD"                   { count (3); return (PARSEOP_FROMBCD); }
 255 "Increment"                 { count (3); return (PARSEOP_INCREMENT); }
 256 "Index"                     { count (3); return (PARSEOP_INDEX); }
 257 "LAnd"                      { count (3); return (PARSEOP_LAND); }
 258 "LEqual"                    { count (3); return (PARSEOP_LEQUAL); }
 259 "LGreater"                  { count (3); return (PARSEOP_LGREATER); }
 260 "LGreaterEqual"             { count (3); return (PARSEOP_LGREATEREQUAL); }
 261 "LLess"                     { count (3); return (PARSEOP_LLESS); }
 262 "LLessEqual"                { count (3); return (PARSEOP_LLESSEQUAL); }
 263 "LNot"                      { count (3); return (PARSEOP_LNOT); }
 264 "LNotEqual"                 { count (3); return (PARSEOP_LNOTEQUAL); }
 265 "LoadTable"                 { count (3); return (PARSEOP_LOADTABLE); }
 266 "LOr"                       { count (3); return (PARSEOP_LOR); }
 267 "Match"                     { count (3); return (PARSEOP_MATCH); }
 268 "Mid"                       { count (3); return (PARSEOP_MID); }
 269 "Mod"                       { count (3); return (PARSEOP_MOD); }
 270 "Multiply"                  { count (3); return (PARSEOP_MULTIPLY); }
 271 "NAnd"                      { count (3); return (PARSEOP_NAND); }
 272 "NOr"                       { count (3); return (PARSEOP_NOR); }
 273 "Not"                       { count (3); return (PARSEOP_NOT); }
 274 "ObjectType"                { count (3); return (PARSEOP_OBJECTTYPE); }
 275 "Or"                        { count (3); return (PARSEOP_OR); }
 276 "RefOf"                     { count (3); return (PARSEOP_REFOF); }
 277 "ShiftLeft"                 { count (3); return (PARSEOP_SHIFTLEFT); }
 278 "ShiftRight"                { count (3); return (PARSEOP_SHIFTRIGHT); }
 279 "SizeOf"                    { count (3); return (PARSEOP_SIZEOF); }
 280 "Store"                     { count (3); return (PARSEOP_STORE); }
 281 "Subtract"                  { count (3); return (PARSEOP_SUBTRACT); }
 282 "ToBCD"                     { count (3); return (PARSEOP_TOBCD); }
 283 "ToBuffer"                  { count (3); return (PARSEOP_TOBUFFER); }
 284 "ToDecimalString"           { count (3); return (PARSEOP_TODECIMALSTRING); }
 285 "ToHexString"               { count (3); return (PARSEOP_TOHEXSTRING); }
 286 "ToInteger"                 { count (3); return (PARSEOP_TOINTEGER); }
 287 "ToString"                  { count (3); return (PARSEOP_TOSTRING); }
 288 "Wait"                      { count (3); return (PARSEOP_WAIT); }
 289 "XOr"                       { count (3); return (PARSEOP_XOR); }
 290
 291 "Arg0"                      { count (1); return (PARSEOP_ARG0); }
 292 "Arg1"                      { count (1); return (PARSEOP_ARG1); }
 293 "Arg2"                      { count (1); return (PARSEOP_ARG2); }
 294 "Arg3"                      { count (1); return (PARSEOP_ARG3); }
 295 "Arg4"                      { count (1); return (PARSEOP_ARG4); }
 296 "Arg5"                      { count (1); return (PARSEOP_ARG5); }
 297 "Arg6"                      { count (1); return (PARSEOP_ARG6); }
 298
 299 "Local0"                    { count (1); return (PARSEOP_LOCAL0); }
 300 "Local1"                    { count (1); return (PARSEOP_LOCAL1); }
 301 "Local2"                    { count (1); return (PARSEOP_LOCAL2); }
 302 "Local3"                    { count (1); return (PARSEOP_LOCAL3); }
 303 "Local4"                    { count (1); return (PARSEOP_LOCAL4); }
 304 "Local5"                    { count (1); return (PARSEOP_LOCAL5); }
 305 "Local6"                    { count (1); return (PARSEOP_LOCAL6); }
 306 "Local7"                    { count (1); return (PARSEOP_LOCAL7); }
 307
 308 "Debug"                     { count (1); return (PARSEOP_DEBUG); }
 309
 310 "DefinitionBlock"           { count (1); return (PARSEOP_DEFINITIONBLOCK); }
 311 "Buffer"                    { count (1); return (PARSEOP_BUFFER); }
 312 "Package"                   { count (1); return (PARSEOP_PACKAGE); }
 313
 314 "EISAID"                    { count (1); return (PARSEOP_EISAID); }
 315 "ResourceTemplate"          { count (1); return (PARSEOP_RESOURCETEMPLATE); }
 316 "Unicode"                   { count (1); return (PARSEOP_UNICODE); }
 317 "DMA"                       { count (1); return (PARSEOP_DMA); }
 318 "DWordIO"                   { count (1); return (PARSEOP_DWORDIO); }
 319 "DWordMemory"               { count (1); return (PARSEOP_DWORDMEMORY); }
 320 "EndDependentFn"            { count (1); return (PARSEOP_ENDDEPENDENTFN); }
 321 "FixedIO"                   { count (1); return (PARSEOP_FIXEDIO); }
 322 "Interrupt"                 { count (1); return (PARSEOP_INTERRUPT); }
 323 "IO"                        { count (1); return (PARSEOP_IO); }
 324 "IRQNoFlags"                { count (1); return (PARSEOP_IRQNOFLAGS); }
 325 "IRQ"                       { count (1); return (PARSEOP_IRQ); }
 326 "Memory24"                  { count (1); return (PARSEOP_MEMORY24); }
 327 "Memory32Fixed"             { count (1); return (PARSEOP_MEMORY32FIXED); }
 328 "Memory32"                  { count (1); return (PARSEOP_MEMORY32); }
 329 "QWordIO"                   { count (1); return (PARSEOP_QWORDIO); }
 330 "QWordMemory"               { count (1); return (PARSEOP_QWORDMEMORY); }
 331 "Register"                  { count (1); return (PARSEOP_REGISTER); }
 332 "StartDependentFn"          { count (1); return (PARSEOP_STARTDEPENDENTFN); }
 333 "StartDependentFnNoPri"     { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); }
 334 "VendorLong"                { count (1); return (PARSEOP_VENDORLONG); }
 335 "VendorShort"               { count (1); return (PARSEOP_VENDORSHORT); }
 336 "WordBusNumber"             { count (1); return (PARSEOP_WORDBUSNUMBER); }
 337 "WordIO"                    { count (1); return (PARSEOP_WORDIO); }
 338
 339 "UnknownObj"                { count (0); return (PARSEOP_OBJECTTYPE_UNK); }
 340 "IntObj"                    { count (0); return (PARSEOP_OBJECTTYPE_INT); }
 341 "StrObj"                    { count (0); return (PARSEOP_OBJECTTYPE_STR); }
 342 "BuffObj"                   { count (0); return (PARSEOP_OBJECTTYPE_BUF); }
 343 "PkgObj"                    { count (0); return (PARSEOP_OBJECTTYPE_PKG); }
 344 "FieldUnitObj"              { count (0); return (PARSEOP_OBJECTTYPE_FLD); }
 345 "DeviceObj"                 { count (0); return (PARSEOP_OBJECTTYPE_DEV); }
 346 "EventObj"                  { count (0); return (PARSEOP_OBJECTTYPE_EVT); }
 347 "MethodObj"                 { count (0); return (PARSEOP_OBJECTTYPE_MTH); }
 348 "MutexObj"                  { count (0); return (PARSEOP_OBJECTTYPE_MTX); }
 349 "OpRegionObj"               { count (0); return (PARSEOP_OBJECTTYPE_OPR); }
 350 "PowerResObj"               { count (0); return (PARSEOP_OBJECTTYPE_POW); }
 351 "ThermalZoneObj"            { count (0); return (PARSEOP_OBJECTTYPE_THZ); }
 352 "BuffFieldObj"              { count (0); return (PARSEOP_OBJECTTYPE_BFF); }
 353 "DDBHandleObj"              { count (0); return (PARSEOP_OBJECTTYPE_DDB); }
 354
 355 "AnyAcc"                    { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
 356 "ByteAcc"                   { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
 357 "WordAcc"                   { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
 358 "DWordAcc"                  { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
 359 "QWordAcc"                  { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
 360 "BufferAcc"                 { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
 361
 362 "Lock"                      { count (0); return (PARSEOP_LOCKRULE_LOCK); }
 363 "NoLock"                    { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
 364
 365 "Preserve"                  { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
 366 "WriteAsOnes"               { count (0); return (PARSEOP_UPDATERULE_ONES); }
 367 "WriteAsZeros"              { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
 368
 369 "Serialized"                { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
 370 "NotSerialized"             { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
 371
 372 "SystemIO"                  { count (0); return (PARSEOP_REGIONSPACE_IO); }
 373 "SystemMemory"              { count (0); return (PARSEOP_REGIONSPACE_MEM); }
 374 "PCI_Config"                { count (0); return (PARSEOP_REGIONSPACE_PCI); }
 375 "EmbeddedControl"           { count (0); return (PARSEOP_REGIONSPACE_EC); }
 376 "SMBus"                     { count (0); return (PARSEOP_REGIONSPACE_SMBUS); }
 377 "SystemCMOS"                { count (0); return (PARSEOP_REGIONSPACE_CMOS); }
 378 "PciBarTarget"              { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); }
 379
 380 "FFixedHW"                  { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); }
 381
 382 "SMBQuick"                  { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
 383 "SMBSendReceive"            { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
 384 "SMBByte"                   { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
 385 "SMBWord"                   { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
 386 "SMBBlock"                  { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
 387 "SMBProcessCall"            { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
 388 "SMBBlockProcessCall"       { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
 389
 390 "MTR"                       { count (0); return (PARSEOP_MATCHTYPE_MTR); }
 391 "MEQ"                       { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
 392 "MLE"                       { count (0); return (PARSEOP_MATCHTYPE_MLE); }
 393 "MLT"                       { count (0); return (PARSEOP_MATCHTYPE_MLT); }
 394 "MGE"                       { count (0); return (PARSEOP_MATCHTYPE_MGE); }
 395 "MGT"                       { count (0); return (PARSEOP_MATCHTYPE_MGT); }
 396
 397 "Compatibility"             { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
 398 "TypeA"                     { count (0); return (PARSEOP_DMATYPE_A); }
 399 "TypeB"                     { count (0); return (PARSEOP_DMATYPE_B); }
 400 "TypeF"                     { count (0); return (PARSEOP_DMATYPE_F); }
 401
 402 "BusMaster"                 { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
 403 "NotBusMaster"              { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
 404
 405 "Transfer8"                 { count (0); return (PARSEOP_XFERTYPE_8); }
 406 "Transfer8_16"              { count (0); return (PARSEOP_XFERTYPE_8_16); }
 407 "Transfer16"                { count (0); return (PARSEOP_XFERTYPE_16); }
 408
 409 "ResourceConsumer"          { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
 410 "ResourceProducer"          { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
 411
 412 "MinFixed"                  { count (0); return (PARSEOP_MINTYPE_FIXED); }
 413 "MinNotFixed"               { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
 414
 415 "MaxFixed"                  { count (0); return (PARSEOP_MAXTYPE_FIXED); }
 416 "MaxNotFixed"               { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
 417
 418 "PosDecode"                 { count (0); return (PARSEOP_DECODETYPE_POS); }
 419 "SubDecode"                 { count (0); return (PARSEOP_DECODETYPE_SUB); }
 420
 421 "ISAOnlyRanges"             { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
 422 "NonISAOnlyRanges"          { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
 423 "EntireRange"               { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
 424
 425 "Cacheable"                 { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
 426 "WriteCombining"            { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
 427 "Prefetchable"              { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
 428 "NonCacheable"              { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
 429
 430 "ReadWrite"                 { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
 431 "ReadOnly"                  { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
 432
 433 "Edge"                      { count (0); return (PARSEOP_INTTYPE_EDGE); }
 434 "Level"                     { count (0); return (PARSEOP_INTTYPE_LEVEL); }
 435
 436 "ActiveHigh"                { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
 437 "ActiveLow"                 { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
 438
 439 "Shared"                    { count (0); return (PARSEOP_SHARETYPE_SHARED); }
 440 "Exclusive"                 { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
 441
 442 "Decode10"                  { count (0); return (PARSEOP_IODECODETYPE_10); }
 443 "Decode16"                  { count (0); return (PARSEOP_IODECODETYPE_16); }
 444
 445 "TypeTranslation"           { count (0); return (PARSEOP_TYPE_TRANSLATION); }
 446 "TypeStatic"                { count (0); return (PARSEOP_TYPE_STATIC); }
 447
 448 "SparseTranslation"         { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
 449 "DenseTranslation"          { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
 450
 451 "AddressRangeMemory"        { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
 452 "AddressRangeReserved"      { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
 453 "AddressRangeNVS"           { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
 454 "AddressRangeACPI"          { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
 455
 456
 457 "{"                         { count (0); return('{'); }
 458 "}"                         { count (0); return('}'); }
 459 ","                         { count (0); return(','); }
 460 "("                         { count (0); return('('); }
 461 ")"                         { count (0); return(')'); }
 462
 463
 464 {NameSeg}                   { char *s;
 465                                 count (0);
 466                                 s=malloc (ACPI_NAME_SIZE + 1);
 467                                 if (strcmp (AslCompilertext, "\\"))
 468                                 {
 469                                     strcpy (s, "____");
 470                                     ACPI_STRUPR (AslCompilertext);
 471                                 }
 472                                 memcpy (s, AslCompilertext, strlen (AslCompilertext));
 473                                 AslCompilerlval.s = s;
 474                                 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s);
 475                                 return (PARSEOP_NAMESEG); }
 476
 477 {NameString}                { char *s;
 478                                 count (0);
 479                                 s=malloc (strlen (AslCompilertext)+1);
 480                                 ACPI_STRUPR (AslCompilertext);
 481                                 strcpy (s, AslCompilertext);
 482                                 s[strlen (AslCompilertext)] = 0;
 483                                 AslCompilerlval.s = s;
 484                                 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s);
 485                                 return (PARSEOP_NAMESTRING); }
 486
 487 "*" |
 488 "/"                         { count (1);
 489                                 AslCompilererror ("Parse error, expecting ASL keyword or name");}
 490
 491 .                           { count (1);
 492                                 sprintf (MsgBuffer,
 493                                     "Invalid character (0x%2.2X), expecting ASL keyword or name",
 494                                     *AslCompilertext);
 495                                 AslCompilererror (MsgBuffer);}
 496
 497 <<EOF>>                     { if (AslPopInputFileStack ())
 498                                 yyterminate();
 499                               else
 500                                 return (PARSEOP_INCLUDE_END);};
 501
 502 %%
 503
 504 /*! [End] no source code translation !*/
 505
 506 typedef struct asl_file_node
 507 {
 508     FILE                    *File;
 509     UINT32                  CurrentLineNumber;
 510     YY_BUFFER_STATE         State;
 511     char                    *Filename;
 512     struct asl_file_node    *Next;
 513
 514 } ASL_FILE_NODE;
 515
 516 ASL_FILE_NODE               *InputStack = NULL;
 517
 518
 519 /*******************************************************************************
 520  *
 521  * FUNCTION:    AslPopInputFileStack
 522  *
 523  * PARAMETERS:  None
 524  *
 525  * RETURN:      0 if a node was popped, -1 otherwise
 526  *
 527  * DESCRIPTION: Pop the top of the input file stack and point the parser to
 528  *              the saved parse buffer contained in the fnode.  Also, set the
 529  *              global line counters to the saved values.  This function is
 530  *              called when an include file reaches EOF.
 531  *
 532  ******************************************************************************/
 533
 534 int
 535 AslPopInputFileStack (
 536     void)
 537 {
 538     ASL_FILE_NODE           *Fnode;
 539     FILE                    *InputFile = NULL;
 540
 541
 542     Fnode = InputStack;
 543     DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
 544
 545
 546     if (!Fnode)
 547     {
 548         return -1;
 549     }
 550
 551     /* Close the current include file */
 552
 553     fclose (yyin);
 554
 555     /* Update the top-of-stack */
 556
 557     InputStack = Fnode->Next;
 558     InputFile = Fnode->File;
 559
 560     /* Reset global line counter and filename */
 561
 562     Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
 563     Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
 564
 565     /* Point the parser to the popped file */
 566
 567     yy_delete_buffer (YY_CURRENT_BUFFER);
 568     yy_switch_to_buffer (Fnode->State);
 569
 570     /* All done with this node */
 571
 572     ACPI_MEM_FREE (Fnode);
 573     return 0;
 574 }
 575
 576
 577 /*******************************************************************************
 578  *
 579  * FUNCTION:    AslPushInputFileStack
 580  *
 581  * PARAMETERS:  InputFile           - Open file pointer
 582  *              Filename            - Name of the file
 583  *
 584  * RETURN:      None
 585  *
 586  * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
 587  *              to this file.  Called when an include file is successfully
 588  *              opened.
 589  *
 590  ******************************************************************************/
 591
 592 void
 593 AslPushInputFileStack (
 594     FILE                    *InputFile,
 595     char                    *Filename)
 596 {
 597     ASL_FILE_NODE           *Fnode;
 598     YY_BUFFER_STATE         State;
 599
 600
 601     /* Save the current state in an Fnode */
 602
 603     Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
 604
 605     Fnode->File                 = yyin;
 606     Fnode->Next                 = InputStack;
 607     Fnode->State                = YY_CURRENT_BUFFER;
 608     Fnode->CurrentLineNumber    = Gbl_CurrentLineNumber;
 609     Fnode->Filename             = Gbl_Files[ASL_FILE_INPUT].Filename;
 610
 611     /* Push it on the stack */
 612
 613     InputStack = Fnode;
 614
 615     /* Point the parser to this file */
 616
 617     State = yy_create_buffer (InputFile, YY_BUF_SIZE);
 618     yy_switch_to_buffer (State);
 619
 620     DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
 621
 622     /* Reset the global line count and filename */
 623
 624     Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
 625     Gbl_CurrentLineNumber = 1;
 626     yyin = InputFile;
 627 }
 628
 629
 630 /*******************************************************************************
 631  *
 632  * FUNCTION:    ResetCurrentLineBuffer
 633  *
 634  * PARAMETERS:  None
 635  *
 636  * RETURN:      None
 637  *
 638  * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
 639  *
 640  ******************************************************************************/
 641
 642 void
 643 ResetCurrentLineBuffer (
 644     void)
 645 {
 646
 647     if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
 648     {
 649         FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
 650             Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
 651     }
 652
 653     Gbl_CurrentLineOffset += Gbl_CurrentColumn;
 654     Gbl_CurrentColumn = 0;
 655
 656     Gbl_CurrentLineNumber++;
 657     Gbl_LogicalLineNumber++;
 658     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
 659 }
 660
 661
 662 /*******************************************************************************
 663  *
 664  * FUNCTION:    InsertLineBuffer
 665  *
 666  * PARAMETERS:  SourceChar      - One char from the input ASL source file
 667  *
 668  * RETURN:      None
 669  *
 670  * DESCRIPTION: Put one character of the source file into the temp line buffer
 671  *
 672  ******************************************************************************/
 673
 674 #define ASL_SPACES_PER_TAB  4
 675
 676 void
 677 InsertLineBuffer (
 678     int                     SourceChar)
 679 {
 680     UINT32                  i;
 681     UINT32                  Count = 1;
 682
 683
 684     if (SourceChar == EOF)
 685     {
 686         return;
 687     }
 688
 689     Gbl_InputByteCount++;
 690
 691     /* Handle tabs.  Convert to spaces */
 692
 693     if (SourceChar == '\t')
 694     {
 695         SourceChar = ' ';
 696         Count = ASL_SPACES_PER_TAB -
 697                     (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
 698     }
 699
 700
 701     for (i = 0; i < Count; i++)
 702     {
 703         Gbl_CurrentColumn++;
 704
 705         /* Insert the character into the line buffer */
 706
 707         *Gbl_LineBufPtr = (UINT8) SourceChar;
 708         Gbl_LineBufPtr++;
 709
 710         if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1)))
 711         {
 712 #if 0
 713             /*
 714              * Warning if we have split a long source line.
 715              * <Probably overkill>
 716              */
 717             sprintf (MsgBuffer, "Max %d", ASL_LINE_BUFFER_SIZE);
 718             AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
 719                             Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 720                             Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 721                             Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
 722 #endif
 723
 724             ResetCurrentLineBuffer ();
 725         }
 726         else if (SourceChar == '\n')
 727         {
 728             /* End of line */
 729
 730             ResetCurrentLineBuffer ();
 731         }
 732     }
 733 }
 734
 735
 736 /*******************************************************************************
 737  *
 738  * FUNCTION:    count
 739  *
 740  * PARAMETERS:  yytext      - Contains the matched keyword.
 741  *              Type        - Keyword/Character type:
 742  *                             0 = anything except a keyword
 743  *                             1 = pseudo-keywords
 744  *                             2 = non-executable ASL keywords
 745  *                             3 = executable ASL keywords
 746  *
 747  * RETURN:      None
 748  *
 749  * DESCRIPTION: Count keywords and put them into the line buffer
 750  *
 751  ******************************************************************************/
 752
 753 void
 754 count (
 755     int                 Type)
 756 {
 757     int                 i;
 758
 759
 760     switch (Type)
 761     {
 762     case 2:
 763         TotalKeywords++;
 764         TotalNamedObjects++;
 765         break;
 766
 767     case 3:
 768         TotalKeywords++;
 769         TotalExecutableOpcodes++;
 770         break;
 771     }
 772
 773     for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
 774     {
 775         InsertLineBuffer (yytext[i]);
 776         *Gbl_LineBufPtr = 0;
 777     }
 778 }
 779
 780
 781 /*******************************************************************************
 782  *
 783  * FUNCTION:    comment
 784  *
 785  * PARAMETERS:  none
 786  *
 787  * RETURN:      none
 788  *
 789  * DESCRIPTION: Process a standard comment.
 790  *
 791  ******************************************************************************/
 792
 793 char
 794 comment (void)
 795 {
 796     char                c;
 797     char                c1 = 0;
 798
 799
 800     InsertLineBuffer ('/');
 801     InsertLineBuffer ('*');
 802
 803 loop:
 804
 805     /* Eat chars until end-of-comment */
 806
 807     while ((c = (char) input()) != '*' && c != EOF)
 808     {
 809         InsertLineBuffer (c);
 810         c1 = c;
 811     }
 812
 813     if (c == EOF)
 814     {
 815         goto EarlyEOF;
 816     }
 817
 818     /*
 819      * Check for nested comment -- can help catch cases where a previous
 820      * comment was accidently left unterminated
 821      */
 822     if ((c1 == '/') && (c == '*'))
 823     {
 824         AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
 825                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 826                         Gbl_InputByteCount, Gbl_CurrentColumn,
 827                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 828     }
 829
 830     /* Comment is closed only if the NEXT character is a slash */
 831
 832     InsertLineBuffer (c);
 833
 834     if ((c1 = (char) input()) != '/' && c1 != EOF)
 835     {
 836         unput(c1);
 837         goto loop;
 838     }
 839
 840     if (c1 == EOF)
 841     {
 842         goto EarlyEOF;
 843     }
 844
 845     InsertLineBuffer (c1);
 846     return TRUE;
 847
 848
 849 EarlyEOF:
 850     /*
 851      * Premature End-Of-File
 852      */
 853     AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
 854                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 855                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 856                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 857     return (FALSE);
 858 }
 859
 860
 861 /*******************************************************************************
 862  *
 863  * FUNCTION:    comment
 864  *
 865  * PARAMETERS:  none
 866  *
 867  * RETURN:      none
 868  *
 869  * DESCRIPTION: Process a new "//" comment.
 870  *
 871  ******************************************************************************/
 872
 873 char
 874 comment2 (void)
 875 {
 876     char                c;
 877
 878
 879     InsertLineBuffer ('/');
 880     InsertLineBuffer ('/');
 881
 882     while ((c = (char) input()) != '\n' && c != EOF)
 883     {
 884         InsertLineBuffer (c);
 885     }
 886
 887     if (c == EOF)
 888     {
 889         /*
 890          * Premature End-Of-File
 891          */
 892         AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
 893                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 894                         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 895                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 896         return (FALSE);
 897     }
 898
 899     InsertLineBuffer (c);
 900     return (TRUE);
 901 }
 902
 903
 904 /*******************************************************************************
 905  *
 906  * FUNCTION:    literal
 907  *
 908  * PARAMETERS:  none
 909  *
 910  * RETURN:      none
 911  *
 912  * DESCRIPTION: Process a string literal (surrounded by quotes)
 913  *
 914  ******************************************************************************/
 915
 916 #define ASL_NORMAL_CHAR         0
 917 #define ASL_ESCAPE_SEQUENCE     1
 918 #define ASL_OCTAL_CONSTANT      2
 919 #define ASL_HEX_CONSTANT        3
 920
 921 char
 922 literal (void)
 923 {
 924     char                *s = MsgBuffer;
 925     char                *CleanString;
 926     char                StringChar;
 927     UINT32              State = ASL_NORMAL_CHAR;
 928     UINT32              i = 0;
 929     UINT8               Digit;
 930     char                ConvertBuffer[4];
 931
 932
 933     /*
 934      * Eat chars until end-of-literal.
 935      * NOTE:  Put back the original surrounding quotes into the
 936      * source line buffer.
 937      */
 938     InsertLineBuffer ('\"');
 939     while ((StringChar = (char) input()) != EOF)
 940     {
 941         InsertLineBuffer (StringChar);
 942
 943 DoCharacter:
 944
 945         switch (State)
 946         {
 947         case ASL_NORMAL_CHAR:
 948
 949             switch (StringChar)
 950             {
 951             case '\\':
 952                 /*
 953                  * Special handling for backslash-escape sequence.  We will
 954                  * toss the backslash and translate the escape char(s).
 955                  */
 956                 State = ASL_ESCAPE_SEQUENCE;
 957                 continue;
 958
 959             case '\"':
 960
 961                 /* String terminator */
 962
 963                 goto CompletedString;
 964             }
 965             break;
 966
 967
 968         case ASL_ESCAPE_SEQUENCE:
 969
 970             State = ASL_NORMAL_CHAR;
 971             switch (StringChar)
 972             {
 973             case 'a':
 974                 StringChar = 0x07;      /* BELL */
 975                 break;
 976
 977             case 'b':
 978                 StringChar = 0x08;      /* BACKSPACE */
 979                 break;
 980
 981             case 'f':
 982                 StringChar = 0x0C;      /* FORMFEED */
 983                 break;
 984
 985             case 'n':
 986                 StringChar = 0x0A;      /* LINEFEED */
 987                 break;
 988
 989             case 'r':
 990                 StringChar = 0x0D;      /* CARRIAGE RETURN*/
 991                 break;
 992
 993             case 't':
 994                 StringChar = 0x09;      /* HORIZONTAL TAB */
 995                 break;
 996
 997             case 'v':
 998                 StringChar = 0x0B;      /* VERTICAL TAB */
 999                 break;
1000
1001             case 'x':
1002                 State = ASL_HEX_CONSTANT;
1003                 i = 0;
1004                 continue;
1005
1006             case '\'':                  /* Single Quote */
1007             case '\"':                  /* Double Quote */
1008             case '\\':                  /* Backslash */
1009                 break;
1010
1011             default:
1012
1013                 /* Check for an octal digit (0-7) */
1014
1015                 if (ACPI_IS_OCTAL_DIGIT (StringChar))
1016                 {
1017                     State = ASL_OCTAL_CONSTANT;
1018                     ConvertBuffer[0] = StringChar;
1019                     i = 1;
1020                     continue;
1021                 }
1022
1023                 /* Unknown escape sequence issue warning, but use the character */
1024
1025                 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
1026                                 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1027                                 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1028                                 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1029                                 break;
1030             }
1031             break;
1032
1033
1034         case ASL_OCTAL_CONSTANT:
1035
1036             /* Up to three octal digits allowed */
1037
1038             if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
1039                 (i > 2))
1040             {
1041                 /*
1042                  * Reached end of the constant.  Convert the assembled ASCII
1043                  * string and resume processing of the next character
1044                  */
1045                 ConvertBuffer[i] = 0;
1046                 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
1047
1048                 /* Check for NULL or non-ascii character (ignore if so) */
1049
1050                 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
1051                 {
1052                     AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
1053                                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1054                                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1055                                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1056                 }
1057                 else
1058                 {
1059                     *s = (char) Digit;
1060                     s++;
1061                 }
1062
1063                 State = ASL_NORMAL_CHAR;
1064                 goto DoCharacter;
1065                 break;
1066             }
1067
1068             /* Append another digit of the constant */
1069
1070             ConvertBuffer[i] = StringChar;
1071             i++;
1072             continue;
1073
1074
1075         case ASL_HEX_CONSTANT:
1076
1077             /* Up to two hex digits allowed */
1078
1079             if (!ACPI_IS_XDIGIT (StringChar) ||
1080                 (i > 1))
1081             {
1082                 /*
1083                  * Reached end of the constant.  Convert the assembled ASCII
1084                  * string and resume processing of the next character
1085                  */
1086                 ConvertBuffer[i] = 0;
1087                 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
1088
1089                 /* Check for NULL or non-ascii character (ignore if so) */
1090
1091                 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
1092                 {
1093                     AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
1094                                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1095                                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1096                                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1097                 }
1098                 else
1099                 {
1100                     *s = (char) Digit;
1101                     s++;
1102                 }
1103
1104                 State = ASL_NORMAL_CHAR;
1105                 goto DoCharacter;
1106                 break;
1107             }
1108
1109             /* Append another digit of the constant */
1110
1111             ConvertBuffer[i] = StringChar;
1112             i++;
1113             continue;
1114         }
1115
1116         /* Save the finished character */
1117
1118         *s = StringChar;
1119         s++;
1120     }
1121
1122     /*
1123      * Premature End-Of-File
1124      */
1125     AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
1126                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1127                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1128                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1129     return (FALSE);
1130
1131
1132 CompletedString:
1133     /*
1134      * Null terminate the input string and copy string to a new buffer
1135      */
1136     *s = 0;
1137
1138     CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
1139     if (!CleanString)
1140     {
1141         AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
1142                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1143                         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1144                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1145         return (FALSE);
1146     }
1147
1148     ACPI_STRCPY (CleanString, MsgBuffer);
1149     AslCompilerlval.s = CleanString;
1150     return (TRUE);
1151 }
1152
1153