1 /****************************************************************************** 2 * 3 * Module Name: asconvrt - Source conversion code 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 AS_BRACE_INFO Gbl_BraceInfo[] = 155 { 156 {" if", 3}, 157 {" else if", 8}, 158 {" else while", 11}, 159 {" else", 5}, 160 {" do ", 4}, 161 {NULL, 0} 162 }; 163 164 165 /* Local prototypes */ 166 167 static char * 168 AsMatchValidToken ( 169 char *Buffer, 170 char *Filename, 171 char TargetChar, 172 AS_SCAN_CALLBACK Callback); 173 174 static char * 175 AsCheckBracesCallback ( 176 char *Buffer, 177 char *Filename, 178 UINT32 LineNumber); 179 180 static UINT32 181 AsCountLines ( 182 char *Buffer, 183 char *Filename); 184 185 186 #define MODULE_HEADER_BEGIN "/******************************************************************************\n *\n * Module Name:"; 187 #define MODULE_HEADER_END " *****************************************************************************/\n\n" 188 #define INTEL_COPYRIGHT " * Copyright (C) 2000 - 2019, Intel Corp.\n" 189 190 /* Opening signature of the Intel legal header */ 191 192 char *HeaderBegin = "/******************************************************************************\n *\n * 1. Copyright Notice"; 193 194 UINT32 NonAnsiCommentCount; 195 196 char CopyRightHeaderEnd[] = INTEL_COPYRIGHT " *\n" MODULE_HEADER_END; 197 198 /****************************************************************************** 199 * 200 * FUNCTION: AsCountNonAnsiComments 201 * 202 * DESCRIPTION: Count the number of "//" comments. This type of comment is 203 * non-ANSI C. 204 * 205 * NOTE: July 2014: Allows // within quoted strings and within normal 206 * comments. Eliminates extraneous warnings from this utility. 207 * 208 ******************************************************************************/ 209 210 void 211 AsCountNonAnsiComments ( 212 char *Buffer, 213 char *Filename) 214 { 215 216 AsMatchValidToken (Buffer, Filename, 0, NULL); 217 218 /* Error if any slash-slash comments found */ 219 220 if (NonAnsiCommentCount) 221 { 222 AsPrint ("Non-ANSI // Comments Found", NonAnsiCommentCount, Filename); 223 Gbl_NonAnsiComments += NonAnsiCommentCount; 224 } 225 } 226 227 228 /****************************************************************************** 229 * 230 * FUNCTION: AsCheckForBraces 231 * 232 * DESCRIPTION: Check for an open brace after each if/else/do (etc.) 233 * statement 234 * 235 ******************************************************************************/ 236 237 void 238 AsCheckForBraces ( 239 char *Buffer, 240 char *Filename) 241 { 242 243 AsMatchValidToken (Buffer, Filename, 0, AsCheckBracesCallback); 244 } 245 246 247 /****************************************************************************** 248 * 249 * FUNCTION: AsCheckBracesCallback 250 * 251 * DESCRIPTION: Check if/else/do statements. Ensure that braces 252 * are always used. 253 * 254 * TBD: Currently, don't check while() statements. The problem is that there 255 * are two forms: do {} while (); and while () {}. 256 * 257 ******************************************************************************/ 258 259 static char * 260 AsCheckBracesCallback ( 261 char *Buffer, 262 char *Filename, 263 UINT32 LineNumber) 264 { 265 char *SubBuffer = Buffer; 266 char *NextBrace; 267 char *NextSemicolon; 268 AS_BRACE_INFO *BraceInfo; 269 270 271 for (BraceInfo = Gbl_BraceInfo; BraceInfo->Operator; BraceInfo++) 272 { 273 if (!(strncmp (BraceInfo->Operator, SubBuffer, BraceInfo->Length))) 274 { 275 SubBuffer += (BraceInfo->Length - 1); 276 277 /* Find next brace and the next semicolon */ 278 279 NextBrace = AsMatchValidToken (SubBuffer, Filename, '{', NULL); 280 NextSemicolon = AsMatchValidToken (SubBuffer, Filename, ';', NULL); 281 282 /* Next brace should appear before next semicolon */ 283 284 if ((!NextBrace) || 285 (NextSemicolon && (NextBrace > NextSemicolon))) 286 { 287 Gbl_MissingBraces++; 288 289 if (!Gbl_QuietMode) 290 { 291 printf ("Missing braces for <%s>, line %u: %s\n", 292 BraceInfo->Operator + 1, LineNumber, Filename); 293 } 294 } 295 296 return (SubBuffer); 297 } 298 } 299 300 /* No match, just return original buffer */ 301 302 return (Buffer); 303 } 304 305 306 /****************************************************************************** 307 * 308 * FUNCTION: AsMatchValidToken 309 * 310 * DESCRIPTION: Find the next matching token in the input buffer. 311 * 312 ******************************************************************************/ 313 314 static char * 315 AsMatchValidToken ( 316 char *Buffer, 317 char *Filename, 318 char TargetChar, 319 AS_SCAN_CALLBACK Callback) 320 { 321 char *SubBuffer = Buffer; 322 char *StringStart; 323 UINT32 TotalLines; 324 325 326 TotalLines = 1; 327 NonAnsiCommentCount = 0; 328 329 /* Scan from current position up to the end if necessary */ 330 331 while (*SubBuffer) 332 { 333 /* Skip normal comments */ 334 335 if ((*SubBuffer == '/') && 336 (*(SubBuffer + 1) == '*')) 337 { 338 /* Must maintain line count */ 339 340 SubBuffer += 2; 341 while (strncmp ("*/", SubBuffer, 2)) 342 { 343 if (*SubBuffer == '\n') 344 { 345 TotalLines++; 346 } 347 SubBuffer++; 348 } 349 350 SubBuffer += 2; 351 continue; 352 } 353 354 /* Skip single quoted chars */ 355 356 if (*SubBuffer == '\'') 357 { 358 SubBuffer++; 359 if (!(*SubBuffer)) 360 { 361 break; 362 } 363 364 if (*SubBuffer == '\\') 365 { 366 SubBuffer++; 367 } 368 369 SubBuffer++; 370 continue; 371 } 372 373 /* Skip quoted strings */ 374 375 if (*SubBuffer == '"') 376 { 377 StringStart = SubBuffer; 378 SubBuffer++; 379 if (!(*SubBuffer)) 380 { 381 break; 382 } 383 384 while (*SubBuffer != '"') 385 { 386 if ((*SubBuffer == '\n') || 387 (!(*SubBuffer))) 388 { 389 AsPrint ("Unbalanced quoted string",1, Filename); 390 printf (" %.32s (line %u)\n", StringStart, TotalLines); 391 break; 392 } 393 394 /* Handle escapes within the string */ 395 396 if (*SubBuffer == '\\') 397 { 398 SubBuffer++; 399 } 400 401 SubBuffer++; 402 } 403 404 SubBuffer++; 405 continue; 406 } 407 408 /* Now we can check for a slash-slash comment */ 409 410 if ((*SubBuffer == '/') && 411 (*(SubBuffer + 1) == '/')) 412 { 413 NonAnsiCommentCount++; 414 415 /* Skip to end-of-line */ 416 417 while ((*SubBuffer != '\n') && 418 (*SubBuffer)) 419 { 420 SubBuffer++; 421 } 422 423 if (!(*SubBuffer)) 424 { 425 break; 426 } 427 428 if (*SubBuffer == '\n') 429 { 430 TotalLines++; 431 } 432 433 SubBuffer++; 434 continue; 435 } 436 437 /* Finally, check for a newline */ 438 439 if (*SubBuffer == '\n') 440 { 441 TotalLines++; 442 SubBuffer++; 443 continue; 444 } 445 446 /* Normal character, do the user actions */ 447 448 if (Callback) 449 { 450 SubBuffer = Callback (SubBuffer, Filename, TotalLines); 451 } 452 453 if (TargetChar && (*SubBuffer == TargetChar)) 454 { 455 return (SubBuffer); 456 } 457 458 SubBuffer++; 459 } 460 461 return (NULL); 462 } 463 464 465 /****************************************************************************** 466 * 467 * FUNCTION: AsRemoveExtraLines 468 * 469 * DESCRIPTION: Remove all extra lines at the start and end of the file. 470 * 471 ******************************************************************************/ 472 473 void 474 AsRemoveExtraLines ( 475 char *FileBuffer, 476 char *Filename) 477 { 478 char *FileEnd; 479 int Length; 480 481 482 /* Remove any extra lines at the start of the file */ 483 484 while (*FileBuffer == '\n') 485 { 486 printf ("Removing extra line at start of file: %s\n", Filename); 487 AsRemoveData (FileBuffer, FileBuffer + 1); 488 } 489 490 /* Remove any extra lines at the end of the file */ 491 492 Length = strlen (FileBuffer); 493 FileEnd = FileBuffer + (Length - 2); 494 495 while (*FileEnd == '\n') 496 { 497 printf ("Removing extra line at end of file: %s\n", Filename); 498 AsRemoveData (FileEnd, FileEnd + 1); 499 FileEnd--; 500 } 501 } 502 503 504 /****************************************************************************** 505 * 506 * FUNCTION: AsRemoveSpacesAfterPeriod 507 * 508 * DESCRIPTION: Remove an extra space after a period. 509 * 510 ******************************************************************************/ 511 512 void 513 AsRemoveSpacesAfterPeriod ( 514 char *FileBuffer, 515 char *Filename) 516 { 517 int ReplaceCount = 0; 518 char *Possible; 519 520 521 Possible = FileBuffer; 522 while (Possible) 523 { 524 Possible = strstr (Possible, ". "); 525 if (Possible) 526 { 527 if ((*(Possible -1) == '.') || 528 (*(Possible -1) == '\"') || 529 (*(Possible -1) == '\n')) 530 { 531 Possible += 3; 532 continue; 533 } 534 535 Possible = AsReplaceData (Possible, 3, ". ", 2); 536 ReplaceCount++; 537 } 538 } 539 540 if (ReplaceCount) 541 { 542 printf ("Removed %d extra blanks after a period: %s\n", 543 ReplaceCount, Filename); 544 } 545 } 546 547 548 /****************************************************************************** 549 * 550 * FUNCTION: AsMatchExactWord 551 * 552 * DESCRIPTION: Check previous and next characters for whitespace 553 * 554 ******************************************************************************/ 555 556 BOOLEAN 557 AsMatchExactWord ( 558 char *Word, 559 UINT32 WordLength) 560 { 561 char NextChar; 562 char PrevChar; 563 564 565 NextChar = Word[WordLength]; 566 PrevChar = * (Word -1); 567 568 if (isalnum ((int) NextChar) || 569 (NextChar == '_') || 570 isalnum ((int) PrevChar) || 571 (PrevChar == '_')) 572 { 573 return (FALSE); 574 } 575 576 return (TRUE); 577 } 578 579 580 /****************************************************************************** 581 * 582 * FUNCTION: AsPrint 583 * 584 * DESCRIPTION: Common formatted print 585 * 586 ******************************************************************************/ 587 588 void 589 AsPrint ( 590 char *Message, 591 UINT32 Count, 592 char *Filename) 593 { 594 595 if (Gbl_QuietMode) 596 { 597 return; 598 } 599 600 printf ("-- %4u %28.28s : %s\n", Count, Message, Filename); 601 } 602 603 604 /****************************************************************************** 605 * 606 * FUNCTION: AsTrimLines 607 * 608 * DESCRIPTION: Remove extra blanks from the end of source lines. Does not 609 * check for tabs. 610 * 611 ******************************************************************************/ 612 613 void 614 AsTrimLines ( 615 char *Buffer, 616 char *Filename) 617 { 618 char *SubBuffer = Buffer; 619 char *StartWhiteSpace = NULL; 620 UINT32 SpaceCount = 0; 621 622 623 while (*SubBuffer) 624 { 625 while (*SubBuffer != '\n') 626 { 627 if (!*SubBuffer) 628 { 629 goto Exit; 630 } 631 632 if (*SubBuffer == ' ') 633 { 634 if (!StartWhiteSpace) 635 { 636 StartWhiteSpace = SubBuffer; 637 } 638 } 639 else 640 { 641 StartWhiteSpace = NULL; 642 } 643 644 SubBuffer++; 645 } 646 647 if (StartWhiteSpace) 648 { 649 SpaceCount += (SubBuffer - StartWhiteSpace); 650 651 /* Remove the spaces */ 652 653 SubBuffer = AsRemoveData (StartWhiteSpace, SubBuffer); 654 StartWhiteSpace = NULL; 655 } 656 657 SubBuffer++; 658 } 659 660 661 Exit: 662 if (SpaceCount) 663 { 664 Gbl_MadeChanges = TRUE; 665 AsPrint ("Extraneous spaces removed", SpaceCount, Filename); 666 } 667 } 668 669 670 /****************************************************************************** 671 * 672 * FUNCTION: AsTrimWhitespace 673 * 674 * DESCRIPTION: Remove "excess" blank lines - any more than 2 blank lines. 675 * this can happen during the translation when lines are removed. 676 * 677 ******************************************************************************/ 678 679 void 680 AsTrimWhitespace ( 681 char *Buffer) 682 { 683 char *SubBuffer; 684 int ReplaceCount = 1; 685 686 687 while (ReplaceCount) 688 { 689 ReplaceCount = AsReplaceString ("\n\n\n\n", "\n\n\n", 690 REPLACE_SUBSTRINGS, Buffer); 691 } 692 693 /* 694 * Check for exactly one blank line after the copyright header 695 */ 696 697 /* Find the header */ 698 699 SubBuffer = strstr (Buffer, HeaderBegin); 700 if (!SubBuffer) 701 { 702 return; 703 } 704 705 /* Find the end of the header */ 706 707 SubBuffer = strstr (SubBuffer, "*/"); 708 SubBuffer = AsSkipPastChar (SubBuffer, '\n'); 709 710 /* Replace a double blank line with a single */ 711 712 if (!strncmp (SubBuffer, "\n\n", 2)) 713 { 714 AsReplaceData (SubBuffer, 2, "\n", 1); 715 AcpiOsPrintf ("Found multiple blank lines after copyright\n"); 716 } 717 718 /* If no blank line after header, insert one */ 719 720 else if (*SubBuffer != '\n') 721 { 722 AsInsertData (SubBuffer, "\n", 1); 723 AcpiOsPrintf ("Inserted blank line after copyright\n"); 724 } 725 } 726 727 728 /****************************************************************************** 729 * 730 * FUNCTION: AsReplaceHeader 731 * 732 * DESCRIPTION: Replace the default Intel legal header with a new header 733 * 734 ******************************************************************************/ 735 736 void 737 AsReplaceHeader ( 738 char *Buffer, 739 char *NewHeader) 740 { 741 char *SubBuffer; 742 char *TokenEnd; 743 744 745 /* Find the original header */ 746 747 SubBuffer = strstr (Buffer, HeaderBegin); 748 if (!SubBuffer) 749 { 750 return; 751 } 752 753 /* Find the end of the original header */ 754 755 TokenEnd = strstr (SubBuffer, "*/"); 756 TokenEnd = AsSkipPastChar (TokenEnd, '\n'); 757 758 /* Delete old header, insert new one */ 759 760 AsReplaceData (SubBuffer, TokenEnd - SubBuffer, 761 NewHeader, strlen (NewHeader)); 762 } 763 764 765 /****************************************************************************** 766 * 767 * FUNCTION: AsDoSpdxHeader 768 * 769 * DESCRIPTION: Replace the default Intel legal header with a new header 770 * 771 ******************************************************************************/ 772 773 void 774 AsDoSpdxHeader ( 775 char *Buffer, 776 char *SpdxHeader) 777 { 778 char *SubBuffer; 779 780 781 /* Place an SPDX header at the very top */ 782 783 AsReplaceData (Buffer, 0, 784 SpdxHeader, strlen (SpdxHeader)); 785 786 /* Place an Intel copyright notice in the module header */ 787 788 SubBuffer = strstr (Buffer, MODULE_HEADER_END); 789 if (!SubBuffer) 790 { 791 return; 792 } 793 794 AsReplaceData (SubBuffer, strlen (MODULE_HEADER_END), 795 CopyRightHeaderEnd, strlen (CopyRightHeaderEnd)); 796 } 797 798 /****************************************************************************** 799 * 800 * FUNCTION: AsReplaceString 801 * 802 * DESCRIPTION: Replace all instances of a target string with a replacement 803 * string. Returns count of the strings replaced. 804 * 805 ******************************************************************************/ 806 807 int 808 AsReplaceString ( 809 char *Target, 810 char *Replacement, 811 UINT8 Type, 812 char *Buffer) 813 { 814 char *SubString1; 815 char *SubString2; 816 char *SubBuffer; 817 int TargetLength; 818 int ReplacementLength; 819 int ReplaceCount = 0; 820 821 822 TargetLength = strlen (Target); 823 ReplacementLength = strlen (Replacement); 824 825 SubBuffer = Buffer; 826 SubString1 = Buffer; 827 828 while (SubString1) 829 { 830 /* Find the target string */ 831 832 SubString1 = strstr (SubBuffer, Target); 833 if (!SubString1) 834 { 835 return (ReplaceCount); 836 } 837 838 /* 839 * Check for translation escape string -- means to ignore 840 * blocks of code while replacing 841 */ 842 if (Gbl_IgnoreTranslationEscapes) 843 { 844 SubString2 = NULL; 845 } 846 else 847 { 848 SubString2 = strstr (SubBuffer, AS_START_IGNORE); 849 } 850 851 if ((SubString2) && 852 (SubString2 < SubString1)) 853 { 854 /* Find end of the escape block starting at "Substring2" */ 855 856 SubString2 = strstr (SubString2, AS_STOP_IGNORE); 857 if (!SubString2) 858 { 859 /* Didn't find terminator */ 860 861 return (ReplaceCount); 862 } 863 864 /* Move buffer to end of escape block and continue */ 865 866 SubBuffer = SubString2; 867 } 868 869 /* Do the actual replace if the target was found */ 870 871 else 872 { 873 if ((Type & REPLACE_MASK) == REPLACE_WHOLE_WORD) 874 { 875 if (!AsMatchExactWord (SubString1, TargetLength)) 876 { 877 SubBuffer = SubString1 + 1; 878 continue; 879 } 880 } 881 882 SubBuffer = AsReplaceData (SubString1, TargetLength, 883 Replacement, ReplacementLength); 884 885 if ((Type & EXTRA_INDENT_C) && 886 (!Gbl_StructDefs)) 887 { 888 SubBuffer = AsInsertData (SubBuffer, " ", 8); 889 } 890 891 ReplaceCount++; 892 } 893 } 894 895 return (ReplaceCount); 896 } 897 898 899 /****************************************************************************** 900 * 901 * FUNCTION: AsConvertToLineFeeds 902 * 903 * DESCRIPTION: Convert all CR/LF pairs to LF only. 904 * 905 ******************************************************************************/ 906 907 void 908 AsConvertToLineFeeds ( 909 char *Buffer) 910 { 911 char *SubString; 912 char *SubBuffer; 913 914 915 SubBuffer = Buffer; 916 SubString = Buffer; 917 918 while (SubString) 919 { 920 /* Find the target string */ 921 922 SubString = strstr (SubBuffer, "\r\n"); 923 if (!SubString) 924 { 925 return; 926 } 927 928 SubBuffer = AsReplaceData (SubString, 1, NULL, 0); 929 } 930 } 931 932 933 /****************************************************************************** 934 * 935 * FUNCTION: AsInsertCarriageReturns 936 * 937 * DESCRIPTION: Convert lone LFs to CR/LF pairs. 938 * 939 ******************************************************************************/ 940 941 void 942 AsInsertCarriageReturns ( 943 char *Buffer) 944 { 945 char *SubString; 946 char *SubBuffer; 947 948 949 SubBuffer = Buffer; 950 SubString = Buffer; 951 952 while (SubString) 953 { 954 /* Find the target string */ 955 956 SubString = strstr (SubBuffer, "\n"); 957 if (!SubString) 958 { 959 return; 960 } 961 962 SubBuffer = AsInsertData (SubString, "\r", 1); 963 SubBuffer += 1; 964 } 965 } 966 967 968 /****************************************************************************** 969 * 970 * FUNCTION: AsBracesOnSameLine 971 * 972 * DESCRIPTION: Move opening braces up to the same line as an if, for, else, 973 * or while statement (leave function opening brace on separate 974 * line). 975 * 976 ******************************************************************************/ 977 978 void 979 AsBracesOnSameLine ( 980 char *Buffer) 981 { 982 char *SubBuffer = Buffer; 983 char *Beginning; 984 char *StartOfThisLine; 985 char *Next; 986 BOOLEAN BlockBegin = TRUE; 987 988 989 while (*SubBuffer) 990 { 991 /* Ignore comments */ 992 993 if ((SubBuffer[0] == '/') && 994 (SubBuffer[1] == '*')) 995 { 996 SubBuffer = strstr (SubBuffer, "*/"); 997 if (!SubBuffer) 998 { 999 return; 1000 } 1001 1002 SubBuffer += 2; 1003 continue; 1004 } 1005 1006 /* Ignore quoted strings */ 1007 1008 if (*SubBuffer == '\"') 1009 { 1010 SubBuffer++; 1011 SubBuffer = AsSkipPastChar (SubBuffer, '\"'); 1012 if (!SubBuffer) 1013 { 1014 return; 1015 } 1016 } 1017 1018 if (!strncmp ("\n}", SubBuffer, 2)) 1019 { 1020 /* 1021 * A newline followed by a closing brace closes a function 1022 * or struct or initializer block 1023 */ 1024 BlockBegin = TRUE; 1025 } 1026 1027 /* 1028 * Move every standalone brace up to the previous line 1029 * Check for digit will ignore initializer lists surrounded by braces. 1030 * This will work until we we need more complex detection. 1031 */ 1032 if ((*SubBuffer == '{') && !isdigit ((int) SubBuffer[1])) 1033 { 1034 if (BlockBegin) 1035 { 1036 BlockBegin = FALSE; 1037 } 1038 else 1039 { 1040 /* 1041 * Backup to previous non-whitespace 1042 */ 1043 Beginning = SubBuffer - 1; 1044 while ((*Beginning == ' ') || 1045 (*Beginning == '\n')) 1046 { 1047 Beginning--; 1048 } 1049 1050 StartOfThisLine = Beginning; 1051 while (*StartOfThisLine != '\n') 1052 { 1053 StartOfThisLine--; 1054 } 1055 1056 /* 1057 * Move the brace up to the previous line, UNLESS: 1058 * 1059 * 1) There is a conditional compile on the line (starts with '#') 1060 * 2) Previous line ends with an '=' (Start of initializer block) 1061 * 3) Previous line ends with a comma (part of an init list) 1062 * 4) Previous line ends with a backslash (part of a macro) 1063 */ 1064 if ((StartOfThisLine[1] != '#') && 1065 (*Beginning != '\\') && 1066 (*Beginning != '/') && 1067 (*Beginning != '{') && 1068 (*Beginning != '=') && 1069 (*Beginning != ',')) 1070 { 1071 Beginning++; 1072 SubBuffer++; 1073 1074 Gbl_MadeChanges = TRUE; 1075 1076 #ifdef ADD_EXTRA_WHITESPACE 1077 AsReplaceData (Beginning, SubBuffer - Beginning, " {\n", 3); 1078 #else 1079 /* Find non-whitespace start of next line */ 1080 1081 Next = SubBuffer + 1; 1082 while ((*Next == ' ') || 1083 (*Next == '\t')) 1084 { 1085 Next++; 1086 } 1087 1088 /* Find non-whitespace start of this line */ 1089 1090 StartOfThisLine++; 1091 while ((*StartOfThisLine == ' ') || 1092 (*StartOfThisLine == '\t')) 1093 { 1094 StartOfThisLine++; 1095 } 1096 1097 /* 1098 * Must be a single-line comment to need more whitespace 1099 * Even then, we don't need more if the previous statement 1100 * is an "else". 1101 */ 1102 if ((Next[0] == '/') && 1103 (Next[1] == '*') && 1104 (Next[2] != '\n') && 1105 1106 (!strncmp (StartOfThisLine, "else if", 7) || 1107 !strncmp (StartOfThisLine, "else while", 10) || 1108 strncmp (StartOfThisLine, "else", 4))) 1109 { 1110 AsReplaceData (Beginning, SubBuffer - Beginning, " {\n", 3); 1111 } 1112 else 1113 { 1114 AsReplaceData (Beginning, SubBuffer - Beginning, " {", 2); 1115 } 1116 #endif 1117 } 1118 } 1119 } 1120 1121 SubBuffer++; 1122 } 1123 } 1124 1125 1126 /****************************************************************************** 1127 * 1128 * FUNCTION: AsTabify4 1129 * 1130 * DESCRIPTION: Convert the text to tabbed text. Alignment of text is 1131 * preserved. 1132 * 1133 ******************************************************************************/ 1134 1135 void 1136 AsTabify4 ( 1137 char *Buffer) 1138 { 1139 char *SubBuffer = Buffer; 1140 char *NewSubBuffer; 1141 UINT32 SpaceCount = 0; 1142 UINT32 Column = 0; 1143 1144 1145 while (*SubBuffer) 1146 { 1147 if (*SubBuffer == '\n') 1148 { 1149 Column = 0; 1150 } 1151 else 1152 { 1153 Column++; 1154 } 1155 1156 /* Ignore comments */ 1157 1158 if ((SubBuffer[0] == '/') && 1159 (SubBuffer[1] == '*')) 1160 { 1161 SubBuffer = strstr (SubBuffer, "*/"); 1162 if (!SubBuffer) 1163 { 1164 return; 1165 } 1166 1167 SubBuffer += 2; 1168 continue; 1169 } 1170 1171 /* Ignore quoted strings */ 1172 1173 if (*SubBuffer == '\"') 1174 { 1175 SubBuffer++; 1176 SubBuffer = AsSkipPastChar (SubBuffer, '\"'); 1177 if (!SubBuffer) 1178 { 1179 return; 1180 } 1181 SpaceCount = 0; 1182 } 1183 1184 if (*SubBuffer == ' ') 1185 { 1186 SpaceCount++; 1187 1188 if (SpaceCount >= 4) 1189 { 1190 SpaceCount = 0; 1191 1192 NewSubBuffer = (SubBuffer + 1) - 4; 1193 *NewSubBuffer = '\t'; 1194 NewSubBuffer++; 1195 1196 /* Remove the spaces */ 1197 1198 SubBuffer = AsRemoveData (NewSubBuffer, SubBuffer + 1); 1199 } 1200 1201 if ((Column % 4) == 0) 1202 { 1203 SpaceCount = 0; 1204 } 1205 } 1206 else 1207 { 1208 SpaceCount = 0; 1209 } 1210 1211 SubBuffer++; 1212 } 1213 } 1214 1215 1216 /****************************************************************************** 1217 * 1218 * FUNCTION: AsTabify8 1219 * 1220 * DESCRIPTION: Convert the text to tabbed text. Alignment of text is 1221 * preserved. 1222 * 1223 ******************************************************************************/ 1224 1225 void 1226 AsTabify8 ( 1227 char *Buffer) 1228 { 1229 char *SubBuffer = Buffer; 1230 char *NewSubBuffer; 1231 char *CommentEnd = NULL; 1232 UINT32 SpaceCount = 0; 1233 UINT32 Column = 0; 1234 UINT32 TabCount = 0; 1235 UINT32 LastLineTabCount = 0; 1236 UINT32 LastLineColumnStart = 0; 1237 UINT32 ThisColumnStart = 0; 1238 UINT32 ThisTabCount = 0; 1239 char *FirstNonBlank = NULL; 1240 1241 1242 while (*SubBuffer) 1243 { 1244 if (*SubBuffer == '\n') 1245 { 1246 /* This is a standalone blank line */ 1247 1248 FirstNonBlank = NULL; 1249 Column = 0; 1250 SpaceCount = 0; 1251 TabCount = 0; 1252 SubBuffer++; 1253 continue; 1254 } 1255 1256 if (!FirstNonBlank) 1257 { 1258 /* Find the first non-blank character on this line */ 1259 1260 FirstNonBlank = SubBuffer; 1261 while (*FirstNonBlank == ' ') 1262 { 1263 FirstNonBlank++; 1264 } 1265 1266 /* 1267 * This mechanism limits the difference in tab counts from 1268 * line to line. It helps avoid the situation where a second 1269 * continuation line (which was indented correctly for tabs=4) would 1270 * get indented off the screen if we just blindly converted to tabs. 1271 */ 1272 ThisColumnStart = FirstNonBlank - SubBuffer; 1273 1274 if (LastLineTabCount == 0) 1275 { 1276 ThisTabCount = 0; 1277 } 1278 else if (ThisColumnStart == LastLineColumnStart) 1279 { 1280 ThisTabCount = LastLineTabCount -1; 1281 } 1282 else 1283 { 1284 ThisTabCount = LastLineTabCount + 1; 1285 } 1286 } 1287 1288 Column++; 1289 1290 /* Check if we are in a comment */ 1291 1292 if ((SubBuffer[0] == '*') && 1293 (SubBuffer[1] == '/')) 1294 { 1295 SpaceCount = 0; 1296 SubBuffer += 2; 1297 1298 if (*SubBuffer == '\n') 1299 { 1300 if (TabCount > 0) 1301 { 1302 LastLineTabCount = TabCount; 1303 TabCount = 0; 1304 } 1305 1306 FirstNonBlank = NULL; 1307 LastLineColumnStart = ThisColumnStart; 1308 SubBuffer++; 1309 } 1310 1311 continue; 1312 } 1313 1314 /* Check for comment open */ 1315 1316 if ((SubBuffer[0] == '/') && 1317 (SubBuffer[1] == '*')) 1318 { 1319 /* Find the end of the comment, it must exist */ 1320 1321 CommentEnd = strstr (SubBuffer, "*/"); 1322 if (!CommentEnd) 1323 { 1324 return; 1325 } 1326 1327 /* Toss the rest of this line or single-line comment */ 1328 1329 while ((SubBuffer < CommentEnd) && 1330 (*SubBuffer != '\n')) 1331 { 1332 SubBuffer++; 1333 } 1334 1335 if (*SubBuffer == '\n') 1336 { 1337 if (TabCount > 0) 1338 { 1339 LastLineTabCount = TabCount; 1340 TabCount = 0; 1341 } 1342 1343 FirstNonBlank = NULL; 1344 LastLineColumnStart = ThisColumnStart; 1345 } 1346 1347 SpaceCount = 0; 1348 continue; 1349 } 1350 1351 /* Ignore quoted strings */ 1352 1353 if ((!CommentEnd) && (*SubBuffer == '\"')) 1354 { 1355 SubBuffer++; 1356 SubBuffer = AsSkipPastChar (SubBuffer, '\"'); 1357 if (!SubBuffer) 1358 { 1359 return; 1360 } 1361 1362 SpaceCount = 0; 1363 } 1364 1365 if (*SubBuffer != ' ') 1366 { 1367 /* Not a space, skip to end of line */ 1368 1369 SubBuffer = AsSkipUntilChar (SubBuffer, '\n'); 1370 if (!SubBuffer) 1371 { 1372 return; 1373 } 1374 if (TabCount > 0) 1375 { 1376 LastLineTabCount = TabCount; 1377 TabCount = 0; 1378 } 1379 1380 FirstNonBlank = NULL; 1381 LastLineColumnStart = ThisColumnStart; 1382 Column = 0; 1383 SpaceCount = 0; 1384 } 1385 else 1386 { 1387 /* Another space */ 1388 1389 SpaceCount++; 1390 1391 if (SpaceCount >= 4) 1392 { 1393 /* Replace this group of spaces with a tab character */ 1394 1395 SpaceCount = 0; 1396 1397 NewSubBuffer = SubBuffer - 3; 1398 1399 if (TabCount <= ThisTabCount ? (ThisTabCount +1) : 0) 1400 { 1401 *NewSubBuffer = '\t'; 1402 NewSubBuffer++; 1403 SubBuffer++; 1404 TabCount++; 1405 } 1406 1407 /* Remove the spaces */ 1408 1409 SubBuffer = AsRemoveData (NewSubBuffer, SubBuffer); 1410 continue; 1411 } 1412 } 1413 1414 SubBuffer++; 1415 } 1416 } 1417 1418 1419 /****************************************************************************** 1420 * 1421 * FUNCTION: AsCountLines 1422 * 1423 * DESCRIPTION: Count the number of lines in the input buffer. Also count 1424 * the number of long lines (lines longer than 80 chars). 1425 * 1426 ******************************************************************************/ 1427 1428 static UINT32 1429 AsCountLines ( 1430 char *Buffer, 1431 char *Filename) 1432 { 1433 char *SubBuffer = Buffer; 1434 char *EndOfLine; 1435 UINT32 LineCount = 0; 1436 UINT32 LongLineCount = 0; 1437 1438 1439 while (*SubBuffer) 1440 { 1441 EndOfLine = AsSkipUntilChar (SubBuffer, '\n'); 1442 if (!EndOfLine) 1443 { 1444 Gbl_TotalLines += LineCount; 1445 return (LineCount); 1446 } 1447 1448 if ((EndOfLine - SubBuffer) > 80) 1449 { 1450 LongLineCount++; 1451 VERBOSE_PRINT (("long: %.80s\n", SubBuffer)); 1452 } 1453 1454 LineCount++; 1455 SubBuffer = EndOfLine + 1; 1456 } 1457 1458 if (LongLineCount) 1459 { 1460 VERBOSE_PRINT (("%u Lines longer than 80 found in %s\n", 1461 LongLineCount, Filename)); 1462 1463 Gbl_LongLines += LongLineCount; 1464 } 1465 1466 Gbl_TotalLines += LineCount; 1467 return (LineCount); 1468 } 1469 1470 1471 /****************************************************************************** 1472 * 1473 * FUNCTION: AsCountTabs 1474 * 1475 * DESCRIPTION: Simply count the number of tabs in the input file buffer 1476 * 1477 ******************************************************************************/ 1478 1479 void 1480 AsCountTabs ( 1481 char *Buffer, 1482 char *Filename) 1483 { 1484 UINT32 i; 1485 UINT32 TabCount = 0; 1486 1487 1488 for (i = 0; Buffer[i]; i++) 1489 { 1490 if (Buffer[i] == '\t') 1491 { 1492 TabCount++; 1493 } 1494 } 1495 1496 if (TabCount) 1497 { 1498 AsPrint ("Tabs found", TabCount, Filename); 1499 Gbl_Tabs += TabCount; 1500 } 1501 1502 AsCountLines (Buffer, Filename); 1503 } 1504 1505 1506 /****************************************************************************** 1507 * 1508 * FUNCTION: AsCountSourceLines 1509 * 1510 * DESCRIPTION: Count the number of C source lines. Defined by 1) not a 1511 * comment, and 2) not a blank line. 1512 * 1513 ******************************************************************************/ 1514 1515 void 1516 AsCountSourceLines ( 1517 char *Buffer, 1518 char *Filename) 1519 { 1520 char *SubBuffer = Buffer; 1521 UINT32 LineCount = 0; 1522 UINT32 WhiteCount = 0; 1523 UINT32 CommentCount = 0; 1524 1525 1526 while (*SubBuffer) 1527 { 1528 /* Detect comments (// comments are not used, non-ansii) */ 1529 1530 if ((SubBuffer[0] == '/') && 1531 (SubBuffer[1] == '*')) 1532 { 1533 SubBuffer += 2; 1534 1535 /* First line of multi-line comment is often just whitespace */ 1536 1537 if (SubBuffer[0] == '\n') 1538 { 1539 WhiteCount++; 1540 SubBuffer++; 1541 } 1542 else 1543 { 1544 CommentCount++; 1545 } 1546 1547 /* Find end of comment */ 1548 1549 while (SubBuffer[0] && SubBuffer[1] && 1550 !(((SubBuffer[0] == '*') && 1551 (SubBuffer[1] == '/')))) 1552 { 1553 if (SubBuffer[0] == '\n') 1554 { 1555 CommentCount++; 1556 } 1557 1558 SubBuffer++; 1559 } 1560 } 1561 1562 /* A linefeed followed by a non-linefeed is a valid source line */ 1563 1564 else if ((SubBuffer[0] == '\n') && 1565 (SubBuffer[1] != '\n')) 1566 { 1567 LineCount++; 1568 } 1569 1570 /* Two back-to-back linefeeds indicate a whitespace line */ 1571 1572 else if ((SubBuffer[0] == '\n') && 1573 (SubBuffer[1] == '\n')) 1574 { 1575 WhiteCount++; 1576 } 1577 1578 SubBuffer++; 1579 } 1580 1581 /* Adjust comment count for legal header */ 1582 1583 if (Gbl_HeaderSize < CommentCount) 1584 { 1585 CommentCount -= Gbl_HeaderSize; 1586 Gbl_HeaderLines += Gbl_HeaderSize; 1587 } 1588 1589 Gbl_SourceLines += LineCount; 1590 Gbl_WhiteLines += WhiteCount; 1591 Gbl_CommentLines += CommentCount; 1592 1593 VERBOSE_PRINT (("%u Comment %u White %u Code %u Lines in %s\n", 1594 CommentCount, WhiteCount, LineCount, 1595 LineCount + WhiteCount + CommentCount, Filename)); 1596 } 1597 1598 1599 /****************************************************************************** 1600 * 1601 * FUNCTION: AsInsertPrefix 1602 * 1603 * DESCRIPTION: Insert struct or union prefixes 1604 * 1605 ******************************************************************************/ 1606 1607 void 1608 AsInsertPrefix ( 1609 char *Buffer, 1610 char *Keyword, 1611 UINT8 Type) 1612 { 1613 char *SubString; 1614 char *SubBuffer; 1615 char *EndKeyword; 1616 int InsertLength; 1617 char *InsertString; 1618 int TrailingSpaces; 1619 char LowerKeyword[128]; 1620 int KeywordLength; 1621 1622 1623 switch (Type) 1624 { 1625 case SRC_TYPE_STRUCT: 1626 1627 InsertString = "struct "; 1628 break; 1629 1630 case SRC_TYPE_UNION: 1631 1632 InsertString = "union "; 1633 break; 1634 1635 default: 1636 1637 return; 1638 } 1639 1640 strcpy (LowerKeyword, Keyword); 1641 AcpiUtStrlwr (LowerKeyword); 1642 1643 SubBuffer = Buffer; 1644 SubString = Buffer; 1645 InsertLength = strlen (InsertString); 1646 KeywordLength = strlen (Keyword); 1647 1648 1649 while (SubString) 1650 { 1651 /* Find an instance of the keyword */ 1652 1653 SubString = strstr (SubBuffer, LowerKeyword); 1654 if (!SubString) 1655 { 1656 return; 1657 } 1658 1659 SubBuffer = SubString; 1660 1661 /* Must be standalone word, not a substring */ 1662 1663 if (AsMatchExactWord (SubString, KeywordLength)) 1664 { 1665 /* Make sure the keyword isn't already prefixed with the insert */ 1666 1667 if (!strncmp (SubString - InsertLength, InsertString, InsertLength)) 1668 { 1669 /* Add spaces if not already at the end-of-line */ 1670 1671 if (*(SubBuffer + KeywordLength) != '\n') 1672 { 1673 /* Already present, add spaces after to align structure members */ 1674 1675 #if 0 1676 /* ONLY FOR C FILES */ 1677 AsInsertData (SubBuffer + KeywordLength, " ", 8); 1678 #endif 1679 } 1680 goto Next; 1681 } 1682 1683 /* Make sure the keyword isn't at the end of a struct/union */ 1684 /* Note: This code depends on a single space after the brace */ 1685 1686 if (*(SubString - 2) == '}') 1687 { 1688 goto Next; 1689 } 1690 1691 /* Prefix the keyword with the insert string */ 1692 1693 Gbl_MadeChanges = TRUE; 1694 1695 /* Is there room for insertion */ 1696 1697 EndKeyword = SubString + strlen (LowerKeyword); 1698 1699 TrailingSpaces = 0; 1700 while (EndKeyword[TrailingSpaces] == ' ') 1701 { 1702 TrailingSpaces++; 1703 } 1704 1705 /* 1706 * Use "if (TrailingSpaces > 1)" if we want to ignore casts 1707 */ 1708 SubBuffer = SubString + InsertLength; 1709 1710 if (TrailingSpaces > InsertLength) 1711 { 1712 /* Insert the keyword */ 1713 1714 memmove (SubBuffer, SubString, KeywordLength); 1715 1716 /* Insert the keyword */ 1717 1718 memmove (SubString, InsertString, InsertLength); 1719 } 1720 else 1721 { 1722 AsInsertData (SubString, InsertString, InsertLength); 1723 } 1724 } 1725 1726 Next: 1727 SubBuffer += KeywordLength; 1728 } 1729 } 1730 1731 #ifdef ACPI_FUTURE_IMPLEMENTATION 1732 /****************************************************************************** 1733 * 1734 * FUNCTION: AsTrimComments 1735 * 1736 * DESCRIPTION: Finds 3-line comments with only a single line of text 1737 * 1738 ******************************************************************************/ 1739 1740 void 1741 AsTrimComments ( 1742 char *Buffer, 1743 char *Filename) 1744 { 1745 char *SubBuffer = Buffer; 1746 char *Ptr1; 1747 char *Ptr2; 1748 UINT32 LineCount; 1749 UINT32 ShortCommentCount = 0; 1750 1751 1752 while (1) 1753 { 1754 /* Find comment open, within procedure level */ 1755 1756 SubBuffer = strstr (SubBuffer, " /*"); 1757 if (!SubBuffer) 1758 { 1759 goto Exit; 1760 } 1761 1762 /* Find comment terminator */ 1763 1764 Ptr1 = strstr (SubBuffer, "*/"); 1765 if (!Ptr1) 1766 { 1767 goto Exit; 1768 } 1769 1770 /* Find next EOL (from original buffer) */ 1771 1772 Ptr2 = strstr (SubBuffer, "\n"); 1773 if (!Ptr2) 1774 { 1775 goto Exit; 1776 } 1777 1778 /* Ignore one-line comments */ 1779 1780 if (Ptr1 < Ptr2) 1781 { 1782 /* Normal comment, ignore and continue; */ 1783 1784 SubBuffer = Ptr2; 1785 continue; 1786 } 1787 1788 /* Examine multi-line comment */ 1789 1790 LineCount = 1; 1791 while (Ptr1 > Ptr2) 1792 { 1793 /* Find next EOL */ 1794 1795 Ptr2++; 1796 Ptr2 = strstr (Ptr2, "\n"); 1797 if (!Ptr2) 1798 { 1799 goto Exit; 1800 } 1801 1802 LineCount++; 1803 } 1804 1805 SubBuffer = Ptr1; 1806 1807 if (LineCount <= 3) 1808 { 1809 ShortCommentCount++; 1810 } 1811 } 1812 1813 1814 Exit: 1815 1816 if (ShortCommentCount) 1817 { 1818 AsPrint ("Short Comments found", ShortCommentCount, Filename); 1819 } 1820 } 1821 #endif 1822 1823 #ifdef ACPI_UNUSED_FUNCTIONS 1824 /****************************************************************************** 1825 * 1826 * FUNCTION: AsCheckAndSkipLiterals 1827 * 1828 * DESCRIPTION: Generic routine to skip comments and quoted string literals. 1829 * Keeps a line count. 1830 * 1831 ******************************************************************************/ 1832 1833 static char * 1834 AsCheckAndSkipLiterals ( 1835 char *Buffer, 1836 UINT32 *TotalLines); 1837 1838 1839 static char * 1840 AsCheckAndSkipLiterals ( 1841 char *Buffer, 1842 UINT32 *TotalLines) 1843 { 1844 UINT32 NewLines = 0; 1845 char *SubBuffer = Buffer; 1846 char *LiteralEnd; 1847 1848 1849 /* Ignore comments */ 1850 1851 if ((SubBuffer[0] == '/') && 1852 (SubBuffer[1] == '*')) 1853 { 1854 LiteralEnd = strstr (SubBuffer, "*/"); 1855 SubBuffer += 2; /* Get past comment opening */ 1856 1857 if (!LiteralEnd) 1858 { 1859 return (SubBuffer); 1860 } 1861 1862 while (SubBuffer < LiteralEnd) 1863 { 1864 if (*SubBuffer == '\n') 1865 { 1866 NewLines++; 1867 } 1868 1869 SubBuffer++; 1870 } 1871 1872 SubBuffer += 2; /* Get past comment close */ 1873 } 1874 1875 /* Ignore quoted strings */ 1876 1877 else if (*SubBuffer == '\"') 1878 { 1879 SubBuffer++; 1880 LiteralEnd = AsSkipPastChar (SubBuffer, '\"'); 1881 if (!LiteralEnd) 1882 { 1883 return (SubBuffer); 1884 } 1885 } 1886 1887 if (TotalLines) 1888 { 1889 (*TotalLines) += NewLines; 1890 } 1891 return (SubBuffer); 1892 } 1893 #endif 1894