1 /****************************************************************************** 2 * 3 * Module Name: prmacros - Preprocessor #define macro support 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 "aslcompiler.h" 153 #include "dtcompiler.h" 154 155 156 #define _COMPONENT ASL_PREPROCESSOR 157 ACPI_MODULE_NAME ("prmacros") 158 159 160 /******************************************************************************* 161 * 162 * FUNCTION: PrDumpPredefinedNames 163 * 164 * PARAMETERS: None 165 * 166 * RETURN: None 167 * 168 * DESCRIPTION: Dump the list of #defines. Used as the preprocessor starts, to 169 * display the names that were defined on the command line. 170 * Debug information only. 171 * 172 ******************************************************************************/ 173 174 void 175 PrDumpPredefinedNames ( 176 void) 177 { 178 PR_DEFINE_INFO *DefineInfo; 179 180 181 DefineInfo = Gbl_DefineList; 182 while (DefineInfo) 183 { 184 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 185 "Predefined #define: %s->%s\n", 186 0, DefineInfo->Identifier, DefineInfo->Replacement); 187 188 DefineInfo = DefineInfo->Next; 189 } 190 } 191 192 193 /******************************************************************************* 194 * 195 * FUNCTION: PrAddDefine 196 * 197 * PARAMETERS: Identifier - Name to be replaced 198 * Replacement - Replacement for Identifier 199 * Persist - Keep define across multiple compiles? 200 * 201 * RETURN: A new define_info struct. NULL on error. 202 * 203 * DESCRIPTION: Add a new #define to the global list 204 * 205 ******************************************************************************/ 206 207 PR_DEFINE_INFO * 208 PrAddDefine ( 209 char *Identifier, 210 char *Replacement, 211 BOOLEAN Persist) 212 { 213 char *IdentifierString; 214 char *ReplacementString; 215 PR_DEFINE_INFO *DefineInfo; 216 217 218 if (!Replacement) 219 { 220 Replacement = ""; 221 } 222 223 /* Check for already-defined first */ 224 225 DefineInfo = PrMatchDefine (Identifier); 226 if (DefineInfo) 227 { 228 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID, 229 "#define: name already exists: %s\n", 230 Gbl_CurrentLineNumber, Identifier); 231 232 /* 233 * Name already exists. This is only an error if the target name 234 * is different. 235 */ 236 if (strcmp (Replacement, DefineInfo->Replacement)) 237 { 238 PrError (ASL_ERROR, ASL_MSG_EXISTING_NAME, 239 THIS_TOKEN_OFFSET (Identifier)); 240 241 return (NULL); 242 } 243 244 return (DefineInfo); 245 } 246 247 /* Copy input strings */ 248 249 IdentifierString = UtLocalCalloc (strlen (Identifier) + 1); 250 strcpy (IdentifierString, Identifier); 251 252 ReplacementString = UtLocalCalloc (strlen (Replacement) + 1); 253 strcpy (ReplacementString, Replacement); 254 255 /* Init and link new define info struct */ 256 257 DefineInfo = UtLocalCalloc (sizeof (PR_DEFINE_INFO)); 258 DefineInfo->Replacement = ReplacementString; 259 DefineInfo->Identifier = IdentifierString; 260 DefineInfo->Persist = Persist; 261 262 if (Gbl_DefineList) 263 { 264 Gbl_DefineList->Previous = DefineInfo; 265 } 266 267 DefineInfo->Next = Gbl_DefineList; 268 Gbl_DefineList = DefineInfo; 269 return (DefineInfo); 270 } 271 272 273 /******************************************************************************* 274 * 275 * FUNCTION: PrRemoveDefine 276 * 277 * PARAMETERS: DefineName - Name of define to be removed 278 * 279 * RETURN: None 280 * 281 * DESCRIPTION: Implements #undef. Remove a #define if found in the global 282 * list. No error if the target of the #undef does not exist, 283 * as per the C #undef definition. 284 * 285 ******************************************************************************/ 286 287 void 288 PrRemoveDefine ( 289 char *DefineName) 290 { 291 PR_DEFINE_INFO *DefineInfo; 292 293 294 /* Match name and delete the node */ 295 296 DefineInfo = Gbl_DefineList; 297 while (DefineInfo) 298 { 299 if (!strcmp (DefineName, DefineInfo->Identifier)) 300 { 301 /* Remove from linked list */ 302 303 if (DefineInfo->Previous) 304 { 305 (DefineInfo->Previous)->Next = DefineInfo->Next; 306 } 307 else 308 { 309 Gbl_DefineList = DefineInfo->Next; 310 } 311 312 if (DefineInfo->Next) 313 { 314 (DefineInfo->Next)->Previous = DefineInfo->Previous; 315 } 316 317 free (DefineInfo); 318 return; 319 } 320 321 DefineInfo = DefineInfo->Next; 322 } 323 324 /* 325 * Name was not found. By definition of #undef, this is not 326 * an error, however. 327 */ 328 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 329 "#undef: could not find %s\n", 330 Gbl_CurrentLineNumber, DefineName); 331 } 332 333 334 /******************************************************************************* 335 * 336 * FUNCTION: PrMatchDefine 337 * 338 * PARAMETERS: MatchString - Name associated with the #define 339 * 340 * RETURN: Matched string if found. NULL otherwise. 341 * 342 * DESCRIPTION: Find a name in global #define list 343 * 344 ******************************************************************************/ 345 346 PR_DEFINE_INFO * 347 PrMatchDefine ( 348 char *MatchString) 349 { 350 PR_DEFINE_INFO *DefineInfo; 351 352 353 DefineInfo = Gbl_DefineList; 354 while (DefineInfo) 355 { 356 if (!strcmp (MatchString, DefineInfo->Identifier)) 357 { 358 return (DefineInfo); 359 } 360 361 DefineInfo = DefineInfo->Next; 362 } 363 364 return (NULL); 365 } 366 367 368 /******************************************************************************* 369 * 370 * FUNCTION: PrAddMacro 371 * 372 * PARAMETERS: Name - Start of the macro definition 373 * Next - "Next" buffer from GetNextToken 374 * 375 * RETURN: None 376 * 377 * DESCRIPTION: Add a new macro to the list of #defines. Handles argument 378 * processing. 379 * 380 ******************************************************************************/ 381 382 void 383 PrAddMacro ( 384 char *Name, 385 char **Next) 386 { 387 char *Token = NULL; 388 ACPI_SIZE TokenOffset; 389 ACPI_SIZE MacroBodyOffset; 390 PR_DEFINE_INFO *DefineInfo; 391 PR_MACRO_ARG *Args; 392 char *Body; 393 char *BodyInSource; 394 UINT32 i; 395 UINT16 UseCount = 0; 396 UINT16 ArgCount = 0; 397 UINT32 Depth = 1; 398 UINT32 EndOfArgList; 399 char BufferChar; 400 401 402 /* Find the end of the arguments list */ 403 404 TokenOffset = Name - Gbl_MainTokenBuffer + strlen (Name) + 1; 405 while (1) 406 { 407 BufferChar = Gbl_CurrentLineBuffer[TokenOffset]; 408 if (BufferChar == '(') 409 { 410 Depth++; 411 } 412 else if (BufferChar == ')') 413 { 414 Depth--; 415 } 416 else if (BufferChar == 0) 417 { 418 PrError (ASL_ERROR, ASL_MSG_MACRO_SYNTAX, TokenOffset); 419 return; 420 } 421 422 if (Depth == 0) 423 { 424 /* Found arg list end */ 425 426 EndOfArgList = TokenOffset; 427 break; 428 } 429 430 TokenOffset++; 431 } 432 433 /* At this point, we know that we have a reasonable argument list */ 434 435 Args = UtLocalCalloc (sizeof (PR_MACRO_ARG) * PR_MAX_MACRO_ARGS); 436 437 /* Get the macro argument names */ 438 439 for (i = 0; i < PR_MAX_MACRO_ARGS; i++) 440 { 441 Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next); 442 if (!Token) 443 { 444 /* This is the case for a NULL macro body */ 445 446 BodyInSource = ""; 447 goto AddMacroToList; 448 } 449 450 /* Don't go beyond the argument list */ 451 452 TokenOffset = Token - Gbl_MainTokenBuffer + strlen (Token); 453 if (TokenOffset > EndOfArgList) 454 { 455 break; 456 } 457 458 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 459 "Macro arg: %s \n", 460 Gbl_CurrentLineNumber, Token); 461 462 Args[i].Name = UtLocalCalloc (strlen (Token) + 1); 463 strcpy (Args[i].Name, Token); 464 465 Args[i].UseCount = 0; 466 467 ArgCount++; 468 if (ArgCount >= PR_MAX_MACRO_ARGS) 469 { 470 PrError (ASL_ERROR, ASL_MSG_TOO_MANY_ARGUMENTS, TokenOffset); 471 goto ErrorExit; 472 } 473 } 474 475 /* Get the macro body. Token now points to start of body */ 476 477 MacroBodyOffset = Token - Gbl_MainTokenBuffer; 478 479 /* Match each method arg in the macro body for later use */ 480 481 Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next); 482 while (Token) 483 { 484 /* Search the macro arg list for matching arg */ 485 486 for (i = 0; ((i < PR_MAX_MACRO_ARGS) && Args[i].Name); i++) 487 { 488 /* 489 * Save argument offset within macro body. This is the mechanism 490 * used to expand the macro upon invocation. 491 * 492 * Handles multiple instances of the same argument 493 */ 494 if (!strcmp (Token, Args[i].Name)) 495 { 496 UseCount = Args[i].UseCount; 497 498 Args[i].Offset[UseCount] = 499 (Token - Gbl_MainTokenBuffer) - MacroBodyOffset; 500 501 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 502 "Macro Arg #%u: %s UseCount %u Offset %u \n", 503 Gbl_CurrentLineNumber, i, Token, 504 UseCount+1, Args[i].Offset[UseCount]); 505 506 Args[i].UseCount++; 507 if (Args[i].UseCount >= PR_MAX_ARG_INSTANCES) 508 { 509 PrError (ASL_ERROR, ASL_MSG_TOO_MANY_ARGUMENTS, 510 THIS_TOKEN_OFFSET (Token)); 511 512 goto ErrorExit; 513 } 514 break; 515 } 516 } 517 518 Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next); 519 } 520 521 BodyInSource = &Gbl_CurrentLineBuffer[MacroBodyOffset]; 522 523 524 AddMacroToList: 525 526 /* Check if name is already defined first */ 527 528 DefineInfo = PrMatchDefine (Name); 529 if (DefineInfo) 530 { 531 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 532 "#define: macro name already exists: %s\n", 533 Gbl_CurrentLineNumber, Name); 534 535 /* Error only if not exactly the same macro */ 536 537 if (strcmp (DefineInfo->Body, BodyInSource) || 538 (DefineInfo->ArgCount != ArgCount)) 539 { 540 PrError (ASL_ERROR, ASL_MSG_EXISTING_NAME, 541 THIS_TOKEN_OFFSET (Name)); 542 } 543 544 goto ErrorExit; 545 } 546 547 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 548 "Macro body: %s \n", 549 Gbl_CurrentLineNumber, BodyInSource); 550 551 /* Add macro to the #define list */ 552 553 DefineInfo = PrAddDefine (Name, BodyInSource, FALSE); 554 if (DefineInfo) 555 { 556 Body = UtLocalCalloc (strlen (BodyInSource) + 1); 557 strcpy (Body, BodyInSource); 558 559 DefineInfo->Body = Body; 560 DefineInfo->Args = Args; 561 DefineInfo->ArgCount = ArgCount; 562 } 563 564 return; 565 566 567 ErrorExit: 568 ACPI_FREE (Args); 569 return; 570 } 571 572 573 /******************************************************************************* 574 * 575 * FUNCTION: PrDoMacroInvocation 576 * 577 * PARAMETERS: TokenBuffer - Current line buffer 578 * MacroStart - Start of the macro invocation within 579 * the token buffer 580 * DefineInfo - Info for this macro 581 * Next - "Next" buffer from GetNextToken 582 * 583 * RETURN: None 584 * 585 * DESCRIPTION: Expand a macro invocation 586 * 587 ******************************************************************************/ 588 589 void 590 PrDoMacroInvocation ( 591 char *TokenBuffer, 592 char *MacroStart, 593 PR_DEFINE_INFO *DefineInfo, 594 char **Next) 595 { 596 PR_MACRO_ARG *Args; 597 char *Token = NULL; 598 UINT32 TokenOffset; 599 UINT32 Length; 600 UINT32 i; 601 602 603 /* Take a copy of the macro body for expansion */ 604 605 strcpy (Gbl_MacroTokenBuffer, DefineInfo->Body); 606 607 /* Replace each argument within the prototype body */ 608 609 Args = DefineInfo->Args; 610 if (!Args->Name) 611 { 612 /* This macro has no arguments */ 613 614 Token = PrGetNextToken (NULL, PR_MACRO_ARGUMENTS, Next); 615 if (!Token) 616 { 617 goto BadInvocation; 618 } 619 620 TokenOffset = (MacroStart - TokenBuffer); 621 Length = Token - MacroStart + strlen (Token) + 1; 622 623 PrReplaceData ( 624 &Gbl_CurrentLineBuffer[TokenOffset], Length, 625 Gbl_MacroTokenBuffer, strlen (Gbl_MacroTokenBuffer)); 626 return; 627 } 628 629 while (Args->Name) 630 { 631 /* Get the next argument from macro invocation */ 632 633 Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next); 634 if (!Token) 635 { 636 goto BadInvocation; 637 } 638 639 /* Replace all instances of this argument */ 640 641 for (i = 0; i < Args->UseCount; i++) 642 { 643 /* Offset zero indicates "arg not used" */ 644 /* TBD: Not really needed now, with UseCount available */ 645 646 if (Args->Offset[i] == 0) 647 { 648 break; 649 } 650 651 PrReplaceData ( 652 &Gbl_MacroTokenBuffer[Args->Offset[i]], strlen (Args->Name), 653 Token, strlen (Token)); 654 655 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 656 "ExpandArg: %s \n", 657 Gbl_CurrentLineNumber, Gbl_MacroTokenBuffer); 658 } 659 660 Args++; 661 } 662 663 /* TBD: need to make sure macro was not invoked with too many arguments */ 664 665 if (!Token) 666 { 667 return; 668 } 669 670 /* Replace the entire macro invocation with the expanded macro */ 671 672 TokenOffset = (MacroStart - TokenBuffer); 673 Length = Token - MacroStart + strlen (Token) + 1; 674 675 PrReplaceData ( 676 &Gbl_CurrentLineBuffer[TokenOffset], Length, 677 Gbl_MacroTokenBuffer, strlen (Gbl_MacroTokenBuffer)); 678 679 return; 680 681 682 BadInvocation: 683 PrError (ASL_ERROR, ASL_MSG_INVALID_INVOCATION, 684 THIS_TOKEN_OFFSET (MacroStart)); 685 686 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 687 "Bad macro invocation: %s \n", 688 Gbl_CurrentLineNumber, Gbl_MacroTokenBuffer); 689 return; 690 } 691