1 /******************************************************************************
2  *
3  * Module Name: prscan - Preprocessor start-up and file scan module
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2020, Intel Corp.
12  * All rights reserved.
13  *
14  * 2. License
15  *
16  * 2.1. This is your license from Intel Corp. under its intellectual property
17  * rights. You may have additional license terms from the party that provided
18  * you this software, covering your right to use that party's intellectual
19  * property rights.
20  *
21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22  * copy of the source code appearing in this file ("Covered Code") an
23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24  * base code distributed originally by Intel ("Original Intel Code") to copy,
25  * make derivatives, distribute, use and display any portion of the Covered
26  * Code in any form, with the right to sublicense such rights; and
27  *
28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29  * license (with the right to sublicense), under only those claims of Intel
30  * patents that are infringed by the Original Intel Code, to make, use, sell,
31  * offer to sell, and import the Covered Code and derivative works thereof
32  * solely to the minimum extent necessary to exercise the above copyright
33  * license, and in no event shall the patent license extend to any additions
34  * to or modifications of the Original Intel Code. No other license or right
35  * is granted directly or by implication, estoppel or otherwise;
36  *
37  * The above copyright and patent license is granted only if the following
38  * conditions are met:
39  *
40  * 3. Conditions
41  *
42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43  * Redistribution of source code of any substantial portion of the Covered
44  * Code or modification with rights to further distribute source must include
45  * the above Copyright Notice, the above License, this list of Conditions,
46  * and the following Disclaimer and Export Compliance provision. In addition,
47  * Licensee must cause all Covered Code to which Licensee contributes to
48  * contain a file documenting the changes Licensee made to create that Covered
49  * Code and the date of any change. Licensee must include in that file the
50  * documentation of any changes made by any predecessor Licensee. Licensee
51  * must include a prominent statement that the modification is derived,
52  * directly or indirectly, from Original Intel Code.
53  *
54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55  * Redistribution of source code of any substantial portion of the Covered
56  * Code or modification without rights to further distribute source must
57  * include the following Disclaimer and Export Compliance provision in the
58  * documentation and/or other materials provided with distribution. In
59  * addition, Licensee may not authorize further sublicense of source of any
60  * portion of the Covered Code, and must include terms to the effect that the
61  * license from Licensee to its licensee is limited to the intellectual
62  * property embodied in the software Licensee provides to its licensee, and
63  * not to intellectual property embodied in modifications its licensee may
64  * make.
65  *
66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
67  * substantial portion of the Covered Code or modification must reproduce the
68  * above Copyright Notice, and the following Disclaimer and Export Compliance
69  * provision in the documentation and/or other materials provided with the
70  * distribution.
71  *
72  * 3.4. Intel retains all right, title, and interest in and to the Original
73  * Intel Code.
74  *
75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76  * Intel shall be used in advertising or otherwise to promote the sale, use or
77  * other dealings in products derived from or relating to the Covered Code
78  * without prior written authorization from Intel.
79  *
80  * 4. Disclaimer and Export Compliance
81  *
82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88  * PARTICULAR PURPOSE.
89  *
90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97  * LIMITED REMEDY.
98  *
99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
100  * software or system incorporating such software without first obtaining any
101  * required license or other approval from the U. S. Department of Commerce or
102  * any other agency or department of the United States Government. In the
103  * event Licensee exports any such software from the United States or
104  * re-exports any such software from a foreign destination, Licensee shall
105  * ensure that the distribution and export/re-export of the software is in
106  * compliance with all laws, regulations, orders, or other restrictions of the
107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108  * any of its subsidiaries will export/re-export any technical data, process,
109  * software, or service, directly or indirectly, to any country for which the
110  * United States government or any agency thereof requires an export license,
111  * other governmental approval, or letter of assurance, without first obtaining
112  * such license, approval or letter.
113  *
114  *****************************************************************************
115  *
116  * Alternatively, you may choose to be licensed under the terms of the
117  * following license:
118  *
119  * Redistribution and use in source and binary forms, with or without
120  * modification, are permitted provided that the following conditions
121  * are met:
122  * 1. Redistributions of source code must retain the above copyright
123  *    notice, this list of conditions, and the following disclaimer,
124  *    without modification.
125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126  *    substantially similar to the "NO WARRANTY" disclaimer below
127  *    ("Disclaimer") and any redistribution must be conditioned upon
128  *    including a substantially similar Disclaimer requirement for further
129  *    binary redistribution.
130  * 3. Neither the names of the above-listed copyright holders nor the names
131  *    of any contributors may be used to endorse or promote products derived
132  *    from this software without specific prior written permission.
133  *
134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145  *
146  * Alternatively, you may choose to be licensed under the terms of the
147  * GNU General Public License ("GPL") version 2 as published by the Free
148  * Software Foundation.
149  *
150  *****************************************************************************/
151 
152 #define _DECLARE_PR_GLOBALS
153 
154 #include "aslcompiler.h"
155 
156 /*
157  * TBDs:
158  *
159  * No nested macros, maybe never
160  * Implement ASL "Include" as well as "#include" here?
161  */
162 #define _COMPONENT          ASL_PREPROCESSOR
163         ACPI_MODULE_NAME    ("prscan")
164 
165 
166 /* Local prototypes */
167 
168 static void
169 PrPreprocessInputFile (
170     void);
171 
172 static void
173 PrDoDirective (
174     char                    *DirectiveToken,
175     char                    **Next);
176 
177 static void
178 PrGetNextLineInit (
179     void);
180 
181 static UINT32
182 PrGetNextLine (
183     FILE                    *Handle);
184 
185 static int
186 PrMatchDirective (
187     char                    *Directive);
188 
189 static void
190 PrPushDirective (
191     int                     Directive,
192     char                    *Argument);
193 
194 static ACPI_STATUS
195 PrPopDirective (
196     void);
197 
198 static void
199 PrDbgPrint (
200     char                    *Action,
201     char                    *DirectiveName);
202 
203 static void
204 PrDoIncludeBuffer (
205     char                    *Pathname,
206     char                    *BufferName);
207 
208 static void
209 PrDoIncludeFile (
210     char                    *Pathname);
211 
212 
213 /*
214  * Supported preprocessor directives
215  * Each entry is of the form "Name, ArgumentCount"
216  */
217 static const PR_DIRECTIVE_INFO      AslGbl_DirectiveInfo[] =
218 {
219     {"define",          1},
220     {"elif",            0}, /* Converted to #else..#if internally */
221     {"else",            0},
222     {"endif",           0},
223     {"error",           1},
224     {"if",              1},
225     {"ifdef",           1},
226     {"ifndef",          1},
227     {"include",         0}, /* Argument is not standard format, so just use 0 here */
228     {"includebuffer",   0}, /* Argument is not standard format, so just use 0 here */
229     {"line",            1},
230     {"pragma",          1},
231     {"undef",           1},
232     {"warning",         1},
233     {NULL,              0}
234 };
235 
236 /* This table must match ordering of above table exactly */
237 
238 enum Gbl_DirectiveIndexes
239 {
240     PR_DIRECTIVE_DEFINE = 0,
241     PR_DIRECTIVE_ELIF,
242     PR_DIRECTIVE_ELSE,
243     PR_DIRECTIVE_ENDIF,
244     PR_DIRECTIVE_ERROR,
245     PR_DIRECTIVE_IF,
246     PR_DIRECTIVE_IFDEF,
247     PR_DIRECTIVE_IFNDEF,
248     PR_DIRECTIVE_INCLUDE,
249     PR_DIRECTIVE_INCLUDEBUFFER,
250     PR_DIRECTIVE_LINE,
251     PR_DIRECTIVE_PRAGMA,
252     PR_DIRECTIVE_UNDEF,
253     PR_DIRECTIVE_WARNING
254 };
255 
256 #define ASL_DIRECTIVE_NOT_FOUND     -1
257 
258 
259 /*******************************************************************************
260  *
261  * FUNCTION:    PrInitializePreprocessor
262  *
263  * PARAMETERS:  None
264  *
265  * RETURN:      None
266  *
267  * DESCRIPTION: Startup initialization for the Preprocessor.
268  *
269  ******************************************************************************/
270 
271 void
272 PrInitializePreprocessor (
273     void)
274 {
275     /* Init globals and the list of #defines */
276 
277     PrInitializeGlobals ();
278     AslGbl_DefineList = NULL;
279 }
280 
281 
282 /*******************************************************************************
283  *
284  * FUNCTION:    PrInitializeGlobals
285  *
286  * PARAMETERS:  None
287  *
288  * RETURN:      None
289  *
290  * DESCRIPTION: Initialize globals for the Preprocessor. Used for startuup
291  *              initialization and re-initialization between compiles during
292  *              a multiple source file compile.
293  *
294  ******************************************************************************/
295 
296 void
297 PrInitializeGlobals (
298     void)
299 {
300     /* Init globals */
301 
302     AslGbl_InputFileList = NULL;
303     AslGbl_CurrentLineNumber = 1;
304     AslGbl_PreprocessorLineNumber = 1;
305     AslGbl_PreprocessorError = FALSE;
306 
307     /* These are used to track #if/#else blocks (possibly nested) */
308 
309     AslGbl_IfDepth = 0;
310     AslGbl_IgnoringThisCodeBlock = FALSE;
311     AslGbl_DirectiveStack = NULL;
312 }
313 
314 
315 /*******************************************************************************
316  *
317  * FUNCTION:    PrTerminatePreprocessor
318  *
319  * PARAMETERS:  None
320  *
321  * RETURN:      None
322  *
323  * DESCRIPTION: Termination of the preprocessor. Delete lists. Keep any
324  *              defines that were specified on the command line, in order to
325  *              support multiple compiles with a single compiler invocation.
326  *
327  ******************************************************************************/
328 
329 void
330 PrTerminatePreprocessor (
331     void)
332 {
333     PR_DEFINE_INFO          *DefineInfo;
334 
335 
336     /*
337      * The persistent defines (created on the command line) are always at the
338      * end of the list. We save them.
339      */
340     while ((AslGbl_DefineList) && (!AslGbl_DefineList->Persist))
341     {
342         DefineInfo = AslGbl_DefineList;
343         AslGbl_DefineList = DefineInfo->Next;
344 
345         ACPI_FREE (DefineInfo->Replacement);
346         ACPI_FREE (DefineInfo->Identifier);
347         ACPI_FREE (DefineInfo);
348     }
349 }
350 
351 
352 /*******************************************************************************
353  *
354  * FUNCTION:    PrDoPreprocess
355  *
356  * PARAMETERS:  None
357  *
358  * RETURN:      None
359  *
360  * DESCRIPTION: Main entry point for the iASL Preprocessor. Input file must
361  *              be already open. Handles multiple input files via the
362  *              #include directive.
363  *
364  ******************************************************************************/
365 
366 void
367 PrDoPreprocess (
368     void)
369 {
370     BOOLEAN                 MoreInputFiles;
371 
372 
373     DbgPrint (ASL_DEBUG_OUTPUT, "Starting preprocessing phase\n\n");
374 
375 
376     FlSeekFile (ASL_FILE_INPUT, 0);
377     PrDumpPredefinedNames ();
378 
379     /* Main preprocessor loop, handles include files */
380 
381     do
382     {
383         PrPreprocessInputFile ();
384         MoreInputFiles = PrPopInputFileStack ();
385 
386     } while (MoreInputFiles);
387 
388     /* Point compiler input to the new preprocessor output file (.pre) */
389 
390     FlCloseFile (ASL_FILE_INPUT);
391     AslGbl_Files[ASL_FILE_INPUT].Handle = AslGbl_Files[ASL_FILE_PREPROCESSOR].Handle;
392     AslCompilerin = AslGbl_Files[ASL_FILE_INPUT].Handle;
393 
394     /* Reset globals to allow compiler to run */
395 
396     FlSeekFile (ASL_FILE_INPUT, 0);
397     if (!AslGbl_PreprocessOnly)
398     {
399         AslGbl_CurrentLineNumber = 0;
400     }
401 
402     DbgPrint (ASL_DEBUG_OUTPUT, "Preprocessing phase complete \n\n");
403 }
404 
405 
406 /*******************************************************************************
407  *
408  * FUNCTION:    PrPreprocessInputFile
409  *
410  * PARAMETERS:  None
411  *
412  * RETURN:      None
413  *
414  * DESCRIPTION: Preprocess one entire file, line-by-line.
415  *
416  * Input:  Raw user ASL from ASL_FILE_INPUT
417  * Output: Preprocessed file written to ASL_FILE_PREPROCESSOR and
418  *         (optionally) ASL_FILE_PREPROCESSOR_USER
419  *
420  ******************************************************************************/
421 
422 static void
423 PrPreprocessInputFile (
424     void)
425 {
426     UINT32                  Status;
427     char                    *Token;
428     char                    *ReplaceString;
429     PR_DEFINE_INFO          *DefineInfo;
430     ACPI_SIZE               TokenOffset;
431     char                    *Next;
432     int                     OffsetAdjust;
433 
434 
435     PrGetNextLineInit ();
436 
437     /* Scan source line-by-line and process directives. Then write the .i file */
438 
439     while ((Status = PrGetNextLine (AslGbl_Files[ASL_FILE_INPUT].Handle)) != ASL_EOF)
440     {
441         AslGbl_CurrentLineNumber++;
442         AslGbl_LogicalLineNumber++;
443 
444         if (Status == ASL_IGNORE_LINE)
445         {
446             goto WriteEntireLine;
447         }
448 
449         /* Need a copy of the input line for strok() */
450 
451         strcpy (AslGbl_MainTokenBuffer, AslGbl_CurrentLineBuffer);
452         Token = PrGetNextToken (AslGbl_MainTokenBuffer, PR_TOKEN_SEPARATORS, &Next);
453         OffsetAdjust = 0;
454 
455         /* All preprocessor directives must begin with '#' */
456 
457         if (Token && (*Token == '#'))
458         {
459             if (strlen (Token) == 1)
460             {
461                 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
462             }
463             else
464             {
465                 Token++;    /* Skip leading # */
466             }
467 
468             /* Execute the directive, do not write line to output file */
469 
470             PrDoDirective (Token, &Next);
471             continue;
472         }
473 
474         /*
475          * If we are currently within the part of an IF/ELSE block that is
476          * FALSE, ignore the line and do not write it to the output file.
477          * This continues until an #else or #endif is encountered.
478          */
479         if (AslGbl_IgnoringThisCodeBlock)
480         {
481             continue;
482         }
483 
484         /* Match and replace all #defined names within this source line */
485 
486         while (Token)
487         {
488             DefineInfo = PrMatchDefine (Token);
489             if (DefineInfo)
490             {
491                 if (DefineInfo->Body)
492                 {
493                     /* This is a macro */
494 
495                     DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
496                         "Matched Macro: %s->%s\n",
497                         AslGbl_CurrentLineNumber, DefineInfo->Identifier,
498                         DefineInfo->Replacement);
499 
500                     PrDoMacroInvocation (AslGbl_MainTokenBuffer, Token,
501                         DefineInfo, &Next);
502                 }
503                 else
504                 {
505                     ReplaceString = DefineInfo->Replacement;
506 
507                     /* Replace the name in the original line buffer */
508 
509                     TokenOffset = Token - AslGbl_MainTokenBuffer + OffsetAdjust;
510                     PrReplaceData (
511                         &AslGbl_CurrentLineBuffer[TokenOffset], strlen (Token),
512                         ReplaceString, strlen (ReplaceString));
513 
514                     /* Adjust for length difference between old and new name length */
515 
516                     OffsetAdjust += strlen (ReplaceString) - strlen (Token);
517 
518                     DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
519                         "Matched #define: %s->%s\n",
520                         AslGbl_CurrentLineNumber, Token,
521                         *ReplaceString ? ReplaceString : "(NULL STRING)");
522                 }
523             }
524 
525             Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
526         }
527 
528         AslGbl_PreprocessorLineNumber++;
529 
530 
531 WriteEntireLine:
532         /*
533          * Now we can write the possibly modified source line to the
534          * preprocessor file(s).
535          */
536         FlWriteFile (ASL_FILE_PREPROCESSOR, AslGbl_CurrentLineBuffer,
537             strlen (AslGbl_CurrentLineBuffer));
538     }
539 }
540 
541 
542 /*******************************************************************************
543  *
544  * FUNCTION:    PrDoDirective
545  *
546  * PARAMETERS:  Directive               - Pointer to directive name token
547  *              Next                    - "Next" buffer from GetNextToken
548  *
549  * RETURN:      None.
550  *
551  * DESCRIPTION: Main processing for all preprocessor directives
552  *
553  ******************************************************************************/
554 
555 static void
556 PrDoDirective (
557     char                    *DirectiveToken,
558     char                    **Next)
559 {
560     char                    *Token = AslGbl_MainTokenBuffer;
561     char                    *Token2 = NULL;
562     char                    *End;
563     UINT64                  Value;
564     ACPI_SIZE               TokenOffset;
565     int                     Directive;
566     ACPI_STATUS             Status;
567 
568 
569     if (!DirectiveToken)
570     {
571         goto SyntaxError;
572     }
573 
574     Directive = PrMatchDirective (DirectiveToken);
575     if (Directive == ASL_DIRECTIVE_NOT_FOUND)
576     {
577         PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE,
578             THIS_TOKEN_OFFSET (DirectiveToken));
579 
580         DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
581             "#%s: Unknown directive\n",
582             AslGbl_CurrentLineNumber, DirectiveToken);
583         return;
584     }
585 
586     /*
587      * Emit a line directive into the preprocessor file (.pre) after
588      * every matched directive. This is passed through to the compiler
589      * so that error/warning messages are kept in sync with the
590      * original source file.
591      */
592     FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\" // #%s\n",
593         AslGbl_CurrentLineNumber, AslGbl_Files[ASL_FILE_INPUT].Filename,
594         AslGbl_DirectiveInfo[Directive].Name);
595 
596     /*
597      * If we are currently ignoring this block and we encounter a #else or
598      * #elif, we must ignore their blocks also if the parent block is also
599      * being ignored.
600      */
601     if (AslGbl_IgnoringThisCodeBlock)
602     {
603         switch (Directive)
604         {
605         case PR_DIRECTIVE_ELSE:
606         case PR_DIRECTIVE_ELIF:
607 
608             if (AslGbl_DirectiveStack &&
609                 AslGbl_DirectiveStack->IgnoringThisCodeBlock)
610             {
611                 PrDbgPrint ("Ignoring", AslGbl_DirectiveInfo[Directive].Name);
612                 return;
613             }
614             break;
615 
616         default:
617             break;
618         }
619     }
620 
621     /*
622      * Need to always check for #else, #elif, #endif regardless of
623      * whether we are ignoring the current code block, since these
624      * are conditional code block terminators.
625      */
626     switch (Directive)
627     {
628     case PR_DIRECTIVE_ELSE:
629 
630         AslGbl_IgnoringThisCodeBlock = !(AslGbl_IgnoringThisCodeBlock);
631         PrDbgPrint ("Executing", "else block");
632         return;
633 
634     case PR_DIRECTIVE_ELIF:
635 
636         AslGbl_IgnoringThisCodeBlock = !(AslGbl_IgnoringThisCodeBlock);
637         Directive = PR_DIRECTIVE_IF;
638 
639         if (AslGbl_IgnoringThisCodeBlock == TRUE)
640         {
641             /* Not executing the ELSE part -- all done here */
642             PrDbgPrint ("Ignoring", "elif block");
643             return;
644         }
645 
646         /*
647          * After this, we will execute the IF part further below.
648          * First, however, pop off the original #if directive.
649          */
650         if (ACPI_FAILURE (PrPopDirective ()))
651         {
652             PrError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
653                 THIS_TOKEN_OFFSET (DirectiveToken));
654         }
655 
656         PrDbgPrint ("Executing", "elif block");
657         break;
658 
659     case PR_DIRECTIVE_ENDIF:
660 
661         PrDbgPrint ("Executing", "endif");
662 
663         /* Pop the owning #if/#ifdef/#ifndef */
664 
665         if (ACPI_FAILURE (PrPopDirective ()))
666         {
667             PrError (ASL_ERROR, ASL_MSG_ENDIF_MISMATCH,
668                 THIS_TOKEN_OFFSET (DirectiveToken));
669         }
670         return;
671 
672     default:
673         break;
674     }
675 
676     /* Most directives have at least one argument */
677 
678     if (AslGbl_DirectiveInfo[Directive].ArgCount >= 1)
679     {
680         Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
681         if (!Token)
682         {
683             goto SyntaxError;
684         }
685     }
686 
687     if (AslGbl_DirectiveInfo[Directive].ArgCount >= 2)
688     {
689         Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
690         if (!Token2)
691         {
692             goto SyntaxError;
693         }
694     }
695 
696     /*
697      * At this point, if we are ignoring the current code block,
698      * do not process any more directives (i.e., ignore them also.)
699      * For "if" style directives, open/push a new block anyway. We
700      * must do this to keep track of #endif directives
701      */
702     if (AslGbl_IgnoringThisCodeBlock)
703     {
704         switch (Directive)
705         {
706         case PR_DIRECTIVE_IF:
707         case PR_DIRECTIVE_IFDEF:
708         case PR_DIRECTIVE_IFNDEF:
709 
710             PrPushDirective (Directive, Token);
711             PrDbgPrint ("Ignoring", AslGbl_DirectiveInfo[Directive].Name);
712             break;
713 
714         default:
715             break;
716         }
717 
718         return;
719     }
720 
721     /*
722      * Execute the directive
723      */
724     PrDbgPrint ("Begin execution", AslGbl_DirectiveInfo[Directive].Name);
725 
726     switch (Directive)
727     {
728     case PR_DIRECTIVE_IF:
729 
730         TokenOffset = Token - AslGbl_MainTokenBuffer;
731 
732         /* Need to expand #define macros in the expression string first */
733 
734         Status = PrResolveIntegerExpression (
735             &AslGbl_CurrentLineBuffer[TokenOffset-1], &Value);
736         if (ACPI_FAILURE (Status))
737         {
738             return;
739         }
740 
741         PrPushDirective (Directive, Token);
742         if (!Value)
743         {
744             AslGbl_IgnoringThisCodeBlock = TRUE;
745         }
746 
747         DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
748             "Resolved #if: %8.8X%8.8X %s\n",
749             AslGbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value),
750             AslGbl_IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>");
751         break;
752 
753     case PR_DIRECTIVE_IFDEF:
754 
755         PrPushDirective (Directive, Token);
756         if (!PrMatchDefine (Token))
757         {
758             AslGbl_IgnoringThisCodeBlock = TRUE;
759         }
760 
761         PrDbgPrint ("Evaluated", "ifdef");
762         break;
763 
764     case PR_DIRECTIVE_IFNDEF:
765 
766         PrPushDirective (Directive, Token);
767         if (PrMatchDefine (Token))
768         {
769             AslGbl_IgnoringThisCodeBlock = TRUE;
770         }
771 
772         PrDbgPrint ("Evaluated", "ifndef");
773         break;
774 
775     case PR_DIRECTIVE_DEFINE:
776         /*
777          * By definition, if first char after the name is a paren,
778          * this is a function macro.
779          */
780         TokenOffset = Token - AslGbl_MainTokenBuffer + strlen (Token);
781         if (*(&AslGbl_CurrentLineBuffer[TokenOffset]) == '(')
782         {
783 #ifndef MACROS_SUPPORTED
784             AcpiOsPrintf (
785                 "%s ERROR - line %u: #define macros are not supported yet\n",
786                 AslGbl_CurrentLineBuffer, AslGbl_LogicalLineNumber);
787             exit(1);
788 #else
789             PrAddMacro (Token, Next);
790 #endif
791         }
792         else
793         {
794             /* Use the remainder of the line for the #define */
795 
796             Token2 = *Next;
797             if (Token2)
798             {
799                 while ((*Token2 == ' ') || (*Token2 == '\t'))
800                 {
801                     Token2++;
802                 }
803 
804                 End = Token2;
805                 while (*End != '\n')
806                 {
807                     End++;
808                 }
809 
810                 *End = 0;
811             }
812             else
813             {
814                 Token2 = "";
815             }
816 #if 0
817             Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next);
818             if (!Token2)
819             {
820                 Token2 = "";
821             }
822 #endif
823             DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
824                 "New #define: %s->%s\n",
825                 AslGbl_LogicalLineNumber, Token, Token2);
826 
827             PrAddDefine (Token, Token2, FALSE);
828         }
829         break;
830 
831     case PR_DIRECTIVE_ERROR:
832 
833         /* Note: No macro expansion */
834 
835         PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE,
836             THIS_TOKEN_OFFSET (Token));
837 
838         AslGbl_SourceLine = 0;
839         AslGbl_NextError = AslGbl_ErrorLog;
840         CmCleanupAndExit ();
841         exit(1);
842 
843     case PR_DIRECTIVE_INCLUDE:
844 
845         Token = PrGetNextToken (NULL, " \"<>", Next);
846         if (!Token)
847         {
848             goto SyntaxError;
849         }
850 
851         DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
852             "Start #include file \"%s\"\n", AslGbl_CurrentLineNumber,
853             Token);
854 
855         PrDoIncludeFile (Token);
856         break;
857 
858     case PR_DIRECTIVE_INCLUDEBUFFER:
859 
860         Token = PrGetNextToken (NULL, " \"<>", Next);
861         if (!Token)
862         {
863             goto SyntaxError;
864         }
865 
866         Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
867         if (!Token2)
868         {
869             goto SyntaxError;
870         }
871 
872         DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
873             "Start #includebuffer input from file \"%s\", buffer name %s\n",
874             AslGbl_CurrentLineNumber, Token, Token2);
875 
876         PrDoIncludeBuffer (Token, Token2);
877         break;
878 
879     case PR_DIRECTIVE_LINE:
880 
881         TokenOffset = Token - AslGbl_MainTokenBuffer;
882 
883         Status = PrResolveIntegerExpression (
884             &AslGbl_CurrentLineBuffer[TokenOffset-1], &Value);
885         if (ACPI_FAILURE (Status))
886         {
887             return;
888         }
889 
890         DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
891             "User #line invocation %s\n", AslGbl_CurrentLineNumber,
892             Token);
893 
894         AslGbl_CurrentLineNumber = (UINT32) Value;
895 
896         /* Emit #line into the preprocessor file */
897 
898         FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
899             AslGbl_CurrentLineNumber, AslGbl_Files[ASL_FILE_INPUT].Filename);
900         break;
901 
902     case PR_DIRECTIVE_PRAGMA:
903 
904         if (!strcmp (Token, "disable"))
905         {
906             Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
907             if (!Token)
908             {
909                 goto SyntaxError;
910             }
911 
912             TokenOffset = Token - AslGbl_MainTokenBuffer;
913             AslDisableException (&AslGbl_CurrentLineBuffer[TokenOffset]);
914         }
915         else if (!strcmp (Token, "message"))
916         {
917             Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
918             if (!Token)
919             {
920                 goto SyntaxError;
921             }
922 
923             TokenOffset = Token - AslGbl_MainTokenBuffer;
924             AcpiOsPrintf ("%s\n", &AslGbl_CurrentLineBuffer[TokenOffset]);
925         }
926         else
927         {
928             PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA,
929                 THIS_TOKEN_OFFSET (Token));
930             return;
931         }
932 
933         break;
934 
935     case PR_DIRECTIVE_UNDEF:
936 
937         DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
938             "#undef: %s\n", AslGbl_CurrentLineNumber, Token);
939 
940         PrRemoveDefine (Token);
941         break;
942 
943     case PR_DIRECTIVE_WARNING:
944 
945         PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE,
946             THIS_TOKEN_OFFSET (Token));
947 
948         AslGbl_SourceLine = 0;
949         AslGbl_NextError = AslGbl_ErrorLog;
950         break;
951 
952     default:
953 
954         /* Should never get here */
955         DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
956             "Unrecognized directive: %u\n",
957             AslGbl_CurrentLineNumber, Directive);
958         break;
959     }
960 
961     return;
962 
963 SyntaxError:
964 
965     PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX,
966         THIS_TOKEN_OFFSET (DirectiveToken));
967     return;
968 }
969 
970 
971 /*******************************************************************************
972  *
973  * FUNCTION:    PrGetNextLine, PrGetNextLineInit
974  *
975  * PARAMETERS:  Handle              - Open file handle for the source file
976  *
977  * RETURN:      Status of the GetLine operation:
978  *              AE_OK               - Normal line, OK status
979  *              ASL_IGNORE_LINE     - Line is blank or part of a multi-line
980  *                                      comment
981  *              ASL_EOF             - End-of-file reached
982  *
983  * DESCRIPTION: Get the next text line from the input file. Does not strip
984  *              comments.
985  *
986  ******************************************************************************/
987 
988 #define PR_NORMAL_TEXT          0
989 #define PR_MULTI_LINE_COMMENT   1
990 #define PR_SINGLE_LINE_COMMENT  2
991 #define PR_QUOTED_STRING        3
992 
993 static UINT8                    AcpiGbl_LineScanState = PR_NORMAL_TEXT;
994 
995 static void
996 PrGetNextLineInit (
997     void)
998 {
999     AcpiGbl_LineScanState = 0;
1000 }
1001 
1002 static UINT32
1003 PrGetNextLine (
1004     FILE                    *Handle)
1005 {
1006     UINT32                  i;
1007     int                     c = 0;
1008     int                     PreviousChar;
1009 
1010 
1011     /* Always clear the global line buffer */
1012 
1013     memset (AslGbl_CurrentLineBuffer, 0, AslGbl_LineBufferSize);
1014     for (i = 0; ;)
1015     {
1016         /*
1017          * If line is too long, expand the line buffers. Also increases
1018          * AslGbl_LineBufferSize.
1019          */
1020         if (i >= AslGbl_LineBufferSize)
1021         {
1022             UtExpandLineBuffers ();
1023         }
1024 
1025         PreviousChar = c;
1026         c = getc (Handle);
1027         if (c == EOF)
1028         {
1029             /*
1030              * On EOF: If there is anything in the line buffer, terminate
1031              * it with a newline, and catch the EOF on the next call
1032              * to this function.
1033              */
1034             if (i > 0)
1035             {
1036                 AslGbl_CurrentLineBuffer[i] = '\n';
1037                 return (AE_OK);
1038             }
1039 
1040             return (ASL_EOF);
1041         }
1042 
1043         /* Update state machine as necessary */
1044 
1045         switch (AcpiGbl_LineScanState)
1046         {
1047         case PR_NORMAL_TEXT:
1048 
1049             /* Check for multi-line comment start */
1050 
1051             if ((PreviousChar == '/') && (c == '*'))
1052             {
1053                 AcpiGbl_LineScanState = PR_MULTI_LINE_COMMENT;
1054             }
1055 
1056             /* Check for single-line comment start */
1057 
1058             else if ((PreviousChar == '/') && (c == '/'))
1059             {
1060                 AcpiGbl_LineScanState = PR_SINGLE_LINE_COMMENT;
1061             }
1062 
1063             /* Check for quoted string start */
1064 
1065             else if (PreviousChar == '"')
1066             {
1067                 AcpiGbl_LineScanState = PR_QUOTED_STRING;
1068             }
1069             break;
1070 
1071         case PR_QUOTED_STRING:
1072 
1073             if (PreviousChar == '"')
1074             {
1075                 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1076             }
1077             break;
1078 
1079         case PR_MULTI_LINE_COMMENT:
1080 
1081             /* Check for multi-line comment end */
1082 
1083             if ((PreviousChar == '*') && (c == '/'))
1084             {
1085                 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1086             }
1087             break;
1088 
1089         case PR_SINGLE_LINE_COMMENT: /* Just ignore text until EOL */
1090         default:
1091             break;
1092         }
1093 
1094         /* Always copy the character into line buffer */
1095 
1096         AslGbl_CurrentLineBuffer[i] = (char) c;
1097         i++;
1098 
1099         /* Always exit on end-of-line */
1100 
1101         if (c == '\n')
1102         {
1103             /* Handle multi-line comments */
1104 
1105             if (AcpiGbl_LineScanState == PR_MULTI_LINE_COMMENT)
1106             {
1107                 return (ASL_IGNORE_LINE);
1108             }
1109 
1110             /* End of single-line comment */
1111 
1112             if (AcpiGbl_LineScanState == PR_SINGLE_LINE_COMMENT)
1113             {
1114                 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1115                 return (AE_OK);
1116             }
1117 
1118             /* Blank line */
1119 
1120             if (i == 1)
1121             {
1122                 return (ASL_IGNORE_LINE);
1123             }
1124 
1125             return (AE_OK);
1126         }
1127     }
1128 }
1129 
1130 
1131 /*******************************************************************************
1132  *
1133  * FUNCTION:    PrMatchDirective
1134  *
1135  * PARAMETERS:  Directive           - Pointer to directive name token
1136  *
1137  * RETURN:      Index into command array, -1 if not found
1138  *
1139  * DESCRIPTION: Lookup the incoming directive in the known directives table.
1140  *
1141  ******************************************************************************/
1142 
1143 static int
1144 PrMatchDirective (
1145     char                    *Directive)
1146 {
1147     int                     i;
1148 
1149 
1150     if (!Directive || Directive[0] == 0)
1151     {
1152         return (ASL_DIRECTIVE_NOT_FOUND);
1153     }
1154 
1155     for (i = 0; AslGbl_DirectiveInfo[i].Name; i++)
1156     {
1157         if (!strcmp (AslGbl_DirectiveInfo[i].Name, Directive))
1158         {
1159             return (i);
1160         }
1161     }
1162 
1163     return (ASL_DIRECTIVE_NOT_FOUND);    /* Command not recognized */
1164 }
1165 
1166 
1167 /*******************************************************************************
1168  *
1169  * FUNCTION:    PrPushDirective
1170  *
1171  * PARAMETERS:  Directive           - Encoded directive ID
1172  *              Argument            - String containing argument to the
1173  *                                    directive
1174  *
1175  * RETURN:      None
1176  *
1177  * DESCRIPTION: Push an item onto the directive stack. Used for processing
1178  *              nested #if/#else type conditional compilation directives.
1179  *              Specifically: Used on detection of #if/#ifdef/#ifndef to open
1180  *              a block.
1181  *
1182  ******************************************************************************/
1183 
1184 static void
1185 PrPushDirective (
1186     int                     Directive,
1187     char                    *Argument)
1188 {
1189     DIRECTIVE_INFO          *Info;
1190 
1191 
1192     /* Allocate and populate a stack info item */
1193 
1194     Info = ACPI_CAST_PTR (DIRECTIVE_INFO,
1195         UtLocalCacheCalloc (sizeof (DIRECTIVE_INFO)));
1196 
1197     Info->Next = AslGbl_DirectiveStack;
1198     Info->Directive = Directive;
1199     Info->IgnoringThisCodeBlock = AslGbl_IgnoringThisCodeBlock;
1200     AcpiUtSafeStrncpy (Info->Argument, Argument, MAX_ARGUMENT_LENGTH);
1201 
1202     DbgPrint (ASL_DEBUG_OUTPUT,
1203         "Pr(%.4u) - [%u %s] %*s Pushed [#%s %s]: IgnoreFlag = %s\n",
1204         AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1205         AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1206         AslGbl_IfDepth * 4, " ",
1207         AslGbl_DirectiveInfo[Directive].Name,
1208         Argument, AslGbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
1209 
1210     /* Push new item */
1211 
1212     AslGbl_DirectiveStack = Info;
1213     AslGbl_IfDepth++;
1214 }
1215 
1216 
1217 /*******************************************************************************
1218  *
1219  * FUNCTION:    PrPopDirective
1220  *
1221  * PARAMETERS:  None
1222  *
1223  * RETURN:      Status. Error if the stack is empty.
1224  *
1225  * DESCRIPTION: Pop an item off the directive stack. Used for processing
1226  *              nested #if/#else type conditional compilation directives.
1227  *              Specifically: Used on detection of #elif and #endif to remove
1228  *              the original #if/#ifdef/#ifndef from the stack and close
1229  *              the block.
1230  *
1231  ******************************************************************************/
1232 
1233 static ACPI_STATUS
1234 PrPopDirective (
1235     void)
1236 {
1237     DIRECTIVE_INFO          *Info;
1238 
1239 
1240     /* Check for empty stack */
1241 
1242     Info = AslGbl_DirectiveStack;
1243     if (!Info)
1244     {
1245         return (AE_ERROR);
1246     }
1247 
1248     /* Pop one item, keep globals up-to-date */
1249 
1250     AslGbl_IfDepth--;
1251     AslGbl_IgnoringThisCodeBlock = Info->IgnoringThisCodeBlock;
1252     AslGbl_DirectiveStack = Info->Next;
1253 
1254     DbgPrint (ASL_DEBUG_OUTPUT,
1255         "Pr(%.4u) - [%u %s] %*s Popped [#%s %s]: IgnoreFlag now = %s\n",
1256         AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1257         AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1258         AslGbl_IfDepth * 4, " ",
1259         AslGbl_DirectiveInfo[Info->Directive].Name,
1260         Info->Argument, AslGbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
1261 
1262     return (AE_OK);
1263 }
1264 
1265 
1266 /*******************************************************************************
1267  *
1268  * FUNCTION:    PrDbgPrint
1269  *
1270  * PARAMETERS:  Action              - Action being performed
1271  *              DirectiveName       - Directive being processed
1272  *
1273  * RETURN:      None
1274  *
1275  * DESCRIPTION: Special debug print for directive processing.
1276  *
1277  ******************************************************************************/
1278 
1279 static void
1280 PrDbgPrint (
1281     char                    *Action,
1282     char                    *DirectiveName)
1283 {
1284 
1285     DbgPrint (ASL_DEBUG_OUTPUT, "Pr(%.4u) - [%u %s] "
1286         "%*s %s #%s, IfDepth %u\n",
1287         AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1288         AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1289         AslGbl_IfDepth * 4, " ",
1290         Action, DirectiveName, AslGbl_IfDepth);
1291 }
1292 
1293 
1294 /*******************************************************************************
1295  *
1296  * FUNCTION:    PrDoIncludeFile
1297  *
1298  * PARAMETERS:  Pathname                - Name of the input file
1299  *
1300  * RETURN:      None.
1301  *
1302  * DESCRIPTION: Open an include file, from #include.
1303  *
1304  ******************************************************************************/
1305 
1306 static void
1307 PrDoIncludeFile (
1308     char                    *Pathname)
1309 {
1310     char                    *FullPathname;
1311 
1312 
1313     (void) PrOpenIncludeFile (Pathname, "r", &FullPathname);
1314 }
1315 
1316 
1317 /*******************************************************************************
1318  *
1319  * FUNCTION:    PrDoIncludeBuffer
1320  *
1321  * PARAMETERS:  Pathname                - Name of the input binary file
1322  *              BufferName              - ACPI namepath of the buffer
1323  *
1324  * RETURN:      None.
1325  *
1326  * DESCRIPTION: Create an ACPI buffer object from a binary file. The contents
1327  *              of the file are emitted into the buffer object as ascii
1328  *              hex data. From #includebuffer.
1329  *
1330  ******************************************************************************/
1331 
1332 static void
1333 PrDoIncludeBuffer (
1334     char                    *Pathname,
1335     char                    *BufferName)
1336 {
1337     char                    *FullPathname;
1338     FILE                    *BinaryBufferFile;
1339     UINT32                  i = 0;
1340     UINT8                   c;
1341 
1342 
1343     BinaryBufferFile = PrOpenIncludeFile (Pathname, "rb", &FullPathname);
1344     if (!BinaryBufferFile)
1345     {
1346         return;
1347     }
1348 
1349     /* Emit "Name (XXXX, Buffer() {" header */
1350 
1351     FlPrintFile (ASL_FILE_PREPROCESSOR, "Name (%s, Buffer()\n{", BufferName);
1352 
1353     /* Dump the entire file in ascii hex format */
1354 
1355     while (fread (&c, 1, 1, BinaryBufferFile))
1356     {
1357         if (!(i % 8))
1358         {
1359             FlPrintFile (ASL_FILE_PREPROCESSOR, "\n   ");
1360         }
1361 
1362         FlPrintFile (ASL_FILE_PREPROCESSOR, " 0x%2.2X,", c);
1363         i++;
1364     }
1365 
1366     DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
1367         "#includebuffer: read %u bytes from %s\n",
1368         AslGbl_CurrentLineNumber, i, FullPathname);
1369 
1370     /* Close the Name() operator */
1371 
1372     FlPrintFile (ASL_FILE_PREPROCESSOR, "\n})\n");
1373     fclose (BinaryBufferFile);
1374 }
1375