sys/contrib/dev/acpica/compiler/prutils.c

   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
  69 char *
  70 PrGetNextToken (
  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
 149 void
 150 PrError (
 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
 192 void
 193 PrReplaceData (
 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
 241 void
 242 PrOpenIncludeFile (
 243     char                    *Filename)
 244 {
 245     FILE                    *IncludeFile;
 246     ASL_INCLUDE_DIR         *NextDir;
 247
 248
 249     /*
 250      * start the actual include file on the next line
 251      */
 252     Gbl_CurrentLineOffset++;
 253
 254     /* Attempt to open the include file */
 255
 256     /* If the file specifies an absolute path, just open it */
 257
 258     if ((Filename[0] == '/')  ||
 259         (Filename[0] == '\\') ||
 260         (Filename[1] == ':'))
 261     {
 262         IncludeFile = PrOpenIncludeWithPrefix ("", Filename);
 263         if (!IncludeFile)
 264         {
 265             goto ErrorExit;
 266         }
 267         return;
 268     }
 269
 270     /*
 271      * The include filename is not an absolute path.
 272      *
 273      * First, search for the file within the "local" directory -- meaning
 274      * the same directory that contains the source file.
 275      *
 276      * Construct the file pathname from the global directory name.
 277      */
 278     IncludeFile = PrOpenIncludeWithPrefix (Gbl_DirectoryPath, Filename);
 279     if (IncludeFile)
 280     {
 281         return;
 282     }
 283
 284     /*
 285      * Second, search for the file within the (possibly multiple)
 286      * directories specified by the -I option on the command line.
 287      */
 288     NextDir = Gbl_IncludeDirList;
 289     while (NextDir)
 290     {
 291         IncludeFile = PrOpenIncludeWithPrefix (NextDir->Dir, Filename);
 292         if (IncludeFile)
 293         {
 294             return;
 295         }
 296
 297         NextDir = NextDir->Next;
 298     }
 299
 300     /* We could not open the include file after trying very hard */
 301
 302 ErrorExit:
 303     sprintf (Gbl_MainTokenBuffer, "%s, %s", Filename, strerror (errno));
 304     PrError (ASL_ERROR, ASL_MSG_INCLUDE_FILE_OPEN, 0);
 305 }
 306
 307
 308 /*******************************************************************************
 309  *
 310  * FUNCTION:    FlOpenIncludeWithPrefix
 311  *
 312  * PARAMETERS:  PrefixDir       - Prefix directory pathname. Can be a zero
 313  *                                length string.
 314  *              Filename        - The include filename from the source ASL.
 315  *
 316  * RETURN:      Valid file descriptor if successful. Null otherwise.
 317  *
 318  * DESCRIPTION: Open an include file and push it on the input file stack.
 319  *
 320  ******************************************************************************/
 321
 322 FILE *
 323 PrOpenIncludeWithPrefix (
 324     char                    *PrefixDir,
 325     char                    *Filename)
 326 {
 327     FILE                    *IncludeFile;
 328     char                    *Pathname;
 329
 330
 331     /* Build the full pathname to the file */
 332
 333     Pathname = ACPI_ALLOCATE (strlen (PrefixDir) + strlen (Filename) + 1);
 334
 335     strcpy (Pathname, PrefixDir);
 336     strcat (Pathname, Filename);
 337
 338     DbgPrint (ASL_PARSE_OUTPUT, "\n" PR_PREFIX_ID
 339         "Opening include file: path %s\n",
 340         Gbl_CurrentLineNumber, Pathname);
 341
 342     /* Attempt to open the file, push if successful */
 343
 344     IncludeFile = fopen (Pathname, "r");
 345     if (IncludeFile)
 346     {
 347         /* Push the include file on the open input file stack */
 348
 349         PrPushInputFileStack (IncludeFile, Pathname);
 350         return (IncludeFile);
 351     }
 352
 353     ACPI_FREE (Pathname);
 354     return (NULL);
 355 }
 356
 357
 358 /*******************************************************************************
 359  *
 360  * FUNCTION:    AslPushInputFileStack
 361  *
 362  * PARAMETERS:  InputFile           - Open file pointer
 363  *              Filename            - Name of the file
 364  *
 365  * RETURN:      None
 366  *
 367  * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
 368  *              to this file. Called when an include file is successfully
 369  *              opened.
 370  *
 371  ******************************************************************************/
 372
 373 void
 374 PrPushInputFileStack (
 375     FILE                    *InputFile,
 376     char                    *Filename)
 377 {
 378     PR_FILE_NODE            *Fnode;
 379
 380
 381     /* Save the current state in an Fnode */
 382
 383     Fnode = UtLocalCalloc (sizeof (PR_FILE_NODE));
 384
 385     Fnode->File = Gbl_Files[ASL_FILE_INPUT].Handle;
 386     Fnode->Next = Gbl_InputFileList;
 387     Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
 388     Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
 389
 390     /* Push it on the stack */
 391
 392     Gbl_InputFileList = Fnode;
 393
 394     DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
 395         "Push InputFile Stack: handle %p\n\n",
 396         Gbl_CurrentLineNumber, InputFile);
 397
 398     /* Reset the global line count and filename */
 399
 400     Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
 401     Gbl_Files[ASL_FILE_INPUT].Handle = InputFile;
 402     Gbl_PreviousLineNumber = 0;
 403     Gbl_CurrentLineNumber = 0;
 404
 405     /* Emit a new #line directive for the include file */
 406
 407     FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
 408         1, Filename);
 409 }
 410
 411
 412 /*******************************************************************************
 413  *
 414  * FUNCTION:    AslPopInputFileStack
 415  *
 416  * PARAMETERS:  None
 417  *
 418  * RETURN:      0 if a node was popped, -1 otherwise
 419  *
 420  * DESCRIPTION: Pop the top of the input file stack and point the parser to
 421  *              the saved parse buffer contained in the fnode.  Also, set the
 422  *              global line counters to the saved values.  This function is
 423  *              called when an include file reaches EOF.
 424  *
 425  ******************************************************************************/
 426
 427 BOOLEAN
 428 PrPopInputFileStack (
 429     void)
 430 {
 431     PR_FILE_NODE            *Fnode;
 432
 433
 434     Fnode = Gbl_InputFileList;
 435     DbgPrint (ASL_PARSE_OUTPUT, "\n" PR_PREFIX_ID
 436         "Pop InputFile Stack, Fnode %p\n\n",
 437         Gbl_CurrentLineNumber, Fnode);
 438
 439     if (!Fnode)
 440     {
 441         return (FALSE);
 442     }
 443
 444     /* Close the current include file */
 445
 446     fclose (Gbl_Files[ASL_FILE_INPUT].Handle);
 447
 448     /* Update the top-of-stack */
 449
 450     Gbl_InputFileList = Fnode->Next;
 451
 452     /* Reset global line counter and filename */
 453
 454     Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
 455     Gbl_Files[ASL_FILE_INPUT].Handle = Fnode->File;
 456     Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
 457     Gbl_PreviousLineNumber = 0;
 458
 459     /* Emit a new #line directive after the include file */
 460
 461     FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
 462         Gbl_CurrentLineNumber + 1, Fnode->Filename);
 463
 464     /* All done with this node */
 465
 466     ACPI_FREE (Fnode);
 467     return (TRUE);
 468 }