sys/contrib/dev/acpica/source/tools/acpisrc/ascase.c

   1 /******************************************************************************
   2  *
   3  * Module Name: ascase - Source conversion - lower/upper case utilities
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2015, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include "acpisrc.h"
  45
  46 /* Local prototypes */
  47
  48 void
  49 AsUppercaseTokens (
  50     char                    *Buffer,
  51     char                    *PrefixString);
  52
  53
  54 /******************************************************************************
  55  *
  56  * FUNCTION:    AsLowerCaseString
  57  *
  58  * DESCRIPTION: LowerCase all instances of a target string with a replacement
  59  *              string. Returns count of the strings replaced.
  60  *
  61  ******************************************************************************/
  62
  63 int
  64 AsLowerCaseString (
  65     char                    *Target,
  66     char                    *Buffer)
  67 {
  68     char                    *SubString1;
  69     char                    *SubString2;
  70     char                    *SubBuffer;
  71     int                     TargetLength;
  72     int                     LowerCaseCount = 0;
  73     int                     i;
  74
  75
  76     TargetLength = strlen (Target);
  77
  78     SubBuffer = Buffer;
  79     SubString1 = Buffer;
  80
  81     while (SubString1)
  82     {
  83         /* Find the target string */
  84
  85         SubString1 = strstr (SubBuffer, Target);
  86         if (!SubString1)
  87         {
  88             return (LowerCaseCount);
  89         }
  90
  91         /*
  92          * Check for translation escape string -- means to ignore
  93          * blocks of code while replacing
  94          */
  95         if (Gbl_IgnoreTranslationEscapes)
  96         {
  97             SubString2 = NULL;
  98         }
  99         else
 100         {
 101             SubString2 = strstr (SubBuffer, AS_START_IGNORE);
 102         }
 103
 104         if ((SubString2) &&
 105             (SubString2 < SubString1))
 106         {
 107             /* Find end of the escape block starting at "Substring2" */
 108
 109             SubString2 = strstr (SubString2, AS_STOP_IGNORE);
 110             if (!SubString2)
 111             {
 112                 /* Didn't find terminator */
 113
 114                 return (LowerCaseCount);
 115             }
 116
 117             /* Move buffer to end of escape block and continue */
 118
 119             SubBuffer = SubString2;
 120         }
 121
 122         /* Do the actual replace if the target was found */
 123
 124         else
 125         {
 126             if (!AsMatchExactWord (SubString1, TargetLength))
 127             {
 128                 SubBuffer = SubString1 + 1;
 129                 continue;
 130             }
 131
 132             for (i = 0; i < TargetLength; i++)
 133             {
 134                 SubString1[i] = (char) tolower ((int) SubString1[i]);
 135             }
 136
 137             SubBuffer = SubString1 + TargetLength;
 138
 139             if ((Gbl_WidenDeclarations) && (!Gbl_StructDefs))
 140             {
 141                 if ((SubBuffer[0] == ' ') && (SubBuffer[1] == ' '))
 142                 {
 143                     AsInsertData (SubBuffer, "        ", 8);
 144                 }
 145             }
 146
 147             LowerCaseCount++;
 148         }
 149     }
 150
 151     return (LowerCaseCount);
 152 }
 153
 154
 155 /******************************************************************************
 156  *
 157  * FUNCTION:    AsMixedCaseToUnderscores
 158  *
 159  * DESCRIPTION: Converts mixed case identifiers to underscored identifiers.
 160  *              for example,
 161  *
 162  *              ThisUsefullyNamedIdentifier   becomes:
 163  *
 164  *              this_usefully_named_identifier
 165  *
 166  ******************************************************************************/
 167
 168 void
 169 AsMixedCaseToUnderscores (
 170     char                    *Buffer,
 171     char                    *Filename)
 172 {
 173     UINT32                  Length;
 174     char                    *SubBuffer = Buffer;
 175     char                    *TokenEnd;
 176     char                    *TokenStart = NULL;
 177     char                    *SubString;
 178     UINT32                  LineNumber = 1;
 179     UINT32                  Count;
 180
 181
 182     /*
 183      * Examine the entire buffer (contains the entire file)
 184      * We are only interested in these tokens:
 185      *      Escape sequences - ignore entire sequence
 186      *      Single-quoted constants - ignore
 187      *      Quoted strings - ignore entire string
 188      *      Translation escape - starts with /,*,!
 189      *      Decimal and hex numeric constants - ignore entire token
 190      *      Entire uppercase token - ignore, it is a macro or define
 191      *      Starts with underscore, then a lowercase or digit: convert
 192      */
 193     while (*SubBuffer)
 194     {
 195         if (*SubBuffer == '\n')
 196         {
 197             LineNumber++;
 198             SubBuffer++;
 199             continue;
 200         }
 201
 202         /* Ignore standard escape sequences (\n, \r, etc.)  Not Hex or Octal escapes */
 203
 204         if (*SubBuffer == '\\')
 205         {
 206             SubBuffer += 2;
 207             continue;
 208         }
 209
 210         /* Ignore single-quoted characters */
 211
 212         if (*SubBuffer == '\'')
 213         {
 214             SubBuffer += 3;
 215             continue;
 216         }
 217
 218         /* Ignore standard double-quoted strings */
 219
 220         if (*SubBuffer == '"')
 221         {
 222             SubBuffer++;
 223             Count = 0;
 224             while (*SubBuffer != '"')
 225             {
 226                 Count++;
 227                 if ((!*SubBuffer) ||
 228                      (Count > 8192))
 229                 {
 230                     printf ("Found an unterminated quoted string!, line %u: %s\n",
 231                         LineNumber, Filename);
 232                     return;
 233                 }
 234
 235                 /* Handle escape sequences */
 236
 237                 if (*SubBuffer == '\\')
 238                 {
 239                     SubBuffer++;
 240                 }
 241
 242                 SubBuffer++;
 243             }
 244             SubBuffer++;
 245             continue;
 246         }
 247
 248         /*
 249          * Check for translation escape string. It means to ignore
 250          * blocks of code during this code conversion.
 251          */
 252         if ((SubBuffer[0] == '/') &&
 253             (SubBuffer[1] == '*') &&
 254             (SubBuffer[2] == '!'))
 255         {
 256             SubBuffer = strstr (SubBuffer, "!*/");
 257             if (!SubBuffer)
 258             {
 259                 printf ("Found an unterminated translation escape!, line %u: %s\n",
 260                     LineNumber, Filename);
 261                 return;
 262             }
 263             continue;
 264         }
 265
 266         /* Ignore anything that starts with a number (0-9) */
 267
 268         if (isdigit ((int) *SubBuffer))
 269         {
 270             /* Ignore hex constants */
 271
 272             if ((SubBuffer[0] == '0') &&
 273                ((SubBuffer[1] == 'x') || (SubBuffer[1] == 'X')))
 274             {
 275                 SubBuffer += 2;
 276             }
 277
 278             /* Skip over all digits, both decimal and hex */
 279
 280             while (isxdigit ((int) *SubBuffer))
 281             {
 282                 SubBuffer++;
 283             }
 284             TokenStart = NULL;
 285             continue;
 286         }
 287
 288         /*
 289          * Check for fully upper case identifiers. These are usually macros
 290          * or defines. Allow decimal digits and embedded underscores.
 291          */
 292         if (isupper ((int) *SubBuffer))
 293         {
 294             SubString = SubBuffer + 1;
 295             while ((isupper ((int) *SubString)) ||
 296                    (isdigit ((int) *SubString)) ||
 297                    (*SubString == '_'))
 298             {
 299                 SubString++;
 300             }
 301
 302             /*
 303              * For the next character, anything other than a lower case
 304              * means that the identifier has terminated, and contains
 305              * exclusively Uppers/Digits/Underscores. Ignore the entire
 306              * identifier.
 307              */
 308             if (!islower ((int) *SubString))
 309             {
 310                 SubBuffer = SubString + 1;
 311                 continue;
 312             }
 313         }
 314
 315         /*
 316          * These forms may indicate an identifier that can be converted:
 317          *      <UpperCase><LowerCase> (Ax)
 318          *      <UpperCase><Number> (An)
 319          */
 320         if (isupper ((int) SubBuffer[0]) &&
 321           ((islower ((int) SubBuffer[1])) || isdigit ((int) SubBuffer[1])))
 322         {
 323             TokenStart = SubBuffer;
 324             SubBuffer++;
 325
 326             while (1)
 327             {
 328                 /* Walk over the lower case letters and decimal digits */
 329
 330                 while (islower ((int) *SubBuffer) ||
 331                        isdigit ((int) *SubBuffer))
 332                 {
 333                     SubBuffer++;
 334                 }
 335
 336                 /* Check for end of line or end of token */
 337
 338                 if (*SubBuffer == '\n')
 339                 {
 340                     LineNumber++;
 341                     break;
 342                 }
 343
 344                 if (*SubBuffer == ' ')
 345                 {
 346                     /* Check for form "Axx - " in a parameter header description */
 347
 348                     while (*SubBuffer == ' ')
 349                     {
 350                         SubBuffer++;
 351                     }
 352
 353                     SubBuffer--;
 354                     if ((SubBuffer[1] == '-') &&
 355                         (SubBuffer[2] == ' '))
 356                     {
 357                         if (TokenStart)
 358                         {
 359                             *TokenStart = (char) tolower ((int) *TokenStart);
 360                         }
 361                     }
 362                     break;
 363                 }
 364
 365                 /*
 366                  * Ignore these combinations:
 367                  *      <Letter><Digit><UpperCase>
 368                  *      <Digit><Digit><UpperCase>
 369                  *      <Underscore><Digit><UpperCase>
 370                  */
 371                 if (isdigit ((int) *SubBuffer))
 372                 {
 373                     if (isalnum ((int) *(SubBuffer-1)) ||
 374                         *(SubBuffer-1) == '_')
 375                     {
 376                         break;
 377                     }
 378                 }
 379
 380                 /* Ignore token if next character is not uppercase or digit */
 381
 382                 if (!isupper ((int) *SubBuffer) &&
 383                     !isdigit ((int) *SubBuffer))
 384                 {
 385                     break;
 386                 }
 387
 388                 /*
 389                  * Form <UpperCase><LowerCaseLetters><UpperCase> (AxxB):
 390                  * Convert leading character of the token to lower case
 391                  */
 392                 if (TokenStart)
 393                 {
 394                     *TokenStart = (char) tolower ((int) *TokenStart);
 395                     TokenStart = NULL;
 396                 }
 397
 398                 /* Find the end of this identifier (token) */
 399
 400                 TokenEnd = SubBuffer - 1;
 401                 while ((isalnum ((int) *TokenEnd)) ||
 402                        (*TokenEnd == '_'))
 403                 {
 404                     TokenEnd++;
 405                 }
 406
 407                 SubString = TokenEnd;
 408                 Length = 0;
 409
 410                 while (*SubString != '\n')
 411                 {
 412                     /*
 413                      * If we have at least two trailing spaces, we can get rid of
 414                      * one to make up for the newly inserted underscore. This will
 415                      * help preserve the alignment of the text
 416                      */
 417                     if ((SubString[0] == ' ') &&
 418                         (SubString[1] == ' '))
 419                     {
 420                         Length = SubString - SubBuffer - 1;
 421                         break;
 422                     }
 423
 424                     SubString++;
 425                 }
 426
 427                 if (!Length)
 428                 {
 429                     Length = strlen (&SubBuffer[0]);
 430                 }
 431
 432                 /*
 433                  * Within this identifier, convert this pair of letters that
 434                  * matches the form:
 435                  *
 436                  *      <LowerCase><UpperCase>
 437                  * to
 438                  *      <LowerCase><Underscore><LowerCase>
 439                  */
 440                 Gbl_MadeChanges = TRUE;
 441
 442                 /* Insert the underscore */
 443
 444                 memmove (&SubBuffer[1], &SubBuffer[0], Length + 1);
 445                 SubBuffer[0] = '_';
 446
 447                 /*
 448                  * If we have <UpperCase><UpperCase>, leave them as-is
 449                  * Enables transforms like:
 450                  *      LocalFADT -> local_FADT
 451                  */
 452                 if (isupper ((int) SubBuffer[2]))
 453                 {
 454                     SubBuffer += 1;
 455                     break;
 456                 }
 457
 458                 /* Lower case the original upper case letter */
 459
 460                 SubBuffer[1] = (char) tolower ((int) SubBuffer[1]);
 461                 SubBuffer += 2;
 462             }
 463         }
 464
 465         SubBuffer++;
 466     }
 467 }
 468
 469
 470 /******************************************************************************
 471  *
 472  * FUNCTION:    AsLowerCaseIdentifiers
 473  *
 474  * DESCRIPTION: Converts mixed case identifiers to lower case. Leaves comments,
 475  *              quoted strings, and all-upper-case macros alone.
 476  *
 477  ******************************************************************************/
 478
 479 void
 480 AsLowerCaseIdentifiers (
 481     char                    *Buffer)
 482 {
 483     char                    *SubBuffer = Buffer;
 484
 485
 486     while (*SubBuffer)
 487     {
 488         /*
 489          * Check for translation escape string -- means to ignore
 490          * blocks of code while replacing
 491          */
 492         if ((SubBuffer[0] == '/') &&
 493             (SubBuffer[1] == '*') &&
 494             (SubBuffer[2] == '!'))
 495         {
 496             SubBuffer = strstr (SubBuffer, "!*/");
 497             if (!SubBuffer)
 498             {
 499                 return;
 500             }
 501         }
 502
 503         /* Ignore comments */
 504
 505         if ((SubBuffer[0] == '/') &&
 506             (SubBuffer[1] == '*'))
 507         {
 508             SubBuffer = strstr (SubBuffer, "*/");
 509             if (!SubBuffer)
 510             {
 511                 return;
 512             }
 513
 514             SubBuffer += 2;
 515         }
 516
 517         /* Ignore quoted strings */
 518
 519         if ((SubBuffer[0] == '\"') && (SubBuffer[1] != '\''))
 520         {
 521             SubBuffer++;
 522
 523             /* Find the closing quote */
 524
 525             while (SubBuffer[0])
 526             {
 527                 /* Ignore escaped quote characters */
 528
 529                 if (SubBuffer[0] == '\\')
 530                 {
 531                     SubBuffer++;
 532                 }
 533                 else if (SubBuffer[0] == '\"')
 534                 {
 535                     SubBuffer++;
 536                     break;
 537                 }
 538                 SubBuffer++;
 539             }
 540         }
 541
 542         if (!SubBuffer[0])
 543         {
 544             return;
 545         }
 546
 547         /*
 548          * Only lower case if we have an upper followed by a lower
 549          * This leaves the all-uppercase things (macros, etc.) intact
 550          */
 551         if ((isupper ((int) SubBuffer[0])) &&
 552             (islower ((int) SubBuffer[1])))
 553         {
 554             Gbl_MadeChanges = TRUE;
 555             *SubBuffer = (char) tolower ((int) *SubBuffer);
 556         }
 557
 558         SubBuffer++;
 559     }
 560 }
 561
 562
 563 /******************************************************************************
 564  *
 565  * FUNCTION:    AsUppercaseTokens
 566  *
 567  * DESCRIPTION: Force to uppercase all tokens that begin with the prefix string.
 568  *              used to convert mixed-case macros and constants to uppercase.
 569  *
 570  ******************************************************************************/
 571
 572 void
 573 AsUppercaseTokens (
 574     char                    *Buffer,
 575     char                    *PrefixString)
 576 {
 577     char                    *SubBuffer;
 578     char                    *TokenEnd;
 579     char                    *SubString;
 580     int                     i;
 581     UINT32                  Length;
 582
 583
 584     SubBuffer = Buffer;
 585
 586     while (SubBuffer)
 587     {
 588         SubBuffer = strstr (SubBuffer, PrefixString);
 589         if (SubBuffer)
 590         {
 591             TokenEnd = SubBuffer;
 592             while ((isalnum ((int) *TokenEnd)) || (*TokenEnd == '_'))
 593             {
 594                 TokenEnd++;
 595             }
 596
 597             for (i = 0; i < (TokenEnd - SubBuffer); i++)
 598             {
 599                 if ((islower ((int) SubBuffer[i])) &&
 600                     (isupper ((int) SubBuffer[i+1])))
 601                 {
 602
 603                     SubString = TokenEnd;
 604                     Length = 0;
 605
 606                     while (*SubString != '\n')
 607                     {
 608                         if ((SubString[0] == ' ') &&
 609                             (SubString[1] == ' '))
 610                         {
 611                             Length = SubString - &SubBuffer[i] - 2;
 612                             break;
 613                         }
 614
 615                         SubString++;
 616                     }
 617
 618                     if (!Length)
 619                     {
 620                         Length = strlen (&SubBuffer[i+1]);
 621                     }
 622
 623                     memmove (&SubBuffer[i+2], &SubBuffer[i+1], (Length+1));
 624                     SubBuffer[i+1] = '_';
 625                     i +=2;
 626                     TokenEnd++;
 627                 }
 628             }
 629
 630             for (i = 0; i < (TokenEnd - SubBuffer); i++)
 631             {
 632                 SubBuffer[i] = (char) toupper ((int) SubBuffer[i]);
 633             }
 634
 635             SubBuffer = TokenEnd;
 636         }
 637     }
 638 }