sys/contrib/dev/acpica/compiler/aslcompiler.l

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