1 2 /****************************************************************************** 3 * 4 * Module Name: aslfiles - file I/O suppoert 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2011, Intel Corp. 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions, and the following disclaimer, 17 * without modification. 18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 19 * substantially similar to the "NO WARRANTY" disclaimer below 20 * ("Disclaimer") and any redistribution must be conditioned upon 21 * including a substantially similar Disclaimer requirement for further 22 * binary redistribution. 23 * 3. Neither the names of the above-listed copyright holders nor the names 24 * of any contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * Alternatively, this software may be distributed under the terms of the 28 * GNU General Public License ("GPL") version 2 as published by the Free 29 * Software Foundation. 30 * 31 * NO WARRANTY 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 42 * POSSIBILITY OF SUCH DAMAGES. 43 */ 44 45 #include <contrib/dev/acpica/compiler/aslcompiler.h> 46 #include <contrib/dev/acpica/include/acapps.h> 47 48 #define _COMPONENT ACPI_COMPILER 49 ACPI_MODULE_NAME ("aslfiles") 50 51 /* Local prototypes */ 52 53 static FILE * 54 FlOpenIncludeWithPrefix ( 55 char *PrefixDir, 56 char *Filename); 57 58 59 #ifdef ACPI_OBSOLETE_FUNCTIONS 60 ACPI_STATUS 61 FlParseInputPathname ( 62 char *InputFilename); 63 #endif 64 65 66 /******************************************************************************* 67 * 68 * FUNCTION: AslAbort 69 * 70 * PARAMETERS: None 71 * 72 * RETURN: None 73 * 74 * DESCRIPTION: Dump the error log and abort the compiler. Used for serious 75 * I/O errors 76 * 77 ******************************************************************************/ 78 79 void 80 AslAbort ( 81 void) 82 { 83 84 AePrintErrorLog (ASL_FILE_STDOUT); 85 if (Gbl_DebugFlag) 86 { 87 /* Print error summary to the debug file */ 88 89 AePrintErrorLog (ASL_FILE_STDERR); 90 } 91 92 exit (1); 93 } 94 95 96 /******************************************************************************* 97 * 98 * FUNCTION: FlFileError 99 * 100 * PARAMETERS: FileId - Index into file info array 101 * ErrorId - Index into error message array 102 * 103 * RETURN: None 104 * 105 * DESCRIPTION: Decode errno to an error message and add the entire error 106 * to the error log. 107 * 108 ******************************************************************************/ 109 110 void 111 FlFileError ( 112 UINT32 FileId, 113 UINT8 ErrorId) 114 { 115 116 sprintf (MsgBuffer, "\"%s\" (%s)", Gbl_Files[FileId].Filename, 117 strerror (errno)); 118 AslCommonError (ASL_ERROR, ErrorId, 0, 0, 0, 0, NULL, MsgBuffer); 119 } 120 121 122 /******************************************************************************* 123 * 124 * FUNCTION: FlOpenFile 125 * 126 * PARAMETERS: FileId - Index into file info array 127 * Filename - file pathname to open 128 * Mode - Open mode for fopen 129 * 130 * RETURN: None 131 * 132 * DESCRIPTION: Open a file. 133 * NOTE: Aborts compiler on any error. 134 * 135 ******************************************************************************/ 136 137 void 138 FlOpenFile ( 139 UINT32 FileId, 140 char *Filename, 141 char *Mode) 142 { 143 FILE *File; 144 145 146 File = fopen (Filename, Mode); 147 148 Gbl_Files[FileId].Filename = Filename; 149 Gbl_Files[FileId].Handle = File; 150 151 if (!File) 152 { 153 FlFileError (FileId, ASL_MSG_OPEN); 154 AslAbort (); 155 } 156 } 157 158 159 /******************************************************************************* 160 * 161 * FUNCTION: FlGetFileSize 162 * 163 * PARAMETERS: FileId - Index into file info array 164 * 165 * RETURN: File Size 166 * 167 * DESCRIPTION: Get current file size. Uses seek-to-EOF. File must be open. 168 * 169 ******************************************************************************/ 170 171 UINT32 172 FlGetFileSize ( 173 UINT32 FileId) 174 { 175 FILE *fp; 176 UINT32 FileSize; 177 long Offset; 178 179 180 fp = Gbl_Files[FileId].Handle; 181 Offset = ftell (fp); 182 183 fseek (fp, 0, SEEK_END); 184 FileSize = (UINT32) ftell (fp); 185 186 /* Restore file pointer */ 187 188 fseek (fp, Offset, SEEK_SET); 189 return (FileSize); 190 } 191 192 193 /******************************************************************************* 194 * 195 * FUNCTION: FlReadFile 196 * 197 * PARAMETERS: FileId - Index into file info array 198 * Buffer - Where to place the data 199 * Length - Amount to read 200 * 201 * RETURN: Status. AE_ERROR indicates EOF. 202 * 203 * DESCRIPTION: Read data from an open file. 204 * NOTE: Aborts compiler on any error. 205 * 206 ******************************************************************************/ 207 208 ACPI_STATUS 209 FlReadFile ( 210 UINT32 FileId, 211 void *Buffer, 212 UINT32 Length) 213 { 214 UINT32 Actual; 215 216 217 /* Read and check for error */ 218 219 Actual = fread (Buffer, 1, Length, Gbl_Files[FileId].Handle); 220 if (Actual != Length) 221 { 222 if (feof (Gbl_Files[FileId].Handle)) 223 { 224 /* End-of-file, just return error */ 225 226 return (AE_ERROR); 227 } 228 229 FlFileError (FileId, ASL_MSG_READ); 230 AslAbort (); 231 } 232 233 return (AE_OK); 234 } 235 236 237 /******************************************************************************* 238 * 239 * FUNCTION: FlWriteFile 240 * 241 * PARAMETERS: FileId - Index into file info array 242 * Buffer - Data to write 243 * Length - Amount of data to write 244 * 245 * RETURN: None 246 * 247 * DESCRIPTION: Write data to an open file. 248 * NOTE: Aborts compiler on any error. 249 * 250 ******************************************************************************/ 251 252 void 253 FlWriteFile ( 254 UINT32 FileId, 255 void *Buffer, 256 UINT32 Length) 257 { 258 UINT32 Actual; 259 260 261 /* Write and check for error */ 262 263 Actual = fwrite ((char *) Buffer, 1, Length, Gbl_Files[FileId].Handle); 264 if (Actual != Length) 265 { 266 FlFileError (FileId, ASL_MSG_WRITE); 267 AslAbort (); 268 } 269 } 270 271 272 /******************************************************************************* 273 * 274 * FUNCTION: FlPrintFile 275 * 276 * PARAMETERS: FileId - Index into file info array 277 * Format - Printf format string 278 * ... - Printf arguments 279 * 280 * RETURN: None 281 * 282 * DESCRIPTION: Formatted write to an open file. 283 * NOTE: Aborts compiler on any error. 284 * 285 ******************************************************************************/ 286 287 void 288 FlPrintFile ( 289 UINT32 FileId, 290 char *Format, 291 ...) 292 { 293 INT32 Actual; 294 va_list Args; 295 296 297 va_start (Args, Format); 298 299 Actual = vfprintf (Gbl_Files[FileId].Handle, Format, Args); 300 va_end (Args); 301 302 if (Actual == -1) 303 { 304 FlFileError (FileId, ASL_MSG_WRITE); 305 AslAbort (); 306 } 307 } 308 309 310 /******************************************************************************* 311 * 312 * FUNCTION: FlSeekFile 313 * 314 * PARAMETERS: FileId - Index into file info array 315 * Offset - Absolute byte offset in file 316 * 317 * RETURN: None 318 * 319 * DESCRIPTION: Seek to absolute offset 320 * NOTE: Aborts compiler on any error. 321 * 322 ******************************************************************************/ 323 324 void 325 FlSeekFile ( 326 UINT32 FileId, 327 long Offset) 328 { 329 int Error; 330 331 332 Error = fseek (Gbl_Files[FileId].Handle, Offset, SEEK_SET); 333 if (Error) 334 { 335 FlFileError (FileId, ASL_MSG_SEEK); 336 AslAbort (); 337 } 338 } 339 340 341 /******************************************************************************* 342 * 343 * FUNCTION: FlCloseFile 344 * 345 * PARAMETERS: FileId - Index into file info array 346 * 347 * RETURN: None 348 * 349 * DESCRIPTION: Close an open file. Aborts compiler on error 350 * 351 ******************************************************************************/ 352 353 void 354 FlCloseFile ( 355 UINT32 FileId) 356 { 357 int Error; 358 359 360 if (!Gbl_Files[FileId].Handle) 361 { 362 return; 363 } 364 365 Error = fclose (Gbl_Files[FileId].Handle); 366 Gbl_Files[FileId].Handle = NULL; 367 368 if (Error) 369 { 370 FlFileError (FileId, ASL_MSG_CLOSE); 371 AslAbort (); 372 } 373 374 return; 375 } 376 377 378 /******************************************************************************* 379 * 380 * FUNCTION: FlSetLineNumber 381 * 382 * PARAMETERS: Op - Parse node for the LINE asl statement 383 * 384 * RETURN: None. 385 * 386 * DESCRIPTION: Set the current line number 387 * 388 ******************************************************************************/ 389 390 void 391 FlSetLineNumber ( 392 ACPI_PARSE_OBJECT *Op) 393 { 394 395 Gbl_CurrentLineNumber = (UINT32) Op->Asl.Value.Integer; 396 Gbl_LogicalLineNumber = (UINT32) Op->Asl.Value.Integer; 397 } 398 399 400 /******************************************************************************* 401 * 402 * FUNCTION: FlAddIncludeDirectory 403 * 404 * PARAMETERS: Dir - Directory pathname string 405 * 406 * RETURN: None 407 * 408 * DESCRIPTION: Add a directory the list of include prefix directories. 409 * 410 ******************************************************************************/ 411 412 void 413 FlAddIncludeDirectory ( 414 char *Dir) 415 { 416 ASL_INCLUDE_DIR *NewDir; 417 ASL_INCLUDE_DIR *NextDir; 418 ASL_INCLUDE_DIR *PrevDir = NULL; 419 UINT32 NeedsSeparator = 0; 420 size_t DirLength; 421 422 423 DirLength = strlen (Dir); 424 if (!DirLength) 425 { 426 return; 427 } 428 429 /* Make sure that the pathname ends with a path separator */ 430 431 if ((Dir[DirLength-1] != '/') && 432 (Dir[DirLength-1] != '\\')) 433 { 434 NeedsSeparator = 1; 435 } 436 437 NewDir = ACPI_ALLOCATE_ZEROED (sizeof (ASL_INCLUDE_DIR)); 438 NewDir->Dir = ACPI_ALLOCATE (DirLength + 1 + NeedsSeparator); 439 strcpy (NewDir->Dir, Dir); 440 if (NeedsSeparator) 441 { 442 strcat (NewDir->Dir, "/"); 443 } 444 445 /* 446 * Preserve command line ordering of -I options by adding new elements 447 * at the end of the list 448 */ 449 NextDir = Gbl_IncludeDirList; 450 while (NextDir) 451 { 452 PrevDir = NextDir; 453 NextDir = NextDir->Next; 454 } 455 456 if (PrevDir) 457 { 458 PrevDir->Next = NewDir; 459 } 460 else 461 { 462 Gbl_IncludeDirList = NewDir; 463 } 464 } 465 466 467 /******************************************************************************* 468 * 469 * FUNCTION: FlOpenIncludeWithPrefix 470 * 471 * PARAMETERS: PrefixDir - Prefix directory pathname. Can be a zero 472 * length string. 473 * Filename - The include filename from the source ASL. 474 * 475 * RETURN: Valid file descriptor if successful. Null otherwise. 476 * 477 * DESCRIPTION: Open an include file and push it on the input file stack. 478 * 479 ******************************************************************************/ 480 481 static FILE * 482 FlOpenIncludeWithPrefix ( 483 char *PrefixDir, 484 char *Filename) 485 { 486 FILE *IncludeFile; 487 char *Pathname; 488 489 490 /* Build the full pathname to the file */ 491 492 Pathname = ACPI_ALLOCATE (strlen (PrefixDir) + strlen (Filename) + 1); 493 494 strcpy (Pathname, PrefixDir); 495 strcat (Pathname, Filename); 496 497 DbgPrint (ASL_PARSE_OUTPUT, "\nAttempt to open include file: path %s\n\n", 498 Pathname); 499 500 /* Attempt to open the file, push if successful */ 501 502 IncludeFile = fopen (Pathname, "r"); 503 if (IncludeFile) 504 { 505 /* Push the include file on the open input file stack */ 506 507 AslPushInputFileStack (IncludeFile, Pathname); 508 return (IncludeFile); 509 } 510 511 ACPI_FREE (Pathname); 512 return (NULL); 513 } 514 515 516 /******************************************************************************* 517 * 518 * FUNCTION: FlOpenIncludeFile 519 * 520 * PARAMETERS: Op - Parse node for the INCLUDE ASL statement 521 * 522 * RETURN: None. 523 * 524 * DESCRIPTION: Open an include file and push it on the input file stack. 525 * 526 ******************************************************************************/ 527 528 void 529 FlOpenIncludeFile ( 530 ACPI_PARSE_OBJECT *Op) 531 { 532 FILE *IncludeFile; 533 ASL_INCLUDE_DIR *NextDir; 534 535 536 /* Op must be valid */ 537 538 if (!Op) 539 { 540 AslCommonError (ASL_ERROR, ASL_MSG_INCLUDE_FILE_OPEN, 541 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber, 542 Gbl_InputByteCount, Gbl_CurrentColumn, 543 Gbl_Files[ASL_FILE_INPUT].Filename, " - Null parse node"); 544 545 return; 546 } 547 548 /* 549 * Flush out the "include ()" statement on this line, start 550 * the actual include file on the next line 551 */ 552 ResetCurrentLineBuffer (); 553 FlPrintFile (ASL_FILE_SOURCE_OUTPUT, "\n"); 554 Gbl_CurrentLineOffset++; 555 556 557 /* Attempt to open the include file */ 558 559 /* If the file specifies an absolute path, just open it */ 560 561 if ((Op->Asl.Value.String[0] == '/') || 562 (Op->Asl.Value.String[0] == '\\') || 563 (Op->Asl.Value.String[1] == ':')) 564 { 565 IncludeFile = FlOpenIncludeWithPrefix ("", Op->Asl.Value.String); 566 if (!IncludeFile) 567 { 568 goto ErrorExit; 569 } 570 return; 571 } 572 573 /* 574 * The include filename is not an absolute path. 575 * 576 * First, search for the file within the "local" directory -- meaning 577 * the same directory that contains the source file. 578 * 579 * Construct the file pathname from the global directory name. 580 */ 581 IncludeFile = FlOpenIncludeWithPrefix (Gbl_DirectoryPath, Op->Asl.Value.String); 582 if (IncludeFile) 583 { 584 return; 585 } 586 587 /* 588 * Second, search for the file within the (possibly multiple) directories 589 * specified by the -I option on the command line. 590 */ 591 NextDir = Gbl_IncludeDirList; 592 while (NextDir) 593 { 594 IncludeFile = FlOpenIncludeWithPrefix (NextDir->Dir, Op->Asl.Value.String); 595 if (IncludeFile) 596 { 597 return; 598 } 599 600 NextDir = NextDir->Next; 601 } 602 603 /* We could not open the include file after trying very hard */ 604 605 ErrorExit: 606 sprintf (MsgBuffer, "%s, %s", Op->Asl.Value.String, strerror (errno)); 607 AslError (ASL_ERROR, ASL_MSG_INCLUDE_FILE_OPEN, Op, MsgBuffer); 608 } 609 610 611 /******************************************************************************* 612 * 613 * FUNCTION: FlOpenInputFile 614 * 615 * PARAMETERS: InputFilename - The user-specified ASL source file to be 616 * compiled 617 * 618 * RETURN: Status 619 * 620 * DESCRIPTION: Open the specified input file, and save the directory path to 621 * the file so that include files can be opened in 622 * the same directory. 623 * 624 ******************************************************************************/ 625 626 ACPI_STATUS 627 FlOpenInputFile ( 628 char *InputFilename) 629 { 630 631 /* Open the input ASL file, text mode */ 632 633 FlOpenFile (ASL_FILE_INPUT, InputFilename, "r"); 634 AslCompilerin = Gbl_Files[ASL_FILE_INPUT].Handle; 635 636 return (AE_OK); 637 } 638 639 640 /******************************************************************************* 641 * 642 * FUNCTION: FlOpenAmlOutputFile 643 * 644 * PARAMETERS: FilenamePrefix - The user-specified ASL source file 645 * 646 * RETURN: Status 647 * 648 * DESCRIPTION: Create the output filename (*.AML) and open the file. The file 649 * is created in the same directory as the parent input file. 650 * 651 ******************************************************************************/ 652 653 ACPI_STATUS 654 FlOpenAmlOutputFile ( 655 char *FilenamePrefix) 656 { 657 char *Filename; 658 659 660 /* Output filename usually comes from the ASL itself */ 661 662 Filename = Gbl_Files[ASL_FILE_AML_OUTPUT].Filename; 663 if (!Filename) 664 { 665 /* Create the output AML filename */ 666 667 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_AML_CODE); 668 if (!Filename) 669 { 670 AslCommonError (ASL_ERROR, ASL_MSG_OUTPUT_FILENAME, 671 0, 0, 0, 0, NULL, NULL); 672 return (AE_ERROR); 673 } 674 } 675 676 /* Open the output AML file in binary mode */ 677 678 FlOpenFile (ASL_FILE_AML_OUTPUT, Filename, "w+b"); 679 return (AE_OK); 680 } 681 682 683 /******************************************************************************* 684 * 685 * FUNCTION: FlOpenMiscOutputFiles 686 * 687 * PARAMETERS: FilenamePrefix - The user-specified ASL source file 688 * 689 * RETURN: Status 690 * 691 * DESCRIPTION: Create and open the various output files needed, depending on 692 * the command line options 693 * 694 ******************************************************************************/ 695 696 ACPI_STATUS 697 FlOpenMiscOutputFiles ( 698 char *FilenamePrefix) 699 { 700 char *Filename; 701 702 703 /* Create/Open a hex output file if asked */ 704 705 if (Gbl_HexOutputFlag) 706 { 707 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_HEX_DUMP); 708 if (!Filename) 709 { 710 AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME, 711 0, 0, 0, 0, NULL, NULL); 712 return (AE_ERROR); 713 } 714 715 /* Open the hex file, text mode */ 716 717 FlOpenFile (ASL_FILE_HEX_OUTPUT, Filename, "w+"); 718 719 AslCompilerSignon (ASL_FILE_HEX_OUTPUT); 720 AslCompilerFileHeader (ASL_FILE_HEX_OUTPUT); 721 } 722 723 /* Create/Open a debug output file if asked */ 724 725 if (Gbl_DebugFlag) 726 { 727 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_DEBUG); 728 if (!Filename) 729 { 730 AslCommonError (ASL_ERROR, ASL_MSG_DEBUG_FILENAME, 731 0, 0, 0, 0, NULL, NULL); 732 return (AE_ERROR); 733 } 734 735 /* Open the debug file as STDERR, text mode */ 736 737 /* TBD: hide this behind a FlReopenFile function */ 738 739 Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Filename = Filename; 740 Gbl_Files[ASL_FILE_DEBUG_OUTPUT].Handle = 741 freopen (Filename, "w+t", stderr); 742 743 AslCompilerSignon (ASL_FILE_DEBUG_OUTPUT); 744 AslCompilerFileHeader (ASL_FILE_DEBUG_OUTPUT); 745 } 746 747 /* Create/Open a listing output file if asked */ 748 749 if (Gbl_ListingFlag) 750 { 751 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_LISTING); 752 if (!Filename) 753 { 754 AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME, 755 0, 0, 0, 0, NULL, NULL); 756 return (AE_ERROR); 757 } 758 759 /* Open the listing file, text mode */ 760 761 FlOpenFile (ASL_FILE_LISTING_OUTPUT, Filename, "w+"); 762 763 AslCompilerSignon (ASL_FILE_LISTING_OUTPUT); 764 AslCompilerFileHeader (ASL_FILE_LISTING_OUTPUT); 765 } 766 767 if (Gbl_FileType == ASL_INPUT_TYPE_ASCII_DATA) 768 { 769 return (AE_OK); 770 } 771 772 /* Create/Open a combined source output file */ 773 774 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_SOURCE); 775 if (!Filename) 776 { 777 AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME, 778 0, 0, 0, 0, NULL, NULL); 779 return (AE_ERROR); 780 } 781 782 /* 783 * Open the source output file, binary mode (so that LF does not get 784 * expanded to CR/LF on some systems, messing up our seek 785 * calculations.) 786 */ 787 FlOpenFile (ASL_FILE_SOURCE_OUTPUT, Filename, "w+b"); 788 789 /* Create/Open a assembly code source output file if asked */ 790 791 if (Gbl_AsmOutputFlag) 792 { 793 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_ASM_SOURCE); 794 if (!Filename) 795 { 796 AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME, 797 0, 0, 0, 0, NULL, NULL); 798 return (AE_ERROR); 799 } 800 801 /* Open the assembly code source file, text mode */ 802 803 FlOpenFile (ASL_FILE_ASM_SOURCE_OUTPUT, Filename, "w+"); 804 805 AslCompilerSignon (ASL_FILE_ASM_SOURCE_OUTPUT); 806 AslCompilerFileHeader (ASL_FILE_ASM_SOURCE_OUTPUT); 807 } 808 809 /* Create/Open a C code source output file if asked */ 810 811 if (Gbl_C_OutputFlag) 812 { 813 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_SOURCE); 814 if (!Filename) 815 { 816 AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME, 817 0, 0, 0, 0, NULL, NULL); 818 return (AE_ERROR); 819 } 820 821 /* Open the C code source file, text mode */ 822 823 FlOpenFile (ASL_FILE_C_SOURCE_OUTPUT, Filename, "w+"); 824 825 FlPrintFile (ASL_FILE_C_SOURCE_OUTPUT, "/*\n"); 826 AslCompilerSignon (ASL_FILE_C_SOURCE_OUTPUT); 827 AslCompilerFileHeader (ASL_FILE_C_SOURCE_OUTPUT); 828 } 829 830 /* Create/Open a assembly include output file if asked */ 831 832 if (Gbl_AsmIncludeOutputFlag) 833 { 834 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_ASM_INCLUDE); 835 if (!Filename) 836 { 837 AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME, 838 0, 0, 0, 0, NULL, NULL); 839 return (AE_ERROR); 840 } 841 842 /* Open the assembly include file, text mode */ 843 844 FlOpenFile (ASL_FILE_ASM_INCLUDE_OUTPUT, Filename, "w+"); 845 846 AslCompilerSignon (ASL_FILE_ASM_INCLUDE_OUTPUT); 847 AslCompilerFileHeader (ASL_FILE_ASM_INCLUDE_OUTPUT); 848 } 849 850 /* Create/Open a C include output file if asked */ 851 852 if (Gbl_C_IncludeOutputFlag) 853 { 854 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_C_INCLUDE); 855 if (!Filename) 856 { 857 AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME, 858 0, 0, 0, 0, NULL, NULL); 859 return (AE_ERROR); 860 } 861 862 /* Open the C include file, text mode */ 863 864 FlOpenFile (ASL_FILE_C_INCLUDE_OUTPUT, Filename, "w+"); 865 866 FlPrintFile (ASL_FILE_C_INCLUDE_OUTPUT, "/*\n"); 867 AslCompilerSignon (ASL_FILE_C_INCLUDE_OUTPUT); 868 AslCompilerFileHeader (ASL_FILE_C_INCLUDE_OUTPUT); 869 } 870 871 /* Create a namespace output file if asked */ 872 873 if (Gbl_NsOutputFlag) 874 { 875 Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_NAMESPACE); 876 if (!Filename) 877 { 878 AslCommonError (ASL_ERROR, ASL_MSG_LISTING_FILENAME, 879 0, 0, 0, 0, NULL, NULL); 880 return (AE_ERROR); 881 } 882 883 /* Open the namespace file, text mode */ 884 885 FlOpenFile (ASL_FILE_NAMESPACE_OUTPUT, Filename, "w+"); 886 887 AslCompilerSignon (ASL_FILE_NAMESPACE_OUTPUT); 888 AslCompilerFileHeader (ASL_FILE_NAMESPACE_OUTPUT); 889 } 890 891 return (AE_OK); 892 } 893 894 895 #ifdef ACPI_OBSOLETE_FUNCTIONS 896 /******************************************************************************* 897 * 898 * FUNCTION: FlParseInputPathname 899 * 900 * PARAMETERS: InputFilename - The user-specified ASL source file to be 901 * compiled 902 * 903 * RETURN: Status 904 * 905 * DESCRIPTION: Split the input path into a directory and filename part 906 * 1) Directory part used to open include files 907 * 2) Filename part used to generate output filenames 908 * 909 ******************************************************************************/ 910 911 ACPI_STATUS 912 FlParseInputPathname ( 913 char *InputFilename) 914 { 915 char *Substring; 916 917 918 if (!InputFilename) 919 { 920 return (AE_OK); 921 } 922 923 /* Get the path to the input filename's directory */ 924 925 Gbl_DirectoryPath = strdup (InputFilename); 926 if (!Gbl_DirectoryPath) 927 { 928 return (AE_NO_MEMORY); 929 } 930 931 Substring = strrchr (Gbl_DirectoryPath, '\\'); 932 if (!Substring) 933 { 934 Substring = strrchr (Gbl_DirectoryPath, '/'); 935 if (!Substring) 936 { 937 Substring = strrchr (Gbl_DirectoryPath, ':'); 938 } 939 } 940 941 if (!Substring) 942 { 943 Gbl_DirectoryPath[0] = 0; 944 if (Gbl_UseDefaultAmlFilename) 945 { 946 Gbl_OutputFilenamePrefix = strdup (InputFilename); 947 } 948 } 949 else 950 { 951 if (Gbl_UseDefaultAmlFilename) 952 { 953 Gbl_OutputFilenamePrefix = strdup (Substring + 1); 954 } 955 *(Substring+1) = 0; 956 } 957 958 return (AE_OK); 959 } 960 #endif 961 962 963