sys/external/intel-public/acpica/dist/compiler/aslcompiler.l

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