sys/contrib/dev/acpica-unix-20050211/tools/acpisrc/asremove.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: asremove - Source conversion - removal functions
   5  *              $Revision: 7 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
  14  * All rights reserved.
  15  *
  16  * 2. License
  17  *
  18  * 2.1. This is your license from Intel Corp. under its intellectual property
  19  * rights.  You may have additional license terms from the party that provided
  20  * you this software, covering your right to use that party's intellectual
  21  * property rights.
  22  *
  23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24  * copy of the source code appearing in this file ("Covered Code") an
  25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27  * make derivatives, distribute, use and display any portion of the Covered
  28  * Code in any form, with the right to sublicense such rights; and
  29  *
  30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31  * license (with the right to sublicense), under only those claims of Intel
  32  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33  * offer to sell, and import the Covered Code and derivative works thereof
  34  * solely to the minimum extent necessary to exercise the above copyright
  35  * license, and in no event shall the patent license extend to any additions
  36  * to or modifications of the Original Intel Code.  No other license or right
  37  * is granted directly or by implication, estoppel or otherwise;
  38  *
  39  * The above copyright and patent license is granted only if the following
  40  * conditions are met:
  41  *
  42  * 3. Conditions
  43  *
  44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45  * Redistribution of source code of any substantial portion of the Covered
  46  * Code or modification with rights to further distribute source must include
  47  * the above Copyright Notice, the above License, this list of Conditions,
  48  * and the following Disclaimer and Export Compliance provision.  In addition,
  49  * Licensee must cause all Covered Code to which Licensee contributes to
  50  * contain a file documenting the changes Licensee made to create that Covered
  51  * Code and the date of any change.  Licensee must include in that file the
  52  * documentation of any changes made by any predecessor Licensee.  Licensee
  53  * must include a prominent statement that the modification is derived,
  54  * directly or indirectly, from Original Intel Code.
  55  *
  56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57  * Redistribution of source code of any substantial portion of the Covered
  58  * Code or modification without rights to further distribute source must
  59  * include the following Disclaimer and Export Compliance provision in the
  60  * documentation and/or other materials provided with distribution.  In
  61  * addition, Licensee may not authorize further sublicense of source of any
  62  * portion of the Covered Code, and must include terms to the effect that the
  63  * license from Licensee to its licensee is limited to the intellectual
  64  * property embodied in the software Licensee provides to its licensee, and
  65  * not to intellectual property embodied in modifications its licensee may
  66  * make.
  67  *
  68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69  * substantial portion of the Covered Code or modification must reproduce the
  70  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71  * provision in the documentation and/or other materials provided with the
  72  * distribution.
  73  *
  74  * 3.4. Intel retains all right, title, and interest in and to the Original
  75  * Intel Code.
  76  *
  77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79  * other dealings in products derived from or relating to the Covered Code
  80  * without prior written authorization from Intel.
  81  *
  82  * 4. Disclaimer and Export Compliance
  83  *
  84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118 #include "acpisrc.h"
 119
 120
 121 /******************************************************************************
 122  *
 123  * FUNCTION:    AsRemoveStatement
 124  *
 125  * DESCRIPTION: Remove all statements that contain the given keyword.
 126  *              Limitations:  Removes text from the start of the line that
 127  *              contains the keyword to the next semicolon.  Currently
 128  *              doesn't ignore comments.
 129  *
 130  ******************************************************************************/
 131
 132 void
 133 AsRemoveStatement (
 134     char                    *Buffer,
 135     char                    *Keyword,
 136     UINT32                  Type)
 137 {
 138     char                    *SubString;
 139     char                    *SubBuffer;
 140     int                     KeywordLength;
 141
 142
 143     KeywordLength = strlen (Keyword);
 144     SubBuffer = Buffer;
 145     SubString = Buffer;
 146
 147
 148     while (SubString)
 149     {
 150         SubString = strstr (SubBuffer, Keyword);
 151
 152         if (SubString)
 153         {
 154             SubBuffer = SubString;
 155
 156             if ((Type == REPLACE_WHOLE_WORD) &&
 157                 (!AsMatchExactWord (SubString, KeywordLength)))
 158             {
 159                 SubBuffer++;
 160                 continue;
 161             }
 162
 163             /* Find start of this line */
 164
 165             while (*SubString != '\n')
 166             {
 167                 SubString--;
 168             }
 169             SubString++;
 170
 171             /* Find end of this statement */
 172
 173             SubBuffer = AsSkipPastChar (SubBuffer, ';');
 174             if (!SubBuffer)
 175             {
 176                 return;
 177             }
 178
 179             /* Find end of this line */
 180
 181             SubBuffer = AsSkipPastChar (SubBuffer, '\n');
 182             if (!SubBuffer)
 183             {
 184                 return;
 185             }
 186
 187             /* If next line is blank, remove it too */
 188
 189             if (*SubBuffer == '\n')
 190             {
 191                 SubBuffer++;
 192             }
 193
 194             /* Remove the lines */
 195
 196             SubBuffer = AsRemoveData (SubString, SubBuffer);
 197         }
 198     }
 199 }
 200
 201
 202 /******************************************************************************
 203  *
 204  * FUNCTION:    AsRemoveConditionalCompile
 205  *
 206  * DESCRIPTION: Remove a "#ifdef" statement, and all text that it encompasses.
 207  *              Limitations: cannot handle nested ifdefs.
 208  *
 209  ******************************************************************************/
 210
 211 void
 212 AsRemoveConditionalCompile (
 213     char                    *Buffer,
 214     char                    *Keyword)
 215 {
 216     char                    *SubString;
 217     char                    *SubBuffer;
 218     char                    *IfPtr;
 219     char                    *EndifPtr;
 220     char                    *ElsePtr;
 221     char                    *Comment;
 222     int                     KeywordLength;
 223
 224
 225     KeywordLength = strlen (Keyword);
 226     SubBuffer = Buffer;
 227     SubString = Buffer;
 228
 229
 230     while (SubString)
 231     {
 232         SubBuffer = strstr (SubString, Keyword);
 233         if (!SubBuffer)
 234         {
 235             return;
 236         }
 237
 238         /*
 239          * Check for translation escape string -- means to ignore
 240          * blocks of code while replacing
 241          */
 242         Comment = strstr (SubString, "/*!");
 243
 244         if ((Comment) &&
 245             (Comment < SubBuffer))
 246         {
 247             SubString = strstr (Comment, "!*/");
 248             if (!SubString)
 249             {
 250                 return;
 251             }
 252
 253             SubString += 3;
 254             continue;
 255         }
 256
 257         /* Check for ordinary comment */
 258
 259         Comment = strstr (SubString, "/*");
 260
 261         if ((Comment) &&
 262             (Comment < SubBuffer))
 263         {
 264             SubString = strstr (Comment, "*/");
 265             if (!SubString)
 266             {
 267                 return;
 268             }
 269
 270             SubString += 2;
 271             continue;
 272         }
 273
 274         SubString = SubBuffer;
 275         if (!AsMatchExactWord (SubString, KeywordLength))
 276         {
 277             SubString++;
 278             continue;
 279         }
 280
 281         /* Find start of this line */
 282
 283         while (*SubString != '\n' && (SubString > Buffer))
 284         {
 285             SubString--;
 286         }
 287         SubString++;
 288
 289         /* Find the "#ifxxxx" */
 290
 291         IfPtr = strstr (SubString, "#if");
 292         if (!IfPtr)
 293         {
 294             return;
 295         }
 296
 297         if (IfPtr > SubBuffer)
 298         {
 299             /* Not the right #if */
 300
 301             SubString = SubBuffer + strlen (Keyword);
 302             continue;
 303         }
 304
 305         /* Find closing #endif or #else */
 306
 307         EndifPtr = strstr (SubBuffer, "#endif");
 308         if (!EndifPtr)
 309         {
 310             /* There has to be an #endif */
 311
 312             return;
 313         }
 314
 315         ElsePtr = strstr (SubBuffer, "#else");
 316         if ((ElsePtr) &&
 317             (EndifPtr > ElsePtr))
 318         {
 319             /* This #ifdef contains an #else clause */
 320             /* Find end of this line */
 321
 322             SubBuffer = AsSkipPastChar (ElsePtr, '\n');
 323             if (!SubBuffer)
 324             {
 325                 return;
 326             }
 327
 328             /* Remove the #ifdef .... #else code */
 329
 330             AsRemoveData (SubString, SubBuffer);
 331
 332             /* Next, we will remove the #endif statement */
 333
 334             EndifPtr = strstr (SubString, "#endif");
 335             if (!EndifPtr)
 336             {
 337                 /* There has to be an #endif */
 338
 339                 return;
 340             }
 341
 342             SubString = EndifPtr;
 343         }
 344
 345         /* Remove the ... #endif part */
 346         /* Find end of this line */
 347
 348         SubBuffer = AsSkipPastChar (EndifPtr, '\n');
 349         if (!SubBuffer)
 350         {
 351             return;
 352         }
 353
 354         /* Remove the lines */
 355
 356         SubBuffer = AsRemoveData (SubString, SubBuffer);
 357     }
 358 }
 359
 360
 361 /******************************************************************************
 362  *
 363  * FUNCTION:    AsRemoveMacro
 364  *
 365  * DESCRIPTION: Remove every line that contains the keyword.  Does not
 366  *              skip comments.
 367  *
 368  ******************************************************************************/
 369
 370 void
 371 AsRemoveMacro (
 372     char                    *Buffer,
 373     char                    *Keyword)
 374 {
 375     char                    *SubString;
 376     char                    *SubBuffer;
 377     int                     NestLevel;
 378
 379
 380     SubBuffer = Buffer;
 381     SubString = Buffer;
 382
 383
 384     while (SubString)
 385     {
 386         SubString = strstr (SubBuffer, Keyword);
 387
 388         if (SubString)
 389         {
 390             SubBuffer = SubString;
 391
 392             /* Find start of the macro parameters */
 393
 394             while (*SubString != '(')
 395             {
 396                 SubString++;
 397             }
 398             SubString++;
 399
 400             /* Remove the macro name and opening paren */
 401
 402             SubString = AsRemoveData (SubBuffer, SubString);
 403
 404             NestLevel = 1;
 405             while (*SubString)
 406             {
 407                 if (*SubString == '(')
 408                 {
 409                     NestLevel++;
 410                 }
 411                 else if (*SubString == ')')
 412                 {
 413                     NestLevel--;
 414                 }
 415
 416                 SubString++;
 417
 418                 if (NestLevel == 0)
 419                 {
 420                     break;
 421                 }
 422             }
 423
 424             /* Remove the closing paren */
 425
 426             SubBuffer = AsRemoveData (SubString-1, SubString);
 427         }
 428     }
 429 }
 430
 431
 432 /******************************************************************************
 433  *
 434  * FUNCTION:    AsRemoveLine
 435  *
 436  * DESCRIPTION: Remove every line that contains the keyword.  Does not
 437  *              skip comments.
 438  *
 439  ******************************************************************************/
 440
 441 void
 442 AsRemoveLine (
 443     char                    *Buffer,
 444     char                    *Keyword)
 445 {
 446     char                    *SubString;
 447     char                    *SubBuffer;
 448
 449
 450     SubBuffer = Buffer;
 451     SubString = Buffer;
 452
 453
 454     while (SubString)
 455     {
 456         SubString = strstr (SubBuffer, Keyword);
 457
 458         if (SubString)
 459         {
 460             SubBuffer = SubString;
 461
 462             /* Find start of this line */
 463
 464             while (*SubString != '\n')
 465             {
 466                 SubString--;
 467             }
 468             SubString++;
 469
 470             /* Find end of this line */
 471
 472             SubBuffer = AsSkipPastChar (SubBuffer, '\n');
 473             if (!SubBuffer)
 474             {
 475                 return;
 476             }
 477
 478             /* Remove the line */
 479
 480             SubBuffer = AsRemoveData (SubString, SubBuffer);
 481         }
 482     }
 483 }
 484
 485
 486 /******************************************************************************
 487  *
 488  * FUNCTION:    AsReduceTypedefs
 489  *
 490  * DESCRIPTION: Eliminate certain typedefs
 491  *
 492  ******************************************************************************/
 493
 494 void
 495 AsReduceTypedefs (
 496     char                    *Buffer,
 497     char                    *Keyword)
 498 {
 499     char                    *SubString;
 500     char                    *SubBuffer;
 501     int                     NestLevel;
 502
 503
 504     SubBuffer = Buffer;
 505     SubString = Buffer;
 506
 507
 508     while (SubString)
 509     {
 510         SubString = strstr (SubBuffer, Keyword);
 511
 512         if (SubString)
 513         {
 514             /* Remove the typedef itself */
 515
 516             SubBuffer = SubString + strlen ("typedef") + 1;
 517             SubBuffer = AsRemoveData (SubString, SubBuffer);
 518
 519             /* Find the opening brace of the struct or union */
 520
 521             while (*SubString != '{')
 522             {
 523                 SubString++;
 524             }
 525             SubString++;
 526
 527             /* Find the closing brace.  Handles nested braces */
 528
 529             NestLevel = 1;
 530             while (*SubString)
 531             {
 532                 if (*SubString == '{')
 533                 {
 534                     NestLevel++;
 535                 }
 536                 else if (*SubString == '}')
 537                 {
 538                     NestLevel--;
 539                 }
 540
 541                 SubString++;
 542
 543                 if (NestLevel == 0)
 544                 {
 545                     break;
 546                 }
 547             }
 548
 549             /* Remove an extra line feed if present */
 550
 551             if (!strncmp (SubString - 3, "\n\n", 2))
 552             {
 553                 *(SubString -2) = '}';
 554                 SubString--;
 555             }
 556
 557             /* Find the end of the typedef name */
 558
 559             SubBuffer = AsSkipUntilChar (SubString, ';');
 560
 561             /* And remove the typedef name */
 562
 563             SubBuffer = AsRemoveData (SubString, SubBuffer);
 564         }
 565     }
 566 }
 567
 568
 569 /******************************************************************************
 570  *
 571  * FUNCTION:    AsRemoveEmptyBlocks
 572  *
 573  * DESCRIPTION: Remove any C blocks (e.g., if {}) that contain no code.  This
 574  *              can happen as a result of removing lines such as DEBUG_PRINT.
 575  *
 576  ******************************************************************************/
 577
 578 void
 579 AsRemoveEmptyBlocks (
 580     char                    *Buffer,
 581     char                    *Filename)
 582 {
 583     char                    *SubBuffer;
 584     char                    *BlockStart;
 585     BOOLEAN                 EmptyBlock = TRUE;
 586     BOOLEAN                 AnotherPassRequired = TRUE;
 587     UINT32                  BlockCount = 0;
 588
 589
 590     while (AnotherPassRequired)
 591     {
 592         SubBuffer = Buffer;
 593         AnotherPassRequired = FALSE;
 594
 595         while (*SubBuffer)
 596         {
 597             if (*SubBuffer == '{')
 598             {
 599                 BlockStart = SubBuffer;
 600                 EmptyBlock = TRUE;
 601
 602                 SubBuffer++;
 603                 while (*SubBuffer != '}')
 604                 {
 605                     if ((*SubBuffer != ' ') &&
 606                         (*SubBuffer != '\n'))
 607                     {
 608                         EmptyBlock = FALSE;
 609                         break;
 610                     }
 611                     SubBuffer++;
 612                 }
 613
 614                 if (EmptyBlock)
 615                 {
 616                     /* Find start of the first line of the block */
 617
 618                     while (*BlockStart != '\n')
 619                     {
 620                         BlockStart--;
 621                     }
 622
 623                     /* Find end of the last line of the block */
 624
 625                     SubBuffer = AsSkipUntilChar (SubBuffer, '\n');
 626                     if (!SubBuffer)
 627                     {
 628                         break;
 629                     }
 630
 631                     /* Remove the block */
 632
 633                     SubBuffer = AsRemoveData (BlockStart, SubBuffer);
 634                     BlockCount++;
 635                     AnotherPassRequired = TRUE;
 636                     continue;
 637                 }
 638             }
 639
 640             SubBuffer++;
 641         }
 642     }
 643
 644     if (BlockCount)
 645     {
 646         Gbl_MadeChanges = TRUE;
 647         AsPrint ("Code blocks deleted", BlockCount, Filename);
 648     }
 649 }
 650
 651
 652 /******************************************************************************
 653  *
 654  * FUNCTION:    AsRemoveDebugMacros
 655  *
 656  * DESCRIPTION: Remove all "Debug" macros -- macros that produce debug output.
 657  *
 658  ******************************************************************************/
 659
 660 void
 661 AsRemoveDebugMacros (
 662     char                    *Buffer)
 663 {
 664     AsRemoveConditionalCompile (Buffer, "ACPI_DEBUG_OUTPUT");
 665
 666     AsRemoveStatement (Buffer, "ACPI_DEBUG_PRINT",      REPLACE_WHOLE_WORD);
 667     AsRemoveStatement (Buffer, "ACPI_DEBUG_PRINT_RAW",  REPLACE_WHOLE_WORD);
 668     AsRemoveStatement (Buffer, "DEBUG_EXEC",            REPLACE_WHOLE_WORD);
 669     AsRemoveStatement (Buffer, "FUNCTION_ENTRY",        REPLACE_WHOLE_WORD);
 670     AsRemoveStatement (Buffer, "PROC_NAME",             REPLACE_WHOLE_WORD);
 671     AsRemoveStatement (Buffer, "FUNCTION_TRACE",        REPLACE_SUBSTRINGS);
 672     AsRemoveStatement (Buffer, "DUMP_",                 REPLACE_SUBSTRINGS);
 673
 674     AsReplaceString ("return_VOID",         "return", REPLACE_WHOLE_WORD, Buffer);
 675     AsReplaceString ("return_PTR",          "return", REPLACE_WHOLE_WORD, Buffer);
 676     AsReplaceString ("return_ACPI_STATUS",  "return", REPLACE_WHOLE_WORD, Buffer);
 677     AsReplaceString ("return_acpi_status",  "return", REPLACE_WHOLE_WORD, Buffer);
 678     AsReplaceString ("return_VALUE",        "return", REPLACE_WHOLE_WORD, Buffer);
 679 }
 680
 681