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

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: ascase - Source conversion - lower/upper case utilities
   5  *              $Revision: 7 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2003, 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, "/*!");
 163
 164         if ((SubString2) &&
 165             (SubString2 < SubString1))
 166         {
 167             /* Find end of the escape block starting at "Substring2" */
 168
 169             SubString2 = strstr (SubString2, "!*/");
 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)
 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
 238
 239     while (*SubBuffer)
 240     {
 241         /*
 242          * Check for translation escape string -- means to ignore
 243          * blocks of code while replacing
 244          */
 245         if ((SubBuffer[0] == '/') &&
 246             (SubBuffer[1] == '*') &&
 247             (SubBuffer[2] == '!'))
 248         {
 249             SubBuffer = strstr (SubBuffer, "!*/");
 250             if (!SubBuffer)
 251             {
 252                 return;
 253             }
 254         }
 255
 256         /* Ignore hex constants */
 257
 258         if (SubBuffer[0] == '0')
 259         {
 260             if ((SubBuffer[1] == 'x') ||
 261                 (SubBuffer[1] == 'X'))
 262             {
 263                 SubBuffer += 2;
 264                 while (isxdigit (*SubBuffer))
 265                 {
 266                     SubBuffer++;
 267                 }
 268                 continue;
 269             }
 270         }
 271
 272         /* Ignore format specification fields */
 273
 274         if (SubBuffer[0] == '%')
 275         {
 276             SubBuffer++;
 277
 278             while ((isalnum (*SubBuffer)) ||
 279                    (*SubBuffer == '.'))
 280             {
 281                 SubBuffer++;
 282             }
 283
 284             continue;
 285         }
 286
 287         /* Ignore standard escape sequences (\n, \r, etc.)  Not Hex or Octal escapes */
 288
 289         if (SubBuffer[0] == '\\')
 290         {
 291             SubBuffer += 2;
 292             continue;
 293         }
 294
 295         /* A capital letter may indicate the start of a token;  save it */
 296
 297         if (isupper (SubBuffer[0]))
 298         {
 299             TokenStart = SubBuffer;
 300         }
 301
 302         /*
 303          * Convert each pair of letters that matches the form:
 304          *
 305          *      <LowerCase><UpperCase>
 306          * to
 307          *      <LowerCase><Underscore><LowerCase>
 308          */
 309         else if ((islower (SubBuffer[0]) || isdigit (SubBuffer[0])) &&
 310                  (isupper (SubBuffer[1])))
 311         {
 312             if (isdigit (SubBuffer[0]))
 313             {
 314                 /* Ignore <UpperCase><Digit><UpperCase> */
 315                 /* Ignore <Underscore><Digit><UpperCase> */
 316
 317                 if (isupper (*(SubBuffer-1)) ||
 318                     *(SubBuffer-1) == '_')
 319                 {
 320                     SubBuffer++;
 321                     continue;
 322                 }
 323             }
 324
 325             /*
 326              * Matched the pattern.
 327              * Find the end of this identifier (token)
 328              */
 329             TokenEnd = SubBuffer;
 330             while ((isalnum (*TokenEnd)) || (*TokenEnd == '_'))
 331             {
 332                 TokenEnd++;
 333             }
 334
 335             /* Force the UpperCase letter (#2) to lower case */
 336
 337             Gbl_MadeChanges = TRUE;
 338             SubBuffer[1] = (char) tolower (SubBuffer[1]);
 339
 340             SubString = TokenEnd;
 341             Length = 0;
 342
 343             while (*SubString != '\n')
 344             {
 345                 /*
 346                  * If we have at least two trailing spaces, we can get rid of
 347                  * one to make up for the newly inserted underscore.  This will
 348                  * help preserve the alignment of the text
 349                  */
 350                 if ((SubString[0] == ' ') &&
 351                     (SubString[1] == ' '))
 352                 {
 353                     Length = SubString - SubBuffer - 2;
 354                     break;
 355                 }
 356
 357                 SubString++;
 358             }
 359
 360             if (!Length)
 361             {
 362                 Length = strlen (&SubBuffer[1]);
 363             }
 364
 365             memmove (&SubBuffer[2], &SubBuffer[1], (Length+1));
 366             SubBuffer[1] = '_';
 367             SubBuffer +=2;
 368
 369             /* Lower case the leading character of the token */
 370
 371             if (TokenStart)
 372             {
 373                 *TokenStart = (char) tolower (*TokenStart);
 374                 TokenStart = NULL;
 375             }
 376         }
 377
 378         SubBuffer++;
 379     }
 380 }
 381
 382
 383 /******************************************************************************
 384  *
 385  * FUNCTION:    AsLowerCaseIdentifiers
 386  *
 387  * DESCRIPTION: Converts mixed case identifiers to lower case.  Leaves comments,
 388  *              quoted strings, and all-upper-case macros alone.
 389  *
 390  ******************************************************************************/
 391
 392 void
 393 AsLowerCaseIdentifiers (
 394     char                    *Buffer)
 395 {
 396     char                    *SubBuffer = Buffer;
 397
 398
 399     while (*SubBuffer)
 400     {
 401         /*
 402          * Check for translation escape string -- means to ignore
 403          * blocks of code while replacing
 404          */
 405         if ((SubBuffer[0] == '/') &&
 406             (SubBuffer[1] == '*') &&
 407             (SubBuffer[2] == '!'))
 408         {
 409             SubBuffer = strstr (SubBuffer, "!*/");
 410             if (!SubBuffer)
 411             {
 412                 return;
 413             }
 414         }
 415
 416         /* Ignore comments */
 417
 418         if ((SubBuffer[0] == '/') &&
 419             (SubBuffer[1] == '*'))
 420         {
 421             SubBuffer = strstr (SubBuffer, "*/");
 422             if (!SubBuffer)
 423             {
 424                 return;
 425             }
 426
 427             SubBuffer += 2;
 428         }
 429
 430         /* Ignore quoted strings */
 431
 432         if ((SubBuffer[0] == '\"') && (SubBuffer[1] != '\''))
 433         {
 434             SubBuffer++;
 435
 436             /* Find the closing quote */
 437
 438             while (SubBuffer[0])
 439             {
 440                 /* Ignore escaped quote characters */
 441
 442                 if (SubBuffer[0] == '\\')
 443                 {
 444                     SubBuffer++;
 445                 }
 446                 else if (SubBuffer[0] == '\"')
 447                 {
 448                     SubBuffer++;
 449                     break;
 450                 }
 451                 SubBuffer++;
 452             }
 453         }
 454
 455         if (!SubBuffer[0])
 456         {
 457             return;
 458         }
 459
 460         /*
 461          * Only lower case if we have an upper followed by a lower
 462          * This leaves the all-uppercase things (macros, etc.) intact
 463          */
 464         if ((isupper (SubBuffer[0])) &&
 465             (islower (SubBuffer[1])))
 466         {
 467             Gbl_MadeChanges = TRUE;
 468             *SubBuffer = (char) tolower (*SubBuffer);
 469         }
 470
 471         SubBuffer++;
 472     }
 473 }
 474
 475
 476 /******************************************************************************
 477  *
 478  * FUNCTION:    AsUppercaseTokens
 479  *
 480  * DESCRIPTION: Force to uppercase all tokens that begin with the prefix string.
 481  *              used to convert mixed-case macros and constants to uppercase.
 482  *
 483  ******************************************************************************/
 484
 485 void
 486 AsUppercaseTokens (
 487     char                    *Buffer,
 488     char                    *PrefixString)
 489 {
 490     char                    *SubBuffer;
 491     char                    *TokenEnd;
 492     char                    *SubString;
 493     int                     i;
 494     UINT32                  Length;
 495
 496
 497     SubBuffer = Buffer;
 498
 499     while (SubBuffer)
 500     {
 501         SubBuffer = strstr (SubBuffer, PrefixString);
 502         if (SubBuffer)
 503         {
 504             TokenEnd = SubBuffer;
 505             while ((isalnum (*TokenEnd)) || (*TokenEnd == '_'))
 506             {
 507                 TokenEnd++;
 508             }
 509
 510             for (i = 0; i < (TokenEnd - SubBuffer); i++)
 511             {
 512                 if ((islower (SubBuffer[i])) &&
 513                     (isupper (SubBuffer[i+1])))
 514                 {
 515
 516                     SubString = TokenEnd;
 517                     Length = 0;
 518
 519                     while (*SubString != '\n')
 520                     {
 521                         if ((SubString[0] == ' ') &&
 522                             (SubString[1] == ' '))
 523                         {
 524                             Length = SubString - &SubBuffer[i] - 2;
 525                             break;
 526                         }
 527
 528                         SubString++;
 529                     }
 530
 531                     if (!Length)
 532                     {
 533                         Length = strlen (&SubBuffer[i+1]);
 534                     }
 535
 536                     memmove (&SubBuffer[i+2], &SubBuffer[i+1], (Length+1));
 537                     SubBuffer[i+1] = '_';
 538                     i +=2;
 539                     TokenEnd++;
 540                 }
 541             }
 542
 543             for (i = 0; i < (TokenEnd - SubBuffer); i++)
 544             {
 545                 SubBuffer[i] = (char) toupper (SubBuffer[i]);
 546             }
 547
 548             SubBuffer = TokenEnd;
 549         }
 550     }
 551 }
 552
 553