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