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

   1 /******************************************************************************
   2  *
   3  * Module Name: asremove - Source conversion - removal functions
   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 AsRemoveStatement (
 158     char                    *Buffer,
 159     char                    *Keyword,
 160     UINT32                  Type);
 161
 162
 163 /******************************************************************************
 164  *
 165  * FUNCTION:    AsRemoveStatement
 166  *
 167  * DESCRIPTION: Remove all statements that contain the given keyword.
 168  *              Limitations:  Removes text from the start of the line that
 169  *              contains the keyword to the next semicolon. Currently
 170  *              doesn't ignore comments.
 171  *
 172  ******************************************************************************/
 173
 174 void
 175 AsRemoveStatement (
 176     char                    *Buffer,
 177     char                    *Keyword,
 178     UINT32                  Type)
 179 {
 180     char                    *SubString;
 181     char                    *SubBuffer;
 182     int                     KeywordLength;
 183
 184
 185     KeywordLength = strlen (Keyword);
 186     SubBuffer = Buffer;
 187     SubString = Buffer;
 188
 189     while (SubString)
 190     {
 191         SubString = strstr (SubBuffer, Keyword);
 192
 193         if (SubString)
 194         {
 195             SubBuffer = SubString;
 196
 197             if ((Type == REPLACE_WHOLE_WORD) &&
 198                 (!AsMatchExactWord (SubString, KeywordLength)))
 199             {
 200                 SubBuffer++;
 201                 continue;
 202             }
 203
 204             /* Find start of this line */
 205
 206             while (*SubString != '\n')
 207             {
 208                 SubString--;
 209             }
 210             SubString++;
 211
 212             /* Find end of this statement */
 213
 214             SubBuffer = AsSkipPastChar (SubBuffer, ';');
 215             if (!SubBuffer)
 216             {
 217                 return;
 218             }
 219
 220             /* Find end of this line */
 221
 222             SubBuffer = AsSkipPastChar (SubBuffer, '\n');
 223             if (!SubBuffer)
 224             {
 225                 return;
 226             }
 227
 228             /* If next line is blank, remove it too */
 229
 230             if (*SubBuffer == '\n')
 231             {
 232                 SubBuffer++;
 233             }
 234
 235             /* Remove the lines */
 236
 237             SubBuffer = AsRemoveData (SubString, SubBuffer);
 238         }
 239     }
 240 }
 241
 242
 243 /******************************************************************************
 244  *
 245  * FUNCTION:    AsRemoveConditionalCompile
 246  *
 247  * DESCRIPTION: Remove a "#ifdef" statement, and all text that it encompasses.
 248  *              Limitations: cannot handle nested ifdefs.
 249  *
 250  ******************************************************************************/
 251
 252 void
 253 AsRemoveConditionalCompile (
 254     char                    *Buffer,
 255     char                    *Keyword)
 256 {
 257     char                    *SubString;
 258     char                    *SubBuffer;
 259     char                    *IfPtr;
 260     char                    *EndifPtr;
 261     char                    *ElsePtr;
 262     char                    *Comment;
 263     int                     KeywordLength;
 264
 265
 266     KeywordLength = strlen (Keyword);
 267     SubBuffer = Buffer;
 268     SubString = Buffer;
 269
 270     while (SubString)
 271     {
 272         SubBuffer = strstr (SubString, Keyword);
 273         if (!SubBuffer)
 274         {
 275             return;
 276         }
 277
 278         /*
 279          * Check for translation escape string -- means to ignore
 280          * blocks of code while replacing
 281          */
 282         if (Gbl_IgnoreTranslationEscapes)
 283         {
 284             Comment = NULL;
 285         }
 286         else
 287         {
 288             Comment = strstr (SubString, AS_START_IGNORE);
 289         }
 290
 291         if ((Comment) &&
 292             (Comment < SubBuffer))
 293         {
 294             SubString = strstr (Comment, AS_STOP_IGNORE);
 295             if (!SubString)
 296             {
 297                 return;
 298             }
 299
 300             SubString += 3;
 301             continue;
 302         }
 303
 304         /* Check for ordinary comment */
 305
 306         Comment = strstr (SubString, "/*");
 307
 308         if ((Comment) &&
 309             (Comment < SubBuffer))
 310         {
 311             SubString = strstr (Comment, "*/");
 312             if (!SubString)
 313             {
 314                 return;
 315             }
 316
 317             SubString += 2;
 318             continue;
 319         }
 320
 321         SubString = SubBuffer;
 322         if (!AsMatchExactWord (SubString, KeywordLength))
 323         {
 324             SubString++;
 325             continue;
 326         }
 327
 328         /* Find start of this line */
 329
 330         while (*SubString != '\n' && (SubString > Buffer))
 331         {
 332             SubString--;
 333         }
 334
 335         SubString++;
 336
 337         /* Find the "#ifxxxx" */
 338
 339         IfPtr = strstr (SubString, "#if");
 340         if (!IfPtr)
 341         {
 342             return;
 343         }
 344
 345         if (IfPtr > SubBuffer)
 346         {
 347             /* Not the right #if */
 348
 349             SubString = SubBuffer + strlen (Keyword);
 350             continue;
 351         }
 352
 353         /* Find closing #endif or #else */
 354
 355         EndifPtr = strstr (SubBuffer, "#endif");
 356         if (!EndifPtr)
 357         {
 358             /* There has to be an #endif */
 359
 360             return;
 361         }
 362
 363         ElsePtr = strstr (SubBuffer, "#else");
 364         if ((ElsePtr) &&
 365             (EndifPtr > ElsePtr))
 366         {
 367             /* This #ifdef contains an #else clause */
 368             /* Find end of this line */
 369
 370             SubBuffer = AsSkipPastChar (ElsePtr, '\n');
 371             if (!SubBuffer)
 372             {
 373                 return;
 374             }
 375
 376             /* Remove the #ifdef .... #else code */
 377
 378             AsRemoveData (SubString, SubBuffer);
 379
 380             /* Next, we will remove the #endif statement */
 381
 382             EndifPtr = strstr (SubString, "#endif");
 383             if (!EndifPtr)
 384             {
 385                 /* There has to be an #endif */
 386
 387                 return;
 388             }
 389
 390             SubString = EndifPtr;
 391         }
 392
 393         /* Remove the ... #endif part */
 394         /* Find end of this line */
 395
 396         SubBuffer = AsSkipPastChar (EndifPtr, '\n');
 397         if (!SubBuffer)
 398         {
 399             return;
 400         }
 401
 402         /* Remove the lines */
 403
 404         SubBuffer = AsRemoveData (SubString, SubBuffer);
 405     }
 406 }
 407
 408
 409 #ifdef _OBSOLETE_FUNCTIONS
 410 /******************************************************************************
 411  *
 412  * FUNCTION:    AsRemoveMacro
 413  *
 414  * DESCRIPTION: Remove every line that contains the keyword. Does not
 415  *              skip comments.
 416  *
 417  ******************************************************************************/
 418
 419 NOTE: This function is no longer used and is commented out for now.
 420
 421 Also, it appears to have one or more bugs in it. It can incorrectly remove
 422 lines of code, producing some garbage.
 423
 424 void
 425 AsRemoveMacro (
 426     char                    *Buffer,
 427     char                    *Keyword)
 428 {
 429     char                    *SubString;
 430     char                    *SubBuffer;
 431     int                     NestLevel;
 432
 433
 434     SubBuffer = Buffer;
 435     SubString = Buffer;
 436
 437     while (SubString)
 438     {
 439         SubString = strstr (SubBuffer, Keyword);
 440
 441         if (SubString)
 442         {
 443             SubBuffer = SubString;
 444
 445             /* Find start of the macro parameters */
 446
 447             while (*SubString != '(')
 448             {
 449                 SubString++;
 450             }
 451             SubString++;
 452
 453             /* Remove the macro name and opening paren */
 454
 455             SubString = AsRemoveData (SubBuffer, SubString);
 456
 457             NestLevel = 1;
 458             while (*SubString)
 459             {
 460                 if (*SubString == '(')
 461                 {
 462                     NestLevel++;
 463                 }
 464                 else if (*SubString == ')')
 465                 {
 466                     NestLevel--;
 467                 }
 468
 469                 SubString++;
 470
 471                 if (NestLevel == 0)
 472                 {
 473                     break;
 474                 }
 475             }
 476
 477             /* Remove the closing paren */
 478
 479             SubBuffer = AsRemoveData (SubString-1, SubString);
 480         }
 481     }
 482 }
 483 #endif
 484
 485 /******************************************************************************
 486  *
 487  * FUNCTION:    AsRemoveLine
 488  *
 489  * DESCRIPTION: Remove every line that contains the keyword. Does not
 490  *              skip comments.
 491  *
 492  ******************************************************************************/
 493
 494 void
 495 AsRemoveLine (
 496     char                    *Buffer,
 497     char                    *Keyword)
 498 {
 499     char                    *SubString;
 500     char                    *SubBuffer;
 501
 502
 503     SubBuffer = Buffer;
 504     SubString = Buffer;
 505
 506     while (SubString)
 507     {
 508         SubString = strstr (SubBuffer, Keyword);
 509
 510         if (SubString)
 511         {
 512             SubBuffer = SubString;
 513
 514             /* Find start of this line */
 515
 516             while (*SubString != '\n')
 517             {
 518                 SubString--;
 519             }
 520             SubString++;
 521
 522             /* Find end of this line */
 523
 524             SubBuffer = AsSkipPastChar (SubBuffer, '\n');
 525             if (!SubBuffer)
 526             {
 527                 return;
 528             }
 529
 530             /* Remove the line */
 531
 532             SubBuffer = AsRemoveData (SubString, SubBuffer);
 533         }
 534     }
 535 }
 536
 537
 538 /******************************************************************************
 539  *
 540  * FUNCTION:    AsReduceTypedefs
 541  *
 542  * DESCRIPTION: Eliminate certain typedefs
 543  *
 544  ******************************************************************************/
 545
 546 void
 547 AsReduceTypedefs (
 548     char                    *Buffer,
 549     char                    *Keyword)
 550 {
 551     char                    *SubString;
 552     char                    *SubBuffer;
 553     char                    *SubSubString;
 554     int                     NestLevel;
 555
 556
 557     SubBuffer = Buffer;
 558     SubString = Buffer;
 559
 560     while (SubString)
 561     {
 562         SubString = strstr (SubBuffer, Keyword);
 563
 564         if (SubString)
 565         {
 566             SubSubString = SubString + strlen (Keyword);
 567
 568             /* skip spaces */
 569
 570             while (strchr(" \t\r\n", *SubSubString))
 571             {
 572                 SubSubString++;
 573             }
 574
 575             /* skip type name */
 576
 577             while (!strchr(" \t\r\n", *SubSubString))
 578             {
 579                 SubSubString++;
 580             }
 581
 582             /* skip spaces */
 583
 584             while (strchr(" \t\r\n", *SubSubString))
 585             {
 586                 SubSubString++;
 587             }
 588
 589             if (*SubSubString == '{')
 590             {
 591                 /* Remove the typedef itself */
 592
 593                 SubBuffer = SubString + strlen ("typedef") + 1;
 594                 SubBuffer = AsRemoveData (SubString, SubBuffer);
 595
 596                 /* Find the opening brace of the struct or union */
 597
 598                 while (*SubString != '{')
 599                 {
 600                     SubString++;
 601                 }
 602                 SubString++;
 603
 604                 /* Find the closing brace. Handles nested braces */
 605
 606                 NestLevel = 1;
 607                 while (*SubString)
 608                 {
 609                     if (*SubString == '{')
 610                     {
 611                         NestLevel++;
 612                     }
 613                     else if (*SubString == '}')
 614                     {
 615                         NestLevel--;
 616                     }
 617
 618                     SubString++;
 619
 620                     if (NestLevel == 0)
 621                     {
 622                         break;
 623                     }
 624                 }
 625
 626                 /* Remove an extra line feed if present */
 627
 628                 if (!strncmp (SubString - 3, "\n\n", 2))
 629                 {
 630                     *(SubString -2) = '}';
 631                     SubString--;
 632                 }
 633
 634                 /* Find the end of the typedef name */
 635
 636                 SubBuffer = AsSkipUntilChar (SubString, ';');
 637
 638                 /* And remove the typedef name */
 639
 640                 SubBuffer = AsRemoveData (SubString, SubBuffer);
 641             }
 642             else
 643             {
 644                 /* Skip the entire definition */
 645
 646                 SubString = strchr (SubString, ';') + 1;
 647                 SubBuffer = SubString;
 648             }
 649         }
 650     }
 651 }
 652
 653
 654 /******************************************************************************
 655  *
 656  * FUNCTION:    AsRemoveEmptyBlocks
 657  *
 658  * DESCRIPTION: Remove any C blocks (e.g., if {}) that contain no code. This
 659  *              can happen as a result of removing lines such as DEBUG_PRINT.
 660  *
 661  ******************************************************************************/
 662
 663 void
 664 AsRemoveEmptyBlocks (
 665     char                    *Buffer,
 666     char                    *Filename)
 667 {
 668     char                    *SubBuffer;
 669     char                    *BlockStart;
 670     BOOLEAN                 EmptyBlock = TRUE;
 671     BOOLEAN                 AnotherPassRequired = TRUE;
 672     UINT32                  BlockCount = 0;
 673
 674
 675     while (AnotherPassRequired)
 676     {
 677         SubBuffer = Buffer;
 678         AnotherPassRequired = FALSE;
 679
 680         while (*SubBuffer)
 681         {
 682             if (*SubBuffer == '{')
 683             {
 684                 BlockStart = SubBuffer;
 685                 EmptyBlock = TRUE;
 686
 687                 SubBuffer++;
 688                 while (*SubBuffer != '}')
 689                 {
 690                     if ((*SubBuffer != ' ') &&
 691                         (*SubBuffer != '\n'))
 692                     {
 693                         EmptyBlock = FALSE;
 694                         break;
 695                     }
 696
 697                     SubBuffer++;
 698                 }
 699
 700                 if (EmptyBlock)
 701                 {
 702                     /* Find start of the first line of the block */
 703
 704                     while (*BlockStart != '\n')
 705                     {
 706                         BlockStart--;
 707                     }
 708
 709                     /* Find end of the last line of the block */
 710
 711                     SubBuffer = AsSkipUntilChar (SubBuffer, '\n');
 712                     if (!SubBuffer)
 713                     {
 714                         break;
 715                     }
 716
 717                     /* Remove the block */
 718
 719                     SubBuffer = AsRemoveData (BlockStart, SubBuffer);
 720                     BlockCount++;
 721                     AnotherPassRequired = TRUE;
 722                     continue;
 723                 }
 724             }
 725
 726             SubBuffer++;
 727         }
 728     }
 729
 730     if (BlockCount)
 731     {
 732         Gbl_MadeChanges = TRUE;
 733         AsPrint ("Code blocks deleted", BlockCount, Filename);
 734     }
 735 }
 736
 737
 738 /******************************************************************************
 739  *
 740  * FUNCTION:    AsRemoveDebugMacros
 741  *
 742  * DESCRIPTION: Remove all "Debug" macros -- macros that produce debug output.
 743  *
 744  ******************************************************************************/
 745
 746 void
 747 AsRemoveDebugMacros (
 748     char                    *Buffer)
 749 {
 750     AsRemoveConditionalCompile (Buffer, "ACPI_DEBUG_OUTPUT");
 751
 752     AsRemoveStatement (Buffer, "ACPI_DEBUG_PRINT",      REPLACE_WHOLE_WORD);
 753     AsRemoveStatement (Buffer, "ACPI_DEBUG_PRINT_RAW",  REPLACE_WHOLE_WORD);
 754     AsRemoveStatement (Buffer, "DEBUG_EXEC",            REPLACE_WHOLE_WORD);
 755     AsRemoveStatement (Buffer, "FUNCTION_ENTRY",        REPLACE_WHOLE_WORD);
 756     AsRemoveStatement (Buffer, "PROC_NAME",             REPLACE_WHOLE_WORD);
 757     AsRemoveStatement (Buffer, "FUNCTION_TRACE",        REPLACE_SUBSTRINGS);
 758     AsRemoveStatement (Buffer, "DUMP_",                 REPLACE_SUBSTRINGS);
 759
 760     AsReplaceString ("return_VOID",         "return", REPLACE_WHOLE_WORD, Buffer);
 761     AsReplaceString ("return_PTR",          "return", REPLACE_WHOLE_WORD, Buffer);
 762     AsReplaceString ("return_STR",          "return", REPLACE_WHOLE_WORD, Buffer);
 763     AsReplaceString ("return_ACPI_STATUS",  "return", REPLACE_WHOLE_WORD, Buffer);
 764     AsReplaceString ("return_acpi_status",  "return", REPLACE_WHOLE_WORD, Buffer);
 765     AsReplaceString ("return_VALUE",        "return", REPLACE_WHOLE_WORD, Buffer);
 766 }
 767
 768
 769 /******************************************************************************
 770  *
 771  * FUNCTION:    AsCleanupSpecialMacro
 772  *
 773  * DESCRIPTION: For special macro invocations (invoked without ";" at the end
 774  *              of the lines), do the following:
 775  *              1. Remove spaces appended by indent at the beginning of lines.
 776  *              2. Add an empty line between two special macro invocations.
 777  *
 778  ******************************************************************************/
 779
 780 void
 781 AsCleanupSpecialMacro (
 782     char                    *Buffer,
 783     char                    *Keyword)
 784 {
 785     char                    *SubString;
 786     char                    *SubBuffer;
 787     char                    *CommentEnd;
 788     int                     NewLine;
 789     int                     NestLevel;
 790
 791
 792     SubBuffer = Buffer;
 793     SubString = Buffer;
 794
 795     while (SubString)
 796     {
 797         SubString = strstr (SubBuffer, Keyword);
 798
 799         if (SubString)
 800         {
 801             /* Find start of the macro parameters */
 802
 803             while (*SubString != '(')
 804             {
 805                 SubString++;
 806             }
 807
 808             SubString++;
 809
 810             NestLevel = 1;
 811             while (*SubString)
 812             {
 813                 if (*SubString == '(')
 814                 {
 815                     NestLevel++;
 816                 }
 817                 else if (*SubString == ')')
 818                 {
 819                     NestLevel--;
 820                 }
 821
 822                 SubString++;
 823
 824                 if (NestLevel == 0)
 825                 {
 826                     break;
 827                 }
 828             }
 829
 830 SkipLine:
 831
 832             /* Find end of the line */
 833
 834             NewLine = FALSE;
 835             while (!NewLine && *SubString)
 836             {
 837                 if (*SubString == '\n' && *(SubString - 1) != '\\')
 838                 {
 839                     NewLine = TRUE;
 840                 }
 841
 842                 SubString++;
 843             }
 844
 845             /* Find end of the line */
 846
 847             if (*SubString == '#' || *SubString == '\n')
 848             {
 849                 goto SkipLine;
 850             }
 851
 852             SubBuffer = SubString;
 853
 854             /* Find start of the non-space */
 855
 856             while (*SubString == ' ')
 857             {
 858                 SubString++;
 859             }
 860
 861             /* Find end of the line */
 862
 863             if (*SubString == '#' || *SubString == '\n')
 864             {
 865                 goto SkipLine;
 866             }
 867
 868             /* Find end of the line */
 869
 870             if (*SubString == '/' || *SubString == '*')
 871             {
 872                 CommentEnd = strstr (SubString, "*/");
 873                 if (CommentEnd)
 874                 {
 875                     SubString = CommentEnd + 2;
 876                     goto SkipLine;
 877                 }
 878             }
 879
 880             SubString = AsRemoveData (SubBuffer, SubString);
 881         }
 882     }
 883 }