arch/all-pc/acpica/source/tools/acpisrc/asremove.c

   1 /******************************************************************************
   2  *
   3  * Module Name: asremove - Source conversion - removal functions
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include "acpisrc.h"
  45
  46 /* Local prototypes */
  47
  48 void
  49 AsRemoveStatement (
  50     char                    *Buffer,
  51     char                    *Keyword,
  52     UINT32                  Type);
  53
  54
  55 /******************************************************************************
  56  *
  57  * FUNCTION:    AsRemoveStatement
  58  *
  59  * DESCRIPTION: Remove all statements that contain the given keyword.
  60  *              Limitations:  Removes text from the start of the line that
  61  *              contains the keyword to the next semicolon. Currently
  62  *              doesn't ignore comments.
  63  *
  64  ******************************************************************************/
  65
  66 void
  67 AsRemoveStatement (
  68     char                    *Buffer,
  69     char                    *Keyword,
  70     UINT32                  Type)
  71 {
  72     char                    *SubString;
  73     char                    *SubBuffer;
  74     int                     KeywordLength;
  75
  76
  77     KeywordLength = strlen (Keyword);
  78     SubBuffer = Buffer;
  79     SubString = Buffer;
  80
  81
  82     while (SubString)
  83     {
  84         SubString = strstr (SubBuffer, Keyword);
  85
  86         if (SubString)
  87         {
  88             SubBuffer = SubString;
  89
  90             if ((Type == REPLACE_WHOLE_WORD) &&
  91                 (!AsMatchExactWord (SubString, KeywordLength)))
  92             {
  93                 SubBuffer++;
  94                 continue;
  95             }
  96
  97             /* Find start of this line */
  98
  99             while (*SubString != '\n')
 100             {
 101                 SubString--;
 102             }
 103             SubString++;
 104
 105             /* Find end of this statement */
 106
 107             SubBuffer = AsSkipPastChar (SubBuffer, ';');
 108             if (!SubBuffer)
 109             {
 110                 return;
 111             }
 112
 113             /* Find end of this line */
 114
 115             SubBuffer = AsSkipPastChar (SubBuffer, '\n');
 116             if (!SubBuffer)
 117             {
 118                 return;
 119             }
 120
 121             /* If next line is blank, remove it too */
 122
 123             if (*SubBuffer == '\n')
 124             {
 125                 SubBuffer++;
 126             }
 127
 128             /* Remove the lines */
 129
 130             SubBuffer = AsRemoveData (SubString, SubBuffer);
 131         }
 132     }
 133 }
 134
 135
 136 /******************************************************************************
 137  *
 138  * FUNCTION:    AsRemoveConditionalCompile
 139  *
 140  * DESCRIPTION: Remove a "#ifdef" statement, and all text that it encompasses.
 141  *              Limitations: cannot handle nested ifdefs.
 142  *
 143  ******************************************************************************/
 144
 145 void
 146 AsRemoveConditionalCompile (
 147     char                    *Buffer,
 148     char                    *Keyword)
 149 {
 150     char                    *SubString;
 151     char                    *SubBuffer;
 152     char                    *IfPtr;
 153     char                    *EndifPtr;
 154     char                    *ElsePtr;
 155     char                    *Comment;
 156     int                     KeywordLength;
 157
 158
 159     KeywordLength = strlen (Keyword);
 160     SubBuffer = Buffer;
 161     SubString = Buffer;
 162
 163
 164     while (SubString)
 165     {
 166         SubBuffer = strstr (SubString, Keyword);
 167         if (!SubBuffer)
 168         {
 169             return;
 170         }
 171
 172         /*
 173          * Check for translation escape string -- means to ignore
 174          * blocks of code while replacing
 175          */
 176         if (Gbl_IgnoreTranslationEscapes)
 177         {
 178             Comment = NULL;
 179         }
 180         else
 181         {
 182             Comment = strstr (SubString, AS_START_IGNORE);
 183         }
 184
 185         if ((Comment) &&
 186             (Comment < SubBuffer))
 187         {
 188             SubString = strstr (Comment, AS_STOP_IGNORE);
 189             if (!SubString)
 190             {
 191                 return;
 192             }
 193
 194             SubString += 3;
 195             continue;
 196         }
 197
 198         /* Check for ordinary comment */
 199
 200         Comment = strstr (SubString, "/*");
 201
 202         if ((Comment) &&
 203             (Comment < SubBuffer))
 204         {
 205             SubString = strstr (Comment, "*/");
 206             if (!SubString)
 207             {
 208                 return;
 209             }
 210
 211             SubString += 2;
 212             continue;
 213         }
 214
 215         SubString = SubBuffer;
 216         if (!AsMatchExactWord (SubString, KeywordLength))
 217         {
 218             SubString++;
 219             continue;
 220         }
 221
 222         /* Find start of this line */
 223
 224         while (*SubString != '\n' && (SubString > Buffer))
 225         {
 226             SubString--;
 227         }
 228         SubString++;
 229
 230         /* Find the "#ifxxxx" */
 231
 232         IfPtr = strstr (SubString, "#if");
 233         if (!IfPtr)
 234         {
 235             return;
 236         }
 237
 238         if (IfPtr > SubBuffer)
 239         {
 240             /* Not the right #if */
 241
 242             SubString = SubBuffer + strlen (Keyword);
 243             continue;
 244         }
 245
 246         /* Find closing #endif or #else */
 247
 248         EndifPtr = strstr (SubBuffer, "#endif");
 249         if (!EndifPtr)
 250         {
 251             /* There has to be an #endif */
 252
 253             return;
 254         }
 255
 256         ElsePtr = strstr (SubBuffer, "#else");
 257         if ((ElsePtr) &&
 258             (EndifPtr > ElsePtr))
 259         {
 260             /* This #ifdef contains an #else clause */
 261             /* Find end of this line */
 262
 263             SubBuffer = AsSkipPastChar (ElsePtr, '\n');
 264             if (!SubBuffer)
 265             {
 266                 return;
 267             }
 268
 269             /* Remove the #ifdef .... #else code */
 270
 271             AsRemoveData (SubString, SubBuffer);
 272
 273             /* Next, we will remove the #endif statement */
 274
 275             EndifPtr = strstr (SubString, "#endif");
 276             if (!EndifPtr)
 277             {
 278                 /* There has to be an #endif */
 279
 280                 return;
 281             }
 282
 283             SubString = EndifPtr;
 284         }
 285
 286         /* Remove the ... #endif part */
 287         /* Find end of this line */
 288
 289         SubBuffer = AsSkipPastChar (EndifPtr, '\n');
 290         if (!SubBuffer)
 291         {
 292             return;
 293         }
 294
 295         /* Remove the lines */
 296
 297         SubBuffer = AsRemoveData (SubString, SubBuffer);
 298     }
 299 }
 300
 301
 302 /******************************************************************************
 303  *
 304  * FUNCTION:    AsRemoveMacro
 305  *
 306  * DESCRIPTION: Remove every line that contains the keyword. Does not
 307  *              skip comments.
 308  *
 309  ******************************************************************************/
 310
 311 void
 312 AsRemoveMacro (
 313     char                    *Buffer,
 314     char                    *Keyword)
 315 {
 316     char                    *SubString;
 317     char                    *SubBuffer;
 318     int                     NestLevel;
 319
 320
 321     SubBuffer = Buffer;
 322     SubString = Buffer;
 323
 324
 325     while (SubString)
 326     {
 327         SubString = strstr (SubBuffer, Keyword);
 328
 329         if (SubString)
 330         {
 331             SubBuffer = SubString;
 332
 333             /* Find start of the macro parameters */
 334
 335             while (*SubString != '(')
 336             {
 337                 SubString++;
 338             }
 339             SubString++;
 340
 341             /* Remove the macro name and opening paren */
 342
 343             SubString = AsRemoveData (SubBuffer, SubString);
 344
 345             NestLevel = 1;
 346             while (*SubString)
 347             {
 348                 if (*SubString == '(')
 349                 {
 350                     NestLevel++;
 351                 }
 352                 else if (*SubString == ')')
 353                 {
 354                     NestLevel--;
 355                 }
 356
 357                 SubString++;
 358
 359                 if (NestLevel == 0)
 360                 {
 361                     break;
 362                 }
 363             }
 364
 365             /* Remove the closing paren */
 366
 367             SubBuffer = AsRemoveData (SubString-1, SubString);
 368         }
 369     }
 370 }
 371
 372
 373 /******************************************************************************
 374  *
 375  * FUNCTION:    AsRemoveLine
 376  *
 377  * DESCRIPTION: Remove every line that contains the keyword. Does not
 378  *              skip comments.
 379  *
 380  ******************************************************************************/
 381
 382 void
 383 AsRemoveLine (
 384     char                    *Buffer,
 385     char                    *Keyword)
 386 {
 387     char                    *SubString;
 388     char                    *SubBuffer;
 389
 390
 391     SubBuffer = Buffer;
 392     SubString = Buffer;
 393
 394
 395     while (SubString)
 396     {
 397         SubString = strstr (SubBuffer, Keyword);
 398
 399         if (SubString)
 400         {
 401             SubBuffer = SubString;
 402
 403             /* Find start of this line */
 404
 405             while (*SubString != '\n')
 406             {
 407                 SubString--;
 408             }
 409             SubString++;
 410
 411             /* Find end of this line */
 412
 413             SubBuffer = AsSkipPastChar (SubBuffer, '\n');
 414             if (!SubBuffer)
 415             {
 416                 return;
 417             }
 418
 419             /* Remove the line */
 420
 421             SubBuffer = AsRemoveData (SubString, SubBuffer);
 422         }
 423     }
 424 }
 425
 426
 427 /******************************************************************************
 428  *
 429  * FUNCTION:    AsReduceTypedefs
 430  *
 431  * DESCRIPTION: Eliminate certain typedefs
 432  *
 433  ******************************************************************************/
 434
 435 void
 436 AsReduceTypedefs (
 437     char                    *Buffer,
 438     char                    *Keyword)
 439 {
 440     char                    *SubString;
 441     char                    *SubBuffer;
 442     int                     NestLevel;
 443
 444
 445     SubBuffer = Buffer;
 446     SubString = Buffer;
 447
 448
 449     while (SubString)
 450     {
 451         SubString = strstr (SubBuffer, Keyword);
 452
 453         if (SubString)
 454         {
 455             /* Remove the typedef itself */
 456
 457             SubBuffer = SubString + strlen ("typedef") + 1;
 458             SubBuffer = AsRemoveData (SubString, SubBuffer);
 459
 460             /* Find the opening brace of the struct or union */
 461
 462             while (*SubString != '{')
 463             {
 464                 SubString++;
 465             }
 466             SubString++;
 467
 468             /* Find the closing brace. Handles nested braces */
 469
 470             NestLevel = 1;
 471             while (*SubString)
 472             {
 473                 if (*SubString == '{')
 474                 {
 475                     NestLevel++;
 476                 }
 477                 else if (*SubString == '}')
 478                 {
 479                     NestLevel--;
 480                 }
 481
 482                 SubString++;
 483
 484                 if (NestLevel == 0)
 485                 {
 486                     break;
 487                 }
 488             }
 489
 490             /* Remove an extra line feed if present */
 491
 492             if (!strncmp (SubString - 3, "\n\n", 2))
 493             {
 494                 *(SubString -2) = '}';
 495                 SubString--;
 496             }
 497
 498             /* Find the end of the typedef name */
 499
 500             SubBuffer = AsSkipUntilChar (SubString, ';');
 501
 502             /* And remove the typedef name */
 503
 504             SubBuffer = AsRemoveData (SubString, SubBuffer);
 505         }
 506     }
 507 }
 508
 509
 510 /******************************************************************************
 511  *
 512  * FUNCTION:    AsRemoveEmptyBlocks
 513  *
 514  * DESCRIPTION: Remove any C blocks (e.g., if {}) that contain no code. This
 515  *              can happen as a result of removing lines such as DEBUG_PRINT.
 516  *
 517  ******************************************************************************/
 518
 519 void
 520 AsRemoveEmptyBlocks (
 521     char                    *Buffer,
 522     char                    *Filename)
 523 {
 524     char                    *SubBuffer;
 525     char                    *BlockStart;
 526     BOOLEAN                 EmptyBlock = TRUE;
 527     BOOLEAN                 AnotherPassRequired = TRUE;
 528     UINT32                  BlockCount = 0;
 529
 530
 531     while (AnotherPassRequired)
 532     {
 533         SubBuffer = Buffer;
 534         AnotherPassRequired = FALSE;
 535
 536         while (*SubBuffer)
 537         {
 538             if (*SubBuffer == '{')
 539             {
 540                 BlockStart = SubBuffer;
 541                 EmptyBlock = TRUE;
 542
 543                 SubBuffer++;
 544                 while (*SubBuffer != '}')
 545                 {
 546                     if ((*SubBuffer != ' ') &&
 547                         (*SubBuffer != '\n'))
 548                     {
 549                         EmptyBlock = FALSE;
 550                         break;
 551                     }
 552                     SubBuffer++;
 553                 }
 554
 555                 if (EmptyBlock)
 556                 {
 557                     /* Find start of the first line of the block */
 558
 559                     while (*BlockStart != '\n')
 560                     {
 561                         BlockStart--;
 562                     }
 563
 564                     /* Find end of the last line of the block */
 565
 566                     SubBuffer = AsSkipUntilChar (SubBuffer, '\n');
 567                     if (!SubBuffer)
 568                     {
 569                         break;
 570                     }
 571
 572                     /* Remove the block */
 573
 574                     SubBuffer = AsRemoveData (BlockStart, SubBuffer);
 575                     BlockCount++;
 576                     AnotherPassRequired = TRUE;
 577                     continue;
 578                 }
 579             }
 580
 581             SubBuffer++;
 582         }
 583     }
 584
 585     if (BlockCount)
 586     {
 587         Gbl_MadeChanges = TRUE;
 588         AsPrint ("Code blocks deleted", BlockCount, Filename);
 589     }
 590 }
 591
 592
 593 /******************************************************************************
 594  *
 595  * FUNCTION:    AsRemoveDebugMacros
 596  *
 597  * DESCRIPTION: Remove all "Debug" macros -- macros that produce debug output.
 598  *
 599  ******************************************************************************/
 600
 601 void
 602 AsRemoveDebugMacros (
 603     char                    *Buffer)
 604 {
 605     AsRemoveConditionalCompile (Buffer, "ACPI_DEBUG_OUTPUT");
 606
 607     AsRemoveStatement (Buffer, "ACPI_DEBUG_PRINT",      REPLACE_WHOLE_WORD);
 608     AsRemoveStatement (Buffer, "ACPI_DEBUG_PRINT_RAW",  REPLACE_WHOLE_WORD);
 609     AsRemoveStatement (Buffer, "DEBUG_EXEC",            REPLACE_WHOLE_WORD);
 610     AsRemoveStatement (Buffer, "FUNCTION_ENTRY",        REPLACE_WHOLE_WORD);
 611     AsRemoveStatement (Buffer, "PROC_NAME",             REPLACE_WHOLE_WORD);
 612     AsRemoveStatement (Buffer, "FUNCTION_TRACE",        REPLACE_SUBSTRINGS);
 613     AsRemoveStatement (Buffer, "DUMP_",                 REPLACE_SUBSTRINGS);
 614
 615     AsReplaceString ("return_VOID",         "return", REPLACE_WHOLE_WORD, Buffer);
 616     AsReplaceString ("return_PTR",          "return", REPLACE_WHOLE_WORD, Buffer);
 617     AsReplaceString ("return_ACPI_STATUS",  "return", REPLACE_WHOLE_WORD, Buffer);
 618     AsReplaceString ("return_acpi_status",  "return", REPLACE_WHOLE_WORD, Buffer);
 619     AsReplaceString ("return_VALUE",        "return", REPLACE_WHOLE_WORD, Buffer);
 620 }
 621
 622
 623 /******************************************************************************
 624  *
 625  * FUNCTION:    AsCleanupSpecialMacro
 626  *
 627  * DESCRIPTION: For special macro invocations (invoked without ";" at the end
 628  *              of the lines), do the following:
 629  *              1. Remove spaces appended by indent at the beginning of lines.
 630  *              2. Add an empty line between two special macro invocations.
 631  *
 632  ******************************************************************************/
 633
 634 void
 635 AsCleanupSpecialMacro (
 636     char                    *Buffer,
 637     char                    *Keyword)
 638 {
 639     char                    *SubString;
 640     char                    *SubBuffer;
 641     char                    *LastNonSpace;
 642
 643
 644     SubBuffer = Buffer;
 645     SubString = Buffer;
 646
 647     while (SubString)
 648     {
 649         SubString = strstr (SubBuffer, Keyword);
 650
 651         if (SubString)
 652         {
 653             /* Find start of the line */
 654
 655             SubBuffer = SubString;
 656             while (*(SubBuffer - 1) == ' ')
 657             {
 658                 SubBuffer--;
 659             }
 660
 661             if (*(SubBuffer - 1) == '\n')
 662             {
 663                 /* Find last non-space character */
 664
 665                 LastNonSpace = SubBuffer - 1;
 666                 while (isspace ((int) *LastNonSpace))
 667                 {
 668                     LastNonSpace--;
 669                 }
 670
 671                 if (*LastNonSpace != '\\')
 672                 {
 673                     /* Remove the extra spaces */
 674
 675                     SubString = AsRemoveData (SubBuffer, SubString);
 676
 677                     /* Enforce an empty line between the invocations */
 678
 679                     if (*(SubBuffer - 2) == ')')
 680                     {
 681                         AsInsertData (SubBuffer, "\n", 1);
 682                     }
 683                 }
 684             }
 685
 686             SubBuffer = SubString + strlen (Keyword);
 687         }
 688     }
 689 }