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