sys/contrib/dev/acpica/source/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 - 2016, 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    Gbl_HasIncludeFiles = TRUE;
 117
 118     /* Eat the entire line that contains the #line directive */
 119
 120     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
 121
 122     while ((c = input()) != '\n' && c != EOF)
 123     {
 124         *Gbl_LineBufPtr = c;
 125         Gbl_LineBufPtr++;
 126     }
 127     *Gbl_LineBufPtr = 0;
 128
 129     /* First argument is the actual line number */
 130
 131     Token = strtok (Gbl_CurrentLineBuffer, " ");
 132     if (!Token)
 133     {
 134         goto ResetAndExit;
 135     }
 136
 137     /* First argument is the line number */
 138
 139     LineNumber = (UINT32) UtDoConstant (Token);
 140
 141     /* Emit the appropriate number of newlines */
 142
 143     Gbl_CurrentColumn = 0;
 144     if (LineNumber > Gbl_CurrentLineNumber)
 145     {
 146         for (i = 0; i < (LineNumber - Gbl_CurrentLineNumber); i++)
 147         {
 148             FlWriteFile (ASL_FILE_SOURCE_OUTPUT, "\n", 1);
 149             Gbl_CurrentColumn++;
 150         }
 151     }
 152
 153     FlSetLineNumber (LineNumber);
 154
 155     /* Second argument is the optional filename (in double quotes) */
 156
 157     Token = strtok (NULL, " \"");
 158     if (Token)
 159     {
 160         Filename = ACPI_ALLOCATE_ZEROED (strlen (Token) + 1);
 161         strcpy (Filename, Token);
 162         FlSetFilename (Filename);
 163     }
 164
 165     /* Third argument is not supported at this time */
 166
 167 ResetAndExit:
 168
 169     /* Reset globals for a new line */
 170
 171     Gbl_CurrentLineOffset += Gbl_CurrentColumn;
 172     Gbl_CurrentColumn = 0;
 173     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
 174 }
 175
 176
 177 /*******************************************************************************
 178  *
 179  * FUNCTION:    AslPopInputFileStack
 180  *
 181  * PARAMETERS:  None
 182  *
 183  * RETURN:      0 if a node was popped, -1 otherwise
 184  *
 185  * DESCRIPTION: Pop the top of the input file stack and point the parser to
 186  *              the saved parse buffer contained in the fnode. Also, set the
 187  *              global line counters to the saved values. This function is
 188  *              called when an include file reaches EOF.
 189  *
 190  ******************************************************************************/
 191
 192 int
 193 AslPopInputFileStack (
 194     void)
 195 {
 196     ASL_FILE_NODE           *Fnode;
 197
 198
 199     Gbl_PreviousIncludeFilename = Gbl_Files[ASL_FILE_INPUT].Filename;
 200     Fnode = Gbl_IncludeFileStack;
 201     DbgPrint (ASL_PARSE_OUTPUT,
 202         "\nPop InputFile Stack, Fnode %p\n", Fnode);
 203
 204     DbgPrint (ASL_PARSE_OUTPUT,
 205         "Include: Closing \"%s\"\n\n", Gbl_Files[ASL_FILE_INPUT].Filename);
 206
 207     if (!Fnode)
 208     {
 209         return (-1);
 210     }
 211
 212     /* Close the current include file */
 213
 214     fclose (yyin);
 215
 216     /* Update the top-of-stack */
 217
 218     Gbl_IncludeFileStack = Fnode->Next;
 219
 220     /* Reset global line counter and filename */
 221
 222     Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
 223     Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
 224
 225     /* Point the parser to the popped file */
 226
 227     yy_delete_buffer (YY_CURRENT_BUFFER);
 228     yy_switch_to_buffer (Fnode->State);
 229
 230     /* All done with this node */
 231
 232     ACPI_FREE (Fnode);
 233     return (0);
 234 }
 235
 236
 237 /*******************************************************************************
 238  *
 239  * FUNCTION:    AslPushInputFileStack
 240  *
 241  * PARAMETERS:  InputFile           - Open file pointer
 242  *              Filename            - Name of the file
 243  *
 244  * RETURN:      None
 245  *
 246  * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
 247  *              to this file. Called when an include file is successfully
 248  *              opened.
 249  *
 250  ******************************************************************************/
 251
 252 void
 253 AslPushInputFileStack (
 254     FILE                    *InputFile,
 255     char                    *Filename)
 256 {
 257     ASL_FILE_NODE           *Fnode;
 258     YY_BUFFER_STATE         State;
 259
 260
 261     /* Save the current state in an Fnode */
 262
 263     Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
 264
 265     Fnode->File = yyin;
 266     Fnode->Next = Gbl_IncludeFileStack;
 267     Fnode->State = YY_CURRENT_BUFFER;
 268     Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
 269     Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
 270
 271     /* Push it on the stack */
 272
 273     Gbl_IncludeFileStack = Fnode;
 274
 275     /* Point the parser to this file */
 276
 277     State = yy_create_buffer (InputFile, YY_BUF_SIZE);
 278     yy_switch_to_buffer (State);
 279
 280     DbgPrint (ASL_PARSE_OUTPUT,
 281         "\nPush InputFile Stack, returning %p\n\n", InputFile);
 282
 283     /* Reset the global line count and filename */
 284
 285     Gbl_Files[ASL_FILE_INPUT].Filename =
 286         UtStringCacheCalloc (strlen (Filename) + 1);
 287
 288     strcpy (Gbl_Files[ASL_FILE_INPUT].Filename, Filename);
 289
 290     Gbl_CurrentLineNumber = 1;
 291     yyin = InputFile;
 292 }
 293
 294
 295 /*******************************************************************************
 296  *
 297  * FUNCTION:    AslResetCurrentLineBuffer
 298  *
 299  * PARAMETERS:  None
 300  *
 301  * RETURN:      None
 302  *
 303  * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
 304  *
 305  ******************************************************************************/
 306
 307 void
 308 AslResetCurrentLineBuffer (
 309     void)
 310 {
 311
 312     if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
 313     {
 314         FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
 315             Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
 316     }
 317
 318     Gbl_CurrentLineOffset += Gbl_CurrentColumn;
 319     Gbl_CurrentColumn = 0;
 320
 321     Gbl_CurrentLineNumber++;
 322     Gbl_LogicalLineNumber++;
 323     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
 324 }
 325
 326
 327 /*******************************************************************************
 328  *
 329  * FUNCTION:    AslInsertLineBuffer
 330  *
 331  * PARAMETERS:  SourceChar          - One char from the input ASL source file
 332  *
 333  * RETURN:      None
 334  *
 335  * DESCRIPTION: Put one character of the source file into the temp line buffer
 336  *
 337  ******************************************************************************/
 338
 339 void
 340 AslInsertLineBuffer (
 341     int                     SourceChar)
 342 {
 343     UINT32                  i;
 344     UINT32                  Count = 1;
 345
 346
 347     if (SourceChar == EOF)
 348     {
 349         return;
 350     }
 351
 352     Gbl_InputByteCount++;
 353
 354     /* Handle tabs. Convert to spaces */
 355
 356     if (SourceChar == '\t')
 357     {
 358         SourceChar = ' ';
 359         Count = ASL_SPACES_PER_TAB -
 360                     (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
 361     }
 362
 363     for (i = 0; i < Count; i++)
 364     {
 365         Gbl_CurrentColumn++;
 366
 367         /* Insert the character into the line buffer */
 368
 369         *Gbl_LineBufPtr = (UINT8) SourceChar;
 370         Gbl_LineBufPtr++;
 371
 372         if (Gbl_LineBufPtr >
 373             (Gbl_CurrentLineBuffer + (Gbl_LineBufferSize - 1)))
 374         {
 375 #if 0
 376             /*
 377              * Warning if we have split a long source line.
 378              * <Probably overkill>
 379              */
 380             sprintf (MsgBuffer, "Max %u", Gbl_LineBufferSize);
 381             AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
 382                 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 383                 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 384                 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
 385 #endif
 386
 387             AslResetCurrentLineBuffer ();
 388         }
 389         else if (SourceChar == '\n')
 390         {
 391             /* End of line */
 392
 393             AslResetCurrentLineBuffer ();
 394         }
 395     }
 396 }
 397
 398
 399 /*******************************************************************************
 400  *
 401  * FUNCTION:    count
 402  *
 403  * PARAMETERS:  yytext              - Contains the matched keyword.
 404  *              Type                - Keyword/Character type:
 405  *                                      0 = anything except a keyword
 406  *                                      1 = pseudo-keywords
 407  *                                      2 = non-executable ASL keywords
 408  *                                      3 = executable ASL keywords
 409  *
 410  * RETURN:      None
 411  *
 412  * DESCRIPTION: Count keywords and put them into the line buffer
 413  *
 414  ******************************************************************************/
 415
 416 static void
 417 count (
 418     int                 Type)
 419 {
 420     int                 i;
 421
 422
 423     switch (Type)
 424     {
 425     case 2:
 426
 427         TotalKeywords++;
 428         TotalNamedObjects++;
 429         break;
 430
 431     case 3:
 432
 433         TotalKeywords++;
 434         TotalExecutableOpcodes++;
 435         break;
 436
 437     default:
 438
 439         break;
 440     }
 441
 442     for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
 443     {
 444         AslInsertLineBuffer (yytext[i]);
 445         *Gbl_LineBufPtr = 0;
 446     }
 447 }
 448
 449
 450 /*******************************************************************************
 451  *
 452  * FUNCTION:    AslDoComment
 453  *
 454  * PARAMETERS:  none
 455  *
 456  * RETURN:      none
 457  *
 458  * DESCRIPTION: Process a standard comment.
 459  *
 460  ******************************************************************************/
 461
 462 static char
 463 AslDoComment (
 464     void)
 465 {
 466     int                 c;
 467     int                 c1 = 0;
 468
 469
 470     AslInsertLineBuffer ('/');
 471     AslInsertLineBuffer ('*');
 472
 473 loop:
 474
 475     /* Eat chars until end-of-comment */
 476
 477     while (((c = input ()) != '*') && (c != EOF))
 478     {
 479         AslInsertLineBuffer (c);
 480         c1 = c;
 481     }
 482
 483     if (c == EOF)
 484     {
 485         goto EarlyEOF;
 486     }
 487
 488     /*
 489      * Check for nested comment -- can help catch cases where a previous
 490      * comment was accidently left unterminated
 491      */
 492     if ((c1 == '/') && (c == '*'))
 493     {
 494         AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
 495             Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 496             Gbl_InputByteCount, Gbl_CurrentColumn,
 497             Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 498     }
 499
 500     /* Comment is closed only if the NEXT character is a slash */
 501
 502     AslInsertLineBuffer (c);
 503
 504     if (((c1 = input ()) != '/') && (c1 != EOF))
 505     {
 506         unput(c1);
 507         goto loop;
 508     }
 509
 510     if (c1 == EOF)
 511     {
 512         goto EarlyEOF;
 513     }
 514
 515     AslInsertLineBuffer (c1);
 516     return (TRUE);
 517
 518
 519 EarlyEOF:
 520     /*
 521      * Premature End-Of-File
 522      */
 523     AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
 524         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 525         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 526         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 527     return (FALSE);
 528 }
 529
 530
 531 /*******************************************************************************
 532  *
 533  * FUNCTION:    AslDoCommentType2
 534  *
 535  * PARAMETERS:  none
 536  *
 537  * RETURN:      none
 538  *
 539  * DESCRIPTION: Process a new "//" comment.
 540  *
 541  ******************************************************************************/
 542
 543 static char
 544 AslDoCommentType2 (
 545     void)
 546 {
 547     int                 c;
 548
 549
 550     AslInsertLineBuffer ('/');
 551     AslInsertLineBuffer ('/');
 552
 553     while (((c = input ()) != '\n') && (c != EOF))
 554     {
 555         AslInsertLineBuffer (c);
 556     }
 557
 558     if (c == EOF)
 559     {
 560         /* End of file is OK, change to newline. Let parser detect EOF later */
 561
 562         c = '\n';
 563     }
 564
 565     AslInsertLineBuffer (c);
 566     return (TRUE);
 567 }
 568
 569
 570 /*******************************************************************************
 571  *
 572  * FUNCTION:    AslDoStringLiteral
 573  *
 574  * PARAMETERS:  none
 575  *
 576  * RETURN:      none
 577  *
 578  * DESCRIPTION: Process a string literal (surrounded by quotes)
 579  *
 580  ******************************************************************************/
 581
 582 static char
 583 AslDoStringLiteral (
 584     void)
 585 {
 586     char                *StringBuffer = MsgBuffer;
 587     char                *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
 588     char                *CleanString;
 589     int                 StringChar;
 590     UINT32              State = ASL_NORMAL_CHAR;
 591     UINT32              i = 0;
 592     UINT8               Digit;
 593     char                ConvertBuffer[4];
 594
 595
 596     /*
 597      * Eat chars until end-of-literal.
 598      * NOTE:  Put back the original surrounding quotes into the
 599      * source line buffer.
 600      */
 601     AslInsertLineBuffer ('\"');
 602     while ((StringChar = input()) != EOF)
 603     {
 604         AslInsertLineBuffer (StringChar);
 605
 606 DoCharacter:
 607         switch (State)
 608         {
 609         case ASL_NORMAL_CHAR:
 610
 611             switch (StringChar)
 612             {
 613             case '\\':
 614                 /*
 615                  * Special handling for backslash-escape sequence. We will
 616                  * toss the backslash and translate the escape char(s).
 617                  */
 618                 State = ASL_ESCAPE_SEQUENCE;
 619                 continue;
 620
 621             case '\"':
 622
 623                 /* String terminator */
 624
 625                 goto CompletedString;
 626
 627             default:
 628
 629                 break;
 630             }
 631             break;
 632
 633
 634         case ASL_ESCAPE_SEQUENCE:
 635
 636             State = ASL_NORMAL_CHAR;
 637             switch (StringChar)
 638             {
 639             case 'a':
 640
 641                 StringChar = 0x07;      /* BELL */
 642                 break;
 643
 644             case 'b':
 645
 646                 StringChar = 0x08;      /* BACKSPACE */
 647                 break;
 648
 649             case 'f':
 650
 651                 StringChar = 0x0C;      /* FORMFEED */
 652                 break;
 653
 654             case 'n':
 655
 656                 StringChar = 0x0A;      /* LINEFEED */
 657                 break;
 658
 659             case 'r':
 660
 661                 StringChar = 0x0D;      /* CARRIAGE RETURN*/
 662                 break;
 663
 664             case 't':
 665
 666                 StringChar = 0x09;      /* HORIZONTAL TAB */
 667                 break;
 668
 669             case 'v':
 670
 671                 StringChar = 0x0B;      /* VERTICAL TAB */
 672                 break;
 673
 674             case 'x':
 675
 676                 State = ASL_HEX_CONSTANT;
 677                 i = 0;
 678                 continue;
 679
 680             case '\'':                  /* Single Quote */
 681             case '\"':                  /* Double Quote */
 682             case '\\':                  /* Backslash */
 683
 684                 break;
 685
 686             default:
 687
 688                 /* Check for an octal digit (0-7) */
 689
 690                 if (ACPI_IS_OCTAL_DIGIT (StringChar))
 691                 {
 692                     State = ASL_OCTAL_CONSTANT;
 693                     ConvertBuffer[0] = StringChar;
 694                     i = 1;
 695                     continue;
 696                 }
 697
 698                 /* Unknown escape sequence issue warning, but use the character */
 699
 700                 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
 701                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 702                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 703                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 704                 break;
 705             }
 706             break;
 707
 708
 709         case ASL_OCTAL_CONSTANT:
 710
 711             /* Up to three octal digits allowed */
 712
 713             if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
 714                 (i > 2))
 715             {
 716                 /*
 717                  * Reached end of the constant. Convert the assembled ASCII
 718                  * string and resume processing of the next character
 719                  */
 720                 ConvertBuffer[i] = 0;
 721                 Digit = (UINT8) strtoul (ConvertBuffer, NULL, 8);
 722
 723                 /* Check for NULL or non-ascii character (ignore if so) */
 724
 725                 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
 726                 {
 727                     AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
 728                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 729                         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 730                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 731                 }
 732                 else
 733                 {
 734                     *StringBuffer = (char) Digit;
 735                     StringBuffer++;
 736                     if (StringBuffer >= EndBuffer)
 737                     {
 738                         goto BufferOverflow;
 739                     }
 740                 }
 741
 742                 State = ASL_NORMAL_CHAR;
 743                 goto DoCharacter;
 744                 break;
 745             }
 746
 747             /* Append another digit of the constant */
 748
 749             ConvertBuffer[i] = StringChar;
 750             i++;
 751             continue;
 752
 753         case ASL_HEX_CONSTANT:
 754
 755             /* Up to two hex digits allowed */
 756
 757             if (!isxdigit (StringChar) ||
 758                 (i > 1))
 759             {
 760                 /*
 761                  * Reached end of the constant. Convert the assembled ASCII
 762                  * string and resume processing of the next character
 763                  */
 764                 ConvertBuffer[i] = 0;
 765                 Digit = (UINT8) strtoul (ConvertBuffer, NULL, 16);
 766
 767                 /* Check for NULL or non-ascii character (ignore if so) */
 768
 769                 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
 770                 {
 771                     AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
 772                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 773                         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 774                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 775                 }
 776                 else
 777                 {
 778                     *StringBuffer = (char) Digit;
 779                     StringBuffer++;
 780                     if (StringBuffer >= EndBuffer)
 781                     {
 782                         goto BufferOverflow;
 783                     }
 784                 }
 785
 786                 State = ASL_NORMAL_CHAR;
 787                 goto DoCharacter;
 788                 break;
 789             }
 790
 791             /* Append another digit of the constant */
 792
 793             ConvertBuffer[i] = StringChar;
 794             i++;
 795             continue;
 796
 797         default:
 798
 799             break;
 800         }
 801
 802         /* Save the finished character */
 803
 804         *StringBuffer = StringChar;
 805         StringBuffer++;
 806         if (StringBuffer >= EndBuffer)
 807         {
 808             goto BufferOverflow;
 809         }
 810     }
 811
 812     /*
 813      * Premature End-Of-File
 814      */
 815     AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
 816         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 817         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 818         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 819     return (FALSE);
 820
 821
 822 CompletedString:
 823     /*
 824      * Null terminate the input string and copy string to a new buffer
 825      */
 826     *StringBuffer = 0;
 827
 828     CleanString = UtStringCacheCalloc (strlen (MsgBuffer) + 1);
 829     if (!CleanString)
 830     {
 831         AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
 832             Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 833             Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 834             Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
 835         return (FALSE);
 836     }
 837
 838     strcpy (CleanString, MsgBuffer);
 839     AslCompilerlval.s = CleanString;
 840     return (TRUE);
 841
 842
 843 BufferOverflow:
 844
 845     /* Literal was too long */
 846
 847     AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
 848         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 849         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
 850         Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");
 851     return (FALSE);
 852 }