1 /****************************************************************************** 2 * 3 * Module Name: asremove - Source conversion - removal functions 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, 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 *CommentEnd; 642 int NewLine; 643 int NestLevel; 644 645 646 SubBuffer = Buffer; 647 SubString = Buffer; 648 649 while (SubString) 650 { 651 SubString = strstr (SubBuffer, Keyword); 652 653 if (SubString) 654 { 655 /* Find start of the macro parameters */ 656 657 while (*SubString != '(') 658 { 659 SubString++; 660 } 661 SubString++; 662 663 NestLevel = 1; 664 while (*SubString) 665 { 666 if (*SubString == '(') 667 { 668 NestLevel++; 669 } 670 else if (*SubString == ')') 671 { 672 NestLevel--; 673 } 674 675 SubString++; 676 677 if (NestLevel == 0) 678 { 679 break; 680 } 681 } 682 683 SkipLine: 684 685 /* Find end of the line */ 686 687 NewLine = FALSE; 688 while (!NewLine && *SubString) 689 { 690 if (*SubString == '\n' && *(SubString - 1) != '\\') 691 { 692 NewLine = TRUE; 693 } 694 SubString++; 695 } 696 697 /* Find end of the line */ 698 699 if (*SubString == '#' || *SubString == '\n') 700 { 701 goto SkipLine; 702 } 703 704 SubBuffer = SubString; 705 706 /* Find start of the non-space */ 707 708 while (*SubString == ' ') 709 { 710 SubString++; 711 } 712 713 /* Find end of the line */ 714 715 if (*SubString == '#' || *SubString == '\n') 716 { 717 goto SkipLine; 718 } 719 720 /* Find end of the line */ 721 722 if (*SubString == '/' || *SubString == '*') 723 { 724 CommentEnd = strstr (SubString, "*/"); 725 if (CommentEnd) 726 { 727 SubString = CommentEnd + 2; 728 goto SkipLine; 729 } 730 } 731 732 SubString = AsRemoveData (SubBuffer, SubString); 733 } 734 } 735 } 736