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
57typedef 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
69ASL_FILE_NODE               *Gbl_IncludeFileStack = NULL;
70
71
72/*******************************************************************************
73 *
74 * FUNCTION:    AslParserCleanup
75 *
76 * Used to delete the current buffer
77 *
78 ******************************************************************************/
79
80void
81AslParserCleanup (
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
106static void
107AslDoLineDirective (
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
167ResetAndExit:
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
192int
193AslPopInputFileStack (
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
252void
253AslPushInputFileStack (
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
307void
308AslResetCurrentLineBuffer (
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
339void
340AslInsertLineBuffer (
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
416static void
417count (
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
462static char
463AslDoComment (
464    void)
465{
466    int                 c;
467    int                 c1 = 0;
468
469
470    AslInsertLineBuffer ('/');
471    AslInsertLineBuffer ('*');
472
473loop:
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
519EarlyEOF:
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
543static char
544AslDoCommentType2 (
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
582static char
583AslDoStringLiteral (
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
606DoCharacter:
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
822CompletedString:
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
843BufferOverflow:
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