arch/all-pc/acpica/source/tools/acpisrc/asconvrt.c

   1 /******************************************************************************
   2  *
   3  * Module Name: asconvrt - Source conversion code
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 char *
  49 AsCheckAndSkipLiterals (
  50     char                    *Buffer,
  51     UINT32                  *TotalLines);
  52
  53 UINT32
  54 AsCountLines (
  55     char                    *Buffer,
  56     char                    *Filename);
  57
  58 /* Opening signature of the Intel legal header */
  59
  60 char        *HeaderBegin = "/******************************************************************************\n *\n * 1. Copyright Notice";
  61
  62
  63 /******************************************************************************
  64  *
  65  * FUNCTION:    AsRemoveExtraLines
  66  *
  67  * DESCRIPTION: Remove all extra lines at the start and end of the file.
  68  *
  69  ******************************************************************************/
  70
  71 void
  72 AsRemoveExtraLines (
  73     char                    *FileBuffer,
  74     char                    *Filename)
  75 {
  76     char                    *FileEnd;
  77     int                     Length;
  78
  79
  80     /* Remove any extra lines at the start of the file */
  81
  82     while (*FileBuffer == '\n')
  83     {
  84         printf ("Removing extra line at start of file: %s\n", Filename);
  85         AsRemoveData (FileBuffer, FileBuffer + 1);
  86     }
  87
  88     /* Remove any extra lines at the end of the file */
  89
  90     Length = strlen (FileBuffer);
  91     FileEnd = FileBuffer + (Length - 2);
  92
  93     while (*FileEnd == '\n')
  94     {
  95         printf ("Removing extra line at end of file: %s\n", Filename);
  96         AsRemoveData (FileEnd, FileEnd + 1);
  97         FileEnd--;
  98     }
  99 }
 100
 101
 102 /******************************************************************************
 103  *
 104  * FUNCTION:    AsRemoveSpacesAfterPeriod
 105  *
 106  * DESCRIPTION: Remove an extra space after a period.
 107  *
 108  ******************************************************************************/
 109
 110 void
 111 AsRemoveSpacesAfterPeriod (
 112     char                    *FileBuffer,
 113     char                    *Filename)
 114 {
 115     int                     ReplaceCount = 0;
 116     char                    *Possible;
 117
 118
 119     Possible = FileBuffer;
 120     while (Possible)
 121     {
 122         Possible = strstr (Possible, ".  ");
 123         if (Possible)
 124         {
 125             if ((*(Possible -1) == '.')  ||
 126                 (*(Possible -1) == '\"') ||
 127                 (*(Possible -1) == '\n'))
 128             {
 129                 Possible += 3;
 130                 continue;
 131             }
 132
 133             Possible = AsReplaceData (Possible, 3, ". ", 2);
 134             ReplaceCount++;
 135         }
 136     }
 137
 138     if (ReplaceCount)
 139     {
 140         printf ("Removed %d extra blanks after a period: %s\n",
 141             ReplaceCount, Filename);
 142     }
 143 }
 144
 145
 146 /******************************************************************************
 147  *
 148  * FUNCTION:    AsMatchExactWord
 149  *
 150  * DESCRIPTION: Check previous and next characters for whitespace
 151  *
 152  ******************************************************************************/
 153
 154 BOOLEAN
 155 AsMatchExactWord (
 156     char                    *Word,
 157     UINT32                  WordLength)
 158 {
 159     char                    NextChar;
 160     char                    PrevChar;
 161
 162
 163     NextChar = Word[WordLength];
 164     PrevChar = * (Word -1);
 165
 166     if (isalnum ((int) NextChar) ||
 167         (NextChar == '_')  ||
 168         isalnum ((int) PrevChar) ||
 169         (PrevChar == '_'))
 170     {
 171         return (FALSE);
 172     }
 173
 174     return (TRUE);
 175 }
 176
 177
 178 /******************************************************************************
 179  *
 180  * FUNCTION:    AsPrint
 181  *
 182  * DESCRIPTION: Common formatted print
 183  *
 184  ******************************************************************************/
 185
 186 void
 187 AsPrint (
 188     char                    *Message,
 189     UINT32                  Count,
 190     char                    *Filename)
 191 {
 192
 193     if (Gbl_QuietMode)
 194     {
 195         return;
 196     }
 197
 198     printf ("-- %4u %28.28s : %s\n", Count, Message, Filename);
 199 }
 200
 201
 202 /******************************************************************************
 203  *
 204  * FUNCTION:    AsCheckAndSkipLiterals
 205  *
 206  * DESCRIPTION: Generic routine to skip comments and quoted string literals.
 207  *              Keeps a line count.
 208  *
 209  ******************************************************************************/
 210
 211 char *
 212 AsCheckAndSkipLiterals (
 213     char                    *Buffer,
 214     UINT32                  *TotalLines)
 215 {
 216     UINT32                  NewLines = 0;
 217     char                    *SubBuffer = Buffer;
 218     char                    *LiteralEnd;
 219
 220
 221     /* Ignore comments */
 222
 223     if ((SubBuffer[0] == '/') &&
 224         (SubBuffer[1] == '*'))
 225     {
 226         LiteralEnd = strstr (SubBuffer, "*/");
 227         SubBuffer += 2;     /* Get past comment opening */
 228
 229         if (!LiteralEnd)
 230         {
 231             return (SubBuffer);
 232         }
 233
 234         while (SubBuffer < LiteralEnd)
 235         {
 236             if (*SubBuffer == '\n')
 237             {
 238                 NewLines++;
 239             }
 240
 241             SubBuffer++;
 242         }
 243
 244         SubBuffer += 2;     /* Get past comment close */
 245     }
 246
 247     /* Ignore quoted strings */
 248
 249     else if (*SubBuffer == '\"')
 250     {
 251         SubBuffer++;
 252         LiteralEnd = AsSkipPastChar (SubBuffer, '\"');
 253         if (!LiteralEnd)
 254         {
 255             return (SubBuffer);
 256         }
 257     }
 258
 259     if (TotalLines)
 260     {
 261         (*TotalLines) += NewLines;
 262     }
 263     return (SubBuffer);
 264 }
 265
 266
 267 /******************************************************************************
 268  *
 269  * FUNCTION:    AsAsCheckForBraces
 270  *
 271  * DESCRIPTION: Check for an open brace after each if statement
 272  *
 273  ******************************************************************************/
 274
 275 void
 276 AsCheckForBraces (
 277     char                    *Buffer,
 278     char                    *Filename)
 279 {
 280     char                    *SubBuffer = Buffer;
 281     char                    *NextBrace;
 282     char                    *NextSemicolon;
 283     char                    *NextIf;
 284     UINT32                  TotalLines = 1;
 285
 286
 287     while (*SubBuffer)
 288     {
 289
 290         SubBuffer = AsCheckAndSkipLiterals (SubBuffer, &TotalLines);
 291
 292         if (*SubBuffer == '\n')
 293         {
 294             TotalLines++;
 295         }
 296         else if (!(strncmp (" if", SubBuffer, 3)))
 297         {
 298             SubBuffer += 2;
 299             NextBrace = strstr (SubBuffer, "{");
 300             NextSemicolon = strstr (SubBuffer, ";");
 301             NextIf = strstr (SubBuffer, " if");
 302
 303             if ((!NextBrace) ||
 304                (NextSemicolon && (NextBrace > NextSemicolon)) ||
 305                (NextIf && (NextBrace > NextIf)))
 306             {
 307                 Gbl_MissingBraces++;
 308
 309                 if (!Gbl_QuietMode)
 310                 {
 311                     printf ("Missing braces for <if>, line %u: %s\n", TotalLines, Filename);
 312                 }
 313             }
 314         }
 315         else if (!(strncmp (" else if", SubBuffer, 8)))
 316         {
 317             SubBuffer += 7;
 318             NextBrace = strstr (SubBuffer, "{");
 319             NextSemicolon = strstr (SubBuffer, ";");
 320             NextIf = strstr (SubBuffer, " if");
 321
 322             if ((!NextBrace) ||
 323                (NextSemicolon && (NextBrace > NextSemicolon)) ||
 324                (NextIf && (NextBrace > NextIf)))
 325             {
 326                 Gbl_MissingBraces++;
 327
 328                 if (!Gbl_QuietMode)
 329                 {
 330                     printf ("Missing braces for <if>, line %u: %s\n", TotalLines, Filename);
 331                 }
 332             }
 333         }
 334         else if (!(strncmp (" else", SubBuffer, 5)))
 335         {
 336             SubBuffer += 4;
 337             NextBrace = strstr (SubBuffer, "{");
 338             NextSemicolon = strstr (SubBuffer, ";");
 339             NextIf = strstr (SubBuffer, " if");
 340
 341             if ((!NextBrace) ||
 342                (NextSemicolon && (NextBrace > NextSemicolon)) ||
 343                (NextIf && (NextBrace > NextIf)))
 344             {
 345                 Gbl_MissingBraces++;
 346
 347                 if (!Gbl_QuietMode)
 348                 {
 349                     printf ("Missing braces for <else>, line %u: %s\n", TotalLines, Filename);
 350                 }
 351             }
 352         }
 353
 354         SubBuffer++;
 355     }
 356 }
 357
 358
 359 /******************************************************************************
 360  *
 361  * FUNCTION:    AsTrimLines
 362  *
 363  * DESCRIPTION: Remove extra blanks from the end of source lines. Does not
 364  *              check for tabs.
 365  *
 366  ******************************************************************************/
 367
 368 void
 369 AsTrimLines (
 370     char                    *Buffer,
 371     char                    *Filename)
 372 {
 373     char                    *SubBuffer = Buffer;
 374     char                    *StartWhiteSpace = NULL;
 375     UINT32                  SpaceCount = 0;
 376
 377
 378     while (*SubBuffer)
 379     {
 380         while (*SubBuffer != '\n')
 381         {
 382             if (!*SubBuffer)
 383             {
 384                 goto Exit;
 385             }
 386
 387             if (*SubBuffer == ' ')
 388             {
 389                 if (!StartWhiteSpace)
 390                 {
 391                     StartWhiteSpace = SubBuffer;
 392                 }
 393             }
 394             else
 395             {
 396                 StartWhiteSpace = NULL;
 397             }
 398
 399             SubBuffer++;
 400         }
 401
 402         if (StartWhiteSpace)
 403         {
 404             SpaceCount += (SubBuffer - StartWhiteSpace);
 405
 406             /* Remove the spaces */
 407
 408             SubBuffer = AsRemoveData (StartWhiteSpace, SubBuffer);
 409             StartWhiteSpace = NULL;
 410         }
 411
 412         SubBuffer++;
 413     }
 414
 415
 416 Exit:
 417     if (SpaceCount)
 418     {
 419         Gbl_MadeChanges = TRUE;
 420         AsPrint ("Extraneous spaces removed", SpaceCount, Filename);
 421     }
 422 }
 423
 424
 425 /******************************************************************************
 426  *
 427  * FUNCTION:    AsTrimWhitespace
 428  *
 429  * DESCRIPTION: Remove "excess" blank lines - any more than 2 blank lines.
 430  *              this can happen during the translation when lines are removed.
 431  *
 432  ******************************************************************************/
 433
 434 void
 435 AsTrimWhitespace (
 436     char                    *Buffer)
 437 {
 438     int                     ReplaceCount = 1;
 439
 440
 441     while (ReplaceCount)
 442     {
 443         ReplaceCount = AsReplaceString ("\n\n\n\n", "\n\n\n", REPLACE_SUBSTRINGS, Buffer);
 444     }
 445 }
 446
 447
 448 /******************************************************************************
 449  *
 450  * FUNCTION:    AsReplaceHeader
 451  *
 452  * DESCRIPTION: Replace the default Intel legal header with a new header
 453  *
 454  ******************************************************************************/
 455
 456 void
 457 AsReplaceHeader (
 458     char                    *Buffer,
 459     char                    *NewHeader)
 460 {
 461     char                    *SubBuffer;
 462     char                    *TokenEnd;
 463
 464
 465     /* Find the original header */
 466
 467     SubBuffer = strstr (Buffer, HeaderBegin);
 468     if (!SubBuffer)
 469     {
 470         return;
 471     }
 472
 473     /* Find the end of the original header */
 474
 475     TokenEnd = strstr (SubBuffer, "*/");
 476     TokenEnd = AsSkipPastChar (TokenEnd, '\n');
 477
 478     /* Delete old header, insert new one */
 479
 480     AsReplaceData (SubBuffer, TokenEnd - SubBuffer, NewHeader, strlen (NewHeader));
 481 }
 482
 483
 484 /******************************************************************************
 485  *
 486  * FUNCTION:    AsReplaceString
 487  *
 488  * DESCRIPTION: Replace all instances of a target string with a replacement
 489  *              string. Returns count of the strings replaced.
 490  *
 491  ******************************************************************************/
 492
 493 int
 494 AsReplaceString (
 495     char                    *Target,
 496     char                    *Replacement,
 497     UINT8                   Type,
 498     char                    *Buffer)
 499 {
 500     char                    *SubString1;
 501     char                    *SubString2;
 502     char                    *SubBuffer;
 503     int                     TargetLength;
 504     int                     ReplacementLength;
 505     int                     ReplaceCount = 0;
 506
 507
 508     TargetLength = strlen (Target);
 509     ReplacementLength = strlen (Replacement);
 510
 511     SubBuffer = Buffer;
 512     SubString1 = Buffer;
 513
 514     while (SubString1)
 515     {
 516         /* Find the target string */
 517
 518         SubString1 = strstr (SubBuffer, Target);
 519         if (!SubString1)
 520         {
 521             return (ReplaceCount);
 522         }
 523
 524         /*
 525          * Check for translation escape string -- means to ignore
 526          * blocks of code while replacing
 527          */
 528         if (Gbl_IgnoreTranslationEscapes)
 529         {
 530             SubString2 = NULL;
 531         }
 532         else
 533         {
 534             SubString2 = strstr (SubBuffer, AS_START_IGNORE);
 535         }
 536
 537         if ((SubString2) &&
 538             (SubString2 < SubString1))
 539         {
 540             /* Find end of the escape block starting at "Substring2" */
 541
 542             SubString2 = strstr (SubString2, AS_STOP_IGNORE);
 543             if (!SubString2)
 544             {
 545                 /* Didn't find terminator */
 546
 547                 return (ReplaceCount);
 548             }
 549
 550             /* Move buffer to end of escape block and continue */
 551
 552             SubBuffer = SubString2;
 553         }
 554
 555         /* Do the actual replace if the target was found */
 556
 557         else
 558         {
 559             if ((Type & REPLACE_MASK) == REPLACE_WHOLE_WORD)
 560             {
 561                 if (!AsMatchExactWord (SubString1, TargetLength))
 562                 {
 563                     SubBuffer = SubString1 + 1;
 564                     continue;
 565                 }
 566             }
 567
 568             SubBuffer = AsReplaceData (SubString1, TargetLength, Replacement, ReplacementLength);
 569
 570             if ((Type & EXTRA_INDENT_C) &&
 571                 (!Gbl_StructDefs))
 572             {
 573                 SubBuffer = AsInsertData (SubBuffer, "        ", 8);
 574             }
 575
 576             ReplaceCount++;
 577         }
 578     }
 579
 580     return (ReplaceCount);
 581 }
 582
 583
 584 /******************************************************************************
 585  *
 586  * FUNCTION:    AsConvertToLineFeeds
 587  *
 588  * DESCRIPTION:
 589  *
 590  ******************************************************************************/
 591
 592 void
 593 AsConvertToLineFeeds (
 594     char                    *Buffer)
 595 {
 596     char                    *SubString;
 597     char                    *SubBuffer;
 598
 599
 600     SubBuffer = Buffer;
 601     SubString = Buffer;
 602
 603     while (SubString)
 604     {
 605         /* Find the target string */
 606
 607         SubString = strstr (SubBuffer, "\r\n");
 608         if (!SubString)
 609         {
 610             return;
 611         }
 612
 613         SubBuffer = AsReplaceData (SubString, 1, NULL, 0);
 614     }
 615     return;
 616 }
 617
 618
 619 /******************************************************************************
 620  *
 621  * FUNCTION:    AsInsertCarriageReturns
 622  *
 623  * DESCRIPTION:
 624  *
 625  ******************************************************************************/
 626
 627 void
 628 AsInsertCarriageReturns (
 629     char                    *Buffer)
 630 {
 631     char                    *SubString;
 632     char                    *SubBuffer;
 633
 634
 635     SubBuffer = Buffer;
 636     SubString = Buffer;
 637
 638     while (SubString)
 639     {
 640         /* Find the target string */
 641
 642         SubString = strstr (SubBuffer, "\n");
 643         if (!SubString)
 644         {
 645             return;
 646         }
 647
 648         SubBuffer = AsInsertData (SubString, "\r", 1);
 649         SubBuffer += 1;
 650     }
 651     return;
 652 }
 653
 654
 655 /******************************************************************************
 656  *
 657  * FUNCTION:    AsBracesOnSameLine
 658  *
 659  * DESCRIPTION: Move opening braces up to the same line as an if, for, else,
 660  *              or while statement (leave function opening brace on separate
 661  *              line).
 662  *
 663  ******************************************************************************/
 664
 665 void
 666 AsBracesOnSameLine (
 667     char                    *Buffer)
 668 {
 669     char                    *SubBuffer = Buffer;
 670     char                    *Beginning;
 671     char                    *StartOfThisLine;
 672     char                    *Next;
 673     BOOLEAN                 BlockBegin = TRUE;
 674
 675
 676     while (*SubBuffer)
 677     {
 678         /* Ignore comments */
 679
 680         if ((SubBuffer[0] == '/') &&
 681             (SubBuffer[1] == '*'))
 682         {
 683             SubBuffer = strstr (SubBuffer, "*/");
 684             if (!SubBuffer)
 685             {
 686                 return;
 687             }
 688
 689             SubBuffer += 2;
 690             continue;
 691         }
 692
 693         /* Ignore quoted strings */
 694
 695         if (*SubBuffer == '\"')
 696         {
 697             SubBuffer++;
 698             SubBuffer = AsSkipPastChar (SubBuffer, '\"');
 699             if (!SubBuffer)
 700             {
 701                 return;
 702             }
 703         }
 704
 705         if (!strncmp ("\n}", SubBuffer, 2))
 706         {
 707             /*
 708              * A newline followed by a closing brace closes a function
 709              * or struct or initializer block
 710              */
 711             BlockBegin = TRUE;
 712         }
 713
 714         /*
 715          * Move every standalone brace up to the previous line
 716          * Check for digit will ignore initializer lists surrounded by braces.
 717          * This will work until we we need more complex detection.
 718          */
 719         if ((*SubBuffer == '{') && !isdigit ((int) SubBuffer[1]))
 720         {
 721             if (BlockBegin)
 722             {
 723                 BlockBegin = FALSE;
 724             }
 725             else
 726             {
 727                 /*
 728                  * Backup to previous non-whitespace
 729                  */
 730                 Beginning = SubBuffer - 1;
 731                 while ((*Beginning == ' ')   ||
 732                        (*Beginning == '\n'))
 733                 {
 734                     Beginning--;
 735                 }
 736
 737                 StartOfThisLine = Beginning;
 738                 while (*StartOfThisLine != '\n')
 739                 {
 740                     StartOfThisLine--;
 741                 }
 742
 743                 /*
 744                  * Move the brace up to the previous line, UNLESS:
 745                  *
 746                  * 1) There is a conditional compile on the line (starts with '#')
 747                  * 2) Previous line ends with an '=' (Start of initializer block)
 748                  * 3) Previous line ends with a comma (part of an init list)
 749                  * 4) Previous line ends with a backslash (part of a macro)
 750                  */
 751                 if ((StartOfThisLine[1] != '#') &&
 752                     (*Beginning != '\\') &&
 753                     (*Beginning != '/') &&
 754                     (*Beginning != '{') &&
 755                     (*Beginning != '=') &&
 756                     (*Beginning != ','))
 757                 {
 758                     Beginning++;
 759                     SubBuffer++;
 760
 761                     Gbl_MadeChanges = TRUE;
 762
 763 #ifdef ADD_EXTRA_WHITESPACE
 764                     AsReplaceData (Beginning, SubBuffer - Beginning, " {\n", 3);
 765 #else
 766                     /* Find non-whitespace start of next line */
 767
 768                     Next = SubBuffer + 1;
 769                     while ((*Next == ' ')   ||
 770                            (*Next == '\t'))
 771                     {
 772                         Next++;
 773                     }
 774
 775                     /* Find non-whitespace start of this line */
 776
 777                     StartOfThisLine++;
 778                     while ((*StartOfThisLine == ' ')   ||
 779                            (*StartOfThisLine == '\t'))
 780                     {
 781                         StartOfThisLine++;
 782                     }
 783
 784                     /*
 785                      * Must be a single-line comment to need more whitespace
 786                      * Even then, we don't need more if the previous statement
 787                      * is an "else".
 788                      */
 789                     if ((Next[0] == '/')  &&
 790                         (Next[1] == '*')  &&
 791                         (Next[2] != '\n') &&
 792
 793                         (!strncmp (StartOfThisLine, "else if", 7)     ||
 794                          !strncmp (StartOfThisLine, "else while", 10) ||
 795                           strncmp (StartOfThisLine, "else", 4)))
 796                     {
 797                         AsReplaceData (Beginning, SubBuffer - Beginning, " {\n", 3);
 798                     }
 799                     else
 800                     {
 801                         AsReplaceData (Beginning, SubBuffer - Beginning, " {", 2);
 802                     }
 803 #endif
 804                 }
 805             }
 806         }
 807
 808         SubBuffer++;
 809     }
 810 }
 811
 812
 813 /******************************************************************************
 814  *
 815  * FUNCTION:    AsTabify4
 816  *
 817  * DESCRIPTION: Convert the text to tabbed text. Alignment of text is
 818  *              preserved.
 819  *
 820  ******************************************************************************/
 821
 822 void
 823 AsTabify4 (
 824     char                    *Buffer)
 825 {
 826     char                    *SubBuffer = Buffer;
 827     char                    *NewSubBuffer;
 828     UINT32                  SpaceCount = 0;
 829     UINT32                  Column = 0;
 830
 831
 832     while (*SubBuffer)
 833     {
 834         if (*SubBuffer == '\n')
 835         {
 836             Column = 0;
 837         }
 838         else
 839         {
 840             Column++;
 841         }
 842
 843         /* Ignore comments */
 844
 845         if ((SubBuffer[0] == '/') &&
 846             (SubBuffer[1] == '*'))
 847         {
 848             SubBuffer = strstr (SubBuffer, "*/");
 849             if (!SubBuffer)
 850             {
 851                 return;
 852             }
 853
 854             SubBuffer += 2;
 855             continue;
 856         }
 857
 858         /* Ignore quoted strings */
 859
 860         if (*SubBuffer == '\"')
 861         {
 862             SubBuffer++;
 863             SubBuffer = AsSkipPastChar (SubBuffer, '\"');
 864             if (!SubBuffer)
 865             {
 866                 return;
 867             }
 868             SpaceCount = 0;
 869         }
 870
 871         if (*SubBuffer == ' ')
 872         {
 873             SpaceCount++;
 874
 875             if (SpaceCount >= 4)
 876             {
 877                 SpaceCount = 0;
 878
 879                 NewSubBuffer = (SubBuffer + 1) - 4;
 880                 *NewSubBuffer = '\t';
 881                 NewSubBuffer++;
 882
 883                 /* Remove the spaces */
 884
 885                 SubBuffer = AsRemoveData (NewSubBuffer, SubBuffer + 1);
 886             }
 887
 888             if ((Column % 4) == 0)
 889             {
 890                 SpaceCount = 0;
 891             }
 892         }
 893         else
 894         {
 895             SpaceCount = 0;
 896         }
 897
 898         SubBuffer++;
 899     }
 900 }
 901
 902
 903 /******************************************************************************
 904  *
 905  * FUNCTION:    AsTabify8
 906  *
 907  * DESCRIPTION: Convert the text to tabbed text. Alignment of text is
 908  *              preserved.
 909  *
 910  ******************************************************************************/
 911
 912 void
 913 AsTabify8 (
 914     char                    *Buffer)
 915 {
 916     char                    *SubBuffer = Buffer;
 917     char                    *NewSubBuffer;
 918     char                    *CommentEnd = NULL;
 919     UINT32                  SpaceCount = 0;
 920     UINT32                  Column = 0;
 921     UINT32                  TabCount = 0;
 922     UINT32                  LastLineTabCount = 0;
 923     UINT32                  LastLineColumnStart = 0;
 924     UINT32                  ThisColumnStart = 0;
 925     UINT32                  ThisTabCount =  0;
 926     char                    *FirstNonBlank = NULL;
 927
 928
 929     while (*SubBuffer)
 930     {
 931         if (*SubBuffer == '\n')
 932         {
 933             /* This is a standalone blank line */
 934
 935             FirstNonBlank = NULL;
 936             Column = 0;
 937             SpaceCount = 0;
 938             TabCount = 0;
 939             SubBuffer++;
 940             continue;
 941         }
 942
 943         if (!FirstNonBlank)
 944         {
 945             /* Find the first non-blank character on this line */
 946
 947             FirstNonBlank = SubBuffer;
 948             while (*FirstNonBlank == ' ')
 949             {
 950                 FirstNonBlank++;
 951             }
 952
 953             /*
 954              * This mechanism limits the difference in tab counts from
 955              * line to line. It helps avoid the situation where a second
 956              * continuation line (which was indented correctly for tabs=4) would
 957              * get indented off the screen if we just blindly converted to tabs.
 958              */
 959             ThisColumnStart = FirstNonBlank - SubBuffer;
 960
 961             if (LastLineTabCount == 0)
 962             {
 963                 ThisTabCount = 0;
 964             }
 965             else if (ThisColumnStart == LastLineColumnStart)
 966             {
 967                 ThisTabCount = LastLineTabCount -1;
 968             }
 969             else
 970             {
 971                 ThisTabCount = LastLineTabCount + 1;
 972             }
 973         }
 974
 975         Column++;
 976
 977         /* Check if we are in a comment */
 978
 979         if ((SubBuffer[0] == '*') &&
 980             (SubBuffer[1] == '/'))
 981         {
 982             SpaceCount = 0;
 983             SubBuffer += 2;
 984
 985             if (*SubBuffer == '\n')
 986             {
 987                 if (TabCount > 0)
 988                 {
 989                     LastLineTabCount = TabCount;
 990                     TabCount = 0;
 991                 }
 992                 FirstNonBlank = NULL;
 993                 LastLineColumnStart = ThisColumnStart;
 994                 SubBuffer++;
 995             }
 996
 997             continue;
 998         }
 999
1000         /* Check for comment open */
1001
1002         if ((SubBuffer[0] == '/') &&
1003             (SubBuffer[1] == '*'))
1004         {
1005             /* Find the end of the comment, it must exist */
1006
1007             CommentEnd = strstr (SubBuffer, "*/");
1008             if (!CommentEnd)
1009             {
1010                 return;
1011             }
1012
1013             /* Toss the rest of this line or single-line comment */
1014
1015             while ((SubBuffer < CommentEnd) &&
1016                    (*SubBuffer != '\n'))
1017             {
1018                 SubBuffer++;
1019             }
1020
1021             if (*SubBuffer == '\n')
1022             {
1023                 if (TabCount > 0)
1024                 {
1025                     LastLineTabCount = TabCount;
1026                     TabCount = 0;
1027                 }
1028                 FirstNonBlank = NULL;
1029                 LastLineColumnStart = ThisColumnStart;
1030             }
1031
1032             SpaceCount = 0;
1033             continue;
1034         }
1035
1036         /* Ignore quoted strings */
1037
1038         if ((!CommentEnd) && (*SubBuffer == '\"'))
1039         {
1040             SubBuffer++;
1041             SubBuffer = AsSkipPastChar (SubBuffer, '\"');
1042             if (!SubBuffer)
1043             {
1044                 return;
1045             }
1046             SpaceCount = 0;
1047         }
1048
1049         if (*SubBuffer != ' ')
1050         {
1051             /* Not a space, skip to end of line */
1052
1053             SubBuffer = AsSkipUntilChar (SubBuffer, '\n');
1054             if (!SubBuffer)
1055             {
1056                 return;
1057             }
1058             if (TabCount > 0)
1059             {
1060                 LastLineTabCount = TabCount;
1061                 TabCount = 0;
1062             }
1063
1064             FirstNonBlank = NULL;
1065             LastLineColumnStart = ThisColumnStart;
1066             Column = 0;
1067             SpaceCount = 0;
1068         }
1069         else
1070         {
1071             /* Another space */
1072
1073             SpaceCount++;
1074
1075             if (SpaceCount >= 4)
1076             {
1077                 /* Replace this group of spaces with a tab character */
1078
1079                 SpaceCount = 0;
1080
1081                 NewSubBuffer = SubBuffer - 3;
1082
1083                 if (TabCount <= ThisTabCount ? (ThisTabCount +1) : 0)
1084                 {
1085                     *NewSubBuffer = '\t';
1086                     NewSubBuffer++;
1087                     SubBuffer++;
1088                     TabCount++;
1089                 }
1090
1091                 /* Remove the spaces */
1092
1093                 SubBuffer = AsRemoveData (NewSubBuffer, SubBuffer);
1094                 continue;
1095             }
1096         }
1097
1098         SubBuffer++;
1099     }
1100 }
1101
1102
1103 /******************************************************************************
1104  *
1105  * FUNCTION:    AsCountLines
1106  *
1107  * DESCRIPTION: Count the number of lines in the input buffer. Also count
1108  *              the number of long lines (lines longer than 80 chars).
1109  *
1110  ******************************************************************************/
1111
1112 UINT32
1113 AsCountLines (
1114     char                    *Buffer,
1115     char                    *Filename)
1116 {
1117     char                    *SubBuffer = Buffer;
1118     char                    *EndOfLine;
1119     UINT32                  LineCount = 0;
1120     UINT32                  LongLineCount = 0;
1121
1122
1123     while (*SubBuffer)
1124     {
1125         EndOfLine = AsSkipUntilChar (SubBuffer, '\n');
1126         if (!EndOfLine)
1127         {
1128             Gbl_TotalLines += LineCount;
1129             return (LineCount);
1130         }
1131
1132         if ((EndOfLine - SubBuffer) > 80)
1133         {
1134             LongLineCount++;
1135             VERBOSE_PRINT (("long: %.80s\n", SubBuffer));
1136         }
1137
1138         LineCount++;
1139         SubBuffer = EndOfLine + 1;
1140     }
1141
1142     if (LongLineCount)
1143     {
1144         VERBOSE_PRINT (("%u Lines longer than 80 found in %s\n", LongLineCount, Filename));
1145         Gbl_LongLines += LongLineCount;
1146     }
1147
1148     Gbl_TotalLines += LineCount;
1149     return (LineCount);
1150 }
1151
1152
1153 /******************************************************************************
1154  *
1155  * FUNCTION:    AsCountTabs
1156  *
1157  * DESCRIPTION: Simply count the number of tabs in the input file buffer
1158  *
1159  ******************************************************************************/
1160
1161 void
1162 AsCountTabs (
1163     char                    *Buffer,
1164     char                    *Filename)
1165 {
1166     UINT32                  i;
1167     UINT32                  TabCount = 0;
1168
1169
1170     for (i = 0; Buffer[i]; i++)
1171     {
1172         if (Buffer[i] == '\t')
1173         {
1174             TabCount++;
1175         }
1176     }
1177
1178     if (TabCount)
1179     {
1180         AsPrint ("Tabs found", TabCount, Filename);
1181         Gbl_Tabs += TabCount;
1182     }
1183
1184     AsCountLines (Buffer, Filename);
1185 }
1186
1187
1188 /******************************************************************************
1189  *
1190  * FUNCTION:    AsCountNonAnsiComments
1191  *
1192  * DESCRIPTION: Count the number of "//" comments. This type of comment is
1193  *              non-ANSI C.
1194  *
1195  ******************************************************************************/
1196
1197 void
1198 AsCountNonAnsiComments (
1199     char                    *Buffer,
1200     char                    *Filename)
1201 {
1202     char                    *SubBuffer = Buffer;
1203     UINT32                  CommentCount = 0;
1204
1205
1206     while (SubBuffer)
1207     {
1208         SubBuffer = strstr (SubBuffer, "//");
1209         if (SubBuffer)
1210         {
1211             CommentCount++;
1212             SubBuffer += 2;
1213         }
1214     }
1215
1216     if (CommentCount)
1217     {
1218         AsPrint ("Non-ANSI Comments found", CommentCount, Filename);
1219         Gbl_NonAnsiComments += CommentCount;
1220     }
1221 }
1222
1223
1224 /******************************************************************************
1225  *
1226  * FUNCTION:    AsCountSourceLines
1227  *
1228  * DESCRIPTION: Count the number of C source lines. Defined by 1) not a
1229  *              comment, and 2) not a blank line.
1230  *
1231  ******************************************************************************/
1232
1233 void
1234 AsCountSourceLines (
1235     char                    *Buffer,
1236     char                    *Filename)
1237 {
1238     char                    *SubBuffer = Buffer;
1239     UINT32                  LineCount = 0;
1240     UINT32                  WhiteCount = 0;
1241     UINT32                  CommentCount = 0;
1242
1243
1244     while (*SubBuffer)
1245     {
1246         /* Detect comments (// comments are not used, non-ansii) */
1247
1248         if ((SubBuffer[0] == '/') &&
1249             (SubBuffer[1] == '*'))
1250         {
1251             SubBuffer += 2;
1252
1253             /* First line of multi-line comment is often just whitespace */
1254
1255             if (SubBuffer[0] == '\n')
1256             {
1257                 WhiteCount++;
1258                 SubBuffer++;
1259             }
1260             else
1261             {
1262                 CommentCount++;
1263             }
1264
1265             /* Find end of comment */
1266
1267             while (SubBuffer[0] && SubBuffer[1] &&
1268                     !(((SubBuffer[0] == '*') &&
1269                       (SubBuffer[1] == '/'))))
1270             {
1271                 if (SubBuffer[0] == '\n')
1272                 {
1273                     CommentCount++;
1274                 }
1275
1276                 SubBuffer++;
1277             }
1278         }
1279
1280         /* A linefeed followed by a non-linefeed is a valid source line */
1281
1282         else if ((SubBuffer[0] == '\n') &&
1283                  (SubBuffer[1] != '\n'))
1284         {
1285             LineCount++;
1286         }
1287
1288         /* Two back-to-back linefeeds indicate a whitespace line */
1289
1290         else if ((SubBuffer[0] == '\n') &&
1291                  (SubBuffer[1] == '\n'))
1292         {
1293             WhiteCount++;
1294         }
1295
1296         SubBuffer++;
1297     }
1298
1299     /* Adjust comment count for legal header */
1300
1301     if (Gbl_HeaderSize < CommentCount)
1302     {
1303         CommentCount -= Gbl_HeaderSize;
1304         Gbl_HeaderLines += Gbl_HeaderSize;
1305     }
1306
1307     Gbl_SourceLines += LineCount;
1308     Gbl_WhiteLines += WhiteCount;
1309     Gbl_CommentLines += CommentCount;
1310
1311     VERBOSE_PRINT (("%u Comment %u White %u Code %u Lines in %s\n",
1312                 CommentCount, WhiteCount, LineCount, LineCount+WhiteCount+CommentCount, Filename));
1313 }
1314
1315
1316 /******************************************************************************
1317  *
1318  * FUNCTION:    AsInsertPrefix
1319  *
1320  * DESCRIPTION: Insert struct or union prefixes
1321  *
1322  ******************************************************************************/
1323
1324 void
1325 AsInsertPrefix (
1326     char                    *Buffer,
1327     char                    *Keyword,
1328     UINT8                   Type)
1329 {
1330     char                    *SubString;
1331     char                    *SubBuffer;
1332     char                    *EndKeyword;
1333     int                     InsertLength;
1334     char                    *InsertString;
1335     int                     TrailingSpaces;
1336     char                    LowerKeyword[128];
1337     int                     KeywordLength;
1338
1339
1340     switch (Type)
1341     {
1342     case SRC_TYPE_STRUCT:
1343
1344         InsertString = "struct ";
1345         break;
1346
1347     case SRC_TYPE_UNION:
1348
1349         InsertString = "union ";
1350         break;
1351
1352     default:
1353
1354         return;
1355     }
1356
1357     strcpy (LowerKeyword, Keyword);
1358     AsStrlwr (LowerKeyword);
1359
1360     SubBuffer = Buffer;
1361     SubString = Buffer;
1362     InsertLength = strlen (InsertString);
1363     KeywordLength = strlen (Keyword);
1364
1365
1366     while (SubString)
1367     {
1368         /* Find an instance of the keyword */
1369
1370         SubString = strstr (SubBuffer, LowerKeyword);
1371         if (!SubString)
1372         {
1373             return;
1374         }
1375
1376         SubBuffer = SubString;
1377
1378         /* Must be standalone word, not a substring */
1379
1380         if (AsMatchExactWord (SubString, KeywordLength))
1381         {
1382             /* Make sure the keyword isn't already prefixed with the insert */
1383
1384             if (!strncmp (SubString - InsertLength, InsertString, InsertLength))
1385             {
1386                 /* Add spaces if not already at the end-of-line */
1387
1388                 if (*(SubBuffer + KeywordLength) != '\n')
1389                 {
1390                     /* Already present, add spaces after to align structure members */
1391
1392 #if 0
1393 /* ONLY FOR C FILES */
1394                     AsInsertData (SubBuffer + KeywordLength, "        ", 8);
1395 #endif
1396                 }
1397                 goto Next;
1398             }
1399
1400             /* Make sure the keyword isn't at the end of a struct/union */
1401             /* Note: This code depends on a single space after the brace */
1402
1403             if (*(SubString - 2) == '}')
1404             {
1405                 goto Next;
1406             }
1407
1408             /* Prefix the keyword with the insert string */
1409
1410             Gbl_MadeChanges = TRUE;
1411
1412             /* Is there room for insertion */
1413
1414             EndKeyword = SubString + strlen (LowerKeyword);
1415
1416             TrailingSpaces = 0;
1417             while (EndKeyword[TrailingSpaces] == ' ')
1418             {
1419                 TrailingSpaces++;
1420             }
1421
1422             /*
1423              * Use "if (TrailingSpaces > 1)" if we want to ignore casts
1424              */
1425             SubBuffer = SubString + InsertLength;
1426
1427             if (TrailingSpaces > InsertLength)
1428             {
1429                 /* Insert the keyword */
1430
1431                 memmove (SubBuffer, SubString, KeywordLength);
1432
1433                 /* Insert the keyword */
1434
1435                 memmove (SubString, InsertString, InsertLength);
1436             }
1437             else
1438             {
1439                 AsInsertData (SubString, InsertString, InsertLength);
1440             }
1441         }
1442
1443 Next:
1444         SubBuffer += KeywordLength;
1445     }
1446 }
1447
1448 #ifdef ACPI_FUTURE_IMPLEMENTATION
1449 /******************************************************************************
1450  *
1451  * FUNCTION:    AsTrimComments
1452  *
1453  * DESCRIPTION: Finds 3-line comments with only a single line of text
1454  *
1455  ******************************************************************************/
1456
1457 void
1458 AsTrimComments (
1459     char                    *Buffer,
1460     char                    *Filename)
1461 {
1462     char                    *SubBuffer = Buffer;
1463     char                    *Ptr1;
1464     char                    *Ptr2;
1465     UINT32                  LineCount;
1466     UINT32                  ShortCommentCount = 0;
1467
1468
1469     while (1)
1470     {
1471         /* Find comment open, within procedure level */
1472
1473         SubBuffer = strstr (SubBuffer, "    /*");
1474         if (!SubBuffer)
1475         {
1476             goto Exit;
1477         }
1478
1479         /* Find comment terminator */
1480
1481         Ptr1 = strstr (SubBuffer, "*/");
1482         if (!Ptr1)
1483         {
1484             goto Exit;
1485         }
1486
1487         /* Find next EOL (from original buffer) */
1488
1489         Ptr2 = strstr (SubBuffer, "\n");
1490         if (!Ptr2)
1491         {
1492             goto Exit;
1493         }
1494
1495         /* Ignore one-line comments */
1496
1497         if (Ptr1 < Ptr2)
1498         {
1499             /* Normal comment, ignore and continue; */
1500
1501             SubBuffer = Ptr2;
1502             continue;
1503         }
1504
1505         /* Examine multi-line comment */
1506
1507         LineCount = 1;
1508         while (Ptr1 > Ptr2)
1509         {
1510             /* Find next EOL */
1511
1512             Ptr2++;
1513             Ptr2 = strstr (Ptr2, "\n");
1514             if (!Ptr2)
1515             {
1516                 goto Exit;
1517             }
1518
1519             LineCount++;
1520         }
1521
1522         SubBuffer = Ptr1;
1523
1524         if (LineCount <= 3)
1525         {
1526             ShortCommentCount++;
1527         }
1528     }
1529
1530
1531 Exit:
1532
1533     if (ShortCommentCount)
1534     {
1535         AsPrint ("Short Comments found", ShortCommentCount, Filename);
1536     }
1537 }
1538 #endif