arch/all-pc/acpica/source/compiler/aslfiles.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslfiles - File support functions
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 "aslcompiler.h"
  45 #include "acapps.h"
  46
  47 #define _COMPONENT          ACPI_COMPILER
  48         ACPI_MODULE_NAME    ("aslfiles")
  49
  50 /* Local prototypes */
  51
  52 FILE *
  53 FlOpenIncludeWithPrefix (
  54     char                    *PrefixDir,
  55     char                    *Filename);
  56
  57
  58 #ifdef ACPI_OBSOLETE_FUNCTIONS
  59 ACPI_STATUS
  60 FlParseInputPathname (
  61     char                    *InputFilename);
  62 #endif
  63
  64
  65 /*******************************************************************************
  66  *
  67  * FUNCTION:    FlSetLineNumber
  68  *
  69  * PARAMETERS:  Op        - Parse node for the LINE asl statement
  70  *
  71  * RETURN:      None.
  72  *
  73  * DESCRIPTION: Set the current line number
  74  *
  75  ******************************************************************************/
  76
  77 void
  78 FlSetLineNumber (
  79     UINT32                  LineNumber)
  80 {
  81
  82     DbgPrint (ASL_PARSE_OUTPUT, "\n#line: New line number %u (old %u)\n",
  83          LineNumber, Gbl_LogicalLineNumber);
  84
  85     Gbl_CurrentLineNumber = LineNumber;
  86     Gbl_LogicalLineNumber = LineNumber;
  87 }
  88
  89
  90 /*******************************************************************************
  91  *
  92  * FUNCTION:    FlSetFilename
  93  *
  94  * PARAMETERS:  Op        - Parse node for the LINE asl statement
  95  *
  96  * RETURN:      None.
  97  *
  98  * DESCRIPTION: Set the current filename
  99  *
 100  ******************************************************************************/
 101
 102 void
 103 FlSetFilename (
 104     char                    *Filename)
 105 {
 106
 107     DbgPrint (ASL_PARSE_OUTPUT, "\n#line: New filename %s (old %s)\n",
 108          Filename, Gbl_Files[ASL_FILE_INPUT].Filename);
 109
 110     Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
 111 }
 112
 113
 114 /*******************************************************************************
 115  *
 116  * FUNCTION:    FlAddIncludeDirectory
 117  *
 118  * PARAMETERS:  Dir             - Directory pathname string
 119  *
 120  * RETURN:      None
 121  *
 122  * DESCRIPTION: Add a directory the list of include prefix directories.
 123  *
 124  ******************************************************************************/
 125
 126 void
 127 FlAddIncludeDirectory (
 128     char                    *Dir)
 129 {
 130     ASL_INCLUDE_DIR         *NewDir;
 131     ASL_INCLUDE_DIR         *NextDir;
 132     ASL_INCLUDE_DIR         *PrevDir = NULL;
 133     UINT32                  NeedsSeparator = 0;
 134     size_t                  DirLength;
 135
 136
 137     DirLength = strlen (Dir);
 138     if (!DirLength)
 139     {
 140         return;
 141     }
 142
 143     /* Make sure that the pathname ends with a path separator */
 144
 145     if ((Dir[DirLength-1] != '/') &&
 146         (Dir[DirLength-1] != '\\'))
 147     {
 148         NeedsSeparator = 1;
 149     }
 150
 151     NewDir = ACPI_ALLOCATE_ZEROED (sizeof (ASL_INCLUDE_DIR));
 152     NewDir->Dir = ACPI_ALLOCATE (DirLength + 1 + NeedsSeparator);
 153     strcpy (NewDir->Dir, Dir);
 154     if (NeedsSeparator)
 155     {
 156         strcat (NewDir->Dir, "/");
 157     }
 158
 159     /*
 160      * Preserve command line ordering of -I options by adding new elements
 161      * at the end of the list
 162      */
 163     NextDir = Gbl_IncludeDirList;
 164     while (NextDir)
 165     {
 166         PrevDir = NextDir;
 167         NextDir = NextDir->Next;
 168     }
 169
 170     if (PrevDir)
 171     {
 172         PrevDir->Next = NewDir;
 173     }
 174     else
 175     {
 176         Gbl_IncludeDirList = NewDir;
 177     }
 178 }
 179
 180
 181 /*******************************************************************************
 182  *
 183  * FUNCTION:    FlMergePathnames
 184  *
 185  * PARAMETERS:  PrefixDir       - Prefix directory pathname. Can be NULL or
 186  *                                a zero length string.
 187  *              FilePathname    - The include filename from the source ASL.
 188  *
 189  * RETURN:      Merged pathname string
 190  *
 191  * DESCRIPTION: Merge two pathnames that (probably) have common elements, to
 192  *              arrive at a minimal length string. Merge can occur if the
 193  *              FilePathname is relative to the PrefixDir.
 194  *
 195  ******************************************************************************/
 196
 197 char *
 198 FlMergePathnames (
 199     char                    *PrefixDir,
 200     char                    *FilePathname)
 201 {
 202     char                    *CommonPath;
 203     char                    *Pathname;
 204     char                    *LastElement;
 205
 206
 207     DbgPrint (ASL_PARSE_OUTPUT, "Include: Prefix path - \"%s\"\n"
 208         "Include: FilePathname - \"%s\"\n",
 209          PrefixDir, FilePathname);
 210
 211     /*
 212      * If there is no prefix directory or if the file pathname is absolute,
 213      * just return the original file pathname
 214      */
 215     if (!PrefixDir || (!*PrefixDir) ||
 216         (*FilePathname == '/') ||
 217          (FilePathname[1] == ':'))
 218     {
 219         Pathname = ACPI_ALLOCATE (strlen (FilePathname) + 1);
 220         strcpy (Pathname, FilePathname);
 221         goto ConvertBackslashes;
 222     }
 223
 224     /* Need a local copy of the prefix directory path */
 225
 226     CommonPath = ACPI_ALLOCATE (strlen (PrefixDir) + 1);
 227     strcpy (CommonPath, PrefixDir);
 228
 229     /*
 230      * Walk forward through the file path, and simultaneously backward
 231      * through the prefix directory path until there are no more
 232      * relative references at the start of the file path.
 233      */
 234     while (*FilePathname && (!strncmp (FilePathname, "../", 3)))
 235     {
 236         /* Remove last element of the prefix directory path */
 237
 238         LastElement = strrchr (CommonPath, '/');
 239         if (!LastElement)
 240         {
 241             goto ConcatenatePaths;
 242         }
 243
 244         *LastElement = 0;   /* Terminate CommonPath string */
 245         FilePathname += 3;  /* Point to next path element */
 246     }
 247
 248     /*
 249      * Remove the last element of the prefix directory path (it is the same as
 250      * the first element of the file pathname), and build the final merged
 251      * pathname.
 252      */
 253     LastElement = strrchr (CommonPath, '/');
 254     if (LastElement)
 255     {
 256         *LastElement = 0;
 257     }
 258
 259     /* Build the final merged pathname */
 260
 261 ConcatenatePaths:
 262     Pathname = ACPI_ALLOCATE_ZEROED (strlen (CommonPath) + strlen (FilePathname) + 2);
 263     if (LastElement && *CommonPath)
 264     {
 265         strcpy (Pathname, CommonPath);
 266         strcat (Pathname, "/");
 267     }
 268     strcat (Pathname, FilePathname);
 269     ACPI_FREE (CommonPath);
 270
 271     /* Convert all backslashes to normal slashes */
 272
 273 ConvertBackslashes:
 274     UtConvertBackslashes (Pathname);
 275
 276     DbgPrint (ASL_PARSE_OUTPUT, "Include: Merged Pathname - \"%s\"\n",
 277          Pathname);
 278     return (Pathname);
 279 }
 280
 281
 282 /*******************************************************************************
 283  *
 284  * FUNCTION:    FlOpenIncludeWithPrefix
 285  *
 286  * PARAMETERS:  PrefixDir       - Prefix directory pathname. Can be a zero
 287  *                                length string.
 288  *              Filename        - The include filename from the source ASL.
 289  *
 290  * RETURN:      Valid file descriptor if successful. Null otherwise.
 291  *
 292  * DESCRIPTION: Open an include file and push it on the input file stack.
 293  *
 294  ******************************************************************************/
 295
 296 FILE *
 297 FlOpenIncludeWithPrefix (
 298     char                    *PrefixDir,
 299     char                    *Filename)
 300 {
 301     FILE                    *IncludeFile;
 302     char                    *Pathname;
 303
 304
 305     /* Build the full pathname to the file */
 306
 307     Pathname = FlMergePathnames (PrefixDir, Filename);
 308
 309     DbgPrint (ASL_PARSE_OUTPUT, "Include: Opening file - \"%s\"\n\n",
 310         Pathname);
 311
 312     /* Attempt to open the file, push if successful */
 313
 314     IncludeFile = fopen (Pathname, "r");
 315     if (!IncludeFile)
 316     {
 317         fprintf (stderr, "Could not open include file %s\n", Pathname);
 318         ACPI_FREE (Pathname);
 319         return (NULL);
 320     }
 321
 322     /* Push the include file on the open input file stack */
 323
 324     AslPushInputFileStack (IncludeFile, Pathname);
 325     return (IncludeFile);
 326 }
 327
 328
 329 /*******************************************************************************
 330  *
 331  * FUNCTION:    FlOpenIncludeFile
 332  *
 333  * PARAMETERS:  Op        - Parse node for the INCLUDE ASL statement
 334  *
 335  * RETURN:      None.
 336  *
 337  * DESCRIPTION: Open an include file and push it on the input file stack.
 338  *
 339  ******************************************************************************/
 340
 341 void
 342 FlOpenIncludeFile (
 343     ACPI_PARSE_OBJECT       *Op)
 344 {
 345     FILE                    *IncludeFile;
 346     ASL_INCLUDE_DIR         *NextDir;
 347
 348
 349     /* Op must be valid */
 350
 351     if (!Op)
 352     {
 353         AslCommonError (ASL_ERROR, ASL_MSG_INCLUDE_FILE_OPEN,
 354             Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
 355             Gbl_InputByteCount, Gbl_CurrentColumn,
 356             Gbl_Files[ASL_FILE_INPUT].Filename, " - Null parse node");
 357
 358         return;
 359     }
 360
 361     /*
 362      * Flush out the "include ()" statement on this line, start
 363      * the actual include file on the next line
 364      */
 365     AslResetCurrentLineBuffer ();
 366     FlPrintFile (ASL_FILE_SOURCE_OUTPUT, "\n");
 367     Gbl_CurrentLineOffset++;
 368
 369
 370     /* Attempt to open the include file */
 371
 372     /* If the file specifies an absolute path, just open it */
 373
 374     if ((Op->Asl.Value.String[0] == '/')  ||
 375         (Op->Asl.Value.String[0] == '\\') ||
 376         (Op->Asl.Value.String[1] == ':'))
 377     {
 378         IncludeFile = FlOpenIncludeWithPrefix ("", Op->Asl.Value.String);
 379         if (!IncludeFile)
 380         {
 381             goto ErrorExit;
 382         }
 383         return;
 384     }
 385
 386     /*
 387      * The include filename is not an absolute path.
 388      *
 389      * First, search for the file within the "local" directory -- meaning
 390      * the same directory that contains the source file.
 391      *
 392      * Construct the file pathname from the global directory name.
 393      */
 394     IncludeFile = FlOpenIncludeWithPrefix (Gbl_DirectoryPath, Op->Asl.Value.String);
 395     if (IncludeFile)
 396     {
 397         return;
 398     }
 399
 400     /*
 401      * Second, search for the file within the (possibly multiple) directories
 402      * specified by the -I option on the command line.
 403      */
 404     NextDir = Gbl_IncludeDirList;
 405     while (NextDir)
 406     {
 407         IncludeFile = FlOpenIncludeWithPrefix (NextDir->Dir, Op->Asl.Value.String);
 408         if (IncludeFile)
 409         {
 410             return;
 411         }
 412
 413         NextDir = NextDir->Next;
 414     }
 415
 416     /* We could not open the include file after trying very hard */
 417
 418 ErrorExit:
 419     sprintf (MsgBuffer, "%s, %s", Op->Asl.Value.String, strerror (errno));
 420     AslError (ASL_ERROR, ASL_MSG_INCLUDE_FILE_OPEN, Op, MsgBuffer);
 421 }
 422
 423
 424 /*******************************************************************************
 425  *
 426  * FUNCTION:    FlOpenInputFile
 427  *
 428  * PARAMETERS:  InputFilename       - The user-specified ASL source file to be
 429  *                                    compiled
 430  *
 431  * RETURN:      Status
 432  *
 433  * DESCRIPTION: Open the specified input file, and save the directory path to
 434  *              the file so that include files can be opened in
 435  *              the same directory.
 436  *
 437  ******************************************************************************/
 438
 439 ACPI_STATUS
 440 FlOpenInputFile (
 441     char                    *InputFilename)
 442 {
 443
 444     /* Open the input ASL file, text mode */
 445
 446     FlOpenFile (ASL_FILE_INPUT, InputFilename, "rt");
 447     AslCompilerin = Gbl_Files[ASL_FILE_INPUT].Handle;
 448
 449     return (AE_OK);
 450 }
 451
 452
 453 /*******************************************************************************
 454  *
 455  * FUNCTION:    FlOpenAmlOutputFile
 456  *
 457  * PARAMETERS:  FilenamePrefix       - The user-specified ASL source file
 458  *
 459  * RETURN:      Status
 460  *
 461  * DESCRIPTION: Create the output filename (*.AML) and open the file. The file
 462  *              is created in the same directory as the parent input file.
 463  *
 464  ******************************************************************************/
 465
 466 ACPI_STATUS
 467 FlOpenAmlOutputFile (
 468     char                    *FilenamePrefix)
 469 {
 470     char                    *Filename;
 471
 472
 473     /* Output filename usually comes from the ASL itself */
 474
 475     Filename = Gbl_Files[ASL_FILE_AML_OUTPUT].Filename;
 476     if (!Filename)
 477     {
 478         /* Create the output AML filename */
 479
 480         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_AML_CODE);
 481         if (!Filename)
 482         {
 483             AslCommonError (ASL_ERROR, ASL_MSG_OUTPUT_FILENAME,
 484                 0, 0, 0, 0, NULL, NULL);
 485             return (AE_ERROR);
 486         }
 487     }
 488
 489     /* Open the output AML file in binary mode */
 490
 491     FlOpenFile (ASL_FILE_AML_OUTPUT, Filename, "w+b");
 492     return (AE_OK);
 493 }
 494
 495
 496 /*******************************************************************************
 497  *
 498  * FUNCTION:    FlOpenMiscOutputFiles
 499  *
 500  * PARAMETERS:  FilenamePrefix       - The user-specified ASL source file
 501  *
 502  * RETURN:      Status
 503  *
 504  * DESCRIPTION: Create and open the various output files needed, depending on
 505  *              the command line options
 506  *
 507  ******************************************************************************/
 508
 509 ACPI_STATUS
 510 FlOpenMiscOutputFiles (
 511     char                    *FilenamePrefix)
 512 {
 513     char                    *Filename;
 514
 515
 516     /* All done for disassembler */
 517
 518     if (Gbl_FileType == ASL_INPUT_TYPE_ACPI_TABLE)
 519     {
 520         return (AE_OK);
 521     }
 522
 523     /* Create/Open a hex output file if asked */
 524
 525     if (Gbl_HexOutputFlag)
 526     {
 527         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_HEX_DUMP);
 528         if (!Filename)
 529         {
 530             AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 531                 0, 0, 0, 0, NULL, NULL);
 532             return (AE_ERROR);
 533         }
 534
 535         /* Open the hex file, text mode */
 536
 537         FlOpenFile (ASL_FILE_HEX_OUTPUT, Filename, "w+t");
 538
 539         AslCompilerSignon (ASL_FILE_HEX_OUTPUT);
 540         AslCompilerFileHeader (ASL_FILE_HEX_OUTPUT);
 541     }
 542
 543     /* Create/Open a debug output file if asked */
 544
 545     if (Gbl_DebugFlag)
 546     {
 547         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_DEBUG);
 548         if (!Filename)
 549         {
 550             AslCommonError (ASL_ERROR, ASL_MSG_DEBUG_FILENAME,
 551                 0, 0, 0, 0, NULL, NULL);
 552             return (AE_ERROR);
 553         }
 554
 555         /* Open the debug file as STDERR, text mode */
 556
 557         /* TBD: hide this behind a FlReopenFile function */
 558
 559         Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Filename = Filename;
 560         Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Handle =
 561             freopen (Filename, "w+t", stderr);
 562
 563         if (!Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Handle)
 564         {
 565             AslCommonError (ASL_ERROR, ASL_MSG_DEBUG_FILENAME,
 566                 0, 0, 0, 0, NULL, NULL);
 567             return (AE_ERROR);
 568         }
 569
 570         AslCompilerSignon (ASL_FILE_DEBUG_OUTPUT);
 571         AslCompilerFileHeader (ASL_FILE_DEBUG_OUTPUT);
 572     }
 573
 574     /* Create/Open a listing output file if asked */
 575
 576     if (Gbl_ListingFlag)
 577     {
 578         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_LISTING);
 579         if (!Filename)
 580         {
 581             AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 582                 0, 0, 0, 0, NULL, NULL);
 583             return (AE_ERROR);
 584         }
 585
 586         /* Open the listing file, text mode */
 587
 588         FlOpenFile (ASL_FILE_LISTING_OUTPUT, Filename, "w+t");
 589
 590         AslCompilerSignon (ASL_FILE_LISTING_OUTPUT);
 591         AslCompilerFileHeader (ASL_FILE_LISTING_OUTPUT);
 592     }
 593
 594     /* Create the preprocessor output file if preprocessor enabled */
 595
 596     if (Gbl_PreprocessFlag)
 597     {
 598         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_PREPROCESSOR);
 599         if (!Filename)
 600         {
 601             AslCommonError (ASL_ERROR, ASL_MSG_PREPROCESSOR_FILENAME,
 602                 0, 0, 0, 0, NULL, NULL);
 603             return (AE_ERROR);
 604         }
 605
 606         FlOpenFile (ASL_FILE_PREPROCESSOR, Filename, "w+t");
 607     }
 608
 609     /* All done for data table compiler */
 610
 611     if (Gbl_FileType == ASL_INPUT_TYPE_ASCII_DATA)
 612     {
 613         return (AE_OK);
 614     }
 615
 616     /* Create/Open a combined source output file */
 617
 618     Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_SOURCE);
 619     if (!Filename)
 620     {
 621         AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 622             0, 0, 0, 0, NULL, NULL);
 623         return (AE_ERROR);
 624     }
 625
 626     /*
 627      * Open the source output file, binary mode (so that LF does not get
 628      * expanded to CR/LF on some systems, messing up our seek
 629      * calculations.)
 630      */
 631     FlOpenFile (ASL_FILE_SOURCE_OUTPUT, Filename, "w+b");
 632
 633 /*
 634 // TBD: TEMP
 635 //    AslCompilerin = Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle;
 636 */
 637     /* Create/Open a assembly code source output file if asked */
 638
 639     if (Gbl_AsmOutputFlag)
 640     {
 641         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_ASM_SOURCE);
 642         if (!Filename)
 643         {
 644             AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 645                 0, 0, 0, 0, NULL, NULL);
 646             return (AE_ERROR);
 647         }
 648
 649         /* Open the assembly code source file, text mode */
 650
 651         FlOpenFile (ASL_FILE_ASM_SOURCE_OUTPUT, Filename, "w+t");
 652
 653         AslCompilerSignon (ASL_FILE_ASM_SOURCE_OUTPUT);
 654         AslCompilerFileHeader (ASL_FILE_ASM_SOURCE_OUTPUT);
 655     }
 656
 657     /* Create/Open a C code source output file if asked */
 658
 659     if (Gbl_C_OutputFlag)
 660     {
 661         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_SOURCE);
 662         if (!Filename)
 663         {
 664             AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 665                 0, 0, 0, 0, NULL, NULL);
 666             return (AE_ERROR);
 667         }
 668
 669         /* Open the C code source file, text mode */
 670
 671         FlOpenFile (ASL_FILE_C_SOURCE_OUTPUT, Filename, "w+t");
 672
 673         FlPrintFile (ASL_FILE_C_SOURCE_OUTPUT, "/*\n");
 674         AslCompilerSignon (ASL_FILE_C_SOURCE_OUTPUT);
 675         AslCompilerFileHeader (ASL_FILE_C_SOURCE_OUTPUT);
 676     }
 677
 678     /* Create/Open a C code source output file for the offset table if asked */
 679
 680     if (Gbl_C_OffsetTableFlag)
 681     {
 682         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_OFFSET);
 683         if (!Filename)
 684         {
 685             AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 686                 0, 0, 0, 0, NULL, NULL);
 687             return (AE_ERROR);
 688         }
 689
 690         /* Open the C code source file, text mode */
 691
 692         FlOpenFile (ASL_FILE_C_OFFSET_OUTPUT, Filename, "w+t");
 693
 694         FlPrintFile (ASL_FILE_C_OFFSET_OUTPUT, "/*\n");
 695         AslCompilerSignon (ASL_FILE_C_OFFSET_OUTPUT);
 696         AslCompilerFileHeader (ASL_FILE_C_OFFSET_OUTPUT);
 697     }
 698
 699     /* Create/Open a assembly include output file if asked */
 700
 701     if (Gbl_AsmIncludeOutputFlag)
 702     {
 703         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_ASM_INCLUDE);
 704         if (!Filename)
 705         {
 706             AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 707                 0, 0, 0, 0, NULL, NULL);
 708             return (AE_ERROR);
 709         }
 710
 711         /* Open the assembly include file, text mode */
 712
 713         FlOpenFile (ASL_FILE_ASM_INCLUDE_OUTPUT, Filename, "w+t");
 714
 715         AslCompilerSignon (ASL_FILE_ASM_INCLUDE_OUTPUT);
 716         AslCompilerFileHeader (ASL_FILE_ASM_INCLUDE_OUTPUT);
 717     }
 718
 719     /* Create/Open a C include output file if asked */
 720
 721     if (Gbl_C_IncludeOutputFlag)
 722     {
 723         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_INCLUDE);
 724         if (!Filename)
 725         {
 726             AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 727                 0, 0, 0, 0, NULL, NULL);
 728             return (AE_ERROR);
 729         }
 730
 731         /* Open the C include file, text mode */
 732
 733         FlOpenFile (ASL_FILE_C_INCLUDE_OUTPUT, Filename, "w+t");
 734
 735         FlPrintFile (ASL_FILE_C_INCLUDE_OUTPUT, "/*\n");
 736         AslCompilerSignon (ASL_FILE_C_INCLUDE_OUTPUT);
 737         AslCompilerFileHeader (ASL_FILE_C_INCLUDE_OUTPUT);
 738     }
 739
 740     /* Create a namespace output file if asked */
 741
 742     if (Gbl_NsOutputFlag)
 743     {
 744         Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_NAMESPACE);
 745         if (!Filename)
 746         {
 747             AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME,
 748                 0, 0, 0, 0, NULL, NULL);
 749             return (AE_ERROR);
 750         }
 751
 752         /* Open the namespace file, text mode */
 753
 754         FlOpenFile (ASL_FILE_NAMESPACE_OUTPUT, Filename, "w+t");
 755
 756         AslCompilerSignon (ASL_FILE_NAMESPACE_OUTPUT);
 757         AslCompilerFileHeader (ASL_FILE_NAMESPACE_OUTPUT);
 758     }
 759
 760     return (AE_OK);
 761 }
 762
 763
 764 #ifdef ACPI_OBSOLETE_FUNCTIONS
 765 /*******************************************************************************
 766  *
 767  * FUNCTION:    FlParseInputPathname
 768  *
 769  * PARAMETERS:  InputFilename       - The user-specified ASL source file to be
 770  *                                    compiled
 771  *
 772  * RETURN:      Status
 773  *
 774  * DESCRIPTION: Split the input path into a directory and filename part
 775  *              1) Directory part used to open include files
 776  *              2) Filename part used to generate output filenames
 777  *
 778  ******************************************************************************/
 779
 780 ACPI_STATUS
 781 FlParseInputPathname (
 782     char                    *InputFilename)
 783 {
 784     char                    *Substring;
 785
 786
 787     if (!InputFilename)
 788     {
 789         return (AE_OK);
 790     }
 791
 792     /* Get the path to the input filename's directory */
 793
 794     Gbl_DirectoryPath = strdup (InputFilename);
 795     if (!Gbl_DirectoryPath)
 796     {
 797         return (AE_NO_MEMORY);
 798     }
 799
 800     Substring = strrchr (Gbl_DirectoryPath, '\\');
 801     if (!Substring)
 802     {
 803         Substring = strrchr (Gbl_DirectoryPath, '/');
 804         if (!Substring)
 805         {
 806             Substring = strrchr (Gbl_DirectoryPath, ':');
 807         }
 808     }
 809
 810     if (!Substring)
 811     {
 812         Gbl_DirectoryPath[0] = 0;
 813         if (Gbl_UseDefaultAmlFilename)
 814         {
 815             Gbl_OutputFilenamePrefix = strdup (InputFilename);
 816         }
 817     }
 818     else
 819     {
 820         if (Gbl_UseDefaultAmlFilename)
 821         {
 822             Gbl_OutputFilenamePrefix = strdup (Substring + 1);
 823         }
 824         *(Substring+1) = 0;
 825     }
 826
 827     return (AE_OK);
 828 }
 829 #endif