1 /****************************************************************************** 2 * 3 * Module Name: ascase - Source conversion - lower/upper case utilities 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2017, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 ***************************************************************************** 115 * 116 * Alternatively, you may choose to be licensed under the terms of the 117 * following license: 118 * 119 * Redistribution and use in source and binary forms, with or without 120 * modification, are permitted provided that the following conditions 121 * are met: 122 * 1. Redistributions of source code must retain the above copyright 123 * notice, this list of conditions, and the following disclaimer, 124 * without modification. 125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 126 * substantially similar to the "NO WARRANTY" disclaimer below 127 * ("Disclaimer") and any redistribution must be conditioned upon 128 * including a substantially similar Disclaimer requirement for further 129 * binary redistribution. 130 * 3. Neither the names of the above-listed copyright holders nor the names 131 * of any contributors may be used to endorse or promote products derived 132 * from this software without specific prior written permission. 133 * 134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 145 * 146 * Alternatively, you may choose to be licensed under the terms of the 147 * GNU General Public License ("GPL") version 2 as published by the Free 148 * Software Foundation. 149 * 150 *****************************************************************************/ 151 152 #include "acpisrc.h" 153 154 /* Local prototypes */ 155 156 void 157 AsUppercaseTokens ( 158 char *Buffer, 159 char *PrefixString); 160 161 162 /****************************************************************************** 163 * 164 * FUNCTION: AsLowerCaseString 165 * 166 * DESCRIPTION: LowerCase all instances of a target string with a replacement 167 * string. Returns count of the strings replaced. 168 * 169 ******************************************************************************/ 170 171 int 172 AsLowerCaseString ( 173 char *Target, 174 char *Buffer) 175 { 176 char *SubString1; 177 char *SubString2; 178 char *SubBuffer; 179 int TargetLength; 180 int LowerCaseCount = 0; 181 int i; 182 183 184 TargetLength = strlen (Target); 185 186 SubBuffer = Buffer; 187 SubString1 = Buffer; 188 189 while (SubString1) 190 { 191 /* Find the target string */ 192 193 SubString1 = strstr (SubBuffer, Target); 194 if (!SubString1) 195 { 196 return (LowerCaseCount); 197 } 198 199 /* 200 * Check for translation escape string -- means to ignore 201 * blocks of code while replacing 202 */ 203 if (Gbl_IgnoreTranslationEscapes) 204 { 205 SubString2 = NULL; 206 } 207 else 208 { 209 SubString2 = strstr (SubBuffer, AS_START_IGNORE); 210 } 211 212 if ((SubString2) && 213 (SubString2 < SubString1)) 214 { 215 /* Find end of the escape block starting at "Substring2" */ 216 217 SubString2 = strstr (SubString2, AS_STOP_IGNORE); 218 if (!SubString2) 219 { 220 /* Didn't find terminator */ 221 222 return (LowerCaseCount); 223 } 224 225 /* Move buffer to end of escape block and continue */ 226 227 SubBuffer = SubString2; 228 } 229 230 /* Do the actual replace if the target was found */ 231 232 else 233 { 234 if (!AsMatchExactWord (SubString1, TargetLength)) 235 { 236 SubBuffer = SubString1 + 1; 237 continue; 238 } 239 240 for (i = 0; i < TargetLength; i++) 241 { 242 SubString1[i] = (char) tolower ((int) SubString1[i]); 243 } 244 245 SubBuffer = SubString1 + TargetLength; 246 247 if ((Gbl_WidenDeclarations) && (!Gbl_StructDefs)) 248 { 249 if ((SubBuffer[0] == ' ') && (SubBuffer[1] == ' ')) 250 { 251 AsInsertData (SubBuffer, " ", 8); 252 } 253 } 254 255 LowerCaseCount++; 256 } 257 } 258 259 return (LowerCaseCount); 260 } 261 262 263 /****************************************************************************** 264 * 265 * FUNCTION: AsMixedCaseToUnderscores 266 * 267 * DESCRIPTION: Converts mixed case identifiers to underscored identifiers. 268 * for example, 269 * 270 * ThisUsefullyNamedIdentifier becomes: 271 * 272 * this_usefully_named_identifier 273 * 274 ******************************************************************************/ 275 276 void 277 AsMixedCaseToUnderscores ( 278 char *Buffer, 279 char *Filename) 280 { 281 UINT32 Length; 282 char *SubBuffer = Buffer; 283 char *TokenEnd; 284 char *TokenStart = NULL; 285 char *SubString; 286 UINT32 LineNumber = 1; 287 UINT32 Count; 288 289 290 /* 291 * Examine the entire buffer (contains the entire file) 292 * We are only interested in these tokens: 293 * Escape sequences - ignore entire sequence 294 * Single-quoted constants - ignore 295 * Quoted strings - ignore entire string 296 * Translation escape - starts with /,*,! 297 * Decimal and hex numeric constants - ignore entire token 298 * Entire uppercase token - ignore, it is a macro or define 299 * Starts with underscore, then a lowercase or digit: convert 300 */ 301 while (*SubBuffer) 302 { 303 if (*SubBuffer == '\n') 304 { 305 LineNumber++; 306 SubBuffer++; 307 continue; 308 } 309 310 /* Ignore standard escape sequences (\n, \r, etc.) Not Hex or Octal escapes */ 311 312 if (*SubBuffer == '\\') 313 { 314 SubBuffer += 2; 315 continue; 316 } 317 318 /* Ignore single-quoted characters */ 319 320 if (*SubBuffer == '\'') 321 { 322 SubBuffer += 3; 323 continue; 324 } 325 326 /* Ignore standard double-quoted strings */ 327 328 if (*SubBuffer == '"') 329 { 330 SubBuffer++; 331 Count = 0; 332 while (*SubBuffer != '"') 333 { 334 Count++; 335 if ((!*SubBuffer) || 336 (Count > 8192)) 337 { 338 printf ("Found an unterminated quoted string!, line %u: %s\n", 339 LineNumber, Filename); 340 return; 341 } 342 343 /* Handle escape sequences */ 344 345 if (*SubBuffer == '\\') 346 { 347 SubBuffer++; 348 } 349 350 SubBuffer++; 351 } 352 353 SubBuffer++; 354 continue; 355 } 356 357 /* 358 * Check for translation escape string. It means to ignore 359 * blocks of code during this code conversion. 360 */ 361 if ((SubBuffer[0] == '/') && 362 (SubBuffer[1] == '*') && 363 (SubBuffer[2] == '!')) 364 { 365 SubBuffer = strstr (SubBuffer, "!*/"); 366 if (!SubBuffer) 367 { 368 printf ("Found an unterminated translation escape!, line %u: %s\n", 369 LineNumber, Filename); 370 return; 371 } 372 373 continue; 374 } 375 376 /* Ignore anything that starts with a number (0-9) */ 377 378 if (isdigit ((int) *SubBuffer)) 379 { 380 /* Ignore hex constants */ 381 382 if ((SubBuffer[0] == '0') && 383 ((SubBuffer[1] == 'x') || (SubBuffer[1] == 'X'))) 384 { 385 SubBuffer += 2; 386 } 387 388 /* Skip over all digits, both decimal and hex */ 389 390 while (isxdigit ((int) *SubBuffer)) 391 { 392 SubBuffer++; 393 } 394 TokenStart = NULL; 395 continue; 396 } 397 398 /* 399 * Check for fully upper case identifiers. These are usually macros 400 * or defines. Allow decimal digits and embedded underscores. 401 */ 402 if (isupper ((int) *SubBuffer)) 403 { 404 SubString = SubBuffer + 1; 405 while ((isupper ((int) *SubString)) || 406 (isdigit ((int) *SubString)) || 407 (*SubString == '_')) 408 { 409 SubString++; 410 } 411 412 /* 413 * For the next character, anything other than a lower case 414 * means that the identifier has terminated, and contains 415 * exclusively Uppers/Digits/Underscores. Ignore the entire 416 * identifier. 417 */ 418 if (!islower ((int) *SubString)) 419 { 420 SubBuffer = SubString + 1; 421 continue; 422 } 423 } 424 425 /* 426 * These forms may indicate an identifier that can be converted: 427 * <UpperCase><LowerCase> (Ax) 428 * <UpperCase><Number> (An) 429 */ 430 if (isupper ((int) SubBuffer[0]) && 431 ((islower ((int) SubBuffer[1])) || isdigit ((int) SubBuffer[1]))) 432 { 433 TokenStart = SubBuffer; 434 SubBuffer++; 435 436 while (1) 437 { 438 /* Walk over the lower case letters and decimal digits */ 439 440 while (islower ((int) *SubBuffer) || 441 isdigit ((int) *SubBuffer)) 442 { 443 SubBuffer++; 444 } 445 446 /* Check for end of line or end of token */ 447 448 if (*SubBuffer == '\n') 449 { 450 LineNumber++; 451 break; 452 } 453 454 if (*SubBuffer == ' ') 455 { 456 /* Check for form "Axx - " in a parameter header description */ 457 458 while (*SubBuffer == ' ') 459 { 460 SubBuffer++; 461 } 462 463 SubBuffer--; 464 if ((SubBuffer[1] == '-') && 465 (SubBuffer[2] == ' ')) 466 { 467 if (TokenStart) 468 { 469 *TokenStart = (char) tolower ((int) *TokenStart); 470 } 471 } 472 break; 473 } 474 475 /* 476 * Ignore these combinations: 477 * <Letter><Digit><UpperCase> 478 * <Digit><Digit><UpperCase> 479 * <Underscore><Digit><UpperCase> 480 */ 481 if (isdigit ((int) *SubBuffer)) 482 { 483 if (isalnum ((int) *(SubBuffer-1)) || 484 *(SubBuffer-1) == '_') 485 { 486 break; 487 } 488 } 489 490 /* Ignore token if next character is not uppercase or digit */ 491 492 if (!isupper ((int) *SubBuffer) && 493 !isdigit ((int) *SubBuffer)) 494 { 495 break; 496 } 497 498 /* 499 * Form <UpperCase><LowerCaseLetters><UpperCase> (AxxB): 500 * Convert leading character of the token to lower case 501 */ 502 if (TokenStart) 503 { 504 *TokenStart = (char) tolower ((int) *TokenStart); 505 TokenStart = NULL; 506 } 507 508 /* Find the end of this identifier (token) */ 509 510 TokenEnd = SubBuffer - 1; 511 while ((isalnum ((int) *TokenEnd)) || 512 (*TokenEnd == '_')) 513 { 514 TokenEnd++; 515 } 516 517 SubString = TokenEnd; 518 Length = 0; 519 520 while (*SubString != '\n') 521 { 522 /* 523 * If we have at least two trailing spaces, we can get rid of 524 * one to make up for the newly inserted underscore. This will 525 * help preserve the alignment of the text 526 */ 527 if ((SubString[0] == ' ') && 528 (SubString[1] == ' ')) 529 { 530 Length = SubString - SubBuffer - 1; 531 break; 532 } 533 534 SubString++; 535 } 536 537 if (!Length) 538 { 539 Length = strlen (&SubBuffer[0]); 540 } 541 542 /* 543 * Within this identifier, convert this pair of letters that 544 * matches the form: 545 * 546 * <LowerCase><UpperCase> 547 * to 548 * <LowerCase><Underscore><LowerCase> 549 */ 550 Gbl_MadeChanges = TRUE; 551 552 /* Insert the underscore */ 553 554 memmove (&SubBuffer[1], &SubBuffer[0], Length + 1); 555 SubBuffer[0] = '_'; 556 557 /* 558 * If we have <UpperCase><UpperCase>, leave them as-is 559 * Enables transforms like: 560 * LocalFADT -> local_FADT 561 */ 562 if (isupper ((int) SubBuffer[2])) 563 { 564 SubBuffer += 1; 565 break; 566 } 567 568 /* Lower case the original upper case letter */ 569 570 SubBuffer[1] = (char) tolower ((int) SubBuffer[1]); 571 SubBuffer += 2; 572 } 573 } 574 575 SubBuffer++; 576 } 577 } 578 579 580 /****************************************************************************** 581 * 582 * FUNCTION: AsLowerCaseIdentifiers 583 * 584 * DESCRIPTION: Converts mixed case identifiers to lower case. Leaves comments, 585 * quoted strings, and all-upper-case macros alone. 586 * 587 ******************************************************************************/ 588 589 void 590 AsLowerCaseIdentifiers ( 591 char *Buffer) 592 { 593 char *SubBuffer = Buffer; 594 595 596 while (*SubBuffer) 597 { 598 /* 599 * Check for translation escape string -- means to ignore 600 * blocks of code while replacing 601 */ 602 if ((SubBuffer[0] == '/') && 603 (SubBuffer[1] == '*') && 604 (SubBuffer[2] == '!')) 605 { 606 SubBuffer = strstr (SubBuffer, "!*/"); 607 if (!SubBuffer) 608 { 609 return; 610 } 611 } 612 613 /* Ignore comments */ 614 615 if ((SubBuffer[0] == '/') && 616 (SubBuffer[1] == '*')) 617 { 618 SubBuffer = strstr (SubBuffer, "*/"); 619 if (!SubBuffer) 620 { 621 return; 622 } 623 624 SubBuffer += 2; 625 } 626 627 /* Ignore quoted strings */ 628 629 if ((SubBuffer[0] == '\"') && (SubBuffer[1] != '\'')) 630 { 631 SubBuffer++; 632 633 /* Find the closing quote */ 634 635 while (SubBuffer[0]) 636 { 637 /* Ignore escaped quote characters */ 638 639 if (SubBuffer[0] == '\\') 640 { 641 SubBuffer++; 642 } 643 else if (SubBuffer[0] == '\"') 644 { 645 SubBuffer++; 646 break; 647 } 648 649 SubBuffer++; 650 } 651 } 652 653 if (!SubBuffer[0]) 654 { 655 return; 656 } 657 658 /* 659 * Only lower case if we have an upper followed by a lower 660 * This leaves the all-uppercase things (macros, etc.) intact 661 */ 662 if ((isupper ((int) SubBuffer[0])) && 663 (islower ((int) SubBuffer[1]))) 664 { 665 Gbl_MadeChanges = TRUE; 666 *SubBuffer = (char) tolower ((int) *SubBuffer); 667 } 668 669 SubBuffer++; 670 } 671 } 672 673 674 /****************************************************************************** 675 * 676 * FUNCTION: AsUppercaseTokens 677 * 678 * DESCRIPTION: Force to uppercase all tokens that begin with the prefix string. 679 * used to convert mixed-case macros and constants to uppercase. 680 * 681 ******************************************************************************/ 682 683 void 684 AsUppercaseTokens ( 685 char *Buffer, 686 char *PrefixString) 687 { 688 char *SubBuffer; 689 char *TokenEnd; 690 char *SubString; 691 int i; 692 UINT32 Length; 693 694 695 SubBuffer = Buffer; 696 697 while (SubBuffer) 698 { 699 SubBuffer = strstr (SubBuffer, PrefixString); 700 if (SubBuffer) 701 { 702 TokenEnd = SubBuffer; 703 while ((isalnum ((int) *TokenEnd)) || (*TokenEnd == '_')) 704 { 705 TokenEnd++; 706 } 707 708 for (i = 0; i < (TokenEnd - SubBuffer); i++) 709 { 710 if ((islower ((int) SubBuffer[i])) && 711 (isupper ((int) SubBuffer[i+1]))) 712 { 713 714 SubString = TokenEnd; 715 Length = 0; 716 717 while (*SubString != '\n') 718 { 719 if ((SubString[0] == ' ') && 720 (SubString[1] == ' ')) 721 { 722 Length = SubString - &SubBuffer[i] - 2; 723 break; 724 } 725 726 SubString++; 727 } 728 729 if (!Length) 730 { 731 Length = strlen (&SubBuffer[i+1]); 732 } 733 734 memmove (&SubBuffer[i+2], &SubBuffer[i+1], (Length+1)); 735 SubBuffer[i+1] = '_'; 736 i +=2; 737 TokenEnd++; 738 } 739 } 740 741 for (i = 0; i < (TokenEnd - SubBuffer); i++) 742 { 743 SubBuffer[i] = (char) toupper ((int) SubBuffer[i]); 744 } 745 746 SubBuffer = TokenEnd; 747 } 748 } 749 } 750