10d02842fSSascha Wildner /******************************************************************************
20d02842fSSascha Wildner *
30d02842fSSascha Wildner * Module Name: prscan - Preprocessor start-up and file scan module
40d02842fSSascha Wildner *
50d02842fSSascha Wildner *****************************************************************************/
60d02842fSSascha Wildner
7b4315fc7SSascha Wildner /******************************************************************************
8b4315fc7SSascha Wildner *
9b4315fc7SSascha Wildner * 1. Copyright Notice
10b4315fc7SSascha Wildner *
11*383048acSSascha Wildner * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp.
120d02842fSSascha Wildner * All rights reserved.
130d02842fSSascha Wildner *
14b4315fc7SSascha Wildner * 2. License
15b4315fc7SSascha Wildner *
16b4315fc7SSascha Wildner * 2.1. This is your license from Intel Corp. under its intellectual property
17b4315fc7SSascha Wildner * rights. You may have additional license terms from the party that provided
18b4315fc7SSascha Wildner * you this software, covering your right to use that party's intellectual
19b4315fc7SSascha Wildner * property rights.
20b4315fc7SSascha Wildner *
21b4315fc7SSascha Wildner * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22b4315fc7SSascha Wildner * copy of the source code appearing in this file ("Covered Code") an
23b4315fc7SSascha Wildner * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24b4315fc7SSascha Wildner * base code distributed originally by Intel ("Original Intel Code") to copy,
25b4315fc7SSascha Wildner * make derivatives, distribute, use and display any portion of the Covered
26b4315fc7SSascha Wildner * Code in any form, with the right to sublicense such rights; and
27b4315fc7SSascha Wildner *
28b4315fc7SSascha Wildner * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29b4315fc7SSascha Wildner * license (with the right to sublicense), under only those claims of Intel
30b4315fc7SSascha Wildner * patents that are infringed by the Original Intel Code, to make, use, sell,
31b4315fc7SSascha Wildner * offer to sell, and import the Covered Code and derivative works thereof
32b4315fc7SSascha Wildner * solely to the minimum extent necessary to exercise the above copyright
33b4315fc7SSascha Wildner * license, and in no event shall the patent license extend to any additions
34b4315fc7SSascha Wildner * to or modifications of the Original Intel Code. No other license or right
35b4315fc7SSascha Wildner * is granted directly or by implication, estoppel or otherwise;
36b4315fc7SSascha Wildner *
37b4315fc7SSascha Wildner * The above copyright and patent license is granted only if the following
38b4315fc7SSascha Wildner * conditions are met:
39b4315fc7SSascha Wildner *
40b4315fc7SSascha Wildner * 3. Conditions
41b4315fc7SSascha Wildner *
42b4315fc7SSascha Wildner * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
44b4315fc7SSascha Wildner * Code or modification with rights to further distribute source must include
45b4315fc7SSascha Wildner * the above Copyright Notice, the above License, this list of Conditions,
46b4315fc7SSascha Wildner * and the following Disclaimer and Export Compliance provision. In addition,
47b4315fc7SSascha Wildner * Licensee must cause all Covered Code to which Licensee contributes to
48b4315fc7SSascha Wildner * contain a file documenting the changes Licensee made to create that Covered
49b4315fc7SSascha Wildner * Code and the date of any change. Licensee must include in that file the
50b4315fc7SSascha Wildner * documentation of any changes made by any predecessor Licensee. Licensee
51b4315fc7SSascha Wildner * must include a prominent statement that the modification is derived,
52b4315fc7SSascha Wildner * directly or indirectly, from Original Intel Code.
53b4315fc7SSascha Wildner *
54b4315fc7SSascha Wildner * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
56b4315fc7SSascha Wildner * Code or modification without rights to further distribute source must
57b4315fc7SSascha Wildner * include the following Disclaimer and Export Compliance provision in the
58b4315fc7SSascha Wildner * documentation and/or other materials provided with distribution. In
59b4315fc7SSascha Wildner * addition, Licensee may not authorize further sublicense of source of any
60b4315fc7SSascha Wildner * portion of the Covered Code, and must include terms to the effect that the
61b4315fc7SSascha Wildner * license from Licensee to its licensee is limited to the intellectual
62b4315fc7SSascha Wildner * property embodied in the software Licensee provides to its licensee, and
63b4315fc7SSascha Wildner * not to intellectual property embodied in modifications its licensee may
64b4315fc7SSascha Wildner * make.
65b4315fc7SSascha Wildner *
66b4315fc7SSascha Wildner * 3.3. Redistribution of Executable. Redistribution in executable form of any
67b4315fc7SSascha Wildner * substantial portion of the Covered Code or modification must reproduce the
68b4315fc7SSascha Wildner * above Copyright Notice, and the following Disclaimer and Export Compliance
69b4315fc7SSascha Wildner * provision in the documentation and/or other materials provided with the
70b4315fc7SSascha Wildner * distribution.
71b4315fc7SSascha Wildner *
72b4315fc7SSascha Wildner * 3.4. Intel retains all right, title, and interest in and to the Original
73b4315fc7SSascha Wildner * Intel Code.
74b4315fc7SSascha Wildner *
75b4315fc7SSascha Wildner * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76b4315fc7SSascha Wildner * Intel shall be used in advertising or otherwise to promote the sale, use or
77b4315fc7SSascha Wildner * other dealings in products derived from or relating to the Covered Code
78b4315fc7SSascha Wildner * without prior written authorization from Intel.
79b4315fc7SSascha Wildner *
80b4315fc7SSascha Wildner * 4. Disclaimer and Export Compliance
81b4315fc7SSascha Wildner *
82b4315fc7SSascha Wildner * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83b4315fc7SSascha Wildner * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84b4315fc7SSascha Wildner * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85b4315fc7SSascha Wildner * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86b4315fc7SSascha Wildner * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87b4315fc7SSascha Wildner * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88b4315fc7SSascha Wildner * PARTICULAR PURPOSE.
89b4315fc7SSascha Wildner *
90b4315fc7SSascha Wildner * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91b4315fc7SSascha Wildner * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92b4315fc7SSascha Wildner * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93b4315fc7SSascha Wildner * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94b4315fc7SSascha Wildner * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95b4315fc7SSascha Wildner * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96b4315fc7SSascha Wildner * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97b4315fc7SSascha Wildner * LIMITED REMEDY.
98b4315fc7SSascha Wildner *
99b4315fc7SSascha Wildner * 4.3. Licensee shall not export, either directly or indirectly, any of this
100b4315fc7SSascha Wildner * software or system incorporating such software without first obtaining any
101b4315fc7SSascha Wildner * required license or other approval from the U. S. Department of Commerce or
102b4315fc7SSascha Wildner * any other agency or department of the United States Government. In the
103b4315fc7SSascha Wildner * event Licensee exports any such software from the United States or
104b4315fc7SSascha Wildner * re-exports any such software from a foreign destination, Licensee shall
105b4315fc7SSascha Wildner * ensure that the distribution and export/re-export of the software is in
106b4315fc7SSascha Wildner * compliance with all laws, regulations, orders, or other restrictions of the
107b4315fc7SSascha Wildner * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108b4315fc7SSascha Wildner * any of its subsidiaries will export/re-export any technical data, process,
109b4315fc7SSascha Wildner * software, or service, directly or indirectly, to any country for which the
110b4315fc7SSascha Wildner * United States government or any agency thereof requires an export license,
111b4315fc7SSascha Wildner * other governmental approval, or letter of assurance, without first obtaining
112b4315fc7SSascha Wildner * such license, approval or letter.
113b4315fc7SSascha Wildner *
114b4315fc7SSascha Wildner *****************************************************************************
115b4315fc7SSascha Wildner *
116b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
117b4315fc7SSascha Wildner * following license:
118b4315fc7SSascha Wildner *
1190d02842fSSascha Wildner * Redistribution and use in source and binary forms, with or without
1200d02842fSSascha Wildner * modification, are permitted provided that the following conditions
1210d02842fSSascha Wildner * are met:
1220d02842fSSascha Wildner * 1. Redistributions of source code must retain the above copyright
1230d02842fSSascha Wildner * notice, this list of conditions, and the following disclaimer,
1240d02842fSSascha Wildner * without modification.
1250d02842fSSascha Wildner * 2. Redistributions in binary form must reproduce at minimum a disclaimer
1260d02842fSSascha Wildner * substantially similar to the "NO WARRANTY" disclaimer below
1270d02842fSSascha Wildner * ("Disclaimer") and any redistribution must be conditioned upon
1280d02842fSSascha Wildner * including a substantially similar Disclaimer requirement for further
1290d02842fSSascha Wildner * binary redistribution.
1300d02842fSSascha Wildner * 3. Neither the names of the above-listed copyright holders nor the names
1310d02842fSSascha Wildner * of any contributors may be used to endorse or promote products derived
1320d02842fSSascha Wildner * from this software without specific prior written permission.
1330d02842fSSascha Wildner *
134b4315fc7SSascha Wildner * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135b4315fc7SSascha Wildner * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136b4315fc7SSascha Wildner * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137b4315fc7SSascha Wildner * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138b4315fc7SSascha Wildner * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139b4315fc7SSascha Wildner * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140b4315fc7SSascha Wildner * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141b4315fc7SSascha Wildner * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142b4315fc7SSascha Wildner * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143b4315fc7SSascha Wildner * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144b4315fc7SSascha Wildner * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145b4315fc7SSascha Wildner *
146b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
1470d02842fSSascha Wildner * GNU General Public License ("GPL") version 2 as published by the Free
1480d02842fSSascha Wildner * Software Foundation.
1490d02842fSSascha Wildner *
150b4315fc7SSascha Wildner *****************************************************************************/
1510d02842fSSascha Wildner
1520d02842fSSascha Wildner #define _DECLARE_PR_GLOBALS
1530d02842fSSascha Wildner
1540d02842fSSascha Wildner #include "aslcompiler.h"
1550d02842fSSascha Wildner
1560d02842fSSascha Wildner /*
1570d02842fSSascha Wildner * TBDs:
1580d02842fSSascha Wildner *
1590d02842fSSascha Wildner * No nested macros, maybe never
1600d02842fSSascha Wildner * Implement ASL "Include" as well as "#include" here?
1610d02842fSSascha Wildner */
1620d02842fSSascha Wildner #define _COMPONENT ASL_PREPROCESSOR
1630d02842fSSascha Wildner ACPI_MODULE_NAME ("prscan")
1640d02842fSSascha Wildner
1650d02842fSSascha Wildner
1660d02842fSSascha Wildner /* Local prototypes */
1670d02842fSSascha Wildner
1680d02842fSSascha Wildner static void
1690d02842fSSascha Wildner PrPreprocessInputFile (
1700d02842fSSascha Wildner void);
1710d02842fSSascha Wildner
1720d02842fSSascha Wildner static void
1730d02842fSSascha Wildner PrDoDirective (
1740d02842fSSascha Wildner char *DirectiveToken,
1750d02842fSSascha Wildner char **Next);
1760d02842fSSascha Wildner
17725ca8c79SSascha Wildner static void
17825ca8c79SSascha Wildner PrGetNextLineInit (
17925ca8c79SSascha Wildner void);
18025ca8c79SSascha Wildner
18125ca8c79SSascha Wildner static UINT32
18225ca8c79SSascha Wildner PrGetNextLine (
18325ca8c79SSascha Wildner FILE *Handle);
18425ca8c79SSascha Wildner
1850d02842fSSascha Wildner static int
1860d02842fSSascha Wildner PrMatchDirective (
1870d02842fSSascha Wildner char *Directive);
1880d02842fSSascha Wildner
1890d02842fSSascha Wildner static void
1900d02842fSSascha Wildner PrPushDirective (
1910d02842fSSascha Wildner int Directive,
1920d02842fSSascha Wildner char *Argument);
1930d02842fSSascha Wildner
1940d02842fSSascha Wildner static ACPI_STATUS
1950d02842fSSascha Wildner PrPopDirective (
1960d02842fSSascha Wildner void);
1970d02842fSSascha Wildner
1980d02842fSSascha Wildner static void
1990d02842fSSascha Wildner PrDbgPrint (
2000d02842fSSascha Wildner char *Action,
2010d02842fSSascha Wildner char *DirectiveName);
2020d02842fSSascha Wildner
203896f2e3aSSascha Wildner static void
204896f2e3aSSascha Wildner PrDoIncludeBuffer (
205896f2e3aSSascha Wildner char *Pathname,
206896f2e3aSSascha Wildner char *BufferName);
207896f2e3aSSascha Wildner
208896f2e3aSSascha Wildner static void
209896f2e3aSSascha Wildner PrDoIncludeFile (
210896f2e3aSSascha Wildner char *Pathname);
211896f2e3aSSascha Wildner
2120d02842fSSascha Wildner
2130d02842fSSascha Wildner /*
2140d02842fSSascha Wildner * Supported preprocessor directives
215896f2e3aSSascha Wildner * Each entry is of the form "Name, ArgumentCount"
2160d02842fSSascha Wildner */
217806343b9SSascha Wildner static const PR_DIRECTIVE_INFO AslGbl_DirectiveInfo[] =
2180d02842fSSascha Wildner {
2190d02842fSSascha Wildner {"define", 1},
2200d02842fSSascha Wildner {"elif", 0}, /* Converted to #else..#if internally */
2210d02842fSSascha Wildner {"else", 0},
2220d02842fSSascha Wildner {"endif", 0},
2230d02842fSSascha Wildner {"error", 1},
2240d02842fSSascha Wildner {"if", 1},
2250d02842fSSascha Wildner {"ifdef", 1},
2260d02842fSSascha Wildner {"ifndef", 1},
227896f2e3aSSascha Wildner {"include", 0}, /* Argument is not standard format, so just use 0 here */
228896f2e3aSSascha Wildner {"includebuffer", 0}, /* Argument is not standard format, so just use 0 here */
2290d02842fSSascha Wildner {"line", 1},
2300d02842fSSascha Wildner {"pragma", 1},
2310d02842fSSascha Wildner {"undef", 1},
2320d02842fSSascha Wildner {"warning", 1},
2330d02842fSSascha Wildner {NULL, 0}
2340d02842fSSascha Wildner };
2350d02842fSSascha Wildner
236896f2e3aSSascha Wildner /* This table must match ordering of above table exactly */
237896f2e3aSSascha Wildner
2380d02842fSSascha Wildner enum Gbl_DirectiveIndexes
2390d02842fSSascha Wildner {
2400d02842fSSascha Wildner PR_DIRECTIVE_DEFINE = 0,
2410d02842fSSascha Wildner PR_DIRECTIVE_ELIF,
2420d02842fSSascha Wildner PR_DIRECTIVE_ELSE,
2430d02842fSSascha Wildner PR_DIRECTIVE_ENDIF,
2440d02842fSSascha Wildner PR_DIRECTIVE_ERROR,
2450d02842fSSascha Wildner PR_DIRECTIVE_IF,
2460d02842fSSascha Wildner PR_DIRECTIVE_IFDEF,
2470d02842fSSascha Wildner PR_DIRECTIVE_IFNDEF,
2480d02842fSSascha Wildner PR_DIRECTIVE_INCLUDE,
249896f2e3aSSascha Wildner PR_DIRECTIVE_INCLUDEBUFFER,
2500d02842fSSascha Wildner PR_DIRECTIVE_LINE,
2510d02842fSSascha Wildner PR_DIRECTIVE_PRAGMA,
2520d02842fSSascha Wildner PR_DIRECTIVE_UNDEF,
253267c04fdSSascha Wildner PR_DIRECTIVE_WARNING
2540d02842fSSascha Wildner };
2550d02842fSSascha Wildner
2560d02842fSSascha Wildner #define ASL_DIRECTIVE_NOT_FOUND -1
2570d02842fSSascha Wildner
2580d02842fSSascha Wildner
2590d02842fSSascha Wildner /*******************************************************************************
2600d02842fSSascha Wildner *
2610d02842fSSascha Wildner * FUNCTION: PrInitializePreprocessor
2620d02842fSSascha Wildner *
2630d02842fSSascha Wildner * PARAMETERS: None
2640d02842fSSascha Wildner *
2650d02842fSSascha Wildner * RETURN: None
2660d02842fSSascha Wildner *
2670d02842fSSascha Wildner * DESCRIPTION: Startup initialization for the Preprocessor.
2680d02842fSSascha Wildner *
2690d02842fSSascha Wildner ******************************************************************************/
2700d02842fSSascha Wildner
2710d02842fSSascha Wildner void
PrInitializePreprocessor(void)2720d02842fSSascha Wildner PrInitializePreprocessor (
2730d02842fSSascha Wildner void)
2740d02842fSSascha Wildner {
2750d02842fSSascha Wildner /* Init globals and the list of #defines */
2760d02842fSSascha Wildner
2770d02842fSSascha Wildner PrInitializeGlobals ();
278806343b9SSascha Wildner AslGbl_DefineList = NULL;
2790d02842fSSascha Wildner }
2800d02842fSSascha Wildner
2810d02842fSSascha Wildner
2820d02842fSSascha Wildner /*******************************************************************************
2830d02842fSSascha Wildner *
2840d02842fSSascha Wildner * FUNCTION: PrInitializeGlobals
2850d02842fSSascha Wildner *
2860d02842fSSascha Wildner * PARAMETERS: None
2870d02842fSSascha Wildner *
2880d02842fSSascha Wildner * RETURN: None
2890d02842fSSascha Wildner *
2900d02842fSSascha Wildner * DESCRIPTION: Initialize globals for the Preprocessor. Used for startuup
2910d02842fSSascha Wildner * initialization and re-initialization between compiles during
2920d02842fSSascha Wildner * a multiple source file compile.
2930d02842fSSascha Wildner *
2940d02842fSSascha Wildner ******************************************************************************/
2950d02842fSSascha Wildner
2960d02842fSSascha Wildner void
PrInitializeGlobals(void)2970d02842fSSascha Wildner PrInitializeGlobals (
2980d02842fSSascha Wildner void)
2990d02842fSSascha Wildner {
3000d02842fSSascha Wildner /* Init globals */
3010d02842fSSascha Wildner
302806343b9SSascha Wildner AslGbl_InputFileList = NULL;
303806343b9SSascha Wildner AslGbl_CurrentLineNumber = 1;
304806343b9SSascha Wildner AslGbl_PreprocessorLineNumber = 1;
305806343b9SSascha Wildner AslGbl_PreprocessorError = FALSE;
3060d02842fSSascha Wildner
3070d02842fSSascha Wildner /* These are used to track #if/#else blocks (possibly nested) */
3080d02842fSSascha Wildner
309806343b9SSascha Wildner AslGbl_IfDepth = 0;
310806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock = FALSE;
311806343b9SSascha Wildner AslGbl_DirectiveStack = NULL;
3120d02842fSSascha Wildner }
3130d02842fSSascha Wildner
3140d02842fSSascha Wildner
3150d02842fSSascha Wildner /*******************************************************************************
3160d02842fSSascha Wildner *
3170d02842fSSascha Wildner * FUNCTION: PrTerminatePreprocessor
3180d02842fSSascha Wildner *
3190d02842fSSascha Wildner * PARAMETERS: None
3200d02842fSSascha Wildner *
3210d02842fSSascha Wildner * RETURN: None
3220d02842fSSascha Wildner *
3230d02842fSSascha Wildner * DESCRIPTION: Termination of the preprocessor. Delete lists. Keep any
3240d02842fSSascha Wildner * defines that were specified on the command line, in order to
3250d02842fSSascha Wildner * support multiple compiles with a single compiler invocation.
3260d02842fSSascha Wildner *
3270d02842fSSascha Wildner ******************************************************************************/
3280d02842fSSascha Wildner
3290d02842fSSascha Wildner void
PrTerminatePreprocessor(void)3300d02842fSSascha Wildner PrTerminatePreprocessor (
3310d02842fSSascha Wildner void)
3320d02842fSSascha Wildner {
3330d02842fSSascha Wildner PR_DEFINE_INFO *DefineInfo;
3340d02842fSSascha Wildner
3350d02842fSSascha Wildner
3360d02842fSSascha Wildner /*
3370d02842fSSascha Wildner * The persistent defines (created on the command line) are always at the
3380d02842fSSascha Wildner * end of the list. We save them.
3390d02842fSSascha Wildner */
340806343b9SSascha Wildner while ((AslGbl_DefineList) && (!AslGbl_DefineList->Persist))
3410d02842fSSascha Wildner {
342806343b9SSascha Wildner DefineInfo = AslGbl_DefineList;
343806343b9SSascha Wildner AslGbl_DefineList = DefineInfo->Next;
3440d02842fSSascha Wildner
3450d02842fSSascha Wildner ACPI_FREE (DefineInfo->Replacement);
3460d02842fSSascha Wildner ACPI_FREE (DefineInfo->Identifier);
3470d02842fSSascha Wildner ACPI_FREE (DefineInfo);
3480d02842fSSascha Wildner }
3490d02842fSSascha Wildner }
3500d02842fSSascha Wildner
3510d02842fSSascha Wildner
3520d02842fSSascha Wildner /*******************************************************************************
3530d02842fSSascha Wildner *
3540d02842fSSascha Wildner * FUNCTION: PrDoPreprocess
3550d02842fSSascha Wildner *
3560d02842fSSascha Wildner * PARAMETERS: None
3570d02842fSSascha Wildner *
3580d02842fSSascha Wildner * RETURN: None
3590d02842fSSascha Wildner *
3600d02842fSSascha Wildner * DESCRIPTION: Main entry point for the iASL Preprocessor. Input file must
3610d02842fSSascha Wildner * be already open. Handles multiple input files via the
3620d02842fSSascha Wildner * #include directive.
3630d02842fSSascha Wildner *
3640d02842fSSascha Wildner ******************************************************************************/
3650d02842fSSascha Wildner
3660d02842fSSascha Wildner void
PrDoPreprocess(void)3670d02842fSSascha Wildner PrDoPreprocess (
3680d02842fSSascha Wildner void)
3690d02842fSSascha Wildner {
3700d02842fSSascha Wildner BOOLEAN MoreInputFiles;
3710d02842fSSascha Wildner
3720d02842fSSascha Wildner
3730d02842fSSascha Wildner DbgPrint (ASL_DEBUG_OUTPUT, "Starting preprocessing phase\n\n");
3740d02842fSSascha Wildner
3750d02842fSSascha Wildner
3760d02842fSSascha Wildner FlSeekFile (ASL_FILE_INPUT, 0);
3770d02842fSSascha Wildner PrDumpPredefinedNames ();
3780d02842fSSascha Wildner
3790d02842fSSascha Wildner /* Main preprocessor loop, handles include files */
3800d02842fSSascha Wildner
3810d02842fSSascha Wildner do
3820d02842fSSascha Wildner {
3830d02842fSSascha Wildner PrPreprocessInputFile ();
3840d02842fSSascha Wildner MoreInputFiles = PrPopInputFileStack ();
3850d02842fSSascha Wildner
3860d02842fSSascha Wildner } while (MoreInputFiles);
3870d02842fSSascha Wildner
38825ca8c79SSascha Wildner /* Point compiler input to the new preprocessor output file (.pre) */
3890d02842fSSascha Wildner
3900d02842fSSascha Wildner FlCloseFile (ASL_FILE_INPUT);
391806343b9SSascha Wildner AslGbl_Files[ASL_FILE_INPUT].Handle = AslGbl_Files[ASL_FILE_PREPROCESSOR].Handle;
392806343b9SSascha Wildner AslCompilerin = AslGbl_Files[ASL_FILE_INPUT].Handle;
3930d02842fSSascha Wildner
3940d02842fSSascha Wildner /* Reset globals to allow compiler to run */
3950d02842fSSascha Wildner
3960d02842fSSascha Wildner FlSeekFile (ASL_FILE_INPUT, 0);
397806343b9SSascha Wildner if (!AslGbl_PreprocessOnly)
39825ca8c79SSascha Wildner {
399806343b9SSascha Wildner AslGbl_CurrentLineNumber = 0;
40025ca8c79SSascha Wildner }
4010d02842fSSascha Wildner
4020d02842fSSascha Wildner DbgPrint (ASL_DEBUG_OUTPUT, "Preprocessing phase complete \n\n");
4030d02842fSSascha Wildner }
4040d02842fSSascha Wildner
4050d02842fSSascha Wildner
4060d02842fSSascha Wildner /*******************************************************************************
4070d02842fSSascha Wildner *
4080d02842fSSascha Wildner * FUNCTION: PrPreprocessInputFile
4090d02842fSSascha Wildner *
4100d02842fSSascha Wildner * PARAMETERS: None
4110d02842fSSascha Wildner *
4120d02842fSSascha Wildner * RETURN: None
4130d02842fSSascha Wildner *
4140d02842fSSascha Wildner * DESCRIPTION: Preprocess one entire file, line-by-line.
4150d02842fSSascha Wildner *
4160d02842fSSascha Wildner * Input: Raw user ASL from ASL_FILE_INPUT
41725ca8c79SSascha Wildner * Output: Preprocessed file written to ASL_FILE_PREPROCESSOR and
41825ca8c79SSascha Wildner * (optionally) ASL_FILE_PREPROCESSOR_USER
4190d02842fSSascha Wildner *
4200d02842fSSascha Wildner ******************************************************************************/
4210d02842fSSascha Wildner
4220d02842fSSascha Wildner static void
PrPreprocessInputFile(void)4230d02842fSSascha Wildner PrPreprocessInputFile (
4240d02842fSSascha Wildner void)
4250d02842fSSascha Wildner {
42625ca8c79SSascha Wildner UINT32 Status;
4270d02842fSSascha Wildner char *Token;
4280d02842fSSascha Wildner char *ReplaceString;
4290d02842fSSascha Wildner PR_DEFINE_INFO *DefineInfo;
4300d02842fSSascha Wildner ACPI_SIZE TokenOffset;
4310d02842fSSascha Wildner char *Next;
4320d02842fSSascha Wildner int OffsetAdjust;
4330d02842fSSascha Wildner
4340d02842fSSascha Wildner
43525ca8c79SSascha Wildner PrGetNextLineInit ();
43625ca8c79SSascha Wildner
437267c04fdSSascha Wildner /* Scan source line-by-line and process directives. Then write the .i file */
4380d02842fSSascha Wildner
439806343b9SSascha Wildner while ((Status = PrGetNextLine (AslGbl_Files[ASL_FILE_INPUT].Handle)) != ASL_EOF)
4400d02842fSSascha Wildner {
441806343b9SSascha Wildner AslGbl_CurrentLineNumber++;
442806343b9SSascha Wildner AslGbl_LogicalLineNumber++;
44325ca8c79SSascha Wildner
4447c9678bcSSascha Wildner if (Status == ASL_IGNORE_LINE)
44525ca8c79SSascha Wildner {
44625ca8c79SSascha Wildner goto WriteEntireLine;
44725ca8c79SSascha Wildner }
44825ca8c79SSascha Wildner
4490d02842fSSascha Wildner /* Need a copy of the input line for strok() */
4500d02842fSSascha Wildner
451806343b9SSascha Wildner strcpy (AslGbl_MainTokenBuffer, AslGbl_CurrentLineBuffer);
452806343b9SSascha Wildner Token = PrGetNextToken (AslGbl_MainTokenBuffer, PR_TOKEN_SEPARATORS, &Next);
4530d02842fSSascha Wildner OffsetAdjust = 0;
4540d02842fSSascha Wildner
4550d02842fSSascha Wildner /* All preprocessor directives must begin with '#' */
4560d02842fSSascha Wildner
4570d02842fSSascha Wildner if (Token && (*Token == '#'))
4580d02842fSSascha Wildner {
4590d02842fSSascha Wildner if (strlen (Token) == 1)
4600d02842fSSascha Wildner {
4610d02842fSSascha Wildner Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
4620d02842fSSascha Wildner }
4630d02842fSSascha Wildner else
4640d02842fSSascha Wildner {
4650d02842fSSascha Wildner Token++; /* Skip leading # */
4660d02842fSSascha Wildner }
4670d02842fSSascha Wildner
4680d02842fSSascha Wildner /* Execute the directive, do not write line to output file */
4690d02842fSSascha Wildner
4700d02842fSSascha Wildner PrDoDirective (Token, &Next);
4710d02842fSSascha Wildner continue;
4720d02842fSSascha Wildner }
4730d02842fSSascha Wildner
4740d02842fSSascha Wildner /*
4750d02842fSSascha Wildner * If we are currently within the part of an IF/ELSE block that is
4760d02842fSSascha Wildner * FALSE, ignore the line and do not write it to the output file.
4770d02842fSSascha Wildner * This continues until an #else or #endif is encountered.
4780d02842fSSascha Wildner */
479806343b9SSascha Wildner if (AslGbl_IgnoringThisCodeBlock)
4800d02842fSSascha Wildner {
4810d02842fSSascha Wildner continue;
4820d02842fSSascha Wildner }
4830d02842fSSascha Wildner
4840d02842fSSascha Wildner /* Match and replace all #defined names within this source line */
4850d02842fSSascha Wildner
4860d02842fSSascha Wildner while (Token)
4870d02842fSSascha Wildner {
4880d02842fSSascha Wildner DefineInfo = PrMatchDefine (Token);
4890d02842fSSascha Wildner if (DefineInfo)
4900d02842fSSascha Wildner {
4910d02842fSSascha Wildner if (DefineInfo->Body)
4920d02842fSSascha Wildner {
4930d02842fSSascha Wildner /* This is a macro */
4940d02842fSSascha Wildner
4950d02842fSSascha Wildner DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
4960d02842fSSascha Wildner "Matched Macro: %s->%s\n",
497806343b9SSascha Wildner AslGbl_CurrentLineNumber, DefineInfo->Identifier,
4980d02842fSSascha Wildner DefineInfo->Replacement);
4990d02842fSSascha Wildner
500806343b9SSascha Wildner PrDoMacroInvocation (AslGbl_MainTokenBuffer, Token,
5010d02842fSSascha Wildner DefineInfo, &Next);
5020d02842fSSascha Wildner }
5030d02842fSSascha Wildner else
5040d02842fSSascha Wildner {
5050d02842fSSascha Wildner ReplaceString = DefineInfo->Replacement;
5060d02842fSSascha Wildner
5070d02842fSSascha Wildner /* Replace the name in the original line buffer */
5080d02842fSSascha Wildner
509806343b9SSascha Wildner TokenOffset = Token - AslGbl_MainTokenBuffer + OffsetAdjust;
5100d02842fSSascha Wildner PrReplaceData (
511806343b9SSascha Wildner &AslGbl_CurrentLineBuffer[TokenOffset], strlen (Token),
5120d02842fSSascha Wildner ReplaceString, strlen (ReplaceString));
5130d02842fSSascha Wildner
5140d02842fSSascha Wildner /* Adjust for length difference between old and new name length */
5150d02842fSSascha Wildner
5160d02842fSSascha Wildner OffsetAdjust += strlen (ReplaceString) - strlen (Token);
5170d02842fSSascha Wildner
5180d02842fSSascha Wildner DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
5190d02842fSSascha Wildner "Matched #define: %s->%s\n",
520806343b9SSascha Wildner AslGbl_CurrentLineNumber, Token,
5210d02842fSSascha Wildner *ReplaceString ? ReplaceString : "(NULL STRING)");
5220d02842fSSascha Wildner }
5230d02842fSSascha Wildner }
5240d02842fSSascha Wildner
5250d02842fSSascha Wildner Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
5260d02842fSSascha Wildner }
5270d02842fSSascha Wildner
528806343b9SSascha Wildner AslGbl_PreprocessorLineNumber++;
5290d02842fSSascha Wildner
53025ca8c79SSascha Wildner
53125ca8c79SSascha Wildner WriteEntireLine:
5320d02842fSSascha Wildner /*
5330d02842fSSascha Wildner * Now we can write the possibly modified source line to the
53425ca8c79SSascha Wildner * preprocessor file(s).
5350d02842fSSascha Wildner */
536806343b9SSascha Wildner FlWriteFile (ASL_FILE_PREPROCESSOR, AslGbl_CurrentLineBuffer,
537806343b9SSascha Wildner strlen (AslGbl_CurrentLineBuffer));
5380d02842fSSascha Wildner }
5390d02842fSSascha Wildner }
5400d02842fSSascha Wildner
5410d02842fSSascha Wildner
5420d02842fSSascha Wildner /*******************************************************************************
5430d02842fSSascha Wildner *
5440d02842fSSascha Wildner * FUNCTION: PrDoDirective
5450d02842fSSascha Wildner *
5460d02842fSSascha Wildner * PARAMETERS: Directive - Pointer to directive name token
5470d02842fSSascha Wildner * Next - "Next" buffer from GetNextToken
5480d02842fSSascha Wildner *
5490d02842fSSascha Wildner * RETURN: None.
5500d02842fSSascha Wildner *
5510d02842fSSascha Wildner * DESCRIPTION: Main processing for all preprocessor directives
5520d02842fSSascha Wildner *
5530d02842fSSascha Wildner ******************************************************************************/
5540d02842fSSascha Wildner
5550d02842fSSascha Wildner static void
PrDoDirective(char * DirectiveToken,char ** Next)5560d02842fSSascha Wildner PrDoDirective (
5570d02842fSSascha Wildner char *DirectiveToken,
5580d02842fSSascha Wildner char **Next)
5590d02842fSSascha Wildner {
560806343b9SSascha Wildner char *Token = AslGbl_MainTokenBuffer;
561896f2e3aSSascha Wildner char *Token2 = NULL;
5620d02842fSSascha Wildner char *End;
5630d02842fSSascha Wildner UINT64 Value;
5640d02842fSSascha Wildner ACPI_SIZE TokenOffset;
5650d02842fSSascha Wildner int Directive;
5660d02842fSSascha Wildner ACPI_STATUS Status;
5670d02842fSSascha Wildner
5680d02842fSSascha Wildner
5690d02842fSSascha Wildner if (!DirectiveToken)
5700d02842fSSascha Wildner {
5710d02842fSSascha Wildner goto SyntaxError;
5720d02842fSSascha Wildner }
5730d02842fSSascha Wildner
5740d02842fSSascha Wildner Directive = PrMatchDirective (DirectiveToken);
5750d02842fSSascha Wildner if (Directive == ASL_DIRECTIVE_NOT_FOUND)
5760d02842fSSascha Wildner {
5770d02842fSSascha Wildner PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE,
5780d02842fSSascha Wildner THIS_TOKEN_OFFSET (DirectiveToken));
5790d02842fSSascha Wildner
580896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
5810d02842fSSascha Wildner "#%s: Unknown directive\n",
582806343b9SSascha Wildner AslGbl_CurrentLineNumber, DirectiveToken);
5830d02842fSSascha Wildner return;
5840d02842fSSascha Wildner }
5850d02842fSSascha Wildner
5860d02842fSSascha Wildner /*
587267c04fdSSascha Wildner * Emit a line directive into the preprocessor file (.pre) after
588267c04fdSSascha Wildner * every matched directive. This is passed through to the compiler
589267c04fdSSascha Wildner * so that error/warning messages are kept in sync with the
590267c04fdSSascha Wildner * original source file.
591267c04fdSSascha Wildner */
592267c04fdSSascha Wildner FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\" // #%s\n",
593806343b9SSascha Wildner AslGbl_CurrentLineNumber, AslGbl_Files[ASL_FILE_INPUT].Filename,
594806343b9SSascha Wildner AslGbl_DirectiveInfo[Directive].Name);
595267c04fdSSascha Wildner
596267c04fdSSascha Wildner /*
5970d02842fSSascha Wildner * If we are currently ignoring this block and we encounter a #else or
5980d02842fSSascha Wildner * #elif, we must ignore their blocks also if the parent block is also
5990d02842fSSascha Wildner * being ignored.
6000d02842fSSascha Wildner */
601806343b9SSascha Wildner if (AslGbl_IgnoringThisCodeBlock)
6020d02842fSSascha Wildner {
6030d02842fSSascha Wildner switch (Directive)
6040d02842fSSascha Wildner {
6050d02842fSSascha Wildner case PR_DIRECTIVE_ELSE:
6060d02842fSSascha Wildner case PR_DIRECTIVE_ELIF:
6070d02842fSSascha Wildner
608806343b9SSascha Wildner if (AslGbl_DirectiveStack &&
609806343b9SSascha Wildner AslGbl_DirectiveStack->IgnoringThisCodeBlock)
6100d02842fSSascha Wildner {
611806343b9SSascha Wildner PrDbgPrint ("Ignoring", AslGbl_DirectiveInfo[Directive].Name);
6120d02842fSSascha Wildner return;
6130d02842fSSascha Wildner }
6140d02842fSSascha Wildner break;
6150d02842fSSascha Wildner
6160d02842fSSascha Wildner default:
6170d02842fSSascha Wildner break;
6180d02842fSSascha Wildner }
6190d02842fSSascha Wildner }
6200d02842fSSascha Wildner
6210d02842fSSascha Wildner /*
6220d02842fSSascha Wildner * Need to always check for #else, #elif, #endif regardless of
6230d02842fSSascha Wildner * whether we are ignoring the current code block, since these
6240d02842fSSascha Wildner * are conditional code block terminators.
6250d02842fSSascha Wildner */
6260d02842fSSascha Wildner switch (Directive)
6270d02842fSSascha Wildner {
6280d02842fSSascha Wildner case PR_DIRECTIVE_ELSE:
6290d02842fSSascha Wildner
630806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock = !(AslGbl_IgnoringThisCodeBlock);
6310d02842fSSascha Wildner PrDbgPrint ("Executing", "else block");
6320d02842fSSascha Wildner return;
6330d02842fSSascha Wildner
6340d02842fSSascha Wildner case PR_DIRECTIVE_ELIF:
6350d02842fSSascha Wildner
636806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock = !(AslGbl_IgnoringThisCodeBlock);
6370d02842fSSascha Wildner Directive = PR_DIRECTIVE_IF;
6380d02842fSSascha Wildner
639806343b9SSascha Wildner if (AslGbl_IgnoringThisCodeBlock == TRUE)
6400d02842fSSascha Wildner {
6410d02842fSSascha Wildner /* Not executing the ELSE part -- all done here */
6420d02842fSSascha Wildner PrDbgPrint ("Ignoring", "elif block");
6430d02842fSSascha Wildner return;
6440d02842fSSascha Wildner }
6450d02842fSSascha Wildner
6460d02842fSSascha Wildner /*
6470d02842fSSascha Wildner * After this, we will execute the IF part further below.
6480d02842fSSascha Wildner * First, however, pop off the original #if directive.
6490d02842fSSascha Wildner */
6500d02842fSSascha Wildner if (ACPI_FAILURE (PrPopDirective ()))
6510d02842fSSascha Wildner {
6520d02842fSSascha Wildner PrError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
6530d02842fSSascha Wildner THIS_TOKEN_OFFSET (DirectiveToken));
6540d02842fSSascha Wildner }
6550d02842fSSascha Wildner
6560d02842fSSascha Wildner PrDbgPrint ("Executing", "elif block");
6570d02842fSSascha Wildner break;
6580d02842fSSascha Wildner
6590d02842fSSascha Wildner case PR_DIRECTIVE_ENDIF:
6600d02842fSSascha Wildner
6610d02842fSSascha Wildner PrDbgPrint ("Executing", "endif");
6620d02842fSSascha Wildner
6630d02842fSSascha Wildner /* Pop the owning #if/#ifdef/#ifndef */
6640d02842fSSascha Wildner
6650d02842fSSascha Wildner if (ACPI_FAILURE (PrPopDirective ()))
6660d02842fSSascha Wildner {
6670d02842fSSascha Wildner PrError (ASL_ERROR, ASL_MSG_ENDIF_MISMATCH,
6680d02842fSSascha Wildner THIS_TOKEN_OFFSET (DirectiveToken));
6690d02842fSSascha Wildner }
6700d02842fSSascha Wildner return;
6710d02842fSSascha Wildner
6720d02842fSSascha Wildner default:
6730d02842fSSascha Wildner break;
6740d02842fSSascha Wildner }
6750d02842fSSascha Wildner
6760d02842fSSascha Wildner /* Most directives have at least one argument */
6770d02842fSSascha Wildner
678806343b9SSascha Wildner if (AslGbl_DirectiveInfo[Directive].ArgCount >= 1)
6790d02842fSSascha Wildner {
6800d02842fSSascha Wildner Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
6810d02842fSSascha Wildner if (!Token)
6820d02842fSSascha Wildner {
6830d02842fSSascha Wildner goto SyntaxError;
6840d02842fSSascha Wildner }
6850d02842fSSascha Wildner }
6860d02842fSSascha Wildner
687806343b9SSascha Wildner if (AslGbl_DirectiveInfo[Directive].ArgCount >= 2)
688896f2e3aSSascha Wildner {
689896f2e3aSSascha Wildner Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
690896f2e3aSSascha Wildner if (!Token2)
691896f2e3aSSascha Wildner {
692896f2e3aSSascha Wildner goto SyntaxError;
693896f2e3aSSascha Wildner }
694896f2e3aSSascha Wildner }
695896f2e3aSSascha Wildner
6960d02842fSSascha Wildner /*
6970d02842fSSascha Wildner * At this point, if we are ignoring the current code block,
6980d02842fSSascha Wildner * do not process any more directives (i.e., ignore them also.)
6990d02842fSSascha Wildner * For "if" style directives, open/push a new block anyway. We
7000d02842fSSascha Wildner * must do this to keep track of #endif directives
7010d02842fSSascha Wildner */
702806343b9SSascha Wildner if (AslGbl_IgnoringThisCodeBlock)
7030d02842fSSascha Wildner {
7040d02842fSSascha Wildner switch (Directive)
7050d02842fSSascha Wildner {
7060d02842fSSascha Wildner case PR_DIRECTIVE_IF:
7070d02842fSSascha Wildner case PR_DIRECTIVE_IFDEF:
7080d02842fSSascha Wildner case PR_DIRECTIVE_IFNDEF:
7090d02842fSSascha Wildner
7100d02842fSSascha Wildner PrPushDirective (Directive, Token);
711806343b9SSascha Wildner PrDbgPrint ("Ignoring", AslGbl_DirectiveInfo[Directive].Name);
7120d02842fSSascha Wildner break;
7130d02842fSSascha Wildner
7140d02842fSSascha Wildner default:
7150d02842fSSascha Wildner break;
7160d02842fSSascha Wildner }
7170d02842fSSascha Wildner
7180d02842fSSascha Wildner return;
7190d02842fSSascha Wildner }
7200d02842fSSascha Wildner
7210d02842fSSascha Wildner /*
7220d02842fSSascha Wildner * Execute the directive
7230d02842fSSascha Wildner */
724806343b9SSascha Wildner PrDbgPrint ("Begin execution", AslGbl_DirectiveInfo[Directive].Name);
7250d02842fSSascha Wildner
7260d02842fSSascha Wildner switch (Directive)
7270d02842fSSascha Wildner {
7280d02842fSSascha Wildner case PR_DIRECTIVE_IF:
7290d02842fSSascha Wildner
730806343b9SSascha Wildner TokenOffset = Token - AslGbl_MainTokenBuffer;
7310d02842fSSascha Wildner
7320d02842fSSascha Wildner /* Need to expand #define macros in the expression string first */
7330d02842fSSascha Wildner
7340d02842fSSascha Wildner Status = PrResolveIntegerExpression (
735806343b9SSascha Wildner &AslGbl_CurrentLineBuffer[TokenOffset-1], &Value);
7360d02842fSSascha Wildner if (ACPI_FAILURE (Status))
7370d02842fSSascha Wildner {
7380d02842fSSascha Wildner return;
7390d02842fSSascha Wildner }
7400d02842fSSascha Wildner
7410d02842fSSascha Wildner PrPushDirective (Directive, Token);
7420d02842fSSascha Wildner if (!Value)
7430d02842fSSascha Wildner {
744806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock = TRUE;
7450d02842fSSascha Wildner }
7460d02842fSSascha Wildner
747896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
7480d02842fSSascha Wildner "Resolved #if: %8.8X%8.8X %s\n",
749806343b9SSascha Wildner AslGbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value),
750806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>");
7510d02842fSSascha Wildner break;
7520d02842fSSascha Wildner
7530d02842fSSascha Wildner case PR_DIRECTIVE_IFDEF:
7540d02842fSSascha Wildner
7550d02842fSSascha Wildner PrPushDirective (Directive, Token);
7560d02842fSSascha Wildner if (!PrMatchDefine (Token))
7570d02842fSSascha Wildner {
758806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock = TRUE;
7590d02842fSSascha Wildner }
7600d02842fSSascha Wildner
7610d02842fSSascha Wildner PrDbgPrint ("Evaluated", "ifdef");
7620d02842fSSascha Wildner break;
7630d02842fSSascha Wildner
7640d02842fSSascha Wildner case PR_DIRECTIVE_IFNDEF:
7650d02842fSSascha Wildner
7660d02842fSSascha Wildner PrPushDirective (Directive, Token);
7670d02842fSSascha Wildner if (PrMatchDefine (Token))
7680d02842fSSascha Wildner {
769806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock = TRUE;
7700d02842fSSascha Wildner }
7710d02842fSSascha Wildner
7720d02842fSSascha Wildner PrDbgPrint ("Evaluated", "ifndef");
7730d02842fSSascha Wildner break;
7740d02842fSSascha Wildner
7750d02842fSSascha Wildner case PR_DIRECTIVE_DEFINE:
7760d02842fSSascha Wildner /*
7770d02842fSSascha Wildner * By definition, if first char after the name is a paren,
7780d02842fSSascha Wildner * this is a function macro.
7790d02842fSSascha Wildner */
780806343b9SSascha Wildner TokenOffset = Token - AslGbl_MainTokenBuffer + strlen (Token);
781806343b9SSascha Wildner if (*(&AslGbl_CurrentLineBuffer[TokenOffset]) == '(')
7820d02842fSSascha Wildner {
7830d02842fSSascha Wildner #ifndef MACROS_SUPPORTED
784820c5b08SSascha Wildner AcpiOsPrintf (
785820c5b08SSascha Wildner "%s ERROR - line %u: #define macros are not supported yet\n",
786806343b9SSascha Wildner AslGbl_CurrentLineBuffer, AslGbl_LogicalLineNumber);
7870d02842fSSascha Wildner exit(1);
7880d02842fSSascha Wildner #else
7890d02842fSSascha Wildner PrAddMacro (Token, Next);
7900d02842fSSascha Wildner #endif
7910d02842fSSascha Wildner }
7920d02842fSSascha Wildner else
7930d02842fSSascha Wildner {
7940d02842fSSascha Wildner /* Use the remainder of the line for the #define */
7950d02842fSSascha Wildner
7960d02842fSSascha Wildner Token2 = *Next;
7970d02842fSSascha Wildner if (Token2)
7980d02842fSSascha Wildner {
7990d02842fSSascha Wildner while ((*Token2 == ' ') || (*Token2 == '\t'))
8000d02842fSSascha Wildner {
8010d02842fSSascha Wildner Token2++;
8020d02842fSSascha Wildner }
803820c5b08SSascha Wildner
8040d02842fSSascha Wildner End = Token2;
8050d02842fSSascha Wildner while (*End != '\n')
8060d02842fSSascha Wildner {
8070d02842fSSascha Wildner End++;
8080d02842fSSascha Wildner }
809820c5b08SSascha Wildner
8100d02842fSSascha Wildner *End = 0;
8110d02842fSSascha Wildner }
8120d02842fSSascha Wildner else
8130d02842fSSascha Wildner {
8140d02842fSSascha Wildner Token2 = "";
8150d02842fSSascha Wildner }
8160d02842fSSascha Wildner #if 0
8170d02842fSSascha Wildner Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next);
8180d02842fSSascha Wildner if (!Token2)
8190d02842fSSascha Wildner {
8200d02842fSSascha Wildner Token2 = "";
8210d02842fSSascha Wildner }
8220d02842fSSascha Wildner #endif
823896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
8240d02842fSSascha Wildner "New #define: %s->%s\n",
825806343b9SSascha Wildner AslGbl_LogicalLineNumber, Token, Token2);
8260d02842fSSascha Wildner
8270d02842fSSascha Wildner PrAddDefine (Token, Token2, FALSE);
8280d02842fSSascha Wildner }
8290d02842fSSascha Wildner break;
8300d02842fSSascha Wildner
8310d02842fSSascha Wildner case PR_DIRECTIVE_ERROR:
8320d02842fSSascha Wildner
8330d02842fSSascha Wildner /* Note: No macro expansion */
8340d02842fSSascha Wildner
8350d02842fSSascha Wildner PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE,
8360d02842fSSascha Wildner THIS_TOKEN_OFFSET (Token));
8370d02842fSSascha Wildner
838806343b9SSascha Wildner AslGbl_SourceLine = 0;
839806343b9SSascha Wildner AslGbl_NextError = AslGbl_ErrorLog;
8400d02842fSSascha Wildner CmCleanupAndExit ();
8410d02842fSSascha Wildner exit(1);
8420d02842fSSascha Wildner
8430d02842fSSascha Wildner case PR_DIRECTIVE_INCLUDE:
8440d02842fSSascha Wildner
8450d02842fSSascha Wildner Token = PrGetNextToken (NULL, " \"<>", Next);
8460d02842fSSascha Wildner if (!Token)
8470d02842fSSascha Wildner {
8480d02842fSSascha Wildner goto SyntaxError;
8490d02842fSSascha Wildner }
8500d02842fSSascha Wildner
851896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
852806343b9SSascha Wildner "Start #include file \"%s\"\n", AslGbl_CurrentLineNumber,
853e5412f1eSSascha Wildner Token);
8540d02842fSSascha Wildner
855896f2e3aSSascha Wildner PrDoIncludeFile (Token);
856896f2e3aSSascha Wildner break;
857896f2e3aSSascha Wildner
858896f2e3aSSascha Wildner case PR_DIRECTIVE_INCLUDEBUFFER:
859896f2e3aSSascha Wildner
860896f2e3aSSascha Wildner Token = PrGetNextToken (NULL, " \"<>", Next);
861896f2e3aSSascha Wildner if (!Token)
862896f2e3aSSascha Wildner {
863896f2e3aSSascha Wildner goto SyntaxError;
864896f2e3aSSascha Wildner }
865896f2e3aSSascha Wildner
866896f2e3aSSascha Wildner Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
867896f2e3aSSascha Wildner if (!Token2)
868896f2e3aSSascha Wildner {
869896f2e3aSSascha Wildner goto SyntaxError;
870896f2e3aSSascha Wildner }
871896f2e3aSSascha Wildner
872896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
873896f2e3aSSascha Wildner "Start #includebuffer input from file \"%s\", buffer name %s\n",
874806343b9SSascha Wildner AslGbl_CurrentLineNumber, Token, Token2);
875896f2e3aSSascha Wildner
876896f2e3aSSascha Wildner PrDoIncludeBuffer (Token, Token2);
8770d02842fSSascha Wildner break;
8780d02842fSSascha Wildner
8790d02842fSSascha Wildner case PR_DIRECTIVE_LINE:
8800d02842fSSascha Wildner
881806343b9SSascha Wildner TokenOffset = Token - AslGbl_MainTokenBuffer;
8820d02842fSSascha Wildner
8830d02842fSSascha Wildner Status = PrResolveIntegerExpression (
884806343b9SSascha Wildner &AslGbl_CurrentLineBuffer[TokenOffset-1], &Value);
8850d02842fSSascha Wildner if (ACPI_FAILURE (Status))
8860d02842fSSascha Wildner {
8870d02842fSSascha Wildner return;
8880d02842fSSascha Wildner }
8890d02842fSSascha Wildner
890896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
891806343b9SSascha Wildner "User #line invocation %s\n", AslGbl_CurrentLineNumber,
8920d02842fSSascha Wildner Token);
8930d02842fSSascha Wildner
894806343b9SSascha Wildner AslGbl_CurrentLineNumber = (UINT32) Value;
8950d02842fSSascha Wildner
8960d02842fSSascha Wildner /* Emit #line into the preprocessor file */
8970d02842fSSascha Wildner
8980d02842fSSascha Wildner FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
899806343b9SSascha Wildner AslGbl_CurrentLineNumber, AslGbl_Files[ASL_FILE_INPUT].Filename);
9000d02842fSSascha Wildner break;
9010d02842fSSascha Wildner
9020d02842fSSascha Wildner case PR_DIRECTIVE_PRAGMA:
9030d02842fSSascha Wildner
9040d02842fSSascha Wildner if (!strcmp (Token, "disable"))
9050d02842fSSascha Wildner {
9060d02842fSSascha Wildner Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
9070d02842fSSascha Wildner if (!Token)
9080d02842fSSascha Wildner {
9090d02842fSSascha Wildner goto SyntaxError;
9100d02842fSSascha Wildner }
9110d02842fSSascha Wildner
912806343b9SSascha Wildner TokenOffset = Token - AslGbl_MainTokenBuffer;
913806343b9SSascha Wildner AslDisableException (&AslGbl_CurrentLineBuffer[TokenOffset]);
9140d02842fSSascha Wildner }
9150d02842fSSascha Wildner else if (!strcmp (Token, "message"))
9160d02842fSSascha Wildner {
9170d02842fSSascha Wildner Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
9180d02842fSSascha Wildner if (!Token)
9190d02842fSSascha Wildner {
9200d02842fSSascha Wildner goto SyntaxError;
9210d02842fSSascha Wildner }
9220d02842fSSascha Wildner
923806343b9SSascha Wildner TokenOffset = Token - AslGbl_MainTokenBuffer;
924806343b9SSascha Wildner AcpiOsPrintf ("%s\n", &AslGbl_CurrentLineBuffer[TokenOffset]);
9250d02842fSSascha Wildner }
9260d02842fSSascha Wildner else
9270d02842fSSascha Wildner {
9280d02842fSSascha Wildner PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA,
9290d02842fSSascha Wildner THIS_TOKEN_OFFSET (Token));
9300d02842fSSascha Wildner return;
9310d02842fSSascha Wildner }
9320d02842fSSascha Wildner
9330d02842fSSascha Wildner break;
9340d02842fSSascha Wildner
9350d02842fSSascha Wildner case PR_DIRECTIVE_UNDEF:
9360d02842fSSascha Wildner
937896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
938806343b9SSascha Wildner "#undef: %s\n", AslGbl_CurrentLineNumber, Token);
9390d02842fSSascha Wildner
9400d02842fSSascha Wildner PrRemoveDefine (Token);
9410d02842fSSascha Wildner break;
9420d02842fSSascha Wildner
9430d02842fSSascha Wildner case PR_DIRECTIVE_WARNING:
9440d02842fSSascha Wildner
9450d02842fSSascha Wildner PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE,
9460d02842fSSascha Wildner THIS_TOKEN_OFFSET (Token));
947267c04fdSSascha Wildner
948806343b9SSascha Wildner AslGbl_SourceLine = 0;
949806343b9SSascha Wildner AslGbl_NextError = AslGbl_ErrorLog;
9500d02842fSSascha Wildner break;
9510d02842fSSascha Wildner
9520d02842fSSascha Wildner default:
9530d02842fSSascha Wildner
9540d02842fSSascha Wildner /* Should never get here */
955896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
9560d02842fSSascha Wildner "Unrecognized directive: %u\n",
957806343b9SSascha Wildner AslGbl_CurrentLineNumber, Directive);
9580d02842fSSascha Wildner break;
9590d02842fSSascha Wildner }
9600d02842fSSascha Wildner
9610d02842fSSascha Wildner return;
9620d02842fSSascha Wildner
9630d02842fSSascha Wildner SyntaxError:
9640d02842fSSascha Wildner
9650d02842fSSascha Wildner PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX,
9660d02842fSSascha Wildner THIS_TOKEN_OFFSET (DirectiveToken));
9670d02842fSSascha Wildner return;
9680d02842fSSascha Wildner }
9690d02842fSSascha Wildner
9700d02842fSSascha Wildner
9710d02842fSSascha Wildner /*******************************************************************************
9720d02842fSSascha Wildner *
97325ca8c79SSascha Wildner * FUNCTION: PrGetNextLine, PrGetNextLineInit
97425ca8c79SSascha Wildner *
97525ca8c79SSascha Wildner * PARAMETERS: Handle - Open file handle for the source file
97625ca8c79SSascha Wildner *
97725ca8c79SSascha Wildner * RETURN: Status of the GetLine operation:
97825ca8c79SSascha Wildner * AE_OK - Normal line, OK status
9797c9678bcSSascha Wildner * ASL_IGNORE_LINE - Line is blank or part of a multi-line
9807c9678bcSSascha Wildner * comment
98125ca8c79SSascha Wildner * ASL_EOF - End-of-file reached
98225ca8c79SSascha Wildner *
98325ca8c79SSascha Wildner * DESCRIPTION: Get the next text line from the input file. Does not strip
98425ca8c79SSascha Wildner * comments.
98525ca8c79SSascha Wildner *
98625ca8c79SSascha Wildner ******************************************************************************/
98725ca8c79SSascha Wildner
98825ca8c79SSascha Wildner #define PR_NORMAL_TEXT 0
989267c04fdSSascha Wildner #define PR_MULTI_LINE_COMMENT 1
990267c04fdSSascha Wildner #define PR_SINGLE_LINE_COMMENT 2
991267c04fdSSascha Wildner #define PR_QUOTED_STRING 3
99225ca8c79SSascha Wildner
99325ca8c79SSascha Wildner static UINT8 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
99425ca8c79SSascha Wildner
99525ca8c79SSascha Wildner static void
PrGetNextLineInit(void)99625ca8c79SSascha Wildner PrGetNextLineInit (
99725ca8c79SSascha Wildner void)
99825ca8c79SSascha Wildner {
99925ca8c79SSascha Wildner AcpiGbl_LineScanState = 0;
100025ca8c79SSascha Wildner }
100125ca8c79SSascha Wildner
100225ca8c79SSascha Wildner static UINT32
PrGetNextLine(FILE * Handle)100325ca8c79SSascha Wildner PrGetNextLine (
100425ca8c79SSascha Wildner FILE *Handle)
100525ca8c79SSascha Wildner {
100625ca8c79SSascha Wildner UINT32 i;
100725ca8c79SSascha Wildner int c = 0;
100825ca8c79SSascha Wildner int PreviousChar;
100925ca8c79SSascha Wildner
101025ca8c79SSascha Wildner
101125ca8c79SSascha Wildner /* Always clear the global line buffer */
101225ca8c79SSascha Wildner
1013806343b9SSascha Wildner memset (AslGbl_CurrentLineBuffer, 0, AslGbl_LineBufferSize);
101425ca8c79SSascha Wildner for (i = 0; ;)
101525ca8c79SSascha Wildner {
101625ca8c79SSascha Wildner /*
101725ca8c79SSascha Wildner * If line is too long, expand the line buffers. Also increases
1018806343b9SSascha Wildner * AslGbl_LineBufferSize.
101925ca8c79SSascha Wildner */
1020806343b9SSascha Wildner if (i >= AslGbl_LineBufferSize)
102125ca8c79SSascha Wildner {
102225ca8c79SSascha Wildner UtExpandLineBuffers ();
102325ca8c79SSascha Wildner }
102425ca8c79SSascha Wildner
102525ca8c79SSascha Wildner PreviousChar = c;
102625ca8c79SSascha Wildner c = getc (Handle);
102725ca8c79SSascha Wildner if (c == EOF)
102825ca8c79SSascha Wildner {
10292ffe9f16SSascha Wildner /*
10302ffe9f16SSascha Wildner * On EOF: If there is anything in the line buffer, terminate
10312ffe9f16SSascha Wildner * it with a newline, and catch the EOF on the next call
10322ffe9f16SSascha Wildner * to this function.
10332ffe9f16SSascha Wildner */
10342ffe9f16SSascha Wildner if (i > 0)
10352ffe9f16SSascha Wildner {
1036806343b9SSascha Wildner AslGbl_CurrentLineBuffer[i] = '\n';
10372ffe9f16SSascha Wildner return (AE_OK);
10382ffe9f16SSascha Wildner }
10392ffe9f16SSascha Wildner
104025ca8c79SSascha Wildner return (ASL_EOF);
104125ca8c79SSascha Wildner }
104225ca8c79SSascha Wildner
1043267c04fdSSascha Wildner /* Update state machine as necessary */
104425ca8c79SSascha Wildner
1045267c04fdSSascha Wildner switch (AcpiGbl_LineScanState)
104625ca8c79SSascha Wildner {
1047267c04fdSSascha Wildner case PR_NORMAL_TEXT:
1048267c04fdSSascha Wildner
1049267c04fdSSascha Wildner /* Check for multi-line comment start */
1050267c04fdSSascha Wildner
1051267c04fdSSascha Wildner if ((PreviousChar == '/') && (c == '*'))
1052267c04fdSSascha Wildner {
1053267c04fdSSascha Wildner AcpiGbl_LineScanState = PR_MULTI_LINE_COMMENT;
105425ca8c79SSascha Wildner }
105525ca8c79SSascha Wildner
1056267c04fdSSascha Wildner /* Check for single-line comment start */
105725ca8c79SSascha Wildner
1058267c04fdSSascha Wildner else if ((PreviousChar == '/') && (c == '/'))
1059267c04fdSSascha Wildner {
1060267c04fdSSascha Wildner AcpiGbl_LineScanState = PR_SINGLE_LINE_COMMENT;
1061267c04fdSSascha Wildner }
1062267c04fdSSascha Wildner
1063267c04fdSSascha Wildner /* Check for quoted string start */
1064267c04fdSSascha Wildner
1065267c04fdSSascha Wildner else if (PreviousChar == '"')
1066267c04fdSSascha Wildner {
1067267c04fdSSascha Wildner AcpiGbl_LineScanState = PR_QUOTED_STRING;
1068267c04fdSSascha Wildner }
1069267c04fdSSascha Wildner break;
1070267c04fdSSascha Wildner
1071267c04fdSSascha Wildner case PR_QUOTED_STRING:
1072267c04fdSSascha Wildner
1073267c04fdSSascha Wildner if (PreviousChar == '"')
107425ca8c79SSascha Wildner {
107525ca8c79SSascha Wildner AcpiGbl_LineScanState = PR_NORMAL_TEXT;
107625ca8c79SSascha Wildner }
1077267c04fdSSascha Wildner break;
1078267c04fdSSascha Wildner
1079267c04fdSSascha Wildner case PR_MULTI_LINE_COMMENT:
1080267c04fdSSascha Wildner
1081267c04fdSSascha Wildner /* Check for multi-line comment end */
1082267c04fdSSascha Wildner
1083267c04fdSSascha Wildner if ((PreviousChar == '*') && (c == '/'))
1084267c04fdSSascha Wildner {
1085267c04fdSSascha Wildner AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1086267c04fdSSascha Wildner }
1087267c04fdSSascha Wildner break;
1088267c04fdSSascha Wildner
1089267c04fdSSascha Wildner case PR_SINGLE_LINE_COMMENT: /* Just ignore text until EOL */
1090267c04fdSSascha Wildner default:
1091267c04fdSSascha Wildner break;
1092267c04fdSSascha Wildner }
109325ca8c79SSascha Wildner
109425ca8c79SSascha Wildner /* Always copy the character into line buffer */
109525ca8c79SSascha Wildner
1096806343b9SSascha Wildner AslGbl_CurrentLineBuffer[i] = (char) c;
109725ca8c79SSascha Wildner i++;
109825ca8c79SSascha Wildner
109925ca8c79SSascha Wildner /* Always exit on end-of-line */
110025ca8c79SSascha Wildner
110125ca8c79SSascha Wildner if (c == '\n')
110225ca8c79SSascha Wildner {
110325ca8c79SSascha Wildner /* Handle multi-line comments */
110425ca8c79SSascha Wildner
1105267c04fdSSascha Wildner if (AcpiGbl_LineScanState == PR_MULTI_LINE_COMMENT)
110625ca8c79SSascha Wildner {
11077c9678bcSSascha Wildner return (ASL_IGNORE_LINE);
110825ca8c79SSascha Wildner }
1109267c04fdSSascha Wildner
1110267c04fdSSascha Wildner /* End of single-line comment */
1111267c04fdSSascha Wildner
1112267c04fdSSascha Wildner if (AcpiGbl_LineScanState == PR_SINGLE_LINE_COMMENT)
1113267c04fdSSascha Wildner {
1114267c04fdSSascha Wildner AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1115267c04fdSSascha Wildner return (AE_OK);
1116267c04fdSSascha Wildner }
1117267c04fdSSascha Wildner
1118267c04fdSSascha Wildner /* Blank line */
1119267c04fdSSascha Wildner
112025ca8c79SSascha Wildner if (i == 1)
112125ca8c79SSascha Wildner {
11227c9678bcSSascha Wildner return (ASL_IGNORE_LINE);
112325ca8c79SSascha Wildner }
1124820c5b08SSascha Wildner
112525ca8c79SSascha Wildner return (AE_OK);
112625ca8c79SSascha Wildner }
112725ca8c79SSascha Wildner }
112825ca8c79SSascha Wildner }
112925ca8c79SSascha Wildner
113025ca8c79SSascha Wildner
113125ca8c79SSascha Wildner /*******************************************************************************
113225ca8c79SSascha Wildner *
11330d02842fSSascha Wildner * FUNCTION: PrMatchDirective
11340d02842fSSascha Wildner *
11350d02842fSSascha Wildner * PARAMETERS: Directive - Pointer to directive name token
11360d02842fSSascha Wildner *
11370d02842fSSascha Wildner * RETURN: Index into command array, -1 if not found
11380d02842fSSascha Wildner *
11390d02842fSSascha Wildner * DESCRIPTION: Lookup the incoming directive in the known directives table.
11400d02842fSSascha Wildner *
11410d02842fSSascha Wildner ******************************************************************************/
11420d02842fSSascha Wildner
11430d02842fSSascha Wildner static int
PrMatchDirective(char * Directive)11440d02842fSSascha Wildner PrMatchDirective (
11450d02842fSSascha Wildner char *Directive)
11460d02842fSSascha Wildner {
11470d02842fSSascha Wildner int i;
11480d02842fSSascha Wildner
11490d02842fSSascha Wildner
11500d02842fSSascha Wildner if (!Directive || Directive[0] == 0)
11510d02842fSSascha Wildner {
11520d02842fSSascha Wildner return (ASL_DIRECTIVE_NOT_FOUND);
11530d02842fSSascha Wildner }
11540d02842fSSascha Wildner
1155806343b9SSascha Wildner for (i = 0; AslGbl_DirectiveInfo[i].Name; i++)
11560d02842fSSascha Wildner {
1157806343b9SSascha Wildner if (!strcmp (AslGbl_DirectiveInfo[i].Name, Directive))
11580d02842fSSascha Wildner {
11590d02842fSSascha Wildner return (i);
11600d02842fSSascha Wildner }
11610d02842fSSascha Wildner }
11620d02842fSSascha Wildner
11630d02842fSSascha Wildner return (ASL_DIRECTIVE_NOT_FOUND); /* Command not recognized */
11640d02842fSSascha Wildner }
11650d02842fSSascha Wildner
11660d02842fSSascha Wildner
11670d02842fSSascha Wildner /*******************************************************************************
11680d02842fSSascha Wildner *
11690d02842fSSascha Wildner * FUNCTION: PrPushDirective
11700d02842fSSascha Wildner *
11710d02842fSSascha Wildner * PARAMETERS: Directive - Encoded directive ID
11720d02842fSSascha Wildner * Argument - String containing argument to the
11730d02842fSSascha Wildner * directive
11740d02842fSSascha Wildner *
11750d02842fSSascha Wildner * RETURN: None
11760d02842fSSascha Wildner *
11770d02842fSSascha Wildner * DESCRIPTION: Push an item onto the directive stack. Used for processing
11780d02842fSSascha Wildner * nested #if/#else type conditional compilation directives.
11790d02842fSSascha Wildner * Specifically: Used on detection of #if/#ifdef/#ifndef to open
11800d02842fSSascha Wildner * a block.
11810d02842fSSascha Wildner *
11820d02842fSSascha Wildner ******************************************************************************/
11830d02842fSSascha Wildner
11840d02842fSSascha Wildner static void
PrPushDirective(int Directive,char * Argument)11850d02842fSSascha Wildner PrPushDirective (
11860d02842fSSascha Wildner int Directive,
11870d02842fSSascha Wildner char *Argument)
11880d02842fSSascha Wildner {
11890d02842fSSascha Wildner DIRECTIVE_INFO *Info;
11900d02842fSSascha Wildner
11910d02842fSSascha Wildner
11920d02842fSSascha Wildner /* Allocate and populate a stack info item */
11930d02842fSSascha Wildner
1194806343b9SSascha Wildner Info = ACPI_CAST_PTR (DIRECTIVE_INFO,
1195806343b9SSascha Wildner UtLocalCacheCalloc (sizeof (DIRECTIVE_INFO)));
11960d02842fSSascha Wildner
1197806343b9SSascha Wildner Info->Next = AslGbl_DirectiveStack;
11980d02842fSSascha Wildner Info->Directive = Directive;
1199806343b9SSascha Wildner Info->IgnoringThisCodeBlock = AslGbl_IgnoringThisCodeBlock;
12007bcb6cafSSascha Wildner AcpiUtSafeStrncpy (Info->Argument, Argument, MAX_ARGUMENT_LENGTH);
12010d02842fSSascha Wildner
12020d02842fSSascha Wildner DbgPrint (ASL_DEBUG_OUTPUT,
12030d02842fSSascha Wildner "Pr(%.4u) - [%u %s] %*s Pushed [#%s %s]: IgnoreFlag = %s\n",
1204806343b9SSascha Wildner AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1205806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1206806343b9SSascha Wildner AslGbl_IfDepth * 4, " ",
1207806343b9SSascha Wildner AslGbl_DirectiveInfo[Directive].Name,
1208806343b9SSascha Wildner Argument, AslGbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
12090d02842fSSascha Wildner
12100d02842fSSascha Wildner /* Push new item */
12110d02842fSSascha Wildner
1212806343b9SSascha Wildner AslGbl_DirectiveStack = Info;
1213806343b9SSascha Wildner AslGbl_IfDepth++;
12140d02842fSSascha Wildner }
12150d02842fSSascha Wildner
12160d02842fSSascha Wildner
12170d02842fSSascha Wildner /*******************************************************************************
12180d02842fSSascha Wildner *
12190d02842fSSascha Wildner * FUNCTION: PrPopDirective
12200d02842fSSascha Wildner *
12210d02842fSSascha Wildner * PARAMETERS: None
12220d02842fSSascha Wildner *
12230d02842fSSascha Wildner * RETURN: Status. Error if the stack is empty.
12240d02842fSSascha Wildner *
12250d02842fSSascha Wildner * DESCRIPTION: Pop an item off the directive stack. Used for processing
12260d02842fSSascha Wildner * nested #if/#else type conditional compilation directives.
12270d02842fSSascha Wildner * Specifically: Used on detection of #elif and #endif to remove
12280d02842fSSascha Wildner * the original #if/#ifdef/#ifndef from the stack and close
12290d02842fSSascha Wildner * the block.
12300d02842fSSascha Wildner *
12310d02842fSSascha Wildner ******************************************************************************/
12320d02842fSSascha Wildner
12330d02842fSSascha Wildner static ACPI_STATUS
PrPopDirective(void)12340d02842fSSascha Wildner PrPopDirective (
12350d02842fSSascha Wildner void)
12360d02842fSSascha Wildner {
12370d02842fSSascha Wildner DIRECTIVE_INFO *Info;
12380d02842fSSascha Wildner
12390d02842fSSascha Wildner
12400d02842fSSascha Wildner /* Check for empty stack */
12410d02842fSSascha Wildner
1242806343b9SSascha Wildner Info = AslGbl_DirectiveStack;
12430d02842fSSascha Wildner if (!Info)
12440d02842fSSascha Wildner {
12450d02842fSSascha Wildner return (AE_ERROR);
12460d02842fSSascha Wildner }
12470d02842fSSascha Wildner
12480d02842fSSascha Wildner /* Pop one item, keep globals up-to-date */
12490d02842fSSascha Wildner
1250806343b9SSascha Wildner AslGbl_IfDepth--;
1251806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock = Info->IgnoringThisCodeBlock;
1252806343b9SSascha Wildner AslGbl_DirectiveStack = Info->Next;
12530d02842fSSascha Wildner
12540d02842fSSascha Wildner DbgPrint (ASL_DEBUG_OUTPUT,
12550d02842fSSascha Wildner "Pr(%.4u) - [%u %s] %*s Popped [#%s %s]: IgnoreFlag now = %s\n",
1256806343b9SSascha Wildner AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1257806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1258806343b9SSascha Wildner AslGbl_IfDepth * 4, " ",
1259806343b9SSascha Wildner AslGbl_DirectiveInfo[Info->Directive].Name,
1260806343b9SSascha Wildner Info->Argument, AslGbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
12610d02842fSSascha Wildner
12620d02842fSSascha Wildner return (AE_OK);
12630d02842fSSascha Wildner }
12640d02842fSSascha Wildner
12650d02842fSSascha Wildner
12660d02842fSSascha Wildner /*******************************************************************************
12670d02842fSSascha Wildner *
12680d02842fSSascha Wildner * FUNCTION: PrDbgPrint
12690d02842fSSascha Wildner *
12700d02842fSSascha Wildner * PARAMETERS: Action - Action being performed
12710d02842fSSascha Wildner * DirectiveName - Directive being processed
12720d02842fSSascha Wildner *
12730d02842fSSascha Wildner * RETURN: None
12740d02842fSSascha Wildner *
12750d02842fSSascha Wildner * DESCRIPTION: Special debug print for directive processing.
12760d02842fSSascha Wildner *
12770d02842fSSascha Wildner ******************************************************************************/
12780d02842fSSascha Wildner
12790d02842fSSascha Wildner static void
PrDbgPrint(char * Action,char * DirectiveName)12800d02842fSSascha Wildner PrDbgPrint (
12810d02842fSSascha Wildner char *Action,
12820d02842fSSascha Wildner char *DirectiveName)
12830d02842fSSascha Wildner {
12840d02842fSSascha Wildner
12850d02842fSSascha Wildner DbgPrint (ASL_DEBUG_OUTPUT, "Pr(%.4u) - [%u %s] "
1286896f2e3aSSascha Wildner "%*s %s #%s, IfDepth %u\n",
1287806343b9SSascha Wildner AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1288806343b9SSascha Wildner AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1289806343b9SSascha Wildner AslGbl_IfDepth * 4, " ",
1290806343b9SSascha Wildner Action, DirectiveName, AslGbl_IfDepth);
12910d02842fSSascha Wildner }
1292896f2e3aSSascha Wildner
1293896f2e3aSSascha Wildner
1294896f2e3aSSascha Wildner /*******************************************************************************
1295896f2e3aSSascha Wildner *
1296896f2e3aSSascha Wildner * FUNCTION: PrDoIncludeFile
1297896f2e3aSSascha Wildner *
1298896f2e3aSSascha Wildner * PARAMETERS: Pathname - Name of the input file
1299896f2e3aSSascha Wildner *
1300896f2e3aSSascha Wildner * RETURN: None.
1301896f2e3aSSascha Wildner *
1302896f2e3aSSascha Wildner * DESCRIPTION: Open an include file, from #include.
1303896f2e3aSSascha Wildner *
1304896f2e3aSSascha Wildner ******************************************************************************/
1305896f2e3aSSascha Wildner
1306896f2e3aSSascha Wildner static void
PrDoIncludeFile(char * Pathname)1307896f2e3aSSascha Wildner PrDoIncludeFile (
1308896f2e3aSSascha Wildner char *Pathname)
1309896f2e3aSSascha Wildner {
1310896f2e3aSSascha Wildner char *FullPathname;
1311896f2e3aSSascha Wildner
1312896f2e3aSSascha Wildner
1313896f2e3aSSascha Wildner (void) PrOpenIncludeFile (Pathname, "r", &FullPathname);
1314896f2e3aSSascha Wildner }
1315896f2e3aSSascha Wildner
1316896f2e3aSSascha Wildner
1317896f2e3aSSascha Wildner /*******************************************************************************
1318896f2e3aSSascha Wildner *
1319896f2e3aSSascha Wildner * FUNCTION: PrDoIncludeBuffer
1320896f2e3aSSascha Wildner *
1321896f2e3aSSascha Wildner * PARAMETERS: Pathname - Name of the input binary file
1322896f2e3aSSascha Wildner * BufferName - ACPI namepath of the buffer
1323896f2e3aSSascha Wildner *
1324896f2e3aSSascha Wildner * RETURN: None.
1325896f2e3aSSascha Wildner *
1326896f2e3aSSascha Wildner * DESCRIPTION: Create an ACPI buffer object from a binary file. The contents
1327896f2e3aSSascha Wildner * of the file are emitted into the buffer object as ascii
1328896f2e3aSSascha Wildner * hex data. From #includebuffer.
1329896f2e3aSSascha Wildner *
1330896f2e3aSSascha Wildner ******************************************************************************/
1331896f2e3aSSascha Wildner
1332896f2e3aSSascha Wildner static void
PrDoIncludeBuffer(char * Pathname,char * BufferName)1333896f2e3aSSascha Wildner PrDoIncludeBuffer (
1334896f2e3aSSascha Wildner char *Pathname,
1335896f2e3aSSascha Wildner char *BufferName)
1336896f2e3aSSascha Wildner {
1337896f2e3aSSascha Wildner char *FullPathname;
1338896f2e3aSSascha Wildner FILE *BinaryBufferFile;
1339896f2e3aSSascha Wildner UINT32 i = 0;
1340896f2e3aSSascha Wildner UINT8 c;
1341896f2e3aSSascha Wildner
1342896f2e3aSSascha Wildner
1343896f2e3aSSascha Wildner BinaryBufferFile = PrOpenIncludeFile (Pathname, "rb", &FullPathname);
1344896f2e3aSSascha Wildner if (!BinaryBufferFile)
1345896f2e3aSSascha Wildner {
1346896f2e3aSSascha Wildner return;
1347896f2e3aSSascha Wildner }
1348896f2e3aSSascha Wildner
1349896f2e3aSSascha Wildner /* Emit "Name (XXXX, Buffer() {" header */
1350896f2e3aSSascha Wildner
1351896f2e3aSSascha Wildner FlPrintFile (ASL_FILE_PREPROCESSOR, "Name (%s, Buffer()\n{", BufferName);
1352896f2e3aSSascha Wildner
1353896f2e3aSSascha Wildner /* Dump the entire file in ascii hex format */
1354896f2e3aSSascha Wildner
1355896f2e3aSSascha Wildner while (fread (&c, 1, 1, BinaryBufferFile))
1356896f2e3aSSascha Wildner {
1357896f2e3aSSascha Wildner if (!(i % 8))
1358896f2e3aSSascha Wildner {
1359e5412f1eSSascha Wildner FlPrintFile (ASL_FILE_PREPROCESSOR, "\n ");
1360896f2e3aSSascha Wildner }
1361896f2e3aSSascha Wildner
1362896f2e3aSSascha Wildner FlPrintFile (ASL_FILE_PREPROCESSOR, " 0x%2.2X,", c);
1363896f2e3aSSascha Wildner i++;
1364896f2e3aSSascha Wildner }
1365896f2e3aSSascha Wildner
1366896f2e3aSSascha Wildner DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
1367896f2e3aSSascha Wildner "#includebuffer: read %u bytes from %s\n",
1368806343b9SSascha Wildner AslGbl_CurrentLineNumber, i, FullPathname);
1369896f2e3aSSascha Wildner
1370896f2e3aSSascha Wildner /* Close the Name() operator */
1371896f2e3aSSascha Wildner
1372e5412f1eSSascha Wildner FlPrintFile (ASL_FILE_PREPROCESSOR, "\n})\n");
1373896f2e3aSSascha Wildner fclose (BinaryBufferFile);
1374896f2e3aSSascha Wildner }
1375