1 /****************************************************************************** 2 * 3 * Module Name: ascase - Source conversion - lower/upper case utilities 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 }