xref: /freebsd/sys/contrib/dev/acpica/compiler/aslsupport.l (revision 642870485c089b57000fe538d3485e272b038d59)
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 - 2017, 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 }
853