1 /****************************************************************************** 2 * 3 * Module Name: asfile - Main module for the acpi source processor utility 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 ***************************************************************************** 115 * 116 * Alternatively, you may choose to be licensed under the terms of the 117 * following license: 118 * 119 * Redistribution and use in source and binary forms, with or without 120 * modification, are permitted provided that the following conditions 121 * are met: 122 * 1. Redistributions of source code must retain the above copyright 123 * notice, this list of conditions, and the following disclaimer, 124 * without modification. 125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 126 * substantially similar to the "NO WARRANTY" disclaimer below 127 * ("Disclaimer") and any redistribution must be conditioned upon 128 * including a substantially similar Disclaimer requirement for further 129 * binary redistribution. 130 * 3. Neither the names of the above-listed copyright holders nor the names 131 * of any contributors may be used to endorse or promote products derived 132 * from this software without specific prior written permission. 133 * 134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 145 * 146 * Alternatively, you may choose to be licensed under the terms of the 147 * GNU General Public License ("GPL") version 2 as published by the Free 148 * Software Foundation. 149 * 150 *****************************************************************************/ 151 152 #include "acpisrc.h" 153 154 /* Local prototypes */ 155 156 void 157 AsDoWildcard ( 158 ACPI_CONVERSION_TABLE *ConversionTable, 159 char *SourcePath, 160 char *TargetPath, 161 int MaxPathLength, 162 int FileType, 163 char *WildcardSpec); 164 165 BOOLEAN 166 AsDetectLoneLineFeeds ( 167 char *Filename, 168 char *Buffer); 169 170 static BOOLEAN 171 AsCheckForNonPrintableChars ( 172 char *FileBuffer, 173 UINT32 FileSize); 174 175 static ACPI_INLINE int 176 AsMaxInt (int a, int b) 177 { 178 return (a > b ? a : b); 179 } 180 181 182 /****************************************************************************** 183 * 184 * FUNCTION: AsDoWildcard 185 * 186 * DESCRIPTION: Process files via wildcards 187 * 188 ******************************************************************************/ 189 190 void 191 AsDoWildcard ( 192 ACPI_CONVERSION_TABLE *ConversionTable, 193 char *SourcePath, 194 char *TargetPath, 195 int MaxPathLength, 196 int FileType, 197 char *WildcardSpec) 198 { 199 void *DirInfo; 200 char *Filename; 201 char *SourceDirPath; 202 char *TargetDirPath; 203 char RequestedFileType; 204 205 206 if (FileType == FILE_TYPE_DIRECTORY) 207 { 208 RequestedFileType = REQUEST_DIR_ONLY; 209 } 210 else 211 { 212 RequestedFileType = REQUEST_FILE_ONLY; 213 } 214 215 VERBOSE_PRINT (("Checking for %s source files in directory \"%s\"\n", 216 WildcardSpec, SourcePath)); 217 218 /* Open the directory for wildcard search */ 219 220 DirInfo = AcpiOsOpenDirectory (SourcePath, WildcardSpec, RequestedFileType); 221 if (DirInfo) 222 { 223 /* 224 * Get all of the files that match both the 225 * wildcard and the requested file type 226 */ 227 while ((Filename = AcpiOsGetNextFilename (DirInfo))) 228 { 229 /* Looking for directory files, must check file type */ 230 231 switch (RequestedFileType) 232 { 233 case REQUEST_DIR_ONLY: 234 235 /* If we actually have a dir, process the subtree */ 236 237 if (!AsCheckForDirectory (SourcePath, TargetPath, Filename, 238 &SourceDirPath, &TargetDirPath)) 239 { 240 VERBOSE_PRINT (("Subdirectory: %s\n", Filename)); 241 242 AsProcessTree (ConversionTable, SourceDirPath, TargetDirPath); 243 free (SourceDirPath); 244 free (TargetDirPath); 245 } 246 break; 247 248 case REQUEST_FILE_ONLY: 249 250 /* Otherwise, this is a file, not a directory */ 251 252 VERBOSE_PRINT (("File: %s\n", Filename)); 253 254 AsProcessOneFile (ConversionTable, SourcePath, TargetPath, 255 MaxPathLength, Filename, FileType); 256 break; 257 258 default: 259 260 break; 261 } 262 } 263 264 /* Cleanup */ 265 266 AcpiOsCloseDirectory (DirInfo); 267 } 268 } 269 270 271 /****************************************************************************** 272 * 273 * FUNCTION: AsProcessTree 274 * 275 * DESCRIPTION: Process the directory tree. Files with the extension ".C" and 276 * ".H" are processed as the tree is traversed. 277 * 278 ******************************************************************************/ 279 280 ACPI_NATIVE_INT 281 AsProcessTree ( 282 ACPI_CONVERSION_TABLE *ConversionTable, 283 char *SourcePath, 284 char *TargetPath) 285 { 286 int MaxPathLength; 287 288 289 MaxPathLength = AsMaxInt (strlen (SourcePath), strlen (TargetPath)); 290 291 if (!(ConversionTable->Flags & FLG_NO_FILE_OUTPUT)) 292 { 293 if (ConversionTable->Flags & FLG_LOWERCASE_DIRNAMES) 294 { 295 AcpiUtStrlwr (TargetPath); 296 } 297 298 VERBOSE_PRINT (("Creating Directory \"%s\"\n", TargetPath)); 299 if (mkdir (TargetPath)) 300 { 301 if (errno != EEXIST) 302 { 303 printf ("Could not create target directory\n"); 304 return (-1); 305 } 306 } 307 } 308 309 /* Do the C source files */ 310 311 AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength, 312 FILE_TYPE_SOURCE, "*.c"); 313 314 /* Do the C header files */ 315 316 AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength, 317 FILE_TYPE_HEADER, "*.h"); 318 319 /* Do the Lex file(s) */ 320 321 AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength, 322 FILE_TYPE_SOURCE, "*.l"); 323 324 /* Do the yacc file(s) */ 325 326 AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength, 327 FILE_TYPE_SOURCE, "*.y"); 328 329 /* Do any ASL files */ 330 331 AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength, 332 FILE_TYPE_HEADER, "*.asl"); 333 334 /* Do any subdirectories */ 335 336 AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength, 337 FILE_TYPE_DIRECTORY, "*"); 338 339 return (0); 340 } 341 342 343 /****************************************************************************** 344 * 345 * FUNCTION: AsDetectLoneLineFeeds 346 * 347 * DESCRIPTION: Find LF without CR. 348 * 349 ******************************************************************************/ 350 351 BOOLEAN 352 AsDetectLoneLineFeeds ( 353 char *Filename, 354 char *Buffer) 355 { 356 UINT32 i = 1; 357 UINT32 LfCount = 0; 358 UINT32 LineCount = 0; 359 360 361 if (!Buffer[0]) 362 { 363 return (FALSE); 364 } 365 366 while (Buffer[i]) 367 { 368 if (Buffer[i] == 0x0A) 369 { 370 if (Buffer[i-1] != 0x0D) 371 { 372 LfCount++; 373 } 374 375 LineCount++; 376 } 377 i++; 378 } 379 380 if (LfCount) 381 { 382 if (LineCount == LfCount) 383 { 384 if (!Gbl_IgnoreLoneLineFeeds) 385 { 386 printf ("%s: ****File has UNIX format**** (LF only, not CR/LF) %u lines\n", 387 Filename, LfCount); 388 } 389 } 390 else 391 { 392 printf ("%s: %u lone linefeeds in file\n", Filename, LfCount); 393 } 394 395 return (TRUE); 396 } 397 398 return (FALSE); 399 } 400 401 402 /****************************************************************************** 403 * 404 * FUNCTION: AsConvertFile 405 * 406 * DESCRIPTION: Perform the requested transforms on the file buffer (as 407 * determined by the ConversionTable and the FileType). 408 * 409 ******************************************************************************/ 410 411 void 412 AsConvertFile ( 413 ACPI_CONVERSION_TABLE *ConversionTable, 414 char *FileBuffer, 415 char *Filename, 416 ACPI_NATIVE_INT FileType) 417 { 418 UINT32 i; 419 UINT32 Functions; 420 ACPI_STRING_TABLE *StringTable; 421 ACPI_IDENTIFIER_TABLE *ConditionalTable; 422 ACPI_IDENTIFIER_TABLE *LineTable; 423 ACPI_TYPED_IDENTIFIER_TABLE *StructTable; 424 ACPI_IDENTIFIER_TABLE *SpecialMacroTable; 425 char *SpdxHeader=NULL; 426 427 428 switch (FileType) 429 { 430 case FILE_TYPE_SOURCE: 431 432 Functions = ConversionTable->SourceFunctions; 433 StringTable = ConversionTable->SourceStringTable; 434 LineTable = ConversionTable->SourceLineTable; 435 ConditionalTable = ConversionTable->SourceConditionalTable; 436 StructTable = ConversionTable->SourceStructTable; 437 SpecialMacroTable = ConversionTable->SourceSpecialMacroTable; 438 SpdxHeader = ConversionTable->SourceSpdxHeader; 439 break; 440 441 case FILE_TYPE_HEADER: 442 443 Functions = ConversionTable->HeaderFunctions; 444 StringTable = ConversionTable->HeaderStringTable; 445 LineTable = ConversionTable->HeaderLineTable; 446 ConditionalTable = ConversionTable->HeaderConditionalTable; 447 StructTable = ConversionTable->HeaderStructTable; 448 SpecialMacroTable = ConversionTable->HeaderSpecialMacroTable; 449 SpdxHeader = ConversionTable->HeaderSpdxHeader; 450 break; 451 452 case FILE_TYPE_PATCH: 453 454 Functions = ConversionTable->PatchFunctions; 455 StringTable = ConversionTable->PatchStringTable; 456 LineTable = ConversionTable->PatchLineTable; 457 ConditionalTable = ConversionTable->PatchConditionalTable; 458 StructTable = ConversionTable->PatchStructTable; 459 SpecialMacroTable = ConversionTable->PatchSpecialMacroTable; 460 break; 461 462 default: 463 464 printf ("Unknown file type, cannot process\n"); 465 return; 466 } 467 468 469 Gbl_StructDefs = strstr (FileBuffer, "/* acpisrc:StructDefs"); 470 Gbl_Files++; 471 VERBOSE_PRINT (("Processing %u bytes\n", 472 (unsigned int) strlen (FileBuffer))); 473 474 if (Gbl_Cleanup) 475 { 476 AsRemoveExtraLines (FileBuffer, Filename); 477 AsRemoveSpacesAfterPeriod (FileBuffer, Filename); 478 } 479 480 if (ConversionTable->LowerCaseTable) 481 { 482 for (i = 0; ConversionTable->LowerCaseTable[i].Identifier; i++) 483 { 484 AsLowerCaseString (ConversionTable->LowerCaseTable[i].Identifier, 485 FileBuffer); 486 } 487 } 488 489 /* Process all the string replacements */ 490 491 if (StringTable) 492 { 493 for (i = 0; StringTable[i].Target; i++) 494 { 495 AsReplaceString (StringTable[i].Target, StringTable[i].Replacement, 496 StringTable[i].Type, FileBuffer); 497 } 498 } 499 500 if (LineTable) 501 { 502 for (i = 0; LineTable[i].Identifier; i++) 503 { 504 AsRemoveLine (FileBuffer, LineTable[i].Identifier); 505 } 506 } 507 508 if (ConditionalTable) 509 { 510 for (i = 0; ConditionalTable[i].Identifier; i++) 511 { 512 AsRemoveConditionalCompile (FileBuffer, ConditionalTable[i].Identifier); 513 } 514 } 515 516 #ifdef _OBSOLETE_FUNCTIONS 517 if (MacroTable) 518 { 519 for (i = 0; MacroTable[i].Identifier; i++) 520 { 521 AsRemoveMacro (FileBuffer, MacroTable[i].Identifier); 522 } 523 } 524 #endif 525 526 if (StructTable) 527 { 528 for (i = 0; StructTable[i].Identifier; i++) 529 { 530 AsInsertPrefix (FileBuffer, StructTable[i].Identifier, 531 StructTable[i].Type); 532 } 533 } 534 535 if (SpecialMacroTable) 536 { 537 for (i = 0; SpecialMacroTable[i].Identifier; i++) 538 { 539 AsCleanupSpecialMacro (FileBuffer, SpecialMacroTable[i].Identifier); 540 } 541 } 542 543 /* Process the function table */ 544 545 for (i = 0; i < 32; i++) 546 { 547 /* Decode the function bitmap */ 548 549 switch (((UINT32) 1 << i) & Functions) 550 { 551 case 0: 552 553 /* This function not configured */ 554 break; 555 556 case CVT_COUNT_TABS: 557 558 AsCountTabs (FileBuffer, Filename); 559 break; 560 561 case CVT_COUNT_NON_ANSI_COMMENTS: 562 563 AsCountNonAnsiComments (FileBuffer, Filename); 564 break; 565 566 case CVT_CHECK_BRACES: 567 568 AsCheckForBraces (FileBuffer, Filename); 569 break; 570 571 case CVT_TRIM_LINES: 572 573 AsTrimLines (FileBuffer, Filename); 574 break; 575 576 case CVT_COUNT_LINES: 577 578 AsCountSourceLines (FileBuffer, Filename); 579 break; 580 581 case CVT_BRACES_ON_SAME_LINE: 582 583 AsBracesOnSameLine (FileBuffer); 584 break; 585 586 case CVT_MIXED_CASE_TO_UNDERSCORES: 587 588 AsMixedCaseToUnderscores (FileBuffer, Filename); 589 break; 590 591 case CVT_LOWER_CASE_IDENTIFIERS: 592 593 AsLowerCaseIdentifiers (FileBuffer); 594 break; 595 596 case CVT_REMOVE_DEBUG_MACROS: 597 598 AsRemoveDebugMacros (FileBuffer); 599 break; 600 601 case CVT_TRIM_WHITESPACE: 602 603 AsTrimWhitespace (FileBuffer); 604 break; 605 606 case CVT_REMOVE_EMPTY_BLOCKS: 607 608 AsRemoveEmptyBlocks (FileBuffer, Filename); 609 break; 610 611 case CVT_REDUCE_TYPEDEFS: 612 613 AsReduceTypedefs (FileBuffer, "typedef union"); 614 AsReduceTypedefs (FileBuffer, "typedef struct"); 615 break; 616 617 case CVT_SPACES_TO_TABS4: 618 619 AsTabify4 (FileBuffer); 620 break; 621 622 case CVT_SPACES_TO_TABS8: 623 624 AsTabify8 (FileBuffer); 625 break; 626 627 case CVT_COUNT_SHORTMULTILINE_COMMENTS: 628 629 #ifdef ACPI_FUTURE_IMPLEMENTATION 630 AsTrimComments (FileBuffer, Filename); 631 #endif 632 break; 633 634 default: 635 636 printf ("Unknown conversion subfunction opcode\n"); 637 break; 638 } 639 } 640 641 if (ConversionTable->NewHeader) 642 { 643 AsReplaceHeader (FileBuffer, ConversionTable->NewHeader); 644 } 645 if (SpdxHeader) 646 { 647 AsDoSpdxHeader (FileBuffer, SpdxHeader); 648 } 649 } 650 651 /******************************************************************************* 652 * 653 * FUNCTION: AsCheckForNonPrintableChars 654 * 655 * PARAMETERS: FileBuffer - Buffer with contents of entire file 656 * FileSize - Size of the file and buffer 657 * 658 * RETURN: TRUE if there are no non-printable characters 659 * 660 * DESCRIPTION: Scan a file for any non-printable ASCII bytes. 661 * 662 ******************************************************************************/ 663 664 static BOOLEAN 665 AsCheckForNonPrintableChars ( 666 char *FileBuffer, 667 UINT32 FileSize) 668 { 669 BOOLEAN Found = TRUE; 670 UINT8 Byte; 671 UINT32 i; 672 673 674 /* Scan entire file for any non-printable characters */ 675 676 for (i = 0; i < FileSize; i++) 677 { 678 Byte = FileBuffer[i]; 679 if (!isprint (Byte) && !isspace (Byte)) 680 { 681 printf ( "Non-printable character (0x%2.2X) " 682 "at file offset: %8u (0x%X)\n", Byte, i, i); 683 Found = FALSE; 684 } 685 } 686 687 return (Found); 688 } 689 690 691 /****************************************************************************** 692 * 693 * FUNCTION: AsProcessOneFile 694 * 695 * DESCRIPTION: Process one source file. The file is opened, read entirely 696 * into a buffer, converted, then written to a new file. 697 * 698 ******************************************************************************/ 699 700 ACPI_NATIVE_INT 701 AsProcessOneFile ( 702 ACPI_CONVERSION_TABLE *ConversionTable, 703 char *SourcePath, 704 char *TargetPath, 705 int MaxPathLength, 706 char *Filename, 707 ACPI_NATIVE_INT FileType) 708 { 709 char *Pathname; 710 char *OutPathname; 711 int Status = 0; 712 713 714 /* Allocate a file pathname buffer for both source and target */ 715 716 Pathname = calloc (MaxPathLength + strlen (Filename) + 2, 1); 717 if (!Pathname) 718 { 719 printf ("Could not allocate buffer for file pathnames\n"); 720 return (-1); 721 } 722 723 Gbl_FileType = FileType; 724 725 /* Generate the source pathname and read the file */ 726 727 if (SourcePath) 728 { 729 strcpy (Pathname, SourcePath); 730 strcat (Pathname, "/"); 731 } 732 733 strcat (Pathname, Filename); 734 if (AsGetFile (Pathname, &Gbl_FileBuffer, &Gbl_FileSize)) 735 { 736 Status = -1; 737 goto Exit1; 738 } 739 740 /* Exit now if simply checking the file for printable ascii chars */ 741 742 if (Gbl_CheckAscii) 743 { 744 Status = 0; 745 goto Exit2; 746 } 747 748 Gbl_HeaderSize = 0; 749 if (strstr (Filename, ".asl")) 750 { 751 Gbl_HeaderSize = LINES_IN_ASL_HEADER; /* Lines in default ASL header */ 752 } 753 else if (strstr (Gbl_FileBuffer, LEGAL_HEADER_SIGNATURE)) 754 { 755 Gbl_HeaderSize = LINES_IN_LEGAL_HEADER; /* Normal C file and H header */ 756 } 757 else if (strstr (Gbl_FileBuffer, LINUX_HEADER_SIGNATURE)) 758 { 759 Gbl_HeaderSize = LINES_IN_LINUX_HEADER; /* Linuxized C file and H header */ 760 } 761 762 /* Process the file in the buffer */ 763 764 Gbl_MadeChanges = FALSE; 765 if (!Gbl_IgnoreLoneLineFeeds && Gbl_HasLoneLineFeeds) 766 { 767 /* 768 * All lone LFs will be converted to CR/LF 769 * (when file is written, Windows version only) 770 */ 771 printf ("Converting lone linefeeds\n"); 772 Gbl_MadeChanges = TRUE; 773 } 774 775 AsConvertFile (ConversionTable, Gbl_FileBuffer, Pathname, FileType); 776 777 if (!(ConversionTable->Flags & FLG_NO_FILE_OUTPUT)) 778 { 779 if (!(Gbl_Overwrite && !Gbl_MadeChanges)) 780 { 781 /* Generate the target pathname and write the file */ 782 783 OutPathname = calloc (MaxPathLength + 784 strlen (Filename) + 2 + strlen (TargetPath), 1); 785 if (!OutPathname) 786 { 787 printf ("Could not allocate buffer for file pathnames\n"); 788 Status = -1; 789 goto Exit2; 790 } 791 792 strcpy (OutPathname, TargetPath); 793 if (SourcePath) 794 { 795 strcat (OutPathname, "/"); 796 strcat (OutPathname, Filename); 797 } 798 799 AsPutFile (OutPathname, Gbl_FileBuffer, ConversionTable->Flags); 800 free (OutPathname); 801 } 802 } 803 804 Exit2: 805 free (Gbl_FileBuffer); 806 807 Exit1: 808 free (Pathname); 809 return (Status); 810 } 811 812 813 /****************************************************************************** 814 * 815 * FUNCTION: AsCheckForDirectory 816 * 817 * DESCRIPTION: Check if the current file is a valid directory. If not, 818 * construct the full pathname for the source and target paths. 819 * Checks for the dot and dot-dot files (they are ignored) 820 * 821 ******************************************************************************/ 822 823 ACPI_NATIVE_INT 824 AsCheckForDirectory ( 825 char *SourceDirPath, 826 char *TargetDirPath, 827 char *Filename, 828 char **SourcePath, 829 char **TargetPath) 830 { 831 char *SrcPath; 832 char *TgtPath; 833 834 835 if (!(strcmp (Filename, ".")) || 836 !(strcmp (Filename, ".."))) 837 { 838 return (-1); 839 } 840 841 SrcPath = calloc (strlen (SourceDirPath) + strlen (Filename) + 2, 1); 842 if (!SrcPath) 843 { 844 printf ("Could not allocate buffer for directory source pathname\n"); 845 return (-1); 846 } 847 848 TgtPath = calloc (strlen (TargetDirPath) + strlen (Filename) + 2, 1); 849 if (!TgtPath) 850 { 851 printf ("Could not allocate buffer for directory target pathname\n"); 852 free (SrcPath); 853 return (-1); 854 } 855 856 strcpy (SrcPath, SourceDirPath); 857 strcat (SrcPath, "/"); 858 strcat (SrcPath, Filename); 859 860 strcpy (TgtPath, TargetDirPath); 861 strcat (TgtPath, "/"); 862 strcat (TgtPath, Filename); 863 864 *SourcePath = SrcPath; 865 *TargetPath = TgtPath; 866 return (0); 867 } 868 869 870 /****************************************************************************** 871 * 872 * FUNCTION: AsGetFile 873 * 874 * DESCRIPTION: Open a file and read it entirely into a an allocated buffer 875 * 876 ******************************************************************************/ 877 878 int 879 AsGetFile ( 880 char *Filename, 881 char **FileBuffer, 882 UINT32 *FileSize) 883 { 884 FILE *File; 885 UINT32 Size; 886 char *Buffer; 887 size_t Actual; 888 889 890 /* Binary mode leaves CR/LF pairs */ 891 892 File = fopen (Filename, "rb"); 893 if (!File) 894 { 895 printf ("Could not open file %s\n", Filename); 896 return (-1); 897 } 898 899 /* Need file size to allocate a buffer */ 900 901 Size = CmGetFileSize (File); 902 if (Size == ACPI_UINT32_MAX) 903 { 904 printf ("Could not get file size for %s\n", Filename); 905 goto ErrorExit; 906 } 907 908 /* 909 * Create a buffer for the entire file 910 * Add plenty extra buffer to accommodate string replacements 911 */ 912 Gbl_TotalSize += Size; 913 914 Buffer = calloc (Size * 2, 1); 915 if (!Buffer) 916 { 917 printf ("Could not allocate buffer of size %u\n", Size * 2); 918 goto ErrorExit; 919 } 920 921 /* Read the entire file */ 922 923 Actual = fread (Buffer, 1, Size, File); 924 if (Actual != Size) 925 { 926 printf ("Could not read the input file %s (%u bytes)\n", 927 Filename, Size); 928 goto ErrorFree; 929 } 930 931 Buffer [Size] = 0; /* Null terminate the buffer */ 932 fclose (File); 933 934 /* This option checks the entire file for non-printable chars */ 935 936 if (Gbl_CheckAscii) 937 { 938 if (AsCheckForNonPrintableChars (Buffer, Size)) 939 { 940 printf ("File contains only printable ASCII characters\n"); 941 } 942 943 free (Buffer); 944 return (0); 945 } 946 947 /* Check for unix contamination */ 948 949 Gbl_HasLoneLineFeeds = AsDetectLoneLineFeeds (Filename, Buffer); 950 951 /* 952 * Convert all CR/LF pairs to LF only. We do this locally so that 953 * this code is portable across operating systems. 954 */ 955 AsConvertToLineFeeds (Buffer); 956 957 *FileBuffer = Buffer; 958 *FileSize = Size; 959 return (0); 960 961 ErrorFree: 962 free (Buffer); 963 964 ErrorExit: 965 fclose (File); 966 return (-1); 967 } 968 969 970 /****************************************************************************** 971 * 972 * FUNCTION: AsPutFile 973 * 974 * DESCRIPTION: Create a new output file and write the entire contents of the 975 * buffer to the new file. Buffer must be a zero terminated string 976 * 977 ******************************************************************************/ 978 979 int 980 AsPutFile ( 981 char *Pathname, 982 char *FileBuffer, 983 UINT32 SystemFlags) 984 { 985 FILE *File; 986 UINT32 FileSize; 987 size_t Actual; 988 int Status = 0; 989 990 991 /* Create the target file */ 992 993 if (!(SystemFlags & FLG_NO_CARRIAGE_RETURNS)) 994 { 995 /* Put back the CR before each LF */ 996 997 AsInsertCarriageReturns (FileBuffer); 998 } 999 1000 File = fopen (Pathname, "w+b"); 1001 if (!File) 1002 { 1003 perror ("Could not create destination file"); 1004 printf ("Could not create destination file \"%s\"\n", Pathname); 1005 return (-1); 1006 } 1007 1008 /* Write the buffer to the file */ 1009 1010 FileSize = strlen (FileBuffer); 1011 Actual = fwrite (FileBuffer, 1, FileSize, File); 1012 if (Actual != FileSize) 1013 { 1014 printf ("Error writing output file \"%s\"\n", Pathname); 1015 Status = -1; 1016 } 1017 1018 fclose (File); 1019 return (Status); 1020 } 1021