sys/contrib/dev/acpica-unix-20061109/tools/acpisrc/ascase.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: ascase - Source conversion - lower/upper case utilities
   5  *              $Revision: 1.20 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2006, Intel Corp.
  14  * All rights reserved.
  15  *
  16  * 2. License
  17  *
  18  * 2.1. This is your license from Intel Corp. under its intellectual property
  19  * rights.  You may have additional license terms from the party that provided
  20  * you this software, covering your right to use that party's intellectual
  21  * property rights.
  22  *
  23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24  * copy of the source code appearing in this file ("Covered Code") an
  25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27  * make derivatives, distribute, use and display any portion of the Covered
  28  * Code in any form, with the right to sublicense such rights; and
  29  *
  30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31  * license (with the right to sublicense), under only those claims of Intel
  32  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33  * offer to sell, and import the Covered Code and derivative works thereof
  34  * solely to the minimum extent necessary to exercise the above copyright
  35  * license, and in no event shall the patent license extend to any additions
  36  * to or modifications of the Original Intel Code.  No other license or right
  37  * is granted directly or by implication, estoppel or otherwise;
  38  *
  39  * The above copyright and patent license is granted only if the following
  40  * conditions are met:
  41  *
  42  * 3. Conditions
  43  *
  44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45  * Redistribution of source code of any substantial portion of the Covered
  46  * Code or modification with rights to further distribute source must include
  47  * the above Copyright Notice, the above License, this list of Conditions,
  48  * and the following Disclaimer and Export Compliance provision.  In addition,
  49  * Licensee must cause all Covered Code to which Licensee contributes to
  50  * contain a file documenting the changes Licensee made to create that Covered
  51  * Code and the date of any change.  Licensee must include in that file the
  52  * documentation of any changes made by any predecessor Licensee.  Licensee
  53  * must include a prominent statement that the modification is derived,
  54  * directly or indirectly, from Original Intel Code.
  55  *
  56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57  * Redistribution of source code of any substantial portion of the Covered
  58  * Code or modification without rights to further distribute source must
  59  * include the following Disclaimer and Export Compliance provision in the
  60  * documentation and/or other materials provided with distribution.  In
  61  * addition, Licensee may not authorize further sublicense of source of any
  62  * portion of the Covered Code, and must include terms to the effect that the
  63  * license from Licensee to its licensee is limited to the intellectual
  64  * property embodied in the software Licensee provides to its licensee, and
  65  * not to intellectual property embodied in modifications its licensee may
  66  * make.
  67  *
  68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69  * substantial portion of the Covered Code or modification must reproduce the
  70  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71  * provision in the documentation and/or other materials provided with the
  72  * distribution.
  73  *
  74  * 3.4. Intel retains all right, title, and interest in and to the Original
  75  * Intel Code.
  76  *
  77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79  * other dealings in products derived from or relating to the Covered Code
  80  * without prior written authorization from Intel.
  81  *
  82  * 4. Disclaimer and Export Compliance
  83  *
  84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118 #include "acpisrc.h"
 119
 120
 121 /******************************************************************************
 122  *
 123  * FUNCTION:    AsLowerCaseString
 124  *
 125  * DESCRIPTION: LowerCase all instances of a target string with a replacement
 126  *              string.  Returns count of the strings replaced.
 127  *
 128  ******************************************************************************/
 129
 130 int
 131 AsLowerCaseString (
 132     char                    *Target,
 133     char                    *Buffer)
 134 {
 135     char                    *SubString1;
 136     char                    *SubString2;
 137     char                    *SubBuffer;
 138     int                     TargetLength;
 139     int                     LowerCaseCount = 0;
 140     int                     i;
 141
 142
 143     TargetLength = strlen (Target);
 144
 145     SubBuffer = Buffer;
 146     SubString1 = Buffer;
 147
 148     while (SubString1)
 149     {
 150         /* Find the target string */
 151
 152         SubString1 = strstr (SubBuffer, Target);
 153         if (!SubString1)
 154         {
 155             return LowerCaseCount;
 156         }
 157
 158         /*
 159          * Check for translation escape string -- means to ignore
 160          * blocks of code while replacing
 161          */
 162         SubString2 = strstr (SubBuffer, AS_START_IGNORE);
 163
 164         if ((SubString2) &&
 165             (SubString2 < SubString1))
 166         {
 167             /* Find end of the escape block starting at "Substring2" */
 168
 169             SubString2 = strstr (SubString2, AS_STOP_IGNORE);
 170             if (!SubString2)
 171             {
 172                 /* Didn't find terminator */
 173
 174                 return LowerCaseCount;
 175             }
 176
 177             /* Move buffer to end of escape block and continue */
 178
 179             SubBuffer = SubString2;
 180         }
 181
 182         /* Do the actual replace if the target was found */
 183
 184         else
 185         {
 186             if (!AsMatchExactWord (SubString1, TargetLength))
 187             {
 188                 SubBuffer = SubString1 + 1;
 189                 continue;
 190             }
 191
 192             for (i = 0; i < TargetLength; i++)
 193             {
 194                 SubString1[i] = (char) tolower (SubString1[i]);
 195             }
 196
 197             SubBuffer = SubString1 + TargetLength;
 198
 199             if ((Gbl_WidenDeclarations) && (!Gbl_StructDefs))
 200             {
 201                 if ((SubBuffer[0] == ' ') && (SubBuffer[1] == ' '))
 202                 {
 203                     AsInsertData (SubBuffer, "        ", 8);
 204                 }
 205             }
 206
 207             LowerCaseCount++;
 208         }
 209     }
 210
 211     return LowerCaseCount;
 212 }
 213
 214
 215 /******************************************************************************
 216  *
 217  * FUNCTION:    AsMixedCaseToUnderscores
 218  *
 219  * DESCRIPTION: Converts mixed case identifiers to underscored identifiers.
 220  *              for example,
 221  *
 222  *              ThisUsefullyNamedIdentifier   becomes:
 223  *
 224  *              this_usefully_named_identifier
 225  *
 226  ******************************************************************************/
 227
 228 void
 229 AsMixedCaseToUnderscores (
 230     char                    *Buffer)
 231 {
 232     UINT32                  Length;
 233     char                    *SubBuffer = Buffer;
 234     char                    *TokenEnd;
 235     char                    *TokenStart = NULL;
 236     char                    *SubString;
 237     BOOLEAN                 HasLowerCase = FALSE;
 238
 239
 240     while (*SubBuffer)
 241     {
 242         /* Ignore whitespace */
 243
 244         if (*SubBuffer == ' ')
 245         {
 246             while (*SubBuffer == ' ')
 247             {
 248                 SubBuffer++;
 249             }
 250             TokenStart = NULL;
 251             HasLowerCase = FALSE;
 252             continue;
 253         }
 254
 255         /* Ignore commas */
 256
 257         if ((*SubBuffer == ',') ||
 258             (*SubBuffer == '>') ||
 259             (*SubBuffer == ')'))
 260         {
 261             SubBuffer++;
 262             TokenStart = NULL;
 263             HasLowerCase = FALSE;
 264             continue;
 265         }
 266
 267         /* Check for quoted string -- ignore */
 268
 269         if (*SubBuffer == '"')
 270         {
 271             SubBuffer++;
 272             while (*SubBuffer != '"')
 273             {
 274                 if (!*SubBuffer)
 275                 {
 276                     return;
 277                 }
 278
 279                 /* Handle embedded escape sequences */
 280
 281                 if (*SubBuffer == '\\')
 282                 {
 283                     SubBuffer++;
 284                 }
 285                 SubBuffer++;
 286             }
 287             SubBuffer++;
 288             continue;
 289         }
 290
 291         if (islower (*SubBuffer))
 292         {
 293             HasLowerCase = TRUE;
 294         }
 295
 296         /*
 297          * Check for translation escape string -- means to ignore
 298          * blocks of code while replacing
 299          */
 300         if ((SubBuffer[0] == '/') &&
 301             (SubBuffer[1] == '*') &&
 302             (SubBuffer[2] == '!'))
 303         {
 304             SubBuffer = strstr (SubBuffer, "!*/");
 305             if (!SubBuffer)
 306             {
 307                 return;
 308             }
 309             continue;
 310         }
 311
 312         /* Ignore hex constants */
 313
 314         if (SubBuffer[0] == '0')
 315         {
 316             if ((SubBuffer[1] == 'x') ||
 317                 (SubBuffer[1] == 'X'))
 318             {
 319                 SubBuffer += 2;
 320                 while (isxdigit (*SubBuffer))
 321                 {
 322                     SubBuffer++;
 323                 }
 324                 continue;
 325             }
 326         }
 327
 328 // OBSOLETE CODE, all quoted strings now completely ignored.
 329 #if 0
 330         /* Ignore format specification fields */
 331
 332         if (SubBuffer[0] == '%')
 333         {
 334             SubBuffer++;
 335
 336             while ((isalnum (*SubBuffer)) || (*SubBuffer == '.'))
 337             {
 338                 SubBuffer++;
 339             }
 340
 341             continue;
 342         }
 343 #endif
 344
 345         /* Ignore standard escape sequences (\n, \r, etc.)  Not Hex or Octal escapes */
 346
 347         if (SubBuffer[0] == '\\')
 348         {
 349             SubBuffer += 2;
 350             continue;
 351         }
 352
 353         /*
 354          * Ignore identifiers that already contain embedded underscores
 355          * These are typically C macros or defines (all upper case)
 356          * Note: there are some cases where identifiers have underscores
 357          * AcpiGbl_* for example. HasLowerCase flag handles these.
 358          */
 359         if ((*SubBuffer == '_') && (!HasLowerCase) && (TokenStart))
 360         {
 361             /* Check the rest of the identifier for any lower case letters */
 362
 363             SubString = SubBuffer;
 364             while ((isalnum (*SubString)) || (*SubString == '_'))
 365             {
 366                 if (islower (*SubString))
 367                 {
 368                     HasLowerCase = TRUE;
 369                 }
 370                 SubString++;
 371             }
 372
 373             /* If no lower case letters, we can safely ignore the entire token */
 374
 375             if (!HasLowerCase)
 376             {
 377                 SubBuffer = SubString;
 378                 continue;
 379             }
 380         }
 381
 382         /* A capital letter may indicate the start of a token; save it */
 383
 384         if (isupper (SubBuffer[0]))
 385         {
 386             TokenStart = SubBuffer;
 387         }
 388
 389         /*
 390          * Convert each pair of letters that matches the form:
 391          *
 392          *      <LowerCase><UpperCase>
 393          * to
 394          *      <LowerCase><Underscore><LowerCase>
 395          */
 396         else if ((islower (SubBuffer[0]) || isdigit (SubBuffer[0])) &&
 397                  (isupper (SubBuffer[1])))
 398         {
 399             if (isdigit (SubBuffer[0]))
 400             {
 401                 /* Ignore <UpperCase><Digit><UpperCase> */
 402                 /* Ignore <Underscore><Digit><UpperCase> */
 403
 404                 if (isupper (*(SubBuffer-1)) ||
 405                     *(SubBuffer-1) == '_')
 406                 {
 407                     SubBuffer++;
 408                     continue;
 409                 }
 410             }
 411
 412             /*
 413              * Matched the pattern.
 414              * Find the end of this identifier (token)
 415              */
 416             TokenEnd = SubBuffer;
 417             while ((isalnum (*TokenEnd)) || (*TokenEnd == '_'))
 418             {
 419                 TokenEnd++;
 420             }
 421
 422             /* Force the UpperCase letter (#2) to lower case */
 423
 424             Gbl_MadeChanges = TRUE;
 425             SubBuffer[1] = (char) tolower (SubBuffer[1]);
 426
 427             SubString = TokenEnd;
 428             Length = 0;
 429
 430             while (*SubString != '\n')
 431             {
 432                 /*
 433                  * If we have at least two trailing spaces, we can get rid of
 434                  * one to make up for the newly inserted underscore.  This will
 435                  * help preserve the alignment of the text
 436                  */
 437                 if ((SubString[0] == ' ') &&
 438                     (SubString[1] == ' '))
 439                 {
 440                     Length = SubString - SubBuffer - 2;
 441                     break;
 442                 }
 443
 444                 SubString++;
 445             }
 446
 447             if (!Length)
 448             {
 449                 Length = strlen (&SubBuffer[1]);
 450             }
 451
 452             memmove (&SubBuffer[2], &SubBuffer[1], Length + 1);
 453             SubBuffer[1] = '_';
 454             SubBuffer +=2;
 455
 456             /* Lower case the leading character of the token */
 457
 458             if (TokenStart)
 459             {
 460                 *TokenStart = (char) tolower (*TokenStart);
 461                 TokenStart = NULL;
 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 (SubBuffer[0])) &&
 552             (islower (SubBuffer[1])))
 553         {
 554             Gbl_MadeChanges = TRUE;
 555             *SubBuffer = (char) tolower (*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 (*TokenEnd)) || (*TokenEnd == '_'))
 593             {
 594                 TokenEnd++;
 595             }
 596
 597             for (i = 0; i < (TokenEnd - SubBuffer); i++)
 598             {
 599                 if ((islower (SubBuffer[i])) &&
 600                     (isupper (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 (SubBuffer[i]);
 633             }
 634
 635             SubBuffer = TokenEnd;
 636         }
 637     }
 638 }
 639
 640