1 /****************************************************************************** 2 * 3 * Module Name: prscan - Preprocessor start-up and file scan module 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2018, 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 #define _DECLARE_PR_GLOBALS 153 154 #include "aslcompiler.h" 155 156 /* 157 * TBDs: 158 * 159 * No nested macros, maybe never 160 * Implement ASL "Include" as well as "#include" here? 161 */ 162 #define _COMPONENT ASL_PREPROCESSOR 163 ACPI_MODULE_NAME ("prscan") 164 165 166 /* Local prototypes */ 167 168 static void 169 PrPreprocessInputFile ( 170 void); 171 172 static void 173 PrDoDirective ( 174 char *DirectiveToken, 175 char **Next); 176 177 static void 178 PrGetNextLineInit ( 179 void); 180 181 static UINT32 182 PrGetNextLine ( 183 FILE *Handle); 184 185 static int 186 PrMatchDirective ( 187 char *Directive); 188 189 static void 190 PrPushDirective ( 191 int Directive, 192 char *Argument); 193 194 static ACPI_STATUS 195 PrPopDirective ( 196 void); 197 198 static void 199 PrDbgPrint ( 200 char *Action, 201 char *DirectiveName); 202 203 static void 204 PrDoIncludeBuffer ( 205 char *Pathname, 206 char *BufferName); 207 208 static void 209 PrDoIncludeFile ( 210 char *Pathname); 211 212 213 /* 214 * Supported preprocessor directives 215 * Each entry is of the form "Name, ArgumentCount" 216 */ 217 static const PR_DIRECTIVE_INFO Gbl_DirectiveInfo[] = 218 { 219 {"define", 1}, 220 {"elif", 0}, /* Converted to #else..#if internally */ 221 {"else", 0}, 222 {"endif", 0}, 223 {"error", 1}, 224 {"if", 1}, 225 {"ifdef", 1}, 226 {"ifndef", 1}, 227 {"include", 0}, /* Argument is not standard format, so just use 0 here */ 228 {"includebuffer", 0}, /* Argument is not standard format, so just use 0 here */ 229 {"line", 1}, 230 {"pragma", 1}, 231 {"undef", 1}, 232 {"warning", 1}, 233 {NULL, 0} 234 }; 235 236 /* This table must match ordering of above table exactly */ 237 238 enum Gbl_DirectiveIndexes 239 { 240 PR_DIRECTIVE_DEFINE = 0, 241 PR_DIRECTIVE_ELIF, 242 PR_DIRECTIVE_ELSE, 243 PR_DIRECTIVE_ENDIF, 244 PR_DIRECTIVE_ERROR, 245 PR_DIRECTIVE_IF, 246 PR_DIRECTIVE_IFDEF, 247 PR_DIRECTIVE_IFNDEF, 248 PR_DIRECTIVE_INCLUDE, 249 PR_DIRECTIVE_INCLUDEBUFFER, 250 PR_DIRECTIVE_LINE, 251 PR_DIRECTIVE_PRAGMA, 252 PR_DIRECTIVE_UNDEF, 253 PR_DIRECTIVE_WARNING 254 }; 255 256 #define ASL_DIRECTIVE_NOT_FOUND -1 257 258 259 /******************************************************************************* 260 * 261 * FUNCTION: PrInitializePreprocessor 262 * 263 * PARAMETERS: None 264 * 265 * RETURN: None 266 * 267 * DESCRIPTION: Startup initialization for the Preprocessor. 268 * 269 ******************************************************************************/ 270 271 void 272 PrInitializePreprocessor ( 273 void) 274 { 275 /* Init globals and the list of #defines */ 276 277 PrInitializeGlobals (); 278 Gbl_DefineList = NULL; 279 } 280 281 282 /******************************************************************************* 283 * 284 * FUNCTION: PrInitializeGlobals 285 * 286 * PARAMETERS: None 287 * 288 * RETURN: None 289 * 290 * DESCRIPTION: Initialize globals for the Preprocessor. Used for startuup 291 * initialization and re-initialization between compiles during 292 * a multiple source file compile. 293 * 294 ******************************************************************************/ 295 296 void 297 PrInitializeGlobals ( 298 void) 299 { 300 /* Init globals */ 301 302 Gbl_InputFileList = NULL; 303 Gbl_CurrentLineNumber = 1; 304 Gbl_PreprocessorLineNumber = 1; 305 Gbl_PreprocessorError = FALSE; 306 307 /* These are used to track #if/#else blocks (possibly nested) */ 308 309 Gbl_IfDepth = 0; 310 Gbl_IgnoringThisCodeBlock = FALSE; 311 Gbl_DirectiveStack = NULL; 312 } 313 314 315 /******************************************************************************* 316 * 317 * FUNCTION: PrTerminatePreprocessor 318 * 319 * PARAMETERS: None 320 * 321 * RETURN: None 322 * 323 * DESCRIPTION: Termination of the preprocessor. Delete lists. Keep any 324 * defines that were specified on the command line, in order to 325 * support multiple compiles with a single compiler invocation. 326 * 327 ******************************************************************************/ 328 329 void 330 PrTerminatePreprocessor ( 331 void) 332 { 333 PR_DEFINE_INFO *DefineInfo; 334 335 336 /* 337 * The persistent defines (created on the command line) are always at the 338 * end of the list. We save them. 339 */ 340 while ((Gbl_DefineList) && (!Gbl_DefineList->Persist)) 341 { 342 DefineInfo = Gbl_DefineList; 343 Gbl_DefineList = DefineInfo->Next; 344 345 ACPI_FREE (DefineInfo->Replacement); 346 ACPI_FREE (DefineInfo->Identifier); 347 ACPI_FREE (DefineInfo); 348 } 349 } 350 351 352 /******************************************************************************* 353 * 354 * FUNCTION: PrDoPreprocess 355 * 356 * PARAMETERS: None 357 * 358 * RETURN: None 359 * 360 * DESCRIPTION: Main entry point for the iASL Preprocessor. Input file must 361 * be already open. Handles multiple input files via the 362 * #include directive. 363 * 364 ******************************************************************************/ 365 366 void 367 PrDoPreprocess ( 368 void) 369 { 370 BOOLEAN MoreInputFiles; 371 372 373 DbgPrint (ASL_DEBUG_OUTPUT, "Starting preprocessing phase\n\n"); 374 375 376 FlSeekFile (ASL_FILE_INPUT, 0); 377 PrDumpPredefinedNames (); 378 379 /* Main preprocessor loop, handles include files */ 380 381 do 382 { 383 PrPreprocessInputFile (); 384 MoreInputFiles = PrPopInputFileStack (); 385 386 } while (MoreInputFiles); 387 388 /* Point compiler input to the new preprocessor output file (.pre) */ 389 390 FlCloseFile (ASL_FILE_INPUT); 391 Gbl_Files[ASL_FILE_INPUT].Handle = Gbl_Files[ASL_FILE_PREPROCESSOR].Handle; 392 AslCompilerin = Gbl_Files[ASL_FILE_INPUT].Handle; 393 394 /* Reset globals to allow compiler to run */ 395 396 FlSeekFile (ASL_FILE_INPUT, 0); 397 if (!Gbl_PreprocessOnly) 398 { 399 Gbl_CurrentLineNumber = 0; 400 } 401 402 DbgPrint (ASL_DEBUG_OUTPUT, "Preprocessing phase complete \n\n"); 403 } 404 405 406 /******************************************************************************* 407 * 408 * FUNCTION: PrPreprocessInputFile 409 * 410 * PARAMETERS: None 411 * 412 * RETURN: None 413 * 414 * DESCRIPTION: Preprocess one entire file, line-by-line. 415 * 416 * Input: Raw user ASL from ASL_FILE_INPUT 417 * Output: Preprocessed file written to ASL_FILE_PREPROCESSOR and 418 * (optionally) ASL_FILE_PREPROCESSOR_USER 419 * 420 ******************************************************************************/ 421 422 static void 423 PrPreprocessInputFile ( 424 void) 425 { 426 UINT32 Status; 427 char *Token; 428 char *ReplaceString; 429 PR_DEFINE_INFO *DefineInfo; 430 ACPI_SIZE TokenOffset; 431 char *Next; 432 int OffsetAdjust; 433 434 435 PrGetNextLineInit (); 436 437 /* Scan source line-by-line and process directives. Then write the .i file */ 438 439 while ((Status = PrGetNextLine (Gbl_Files[ASL_FILE_INPUT].Handle)) != ASL_EOF) 440 { 441 Gbl_CurrentLineNumber++; 442 Gbl_LogicalLineNumber++; 443 444 if (Status == ASL_IGNORE_LINE) 445 { 446 goto WriteEntireLine; 447 } 448 449 /* Need a copy of the input line for strok() */ 450 451 strcpy (Gbl_MainTokenBuffer, Gbl_CurrentLineBuffer); 452 Token = PrGetNextToken (Gbl_MainTokenBuffer, PR_TOKEN_SEPARATORS, &Next); 453 OffsetAdjust = 0; 454 455 /* All preprocessor directives must begin with '#' */ 456 457 if (Token && (*Token == '#')) 458 { 459 if (strlen (Token) == 1) 460 { 461 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next); 462 } 463 else 464 { 465 Token++; /* Skip leading # */ 466 } 467 468 /* Execute the directive, do not write line to output file */ 469 470 PrDoDirective (Token, &Next); 471 continue; 472 } 473 474 /* 475 * If we are currently within the part of an IF/ELSE block that is 476 * FALSE, ignore the line and do not write it to the output file. 477 * This continues until an #else or #endif is encountered. 478 */ 479 if (Gbl_IgnoringThisCodeBlock) 480 { 481 continue; 482 } 483 484 /* Match and replace all #defined names within this source line */ 485 486 while (Token) 487 { 488 DefineInfo = PrMatchDefine (Token); 489 if (DefineInfo) 490 { 491 if (DefineInfo->Body) 492 { 493 /* This is a macro */ 494 495 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 496 "Matched Macro: %s->%s\n", 497 Gbl_CurrentLineNumber, DefineInfo->Identifier, 498 DefineInfo->Replacement); 499 500 PrDoMacroInvocation (Gbl_MainTokenBuffer, Token, 501 DefineInfo, &Next); 502 } 503 else 504 { 505 ReplaceString = DefineInfo->Replacement; 506 507 /* Replace the name in the original line buffer */ 508 509 TokenOffset = Token - Gbl_MainTokenBuffer + OffsetAdjust; 510 PrReplaceData ( 511 &Gbl_CurrentLineBuffer[TokenOffset], strlen (Token), 512 ReplaceString, strlen (ReplaceString)); 513 514 /* Adjust for length difference between old and new name length */ 515 516 OffsetAdjust += strlen (ReplaceString) - strlen (Token); 517 518 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID 519 "Matched #define: %s->%s\n", 520 Gbl_CurrentLineNumber, Token, 521 *ReplaceString ? ReplaceString : "(NULL STRING)"); 522 } 523 } 524 525 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next); 526 } 527 528 Gbl_PreprocessorLineNumber++; 529 530 531 WriteEntireLine: 532 /* 533 * Now we can write the possibly modified source line to the 534 * preprocessor file(s). 535 */ 536 FlWriteFile (ASL_FILE_PREPROCESSOR, Gbl_CurrentLineBuffer, 537 strlen (Gbl_CurrentLineBuffer)); 538 } 539 } 540 541 542 /******************************************************************************* 543 * 544 * FUNCTION: PrDoDirective 545 * 546 * PARAMETERS: Directive - Pointer to directive name token 547 * Next - "Next" buffer from GetNextToken 548 * 549 * RETURN: None. 550 * 551 * DESCRIPTION: Main processing for all preprocessor directives 552 * 553 ******************************************************************************/ 554 555 static void 556 PrDoDirective ( 557 char *DirectiveToken, 558 char **Next) 559 { 560 char *Token = Gbl_MainTokenBuffer; 561 char *Token2 = NULL; 562 char *End; 563 UINT64 Value; 564 ACPI_SIZE TokenOffset; 565 int Directive; 566 ACPI_STATUS Status; 567 568 569 if (!DirectiveToken) 570 { 571 goto SyntaxError; 572 } 573 574 Directive = PrMatchDirective (DirectiveToken); 575 if (Directive == ASL_DIRECTIVE_NOT_FOUND) 576 { 577 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE, 578 THIS_TOKEN_OFFSET (DirectiveToken)); 579 580 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 581 "#%s: Unknown directive\n", 582 Gbl_CurrentLineNumber, DirectiveToken); 583 return; 584 } 585 586 /* 587 * Emit a line directive into the preprocessor file (.pre) after 588 * every matched directive. This is passed through to the compiler 589 * so that error/warning messages are kept in sync with the 590 * original source file. 591 */ 592 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\" // #%s\n", 593 Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename, 594 Gbl_DirectiveInfo[Directive].Name); 595 596 /* 597 * If we are currently ignoring this block and we encounter a #else or 598 * #elif, we must ignore their blocks also if the parent block is also 599 * being ignored. 600 */ 601 if (Gbl_IgnoringThisCodeBlock) 602 { 603 switch (Directive) 604 { 605 case PR_DIRECTIVE_ELSE: 606 case PR_DIRECTIVE_ELIF: 607 608 if (Gbl_DirectiveStack && 609 Gbl_DirectiveStack->IgnoringThisCodeBlock) 610 { 611 PrDbgPrint ("Ignoring", Gbl_DirectiveInfo[Directive].Name); 612 return; 613 } 614 break; 615 616 default: 617 break; 618 } 619 } 620 621 /* 622 * Need to always check for #else, #elif, #endif regardless of 623 * whether we are ignoring the current code block, since these 624 * are conditional code block terminators. 625 */ 626 switch (Directive) 627 { 628 case PR_DIRECTIVE_ELSE: 629 630 Gbl_IgnoringThisCodeBlock = !(Gbl_IgnoringThisCodeBlock); 631 PrDbgPrint ("Executing", "else block"); 632 return; 633 634 case PR_DIRECTIVE_ELIF: 635 636 Gbl_IgnoringThisCodeBlock = !(Gbl_IgnoringThisCodeBlock); 637 Directive = PR_DIRECTIVE_IF; 638 639 if (Gbl_IgnoringThisCodeBlock == TRUE) 640 { 641 /* Not executing the ELSE part -- all done here */ 642 PrDbgPrint ("Ignoring", "elif block"); 643 return; 644 } 645 646 /* 647 * After this, we will execute the IF part further below. 648 * First, however, pop off the original #if directive. 649 */ 650 if (ACPI_FAILURE (PrPopDirective ())) 651 { 652 PrError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, 653 THIS_TOKEN_OFFSET (DirectiveToken)); 654 } 655 656 PrDbgPrint ("Executing", "elif block"); 657 break; 658 659 case PR_DIRECTIVE_ENDIF: 660 661 PrDbgPrint ("Executing", "endif"); 662 663 /* Pop the owning #if/#ifdef/#ifndef */ 664 665 if (ACPI_FAILURE (PrPopDirective ())) 666 { 667 PrError (ASL_ERROR, ASL_MSG_ENDIF_MISMATCH, 668 THIS_TOKEN_OFFSET (DirectiveToken)); 669 } 670 return; 671 672 default: 673 break; 674 } 675 676 /* Most directives have at least one argument */ 677 678 if (Gbl_DirectiveInfo[Directive].ArgCount >= 1) 679 { 680 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); 681 if (!Token) 682 { 683 goto SyntaxError; 684 } 685 } 686 687 if (Gbl_DirectiveInfo[Directive].ArgCount >= 2) 688 { 689 Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); 690 if (!Token2) 691 { 692 goto SyntaxError; 693 } 694 } 695 696 /* 697 * At this point, if we are ignoring the current code block, 698 * do not process any more directives (i.e., ignore them also.) 699 * For "if" style directives, open/push a new block anyway. We 700 * must do this to keep track of #endif directives 701 */ 702 if (Gbl_IgnoringThisCodeBlock) 703 { 704 switch (Directive) 705 { 706 case PR_DIRECTIVE_IF: 707 case PR_DIRECTIVE_IFDEF: 708 case PR_DIRECTIVE_IFNDEF: 709 710 PrPushDirective (Directive, Token); 711 PrDbgPrint ("Ignoring", Gbl_DirectiveInfo[Directive].Name); 712 break; 713 714 default: 715 break; 716 } 717 718 return; 719 } 720 721 /* 722 * Execute the directive 723 */ 724 PrDbgPrint ("Begin execution", Gbl_DirectiveInfo[Directive].Name); 725 726 switch (Directive) 727 { 728 case PR_DIRECTIVE_IF: 729 730 TokenOffset = Token - Gbl_MainTokenBuffer; 731 732 /* Need to expand #define macros in the expression string first */ 733 734 Status = PrResolveIntegerExpression ( 735 &Gbl_CurrentLineBuffer[TokenOffset-1], &Value); 736 if (ACPI_FAILURE (Status)) 737 { 738 return; 739 } 740 741 PrPushDirective (Directive, Token); 742 if (!Value) 743 { 744 Gbl_IgnoringThisCodeBlock = TRUE; 745 } 746 747 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 748 "Resolved #if: %8.8X%8.8X %s\n", 749 Gbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value), 750 Gbl_IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>"); 751 break; 752 753 case PR_DIRECTIVE_IFDEF: 754 755 PrPushDirective (Directive, Token); 756 if (!PrMatchDefine (Token)) 757 { 758 Gbl_IgnoringThisCodeBlock = TRUE; 759 } 760 761 PrDbgPrint ("Evaluated", "ifdef"); 762 break; 763 764 case PR_DIRECTIVE_IFNDEF: 765 766 PrPushDirective (Directive, Token); 767 if (PrMatchDefine (Token)) 768 { 769 Gbl_IgnoringThisCodeBlock = TRUE; 770 } 771 772 PrDbgPrint ("Evaluated", "ifndef"); 773 break; 774 775 case PR_DIRECTIVE_DEFINE: 776 /* 777 * By definition, if first char after the name is a paren, 778 * this is a function macro. 779 */ 780 TokenOffset = Token - Gbl_MainTokenBuffer + strlen (Token); 781 if (*(&Gbl_CurrentLineBuffer[TokenOffset]) == '(') 782 { 783 #ifndef MACROS_SUPPORTED 784 AcpiOsPrintf ( 785 "%s ERROR - line %u: #define macros are not supported yet\n", 786 Gbl_CurrentLineBuffer, Gbl_LogicalLineNumber); 787 exit(1); 788 #else 789 PrAddMacro (Token, Next); 790 #endif 791 } 792 else 793 { 794 /* Use the remainder of the line for the #define */ 795 796 Token2 = *Next; 797 if (Token2) 798 { 799 while ((*Token2 == ' ') || (*Token2 == '\t')) 800 { 801 Token2++; 802 } 803 804 End = Token2; 805 while (*End != '\n') 806 { 807 End++; 808 } 809 810 *End = 0; 811 } 812 else 813 { 814 Token2 = ""; 815 } 816 #if 0 817 Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next); 818 if (!Token2) 819 { 820 Token2 = ""; 821 } 822 #endif 823 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 824 "New #define: %s->%s\n", 825 Gbl_LogicalLineNumber, Token, Token2); 826 827 PrAddDefine (Token, Token2, FALSE); 828 } 829 break; 830 831 case PR_DIRECTIVE_ERROR: 832 833 /* Note: No macro expansion */ 834 835 PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE, 836 THIS_TOKEN_OFFSET (Token)); 837 838 Gbl_SourceLine = 0; 839 Gbl_NextError = Gbl_ErrorLog; 840 CmCleanupAndExit (); 841 exit(1); 842 843 case PR_DIRECTIVE_INCLUDE: 844 845 Token = PrGetNextToken (NULL, " \"<>", Next); 846 if (!Token) 847 { 848 goto SyntaxError; 849 } 850 851 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 852 "Start #include file \"%s\"\n", Gbl_CurrentLineNumber, 853 Token, Gbl_CurrentLineNumber); 854 855 PrDoIncludeFile (Token); 856 break; 857 858 case PR_DIRECTIVE_INCLUDEBUFFER: 859 860 Token = PrGetNextToken (NULL, " \"<>", Next); 861 if (!Token) 862 { 863 goto SyntaxError; 864 } 865 866 Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); 867 if (!Token2) 868 { 869 goto SyntaxError; 870 } 871 872 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 873 "Start #includebuffer input from file \"%s\", buffer name %s\n", 874 Gbl_CurrentLineNumber, Token, Token2); 875 876 PrDoIncludeBuffer (Token, Token2); 877 break; 878 879 case PR_DIRECTIVE_LINE: 880 881 TokenOffset = Token - Gbl_MainTokenBuffer; 882 883 Status = PrResolveIntegerExpression ( 884 &Gbl_CurrentLineBuffer[TokenOffset-1], &Value); 885 if (ACPI_FAILURE (Status)) 886 { 887 return; 888 } 889 890 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 891 "User #line invocation %s\n", Gbl_CurrentLineNumber, 892 Token); 893 894 Gbl_CurrentLineNumber = (UINT32) Value; 895 896 /* Emit #line into the preprocessor file */ 897 898 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n", 899 Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename); 900 break; 901 902 case PR_DIRECTIVE_PRAGMA: 903 904 if (!strcmp (Token, "disable")) 905 { 906 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); 907 if (!Token) 908 { 909 goto SyntaxError; 910 } 911 912 TokenOffset = Token - Gbl_MainTokenBuffer; 913 AslDisableException (&Gbl_CurrentLineBuffer[TokenOffset]); 914 } 915 else if (!strcmp (Token, "message")) 916 { 917 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next); 918 if (!Token) 919 { 920 goto SyntaxError; 921 } 922 923 TokenOffset = Token - Gbl_MainTokenBuffer; 924 AcpiOsPrintf ("%s\n", &Gbl_CurrentLineBuffer[TokenOffset]); 925 } 926 else 927 { 928 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA, 929 THIS_TOKEN_OFFSET (Token)); 930 return; 931 } 932 933 break; 934 935 case PR_DIRECTIVE_UNDEF: 936 937 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 938 "#undef: %s\n", Gbl_CurrentLineNumber, Token); 939 940 PrRemoveDefine (Token); 941 break; 942 943 case PR_DIRECTIVE_WARNING: 944 945 PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE, 946 THIS_TOKEN_OFFSET (Token)); 947 948 Gbl_SourceLine = 0; 949 Gbl_NextError = Gbl_ErrorLog; 950 break; 951 952 default: 953 954 /* Should never get here */ 955 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 956 "Unrecognized directive: %u\n", 957 Gbl_CurrentLineNumber, Directive); 958 break; 959 } 960 961 return; 962 963 SyntaxError: 964 965 PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX, 966 THIS_TOKEN_OFFSET (DirectiveToken)); 967 return; 968 } 969 970 971 /******************************************************************************* 972 * 973 * FUNCTION: PrGetNextLine, PrGetNextLineInit 974 * 975 * PARAMETERS: Handle - Open file handle for the source file 976 * 977 * RETURN: Status of the GetLine operation: 978 * AE_OK - Normal line, OK status 979 * ASL_IGNORE_LINE - Line is blank or part of a multi-line 980 * comment 981 * ASL_EOF - End-of-file reached 982 * 983 * DESCRIPTION: Get the next text line from the input file. Does not strip 984 * comments. 985 * 986 ******************************************************************************/ 987 988 #define PR_NORMAL_TEXT 0 989 #define PR_MULTI_LINE_COMMENT 1 990 #define PR_SINGLE_LINE_COMMENT 2 991 #define PR_QUOTED_STRING 3 992 993 static UINT8 AcpiGbl_LineScanState = PR_NORMAL_TEXT; 994 995 static void 996 PrGetNextLineInit ( 997 void) 998 { 999 AcpiGbl_LineScanState = 0; 1000 } 1001 1002 static UINT32 1003 PrGetNextLine ( 1004 FILE *Handle) 1005 { 1006 UINT32 i; 1007 int c = 0; 1008 int PreviousChar; 1009 1010 1011 /* Always clear the global line buffer */ 1012 1013 memset (Gbl_CurrentLineBuffer, 0, Gbl_LineBufferSize); 1014 for (i = 0; ;) 1015 { 1016 /* 1017 * If line is too long, expand the line buffers. Also increases 1018 * Gbl_LineBufferSize. 1019 */ 1020 if (i >= Gbl_LineBufferSize) 1021 { 1022 UtExpandLineBuffers (); 1023 } 1024 1025 PreviousChar = c; 1026 c = getc (Handle); 1027 if (c == EOF) 1028 { 1029 /* 1030 * On EOF: If there is anything in the line buffer, terminate 1031 * it with a newline, and catch the EOF on the next call 1032 * to this function. 1033 */ 1034 if (i > 0) 1035 { 1036 Gbl_CurrentLineBuffer[i] = '\n'; 1037 return (AE_OK); 1038 } 1039 1040 return (ASL_EOF); 1041 } 1042 1043 /* Update state machine as necessary */ 1044 1045 switch (AcpiGbl_LineScanState) 1046 { 1047 case PR_NORMAL_TEXT: 1048 1049 /* Check for multi-line comment start */ 1050 1051 if ((PreviousChar == '/') && (c == '*')) 1052 { 1053 AcpiGbl_LineScanState = PR_MULTI_LINE_COMMENT; 1054 } 1055 1056 /* Check for single-line comment start */ 1057 1058 else if ((PreviousChar == '/') && (c == '/')) 1059 { 1060 AcpiGbl_LineScanState = PR_SINGLE_LINE_COMMENT; 1061 } 1062 1063 /* Check for quoted string start */ 1064 1065 else if (PreviousChar == '"') 1066 { 1067 AcpiGbl_LineScanState = PR_QUOTED_STRING; 1068 } 1069 break; 1070 1071 case PR_QUOTED_STRING: 1072 1073 if (PreviousChar == '"') 1074 { 1075 AcpiGbl_LineScanState = PR_NORMAL_TEXT; 1076 } 1077 break; 1078 1079 case PR_MULTI_LINE_COMMENT: 1080 1081 /* Check for multi-line comment end */ 1082 1083 if ((PreviousChar == '*') && (c == '/')) 1084 { 1085 AcpiGbl_LineScanState = PR_NORMAL_TEXT; 1086 } 1087 break; 1088 1089 case PR_SINGLE_LINE_COMMENT: /* Just ignore text until EOL */ 1090 default: 1091 break; 1092 } 1093 1094 /* Always copy the character into line buffer */ 1095 1096 Gbl_CurrentLineBuffer[i] = (char) c; 1097 i++; 1098 1099 /* Always exit on end-of-line */ 1100 1101 if (c == '\n') 1102 { 1103 /* Handle multi-line comments */ 1104 1105 if (AcpiGbl_LineScanState == PR_MULTI_LINE_COMMENT) 1106 { 1107 return (ASL_IGNORE_LINE); 1108 } 1109 1110 /* End of single-line comment */ 1111 1112 if (AcpiGbl_LineScanState == PR_SINGLE_LINE_COMMENT) 1113 { 1114 AcpiGbl_LineScanState = PR_NORMAL_TEXT; 1115 return (AE_OK); 1116 } 1117 1118 /* Blank line */ 1119 1120 if (i == 1) 1121 { 1122 return (ASL_IGNORE_LINE); 1123 } 1124 1125 return (AE_OK); 1126 } 1127 } 1128 } 1129 1130 1131 /******************************************************************************* 1132 * 1133 * FUNCTION: PrMatchDirective 1134 * 1135 * PARAMETERS: Directive - Pointer to directive name token 1136 * 1137 * RETURN: Index into command array, -1 if not found 1138 * 1139 * DESCRIPTION: Lookup the incoming directive in the known directives table. 1140 * 1141 ******************************************************************************/ 1142 1143 static int 1144 PrMatchDirective ( 1145 char *Directive) 1146 { 1147 int i; 1148 1149 1150 if (!Directive || Directive[0] == 0) 1151 { 1152 return (ASL_DIRECTIVE_NOT_FOUND); 1153 } 1154 1155 for (i = 0; Gbl_DirectiveInfo[i].Name; i++) 1156 { 1157 if (!strcmp (Gbl_DirectiveInfo[i].Name, Directive)) 1158 { 1159 return (i); 1160 } 1161 } 1162 1163 return (ASL_DIRECTIVE_NOT_FOUND); /* Command not recognized */ 1164 } 1165 1166 1167 /******************************************************************************* 1168 * 1169 * FUNCTION: PrPushDirective 1170 * 1171 * PARAMETERS: Directive - Encoded directive ID 1172 * Argument - String containing argument to the 1173 * directive 1174 * 1175 * RETURN: None 1176 * 1177 * DESCRIPTION: Push an item onto the directive stack. Used for processing 1178 * nested #if/#else type conditional compilation directives. 1179 * Specifically: Used on detection of #if/#ifdef/#ifndef to open 1180 * a block. 1181 * 1182 ******************************************************************************/ 1183 1184 static void 1185 PrPushDirective ( 1186 int Directive, 1187 char *Argument) 1188 { 1189 DIRECTIVE_INFO *Info; 1190 1191 1192 /* Allocate and populate a stack info item */ 1193 1194 Info = ACPI_ALLOCATE (sizeof (DIRECTIVE_INFO)); 1195 1196 Info->Next = Gbl_DirectiveStack; 1197 Info->Directive = Directive; 1198 Info->IgnoringThisCodeBlock = Gbl_IgnoringThisCodeBlock; 1199 AcpiUtSafeStrncpy (Info->Argument, Argument, MAX_ARGUMENT_LENGTH); 1200 1201 DbgPrint (ASL_DEBUG_OUTPUT, 1202 "Pr(%.4u) - [%u %s] %*s Pushed [#%s %s]: IgnoreFlag = %s\n", 1203 Gbl_CurrentLineNumber, Gbl_IfDepth, 1204 Gbl_IgnoringThisCodeBlock ? "I" : "E", 1205 Gbl_IfDepth * 4, " ", 1206 Gbl_DirectiveInfo[Directive].Name, 1207 Argument, Gbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE"); 1208 1209 /* Push new item */ 1210 1211 Gbl_DirectiveStack = Info; 1212 Gbl_IfDepth++; 1213 } 1214 1215 1216 /******************************************************************************* 1217 * 1218 * FUNCTION: PrPopDirective 1219 * 1220 * PARAMETERS: None 1221 * 1222 * RETURN: Status. Error if the stack is empty. 1223 * 1224 * DESCRIPTION: Pop an item off the directive stack. Used for processing 1225 * nested #if/#else type conditional compilation directives. 1226 * Specifically: Used on detection of #elif and #endif to remove 1227 * the original #if/#ifdef/#ifndef from the stack and close 1228 * the block. 1229 * 1230 ******************************************************************************/ 1231 1232 static ACPI_STATUS 1233 PrPopDirective ( 1234 void) 1235 { 1236 DIRECTIVE_INFO *Info; 1237 1238 1239 /* Check for empty stack */ 1240 1241 Info = Gbl_DirectiveStack; 1242 if (!Info) 1243 { 1244 return (AE_ERROR); 1245 } 1246 1247 /* Pop one item, keep globals up-to-date */ 1248 1249 Gbl_IfDepth--; 1250 Gbl_IgnoringThisCodeBlock = Info->IgnoringThisCodeBlock; 1251 Gbl_DirectiveStack = Info->Next; 1252 1253 DbgPrint (ASL_DEBUG_OUTPUT, 1254 "Pr(%.4u) - [%u %s] %*s Popped [#%s %s]: IgnoreFlag now = %s\n", 1255 Gbl_CurrentLineNumber, Gbl_IfDepth, 1256 Gbl_IgnoringThisCodeBlock ? "I" : "E", 1257 Gbl_IfDepth * 4, " ", 1258 Gbl_DirectiveInfo[Info->Directive].Name, 1259 Info->Argument, Gbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE"); 1260 1261 ACPI_FREE (Info); 1262 return (AE_OK); 1263 } 1264 1265 1266 /******************************************************************************* 1267 * 1268 * FUNCTION: PrDbgPrint 1269 * 1270 * PARAMETERS: Action - Action being performed 1271 * DirectiveName - Directive being processed 1272 * 1273 * RETURN: None 1274 * 1275 * DESCRIPTION: Special debug print for directive processing. 1276 * 1277 ******************************************************************************/ 1278 1279 static void 1280 PrDbgPrint ( 1281 char *Action, 1282 char *DirectiveName) 1283 { 1284 1285 DbgPrint (ASL_DEBUG_OUTPUT, "Pr(%.4u) - [%u %s] " 1286 "%*s %s #%s, IfDepth %u\n", 1287 Gbl_CurrentLineNumber, Gbl_IfDepth, 1288 Gbl_IgnoringThisCodeBlock ? "I" : "E", 1289 Gbl_IfDepth * 4, " ", 1290 Action, DirectiveName, Gbl_IfDepth); 1291 } 1292 1293 1294 /******************************************************************************* 1295 * 1296 * FUNCTION: PrDoIncludeFile 1297 * 1298 * PARAMETERS: Pathname - Name of the input file 1299 * 1300 * RETURN: None. 1301 * 1302 * DESCRIPTION: Open an include file, from #include. 1303 * 1304 ******************************************************************************/ 1305 1306 static void 1307 PrDoIncludeFile ( 1308 char *Pathname) 1309 { 1310 char *FullPathname; 1311 1312 1313 (void) PrOpenIncludeFile (Pathname, "r", &FullPathname); 1314 } 1315 1316 1317 /******************************************************************************* 1318 * 1319 * FUNCTION: PrDoIncludeBuffer 1320 * 1321 * PARAMETERS: Pathname - Name of the input binary file 1322 * BufferName - ACPI namepath of the buffer 1323 * 1324 * RETURN: None. 1325 * 1326 * DESCRIPTION: Create an ACPI buffer object from a binary file. The contents 1327 * of the file are emitted into the buffer object as ascii 1328 * hex data. From #includebuffer. 1329 * 1330 ******************************************************************************/ 1331 1332 static void 1333 PrDoIncludeBuffer ( 1334 char *Pathname, 1335 char *BufferName) 1336 { 1337 char *FullPathname; 1338 FILE *BinaryBufferFile; 1339 UINT32 i = 0; 1340 UINT8 c; 1341 1342 1343 BinaryBufferFile = PrOpenIncludeFile (Pathname, "rb", &FullPathname); 1344 if (!BinaryBufferFile) 1345 { 1346 return; 1347 } 1348 1349 /* Emit "Name (XXXX, Buffer() {" header */ 1350 1351 FlPrintFile (ASL_FILE_PREPROCESSOR, "Name (%s, Buffer()\n{", BufferName); 1352 1353 /* Dump the entire file in ascii hex format */ 1354 1355 while (fread (&c, 1, 1, BinaryBufferFile)) 1356 { 1357 if (!(i % 8)) 1358 { 1359 FlPrintFile (ASL_FILE_PREPROCESSOR, "\n ", c); 1360 } 1361 1362 FlPrintFile (ASL_FILE_PREPROCESSOR, " 0x%2.2X,", c); 1363 i++; 1364 } 1365 1366 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID 1367 "#includebuffer: read %u bytes from %s\n", 1368 Gbl_CurrentLineNumber, i, FullPathname); 1369 1370 /* Close the Name() operator */ 1371 1372 FlPrintFile (ASL_FILE_PREPROCESSOR, "\n})\n", BufferName); 1373 fclose (BinaryBufferFile); 1374 } 1375