prutils.c revision 243347 
1/******************************************************************************
2 *
3 * Module Name: prutils - Preprocessor utilities
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2012, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#include <contrib/dev/acpica/compiler/aslcompiler.h>
45#include <contrib/dev/acpica/compiler/dtcompiler.h>
46
47
48#define _COMPONENT          ASL_PREPROCESSOR
49        ACPI_MODULE_NAME    ("prutils")
50
51
52/******************************************************************************
53 *
54 * FUNCTION:    PrGetNextToken
55 *
56 * PARAMETERS:  Buffer              - Current line buffer
57 *              MatchString         - String with valid token delimiters
58 *              Next                - Set to next possible token in buffer
59 *
60 * RETURN:      Next token (null-terminated). Modifies the input line.
61 *              Remainder of line is stored in *Next.
62 *
63 * DESCRIPTION: Local implementation of strtok() with local storage for the
64 *              next pointer. Not only thread-safe, but allows multiple
65 *              parsing of substrings such as expressions.
66 *
67 *****************************************************************************/
68
69char *
70PrGetNextToken (
71    char                    *Buffer,
72    char                    *MatchString,
73    char                    **Next)
74{
75    char                    *TokenStart;
76
77
78    if (!Buffer)
79    {
80        /* Use Next if it is valid */
81
82        Buffer = *Next;
83        if (!(*Next))
84        {
85            return (NULL);
86        }
87    }
88
89    /* Skip any leading delimiters */
90
91    while (*Buffer)
92    {
93        if (strchr (MatchString, *Buffer))
94        {
95            Buffer++;
96        }
97        else
98        {
99            break;
100        }
101    }
102
103    /* Anything left on the line? */
104
105    if (!(*Buffer))
106    {
107        *Next = NULL;
108        return (NULL);
109    }
110
111    TokenStart = Buffer;
112
113    /* Find the end of this token */
114
115    while (*Buffer)
116    {
117        if (strchr (MatchString, *Buffer))
118        {
119            *Buffer = 0;
120            *Next = Buffer+1;
121            if (!**Next)
122            {
123                *Next = NULL;
124            }
125            return (TokenStart);
126        }
127        Buffer++;
128    }
129
130    *Next = NULL;
131    return (TokenStart);
132}
133
134
135/*******************************************************************************
136 *
137 * FUNCTION:    PrError
138 *
139 * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
140 *              MessageId           - Index into global message buffer
141 *              Column              - Column in current line
142 *
143 * RETURN:      None
144 *
145 * DESCRIPTION: Preprocessor error reporting. Front end to AslCommonError2
146 *
147 ******************************************************************************/
148
149void
150PrError (
151    UINT8                   Level,
152    UINT8                   MessageId,
153    UINT32                  Column)
154{
155#if 0
156    AcpiOsPrintf ("%s (%u) : %s", Gbl_Files[ASL_FILE_INPUT].Filename,
157        Gbl_CurrentLineNumber, Gbl_CurrentLineBuffer);
158#endif
159
160
161    if (Column > 120)
162    {
163        Column = 0;
164    }
165
166    /* TBD: Need Logical line number? */
167
168    AslCommonError2 (Level, MessageId,
169        Gbl_CurrentLineNumber, Column,
170        Gbl_CurrentLineBuffer,
171        Gbl_Files[ASL_FILE_INPUT].Filename, "Preprocessor");
172
173    Gbl_PreprocessorError = TRUE;
174}
175
176
177/*******************************************************************************
178 *
179 * FUNCTION:    PrReplaceData
180 *
181 * PARAMETERS:  Buffer              - Original(target) buffer pointer
182 *              LengthToRemove      - Length to be removed from target buffer
183 *              BufferToAdd         - Data to be inserted into target buffer
184 *              LengthToAdd         - Length of BufferToAdd
185 *
186 * RETURN:      None
187 *
188 * DESCRIPTION: Generic buffer data replacement.
189 *
190 ******************************************************************************/
191
192void
193PrReplaceData (
194    char                    *Buffer,
195    UINT32                  LengthToRemove,
196    char                    *BufferToAdd,
197    UINT32                  LengthToAdd)
198{
199    UINT32                  BufferLength;
200
201
202    /* Buffer is a string, so the length must include the terminating zero */
203
204    BufferLength = strlen (Buffer) + 1;
205
206    if (LengthToRemove != LengthToAdd)
207    {
208        /*
209         * Move some of the existing data
210         * 1) If adding more bytes than removing, make room for the new data
211         * 2) if removing more bytes than adding, delete the extra space
212         */
213        if (LengthToRemove > 0)
214        {
215            memmove ((Buffer + LengthToAdd), (Buffer + LengthToRemove),
216                (BufferLength - LengthToRemove));
217        }
218    }
219
220    /* Now we can move in the new data */
221
222    if (LengthToAdd > 0)
223    {
224        memmove (Buffer, BufferToAdd, LengthToAdd);
225    }
226}
227
228
229/*******************************************************************************
230 *
231 * FUNCTION:    PrOpenIncludeFile
232 *
233 * PARAMETERS:  Filename            - Filename or pathname for include file
234 *
235 * RETURN:      None.
236 *
237 * DESCRIPTION: Open an include file and push it on the input file stack.
238 *
239 ******************************************************************************/
240
241void
242PrOpenIncludeFile (
243    char                    *Filename)
244{
245    FILE                    *IncludeFile;
246    ASL_INCLUDE_DIR         *NextDir;
247
248
249    /* Start the actual include file on the next line */
250
251    Gbl_CurrentLineOffset++;
252
253    /* Attempt to open the include file */
254    /* If the file specifies an absolute path, just open it */
255
256    if ((Filename[0] == '/')  ||
257        (Filename[0] == '\\') ||
258        (Filename[1] == ':'))
259    {
260        IncludeFile = PrOpenIncludeWithPrefix ("", Filename);
261        if (!IncludeFile)
262        {
263            goto ErrorExit;
264        }
265        return;
266    }
267
268    /*
269     * The include filename is not an absolute path.
270     *
271     * First, search for the file within the "local" directory -- meaning
272     * the same directory that contains the source file.
273     *
274     * Construct the file pathname from the global directory name.
275     */
276    IncludeFile = PrOpenIncludeWithPrefix (Gbl_DirectoryPath, Filename);
277    if (IncludeFile)
278    {
279        return;
280    }
281
282    /*
283     * Second, search for the file within the (possibly multiple)
284     * directories specified by the -I option on the command line.
285     */
286    NextDir = Gbl_IncludeDirList;
287    while (NextDir)
288    {
289        IncludeFile = PrOpenIncludeWithPrefix (NextDir->Dir, Filename);
290        if (IncludeFile)
291        {
292            return;
293        }
294
295        NextDir = NextDir->Next;
296    }
297
298    /* We could not open the include file after trying very hard */
299
300ErrorExit:
301    sprintf (Gbl_MainTokenBuffer, "%s, %s", Filename, strerror (errno));
302    PrError (ASL_ERROR, ASL_MSG_INCLUDE_FILE_OPEN, 0);
303}
304
305
306/*******************************************************************************
307 *
308 * FUNCTION:    FlOpenIncludeWithPrefix
309 *
310 * PARAMETERS:  PrefixDir       - Prefix directory pathname. Can be a zero
311 *                                length string.
312 *              Filename        - The include filename from the source ASL.
313 *
314 * RETURN:      Valid file descriptor if successful. Null otherwise.
315 *
316 * DESCRIPTION: Open an include file and push it on the input file stack.
317 *
318 ******************************************************************************/
319
320FILE *
321PrOpenIncludeWithPrefix (
322    char                    *PrefixDir,
323    char                    *Filename)
324{
325    FILE                    *IncludeFile;
326    char                    *Pathname;
327
328
329    /* Build the full pathname to the file */
330
331    Pathname = FlMergePathnames (PrefixDir, Filename);
332
333    DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
334        "Include: Opening file - \"%s\"\n",
335        Gbl_CurrentLineNumber, Pathname);
336
337    /* Attempt to open the file, push if successful */
338
339    IncludeFile = fopen (Pathname, "r");
340    if (!IncludeFile)
341    {
342        fprintf (stderr, "Could not open include file %s\n", Pathname);
343        ACPI_FREE (Pathname);
344        return (NULL);
345    }
346
347    /* Push the include file on the open input file stack */
348
349    PrPushInputFileStack (IncludeFile, Pathname);
350    return (IncludeFile);
351}
352
353
354/*******************************************************************************
355 *
356 * FUNCTION:    AslPushInputFileStack
357 *
358 * PARAMETERS:  InputFile           - Open file pointer
359 *              Filename            - Name of the file
360 *
361 * RETURN:      None
362 *
363 * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
364 *              to this file. Called when an include file is successfully
365 *              opened.
366 *
367 ******************************************************************************/
368
369void
370PrPushInputFileStack (
371    FILE                    *InputFile,
372    char                    *Filename)
373{
374    PR_FILE_NODE            *Fnode;
375
376
377    /* Save the current state in an Fnode */
378
379    Fnode = UtLocalCalloc (sizeof (PR_FILE_NODE));
380
381    Fnode->File = Gbl_Files[ASL_FILE_INPUT].Handle;
382    Fnode->Next = Gbl_InputFileList;
383    Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
384    Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
385
386    /* Push it on the stack */
387
388    Gbl_InputFileList = Fnode;
389
390    DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
391        "Push InputFile Stack: handle %p\n\n",
392        Gbl_CurrentLineNumber, InputFile);
393
394    /* Reset the global line count and filename */
395
396    Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
397    Gbl_Files[ASL_FILE_INPUT].Handle = InputFile;
398    Gbl_PreviousLineNumber = 0;
399    Gbl_CurrentLineNumber = 0;
400
401    /* Emit a new #line directive for the include file */
402
403    FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
404        1, Filename);
405}
406
407
408/*******************************************************************************
409 *
410 * FUNCTION:    AslPopInputFileStack
411 *
412 * PARAMETERS:  None
413 *
414 * RETURN:      0 if a node was popped, -1 otherwise
415 *
416 * DESCRIPTION: Pop the top of the input file stack and point the parser to
417 *              the saved parse buffer contained in the fnode. Also, set the
418 *              global line counters to the saved values. This function is
419 *              called when an include file reaches EOF.
420 *
421 ******************************************************************************/
422
423BOOLEAN
424PrPopInputFileStack (
425    void)
426{
427    PR_FILE_NODE            *Fnode;
428
429
430    Fnode = Gbl_InputFileList;
431    DbgPrint (ASL_PARSE_OUTPUT, "\n" PR_PREFIX_ID
432        "Pop InputFile Stack, Fnode %p\n\n",
433        Gbl_CurrentLineNumber, Fnode);
434
435    if (!Fnode)
436    {
437        return (FALSE);
438    }
439
440    /* Close the current include file */
441
442    fclose (Gbl_Files[ASL_FILE_INPUT].Handle);
443
444    /* Update the top-of-stack */
445
446    Gbl_InputFileList = Fnode->Next;
447
448    /* Reset global line counter and filename */
449
450    Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
451    Gbl_Files[ASL_FILE_INPUT].Handle = Fnode->File;
452    Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
453    Gbl_PreviousLineNumber = 0;
454
455    /* Emit a new #line directive after the include file */
456
457    FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
458        Gbl_CurrentLineNumber + 1, Fnode->Filename);
459
460    /* All done with this node */
461
462    ACPI_FREE (Fnode);
463    return (TRUE);
464}
465