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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslsupport.l - Flex/lex scanner C support routines.
   4  *              NOTE: Included into aslcompile.l, not compiled by itself.
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  * Copyright (C) 2000 - 2015, Intel Corp.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions, and the following disclaimer,
  17  *    without modification.
  18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19  *    substantially similar to the "NO WARRANTY" disclaimer below
  20  *    ("Disclaimer") and any redistribution must be conditioned upon
  21  *    including a substantially similar Disclaimer requirement for further
  22  *    binary redistribution.
  23  * 3. Neither the names of the above-listed copyright holders nor the names
  24  *    of any contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * Alternatively, this software may be distributed under the terms of the
  28  * GNU General Public License ("GPL") version 2 as published by the Free
  29  * Software Foundation.
  30  *
  31  * NO WARRANTY
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGES.
  43  */
  44
  45 /* Configuration */
  46
  47 #define ASL_SPACES_PER_TAB      4
  48
  49 #define ASL_NORMAL_CHAR         0
  50 #define ASL_ESCAPE_SEQUENCE     1
  51 #define ASL_OCTAL_CONSTANT      2
  52 #define ASL_HEX_CONSTANT        3
  53
  54
  55 /* File node - used for "Include" operator file stack */
  56
  57 typedef struct asl_file_node
  58 {
  59     FILE                    *File;
  60     UINT32                  CurrentLineNumber;
  61     YY_BUFFER_STATE         State;
  62     char                    *Filename;
  63     struct asl_file_node    *Next;
  64
  65 } ASL_FILE_NODE;
  66
  67 /* File stack for the "Include" operator (NOT #include operator) */
  68
  69 ASL_FILE_NODE               *Gbl_IncludeFileStack = NULL;
  70
  71
  72 /*******************************************************************************
  73  *
  74  * FUNCTION:    AslParserCleanup
  75  *
  76  * Used to delete the current buffer
  77  *
  78  ******************************************************************************/
  79
  80 void
  81 AslParserCleanup (
  82     void)
  83 {
  84
  85     yy_delete_buffer (YY_CURRENT_BUFFER);
  86 }
  87
  88
  89 /*******************************************************************************
  90  *
  91  * FUNCTION:    AslDoLineDirective
  92  *
  93  * PARAMETERS:  None. Uses input() to access current source code line
  94  *
  95  * RETURN:      Updates global line number and filename
  96  *
  97  * DESCRIPTION: Handle #line directives emitted by the preprocessor.
  98  *
  99  * The #line directive is emitted by the preprocesser, and is used to
 100  * pass through line numbers from the original source code file to the
 101  * preprocessor output file (.i). This allows any compiler-generated
 102  * error messages to be displayed with the correct line number.
 103  *
 104  ******************************************************************************/
 105
 106 static void
 107 AslDoLineDirective (
 108     void)
 109 {
 110     int                     c;
 111     char                    *Token;
 112     UINT32                  LineNumber;
 113     char                    *Filename;
 114     UINT32                  i;
 115
 116
 117     /* Eat the entire line that contains the #line directive */
 118
 119     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
 120
 121     while ((c = input()) != '\n' && c != EOF)
 122     {
 123         *Gbl_LineBufPtr = c;
 124         Gbl_LineBufPtr++;
 125     }
 126     *Gbl_LineBufPtr = 0;
 127
 128     /* First argument is the actual line number */
 129
 130     Token = strtok (Gbl_CurrentLineBuffer, " ");
 131     if (!Token)
 132     {
 133         goto ResetAndExit;
 134     }
 135
 136     /* First argument is the line number */
 137
 138     LineNumber = (UINT32) UtDoConstant (Token);
 139
 140     /* Emit the appropriate number of newlines */
 141
 142     Gbl_CurrentColumn = 0;
 143     if (LineNumber > Gbl_CurrentLineNumber)
 144     {
 145         for (i = 0; i < (LineNumber - Gbl_CurrentLineNumber); i++)
 146         {
 147             FlWriteFile (ASL_FILE_SOURCE_OUTPUT, "\n", 1);
 148             Gbl_CurrentColumn++;
 149         }
 150     }
 151
 152     FlSetLineNumber (LineNumber);
 153
 154     /* Second argument is the optional filename (in double quotes) */
 155
 156     Token = strtok (NULL, " \"");
 157     if (Token)
 158     {
 159         Filename = ACPI_ALLOCATE_ZEROED (strlen (Token) + 1);
 160         strcpy (Filename, Token);
 161         FlSetFilename (Filename);
 162     }
 163
 164     /* Third argument is not supported at this time */
 165
 166 ResetAndExit:
 167
 168     /* Reset globals for a new line */
 169
 170     Gbl_CurrentLineOffset += Gbl_CurrentColumn;
 171     Gbl_CurrentColumn = 0;
 172     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
 173 }
 174
 175
 176 /*******************************************************************************
 177  *
 178  * FUNCTION:    AslPopInputFileStack
 179  *
 180  * PARAMETERS:  None
 181  *
 182  * RETURN:      0 if a node was popped, -1 otherwise
 183  *
 184  * DESCRIPTION: Pop the top of the input file stack and point the parser to
 185  *              the saved parse buffer contained in the fnode. Also, set the
 186  *              global line counters to the saved values. This function is
 187  *              called when an include file reaches EOF.
 188  *
 189  ******************************************************************************/
 190
 191 int
 192 AslPopInputFileStack (
 193     void)
 194 {
 195     ASL_FILE_NODE           *Fnode;
 196
 197
 198     Fnode = Gbl_IncludeFileStack;
 199     DbgPrint (ASL_PARSE_OUTPUT,
 200         "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
 201
 202     if (!Fnode)
 203     {
 204         return (-1);
 205     }
 206
 207     /* Close the current include file */
 208
 209     fclose (yyin);
 210
 211     /* Update the top-of-stack */
 212
 213     Gbl_IncludeFileStack = Fnode->Next;
 214
 215     /* Reset global line counter and filename */
 216
 217     Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
 218     Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
 219
 220     /* Point the parser to the popped file */
 221
 222     yy_delete_buffer (YY_CURRENT_BUFFER);
 223     yy_switch_to_buffer (Fnode->State);
 224
 225     /* All done with this node */
 226
 227     ACPI_FREE (Fnode);
 228     return (0);
 229 }
 230
 231
 232 /*******************************************************************************
 233  *
 234  * FUNCTION:    AslPushInputFileStack
 235  *
 236  * PARAMETERS:  InputFile           - Open file pointer
 237  *              Filename            - Name of the file
 238  *
 239  * RETURN:      None
 240  *
 241  * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
 242  *              to this file. Called when an include file is successfully
 243  *              opened.
 244  *
 245  ******************************************************************************/
 246
 247 void
 248 AslPushInputFileStack (
 249     FILE                    *InputFile,
 250     char                    *Filename)
 251 {
 252     ASL_FILE_NODE           *Fnode;
 253     YY_BUFFER_STATE         State;
 254
 255
 256     /* Save the current state in an Fnode */
 257
 258     Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
 259
 260     Fnode->File = yyin;
 261     Fnode->Next = Gbl_IncludeFileStack;
 262     Fnode->State = YY_CURRENT_BUFFER;
 263     Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
 264     Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
 265
 266     /* Push it on the stack */
 267
 268     Gbl_IncludeFileStack = Fnode;
 269
 270     /* Point the parser to this file */
 271
 272     State = yy_create_buffer (InputFile, YY_BUF_SIZE);
 273     yy_switch_to_buffer (State);
 274
 275     DbgPrint (ASL_PARSE_OUTPUT,
 276         "\nPush InputFile Stack, returning %p\n\n", InputFile);
 277
 278     /* Reset the global line count and filename */
 279
 280     Gbl_Files[ASL_FILE_INPUT].Filename =
 281         UtStringCacheCalloc (strlen (Filename) + 1);
 282
 283     strcpy (Gbl_Files[ASL_FILE_INPUT].Filename, Filename);
 284
 285     Gbl_CurrentLineNumber = 1;
 286     yyin = InputFile;
 287 }
 288
 289
 290 /*******************************************************************************
 291  *
 292  * FUNCTION:    AslResetCurrentLineBuffer
 293  *
 294  * PARAMETERS:  None
 295  *
 296  * RETURN:      None
 297  *
 298  * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
 299  *
 300  ******************************************************************************/
 301
 302 void
 303 AslResetCurrentLineBuffer (
 304     void)
 305 {
 306
 307     if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
 308     {
 309         FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
 310             Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
 311     }
 312
 313     Gbl_CurrentLineOffset += Gbl_CurrentColumn;
 314     Gbl_CurrentColumn = 0;
 315
 316     Gbl_CurrentLineNumber++;
 317     Gbl_LogicalLineNumber++;
 318     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
 319 }
 320
 321
 322 /*******************************************************************************
 323  *
 324  * FUNCTION:    AslInsertLineBuffer
 325  *
 326  * PARAMETERS:  SourceChar          - One char from the input ASL source file
 327  *
 328  * RETURN:      None
 329  *
 330  * DESCRIPTION: Put one character of the source file into the temp line buffer
 331  *
 332  ******************************************************************************/
 333
 334 void
 335 AslInsertLineBuffer (
 336     int                     SourceChar)
 337 {
 338     UINT32                  i;
 339     UINT32                  Count = 1;
 340
 341
 342     if (SourceChar == EOF)
 343     {
 344         return;
 345     }
 346
 347     Gbl_InputByteCount++;
 348
 349     /* Handle tabs. Convert to spaces */
 350
 351     if (SourceChar == '\t')
 352     {
 353         SourceChar = ' ';
 354         Count = ASL_SPACES_PER_TAB -
 355                     (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
 356     }
 357
 358     for (i = 0; i < Count; i++)
 359     {
 360         Gbl_CurrentColumn++;
 361
 362         /* Insert the character into the line buffer */
 363
 364         *Gbl_LineBufPtr = (UINT8) SourceChar;
 365         Gbl_LineBufPtr++;
 366
 367         if (Gbl_LineBufPtr >
 368             (Gbl_CurrentLineBuffer + (Gbl_LineBufferSize - 1)))
 369         {
 370 #if 0
 371             /*
 372              * Warning if we have split a long source line.
 373              * <Probably overkill>
 374              */
 375             sprintf (MsgBuffer, "Max %u", Gbl_LineBufferSize);
 376             AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
 377                 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 378                 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 379                 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
 380 #endif
 381
 382             AslResetCurrentLineBuffer ();
 383         }
 384         else if (SourceChar == '\n')
 385         {
 386             /* End of line */
 387
 388             AslResetCurrentLineBuffer ();
 389         }
 390     }
 391 }
 392
 393
 394 /*******************************************************************************
 395  *
 396  * FUNCTION:    count
 397  *
 398  * PARAMETERS:  yytext              - Contains the matched keyword.
 399  *              Type                - Keyword/Character type:
 400  *                                      0 = anything except a keyword
 401  *                                      1 = pseudo-keywords
 402  *                                      2 = non-executable ASL keywords
 403  *                                      3 = executable ASL keywords
 404  *
 405  * RETURN:      None
 406  *
 407  * DESCRIPTION: Count keywords and put them into the line buffer
 408  *
 409  ******************************************************************************/
 410
 411 static void
 412 count (
 413     int                 Type)
 414 {
 415     int                 i;
 416
 417
 418     switch (Type)
 419     {
 420     case 2:
 421
 422         TotalKeywords++;
 423         TotalNamedObjects++;
 424         break;
 425
 426     case 3:
 427
 428         TotalKeywords++;
 429         TotalExecutableOpcodes++;
 430         break;
 431
 432     default:
 433
 434         break;
 435     }
 436
 437     for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
 438     {
 439         AslInsertLineBuffer (yytext[i]);
 440         *Gbl_LineBufPtr = 0;
 441     }
 442 }
 443
 444
 445 /*******************************************************************************
 446  *
 447  * FUNCTION:    AslDoComment
 448  *
 449  * PARAMETERS:  none
 450  *
 451  * RETURN:      none
 452  *
 453  * DESCRIPTION: Process a standard comment.
 454  *
 455  ******************************************************************************/
 456
 457 static char
 458 AslDoComment (
 459     void)
 460 {
 461     int                 c;
 462     int                 c1 = 0;
 463
 464
 465     AslInsertLineBuffer ('/');
 466     AslInsertLineBuffer ('*');
 467
 468 loop:
 469
 470     /* Eat chars until end-of-comment */
 471
 472     while (((c = input ()) != '*') && (c != EOF))
 473     {
 474         AslInsertLineBuffer (c);
 475         c1 = c;
 476     }
 477
 478     if (c == EOF)
 479     {
 480         goto EarlyEOF;
 481     }
 482
 483     /*
 484      * Check for nested comment -- can help catch cases where a previous
 485      * comment was accidently left unterminated
 486      */
 487     if ((c1 == '/') && (c == '*'))
 488     {
 489         AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
 490             Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 491             Gbl_InputByteCount, Gbl_CurrentColumn,
 492             Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 493     }
 494
 495     /* Comment is closed only if the NEXT character is a slash */
 496
 497     AslInsertLineBuffer (c);
 498
 499     if (((c1 = input ()) != '/') && (c1 != EOF))
 500     {
 501         unput(c1);
 502         goto loop;
 503     }
 504
 505     if (c1 == EOF)
 506     {
 507         goto EarlyEOF;
 508     }
 509
 510     AslInsertLineBuffer (c1);
 511     return (TRUE);
 512
 513
 514 EarlyEOF:
 515     /*
 516      * Premature End-Of-File
 517      */
 518     AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
 519         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 520         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 521         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 522     return (FALSE);
 523 }
 524
 525
 526 /*******************************************************************************
 527  *
 528  * FUNCTION:    AslDoCommentType2
 529  *
 530  * PARAMETERS:  none
 531  *
 532  * RETURN:      none
 533  *
 534  * DESCRIPTION: Process a new "//" comment.
 535  *
 536  ******************************************************************************/
 537
 538 static char
 539 AslDoCommentType2 (
 540     void)
 541 {
 542     int                 c;
 543
 544
 545     AslInsertLineBuffer ('/');
 546     AslInsertLineBuffer ('/');
 547
 548     while (((c = input ()) != '\n') && (c != EOF))
 549     {
 550         AslInsertLineBuffer (c);
 551     }
 552
 553     if (c == EOF)
 554     {
 555         /* End of file is OK, change to newline. Let parser detect EOF later */
 556
 557         c = '\n';
 558     }
 559
 560     AslInsertLineBuffer (c);
 561     return (TRUE);
 562 }
 563
 564
 565 /*******************************************************************************
 566  *
 567  * FUNCTION:    AslDoStringLiteral
 568  *
 569  * PARAMETERS:  none
 570  *
 571  * RETURN:      none
 572  *
 573  * DESCRIPTION: Process a string literal (surrounded by quotes)
 574  *
 575  ******************************************************************************/
 576
 577 static char
 578 AslDoStringLiteral (
 579     void)
 580 {
 581     char                *StringBuffer = MsgBuffer;
 582     char                *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
 583     char                *CleanString;
 584     int                 StringChar;
 585     UINT32              State = ASL_NORMAL_CHAR;
 586     UINT32              i = 0;
 587     UINT8               Digit;
 588     char                ConvertBuffer[4];
 589
 590
 591     /*
 592      * Eat chars until end-of-literal.
 593      * NOTE:  Put back the original surrounding quotes into the
 594      * source line buffer.
 595      */
 596     AslInsertLineBuffer ('\"');
 597     while ((StringChar = input()) != EOF)
 598     {
 599         AslInsertLineBuffer (StringChar);
 600
 601 DoCharacter:
 602         switch (State)
 603         {
 604         case ASL_NORMAL_CHAR:
 605
 606             switch (StringChar)
 607             {
 608             case '\\':
 609                 /*
 610                  * Special handling for backslash-escape sequence. We will
 611                  * toss the backslash and translate the escape char(s).
 612                  */
 613                 State = ASL_ESCAPE_SEQUENCE;
 614                 continue;
 615
 616             case '\"':
 617
 618                 /* String terminator */
 619
 620                 goto CompletedString;
 621
 622             default:
 623
 624                 break;
 625             }
 626             break;
 627
 628
 629         case ASL_ESCAPE_SEQUENCE:
 630
 631             State = ASL_NORMAL_CHAR;
 632             switch (StringChar)
 633             {
 634             case 'a':
 635
 636                 StringChar = 0x07;      /* BELL */
 637                 break;
 638
 639             case 'b':
 640
 641                 StringChar = 0x08;      /* BACKSPACE */
 642                 break;
 643
 644             case 'f':
 645
 646                 StringChar = 0x0C;      /* FORMFEED */
 647                 break;
 648
 649             case 'n':
 650
 651                 StringChar = 0x0A;      /* LINEFEED */
 652                 break;
 653
 654             case 'r':
 655
 656                 StringChar = 0x0D;      /* CARRIAGE RETURN*/
 657                 break;
 658
 659             case 't':
 660
 661                 StringChar = 0x09;      /* HORIZONTAL TAB */
 662                 break;
 663
 664             case 'v':
 665
 666                 StringChar = 0x0B;      /* VERTICAL TAB */
 667                 break;
 668
 669             case 'x':
 670
 671                 State = ASL_HEX_CONSTANT;
 672                 i = 0;
 673                 continue;
 674
 675             case '\'':                  /* Single Quote */
 676             case '\"':                  /* Double Quote */
 677             case '\\':                  /* Backslash */
 678
 679                 break;
 680
 681             default:
 682
 683                 /* Check for an octal digit (0-7) */
 684
 685                 if (ACPI_IS_OCTAL_DIGIT (StringChar))
 686                 {
 687                     State = ASL_OCTAL_CONSTANT;
 688                     ConvertBuffer[0] = StringChar;
 689                     i = 1;
 690                     continue;
 691                 }
 692
 693                 /* Unknown escape sequence issue warning, but use the character */
 694
 695                 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
 696                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 697                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 698                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 699                 break;
 700             }
 701             break;
 702
 703
 704         case ASL_OCTAL_CONSTANT:
 705
 706             /* Up to three octal digits allowed */
 707
 708             if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
 709                 (i > 2))
 710             {
 711                 /*
 712                  * Reached end of the constant. Convert the assembled ASCII
 713                  * string and resume processing of the next character
 714                  */
 715                 ConvertBuffer[i] = 0;
 716                 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
 717
 718                 /* Check for NULL or non-ascii character (ignore if so) */
 719
 720                 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
 721                 {
 722                     AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
 723                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 724                         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 725                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 726                 }
 727                 else
 728                 {
 729                     *StringBuffer = (char) Digit;
 730                     StringBuffer++;
 731                     if (StringBuffer >= EndBuffer)
 732                     {
 733                         goto BufferOverflow;
 734                     }
 735                 }
 736
 737                 State = ASL_NORMAL_CHAR;
 738                 goto DoCharacter;
 739                 break;
 740             }
 741
 742             /* Append another digit of the constant */
 743
 744             ConvertBuffer[i] = StringChar;
 745             i++;
 746             continue;
 747
 748         case ASL_HEX_CONSTANT:
 749
 750             /* Up to two hex digits allowed */
 751
 752             if (!ACPI_IS_XDIGIT (StringChar) ||
 753                 (i > 1))
 754             {
 755                 /*
 756                  * Reached end of the constant. Convert the assembled ASCII
 757                  * string and resume processing of the next character
 758                  */
 759                 ConvertBuffer[i] = 0;
 760                 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
 761
 762                 /* Check for NULL or non-ascii character (ignore if so) */
 763
 764                 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
 765                 {
 766                     AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
 767                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 768                         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 769                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 770                 }
 771                 else
 772                 {
 773                     *StringBuffer = (char) Digit;
 774                     StringBuffer++;
 775                     if (StringBuffer >= EndBuffer)
 776                     {
 777                         goto BufferOverflow;
 778                     }
 779                 }
 780
 781                 State = ASL_NORMAL_CHAR;
 782                 goto DoCharacter;
 783                 break;
 784             }
 785
 786             /* Append another digit of the constant */
 787
 788             ConvertBuffer[i] = StringChar;
 789             i++;
 790             continue;
 791
 792         default:
 793
 794             break;
 795         }
 796
 797         /* Save the finished character */
 798
 799         *StringBuffer = StringChar;
 800         StringBuffer++;
 801         if (StringBuffer >= EndBuffer)
 802         {
 803             goto BufferOverflow;
 804         }
 805     }
 806
 807     /*
 808      * Premature End-Of-File
 809      */
 810     AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
 811         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 812         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 813         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 814     return (FALSE);
 815
 816
 817 CompletedString:
 818     /*
 819      * Null terminate the input string and copy string to a new buffer
 820      */
 821     *StringBuffer = 0;
 822
 823     CleanString = UtStringCacheCalloc (strlen (MsgBuffer) + 1);
 824     if (!CleanString)
 825     {
 826         AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
 827             Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 828             Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 829             Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 830         return (FALSE);
 831     }
 832
 833     ACPI_STRCPY (CleanString, MsgBuffer);
 834     AslCompilerlval.s = CleanString;
 835     return (TRUE);
 836
 837
 838 BufferOverflow:
 839
 840     /* Literal was too long */
 841
 842     AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
 843         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 844         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 845         Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");
 846     return (FALSE);
 847 }