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 - 2019, 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 } 884