sys/contrib/dev/acpica/source/tools/acpisrc/asfile.c

   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 - 2018, 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 ((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 }