1 /******************************************************************************
3 * Module Name: prscan - Preprocessor start-up and file scan module
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2016, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #define _DECLARE_PR_GLOBALS
46 #include <contrib/dev/acpica/compiler/aslcompiler.h>
47 #include <contrib/dev/acpica/compiler/dtcompiler.h>
52 * No nested macros, maybe never
53 * Implement ASL "Include" as well as "#include" here?
55 #define _COMPONENT ASL_PREPROCESSOR
56 ACPI_MODULE_NAME ("prscan")
59 /* Local prototypes */
62 PrPreprocessInputFile (
107 * Supported preprocessor directives
108 * Each entry is of the form "Name, ArgumentCount"
110 static const PR_DIRECTIVE_INFO Gbl_DirectiveInfo[] =
113 {"elif", 0}, /* Converted to #else..#if internally */
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 */
129 /* This table must match ordering of above table exactly */
131 enum Gbl_DirectiveIndexes
133 PR_DIRECTIVE_DEFINE = 0,
141 PR_DIRECTIVE_INCLUDE,
142 PR_DIRECTIVE_INCLUDEBUFFER,
149 #define ASL_DIRECTIVE_NOT_FOUND -1
152 /*******************************************************************************
154 * FUNCTION: PrInitializePreprocessor
160 * DESCRIPTION: Startup initialization for the Preprocessor.
162 ******************************************************************************/
165 PrInitializePreprocessor (
168 /* Init globals and the list of #defines */
170 PrInitializeGlobals ();
171 Gbl_DefineList = NULL;
175 /*******************************************************************************
177 * FUNCTION: PrInitializeGlobals
183 * DESCRIPTION: Initialize globals for the Preprocessor. Used for startuup
184 * initialization and re-initialization between compiles during
185 * a multiple source file compile.
187 ******************************************************************************/
190 PrInitializeGlobals (
195 Gbl_InputFileList = NULL;
196 Gbl_CurrentLineNumber = 1;
197 Gbl_PreprocessorLineNumber = 1;
198 Gbl_PreprocessorError = FALSE;
200 /* These are used to track #if/#else blocks (possibly nested) */
203 Gbl_IgnoringThisCodeBlock = FALSE;
204 Gbl_DirectiveStack = NULL;
208 /*******************************************************************************
210 * FUNCTION: PrTerminatePreprocessor
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.
220 ******************************************************************************/
223 PrTerminatePreprocessor (
226 PR_DEFINE_INFO *DefineInfo;
230 * The persistent defines (created on the command line) are always at the
231 * end of the list. We save them.
233 while ((Gbl_DefineList) && (!Gbl_DefineList->Persist))
235 DefineInfo = Gbl_DefineList;
236 Gbl_DefineList = DefineInfo->Next;
238 ACPI_FREE (DefineInfo->Replacement);
239 ACPI_FREE (DefineInfo->Identifier);
240 ACPI_FREE (DefineInfo);
245 /*******************************************************************************
247 * FUNCTION: PrDoPreprocess
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.
257 ******************************************************************************/
263 BOOLEAN MoreInputFiles;
266 DbgPrint (ASL_DEBUG_OUTPUT, "Starting preprocessing phase\n\n");
269 FlSeekFile (ASL_FILE_INPUT, 0);
270 PrDumpPredefinedNames ();
272 /* Main preprocessor loop, handles include files */
276 PrPreprocessInputFile ();
277 MoreInputFiles = PrPopInputFileStack ();
279 } while (MoreInputFiles);
281 /* Point compiler input to the new preprocessor output file (.pre) */
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;
287 /* Reset globals to allow compiler to run */
289 FlSeekFile (ASL_FILE_INPUT, 0);
290 if (!Gbl_PreprocessOnly)
292 Gbl_CurrentLineNumber = 0;
295 DbgPrint (ASL_DEBUG_OUTPUT, "Preprocessing phase complete \n\n");
299 /*******************************************************************************
301 * FUNCTION: PrPreprocessInputFile
307 * DESCRIPTION: Preprocess one entire file, line-by-line.
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
313 ******************************************************************************/
316 PrPreprocessInputFile (
322 PR_DEFINE_INFO *DefineInfo;
323 ACPI_SIZE TokenOffset;
328 PrGetNextLineInit ();
330 /* Scan source line-by-line and process directives. Then write the .i file */
332 while ((Status = PrGetNextLine (Gbl_Files[ASL_FILE_INPUT].Handle)) != ASL_EOF)
334 Gbl_CurrentLineNumber++;
335 Gbl_LogicalLineNumber++;
337 if (Status == ASL_IGNORE_LINE)
339 goto WriteEntireLine;
342 /* Need a copy of the input line for strok() */
344 strcpy (Gbl_MainTokenBuffer, Gbl_CurrentLineBuffer);
345 Token = PrGetNextToken (Gbl_MainTokenBuffer, PR_TOKEN_SEPARATORS, &Next);
348 /* All preprocessor directives must begin with '#' */
350 if (Token && (*Token == '#'))
352 if (strlen (Token) == 1)
354 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
358 Token++; /* Skip leading # */
361 /* Execute the directive, do not write line to output file */
363 PrDoDirective (Token, &Next);
368 * If we are currently within the part of an IF/ELSE block that is
369 * FALSE, ignore the line and do not write it to the output file.
370 * This continues until an #else or #endif is encountered.
372 if (Gbl_IgnoringThisCodeBlock)
377 /* Match and replace all #defined names within this source line */
381 DefineInfo = PrMatchDefine (Token);
384 if (DefineInfo->Body)
386 /* This is a macro */
388 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
389 "Matched Macro: %s->%s\n",
390 Gbl_CurrentLineNumber, DefineInfo->Identifier,
391 DefineInfo->Replacement);
393 PrDoMacroInvocation (Gbl_MainTokenBuffer, Token,
398 ReplaceString = DefineInfo->Replacement;
400 /* Replace the name in the original line buffer */
402 TokenOffset = Token - Gbl_MainTokenBuffer + OffsetAdjust;
404 &Gbl_CurrentLineBuffer[TokenOffset], strlen (Token),
405 ReplaceString, strlen (ReplaceString));
407 /* Adjust for length difference between old and new name length */
409 OffsetAdjust += strlen (ReplaceString) - strlen (Token);
411 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
412 "Matched #define: %s->%s\n",
413 Gbl_CurrentLineNumber, Token,
414 *ReplaceString ? ReplaceString : "(NULL STRING)");
418 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
421 Gbl_PreprocessorLineNumber++;
426 * Now we can write the possibly modified source line to the
427 * preprocessor file(s).
429 FlWriteFile (ASL_FILE_PREPROCESSOR, Gbl_CurrentLineBuffer,
430 strlen (Gbl_CurrentLineBuffer));
435 /*******************************************************************************
437 * FUNCTION: PrDoDirective
439 * PARAMETERS: Directive - Pointer to directive name token
440 * Next - "Next" buffer from GetNextToken
444 * DESCRIPTION: Main processing for all preprocessor directives
446 ******************************************************************************/
450 char *DirectiveToken,
453 char *Token = Gbl_MainTokenBuffer;
457 ACPI_SIZE TokenOffset;
467 Directive = PrMatchDirective (DirectiveToken);
468 if (Directive == ASL_DIRECTIVE_NOT_FOUND)
470 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE,
471 THIS_TOKEN_OFFSET (DirectiveToken));
473 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
474 "#%s: Unknown directive\n",
475 Gbl_CurrentLineNumber, DirectiveToken);
480 * Emit a line directive into the preprocessor file (.pre) after
481 * every matched directive. This is passed through to the compiler
482 * so that error/warning messages are kept in sync with the
483 * original source file.
485 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\" // #%s\n",
486 Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename,
487 Gbl_DirectiveInfo[Directive].Name);
490 * If we are currently ignoring this block and we encounter a #else or
491 * #elif, we must ignore their blocks also if the parent block is also
494 if (Gbl_IgnoringThisCodeBlock)
498 case PR_DIRECTIVE_ELSE:
499 case PR_DIRECTIVE_ELIF:
501 if (Gbl_DirectiveStack &&
502 Gbl_DirectiveStack->IgnoringThisCodeBlock)
504 PrDbgPrint ("Ignoring", Gbl_DirectiveInfo[Directive].Name);
515 * Need to always check for #else, #elif, #endif regardless of
516 * whether we are ignoring the current code block, since these
517 * are conditional code block terminators.
521 case PR_DIRECTIVE_ELSE:
523 Gbl_IgnoringThisCodeBlock = !(Gbl_IgnoringThisCodeBlock);
524 PrDbgPrint ("Executing", "else block");
527 case PR_DIRECTIVE_ELIF:
529 Gbl_IgnoringThisCodeBlock = !(Gbl_IgnoringThisCodeBlock);
530 Directive = PR_DIRECTIVE_IF;
532 if (Gbl_IgnoringThisCodeBlock == TRUE)
534 /* Not executing the ELSE part -- all done here */
535 PrDbgPrint ("Ignoring", "elif block");
540 * After this, we will execute the IF part further below.
541 * First, however, pop off the original #if directive.
543 if (ACPI_FAILURE (PrPopDirective ()))
545 PrError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
546 THIS_TOKEN_OFFSET (DirectiveToken));
549 PrDbgPrint ("Executing", "elif block");
552 case PR_DIRECTIVE_ENDIF:
554 PrDbgPrint ("Executing", "endif");
556 /* Pop the owning #if/#ifdef/#ifndef */
558 if (ACPI_FAILURE (PrPopDirective ()))
560 PrError (ASL_ERROR, ASL_MSG_ENDIF_MISMATCH,
561 THIS_TOKEN_OFFSET (DirectiveToken));
569 /* Most directives have at least one argument */
571 if (Gbl_DirectiveInfo[Directive].ArgCount >= 1)
573 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
580 if (Gbl_DirectiveInfo[Directive].ArgCount >= 2)
582 Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
590 * At this point, if we are ignoring the current code block,
591 * do not process any more directives (i.e., ignore them also.)
592 * For "if" style directives, open/push a new block anyway. We
593 * must do this to keep track of #endif directives
595 if (Gbl_IgnoringThisCodeBlock)
599 case PR_DIRECTIVE_IF:
600 case PR_DIRECTIVE_IFDEF:
601 case PR_DIRECTIVE_IFNDEF:
603 PrPushDirective (Directive, Token);
604 PrDbgPrint ("Ignoring", Gbl_DirectiveInfo[Directive].Name);
615 * Execute the directive
617 PrDbgPrint ("Begin execution", Gbl_DirectiveInfo[Directive].Name);
621 case PR_DIRECTIVE_IF:
623 TokenOffset = Token - Gbl_MainTokenBuffer;
625 /* Need to expand #define macros in the expression string first */
627 Status = PrResolveIntegerExpression (
628 &Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
629 if (ACPI_FAILURE (Status))
634 PrPushDirective (Directive, Token);
637 Gbl_IgnoringThisCodeBlock = TRUE;
640 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
641 "Resolved #if: %8.8X%8.8X %s\n",
642 Gbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value),
643 Gbl_IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>");
646 case PR_DIRECTIVE_IFDEF:
648 PrPushDirective (Directive, Token);
649 if (!PrMatchDefine (Token))
651 Gbl_IgnoringThisCodeBlock = TRUE;
654 PrDbgPrint ("Evaluated", "ifdef");
657 case PR_DIRECTIVE_IFNDEF:
659 PrPushDirective (Directive, Token);
660 if (PrMatchDefine (Token))
662 Gbl_IgnoringThisCodeBlock = TRUE;
665 PrDbgPrint ("Evaluated", "ifndef");
668 case PR_DIRECTIVE_DEFINE:
670 * By definition, if first char after the name is a paren,
671 * this is a function macro.
673 TokenOffset = Token - Gbl_MainTokenBuffer + strlen (Token);
674 if (*(&Gbl_CurrentLineBuffer[TokenOffset]) == '(')
676 #ifndef MACROS_SUPPORTED
678 "%s ERROR - line %u: #define macros are not supported yet\n",
679 Gbl_CurrentLineBuffer, Gbl_LogicalLineNumber);
682 PrAddMacro (Token, Next);
687 /* Use the remainder of the line for the #define */
692 while ((*Token2 == ' ') || (*Token2 == '\t'))
710 Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next);
716 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
717 "New #define: %s->%s\n",
718 Gbl_LogicalLineNumber, Token, Token2);
720 PrAddDefine (Token, Token2, FALSE);
724 case PR_DIRECTIVE_ERROR:
726 /* Note: No macro expansion */
728 PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE,
729 THIS_TOKEN_OFFSET (Token));
732 Gbl_NextError = Gbl_ErrorLog;
736 case PR_DIRECTIVE_INCLUDE:
738 Token = PrGetNextToken (NULL, " \"<>", Next);
744 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
745 "Start #include file \"%s\"\n", Gbl_CurrentLineNumber,
746 Token, Gbl_CurrentLineNumber);
748 PrDoIncludeFile (Token);
751 case PR_DIRECTIVE_INCLUDEBUFFER:
753 Token = PrGetNextToken (NULL, " \"<>", Next);
759 Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
765 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
766 "Start #includebuffer input from file \"%s\", buffer name %s\n",
767 Gbl_CurrentLineNumber, Token, Token2);
769 PrDoIncludeBuffer (Token, Token2);
772 case PR_DIRECTIVE_LINE:
774 TokenOffset = Token - Gbl_MainTokenBuffer;
776 Status = PrResolveIntegerExpression (
777 &Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
778 if (ACPI_FAILURE (Status))
783 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
784 "User #line invocation %s\n", Gbl_CurrentLineNumber,
787 Gbl_CurrentLineNumber = (UINT32) Value;
789 /* Emit #line into the preprocessor file */
791 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
792 Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename);
795 case PR_DIRECTIVE_PRAGMA:
797 if (!strcmp (Token, "disable"))
799 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
805 TokenOffset = Token - Gbl_MainTokenBuffer;
806 AslDisableException (&Gbl_CurrentLineBuffer[TokenOffset]);
808 else if (!strcmp (Token, "message"))
810 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
816 TokenOffset = Token - Gbl_MainTokenBuffer;
817 AcpiOsPrintf ("%s\n", &Gbl_CurrentLineBuffer[TokenOffset]);
821 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA,
822 THIS_TOKEN_OFFSET (Token));
828 case PR_DIRECTIVE_UNDEF:
830 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
831 "#undef: %s\n", Gbl_CurrentLineNumber, Token);
833 PrRemoveDefine (Token);
836 case PR_DIRECTIVE_WARNING:
838 PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE,
839 THIS_TOKEN_OFFSET (Token));
842 Gbl_NextError = Gbl_ErrorLog;
847 /* Should never get here */
848 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
849 "Unrecognized directive: %u\n",
850 Gbl_CurrentLineNumber, Directive);
858 PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX,
859 THIS_TOKEN_OFFSET (DirectiveToken));
864 /*******************************************************************************
866 * FUNCTION: PrGetNextLine, PrGetNextLineInit
868 * PARAMETERS: Handle - Open file handle for the source file
870 * RETURN: Status of the GetLine operation:
871 * AE_OK - Normal line, OK status
872 * ASL_IGNORE_LINE - Line is blank or part of a multi-line
874 * ASL_EOF - End-of-file reached
876 * DESCRIPTION: Get the next text line from the input file. Does not strip
879 ******************************************************************************/
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
886 static UINT8 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
892 AcpiGbl_LineScanState = 0;
904 /* Always clear the global line buffer */
906 memset (Gbl_CurrentLineBuffer, 0, Gbl_LineBufferSize);
910 * If line is too long, expand the line buffers. Also increases
911 * Gbl_LineBufferSize.
913 if (i >= Gbl_LineBufferSize)
915 UtExpandLineBuffers ();
923 * On EOF: If there is anything in the line buffer, terminate
924 * it with a newline, and catch the EOF on the next call
929 Gbl_CurrentLineBuffer[i] = '\n';
936 /* Update state machine as necessary */
938 switch (AcpiGbl_LineScanState)
942 /* Check for multi-line comment start */
944 if ((PreviousChar == '/') && (c == '*'))
946 AcpiGbl_LineScanState = PR_MULTI_LINE_COMMENT;
949 /* Check for single-line comment start */
951 else if ((PreviousChar == '/') && (c == '/'))
953 AcpiGbl_LineScanState = PR_SINGLE_LINE_COMMENT;
956 /* Check for quoted string start */
958 else if (PreviousChar == '"')
960 AcpiGbl_LineScanState = PR_QUOTED_STRING;
964 case PR_QUOTED_STRING:
966 if (PreviousChar == '"')
968 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
972 case PR_MULTI_LINE_COMMENT:
974 /* Check for multi-line comment end */
976 if ((PreviousChar == '*') && (c == '/'))
978 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
982 case PR_SINGLE_LINE_COMMENT: /* Just ignore text until EOL */
987 /* Always copy the character into line buffer */
989 Gbl_CurrentLineBuffer[i] = (char) c;
992 /* Always exit on end-of-line */
996 /* Handle multi-line comments */
998 if (AcpiGbl_LineScanState == PR_MULTI_LINE_COMMENT)
1000 return (ASL_IGNORE_LINE);
1003 /* End of single-line comment */
1005 if (AcpiGbl_LineScanState == PR_SINGLE_LINE_COMMENT)
1007 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1015 return (ASL_IGNORE_LINE);
1024 /*******************************************************************************
1026 * FUNCTION: PrMatchDirective
1028 * PARAMETERS: Directive - Pointer to directive name token
1030 * RETURN: Index into command array, -1 if not found
1032 * DESCRIPTION: Lookup the incoming directive in the known directives table.
1034 ******************************************************************************/
1043 if (!Directive || Directive[0] == 0)
1045 return (ASL_DIRECTIVE_NOT_FOUND);
1048 for (i = 0; Gbl_DirectiveInfo[i].Name; i++)
1050 if (!strcmp (Gbl_DirectiveInfo[i].Name, Directive))
1056 return (ASL_DIRECTIVE_NOT_FOUND); /* Command not recognized */
1060 /*******************************************************************************
1062 * FUNCTION: PrPushDirective
1064 * PARAMETERS: Directive - Encoded directive ID
1065 * Argument - String containing argument to the
1070 * DESCRIPTION: Push an item onto the directive stack. Used for processing
1071 * nested #if/#else type conditional compilation directives.
1072 * Specifically: Used on detection of #if/#ifdef/#ifndef to open
1075 ******************************************************************************/
1082 DIRECTIVE_INFO *Info;
1085 /* Allocate and populate a stack info item */
1087 Info = ACPI_ALLOCATE (sizeof (DIRECTIVE_INFO));
1089 Info->Next = Gbl_DirectiveStack;
1090 Info->Directive = Directive;
1091 Info->IgnoringThisCodeBlock = Gbl_IgnoringThisCodeBlock;
1092 strncpy (Info->Argument, Argument, MAX_ARGUMENT_LENGTH);
1094 DbgPrint (ASL_DEBUG_OUTPUT,
1095 "Pr(%.4u) - [%u %s] %*s Pushed [#%s %s]: IgnoreFlag = %s\n",
1096 Gbl_CurrentLineNumber, Gbl_IfDepth,
1097 Gbl_IgnoringThisCodeBlock ? "I" : "E",
1098 Gbl_IfDepth * 4, " ",
1099 Gbl_DirectiveInfo[Directive].Name,
1100 Argument, Gbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
1104 Gbl_DirectiveStack = Info;
1109 /*******************************************************************************
1111 * FUNCTION: PrPopDirective
1115 * RETURN: Status. Error if the stack is empty.
1117 * DESCRIPTION: Pop an item off the directive stack. Used for processing
1118 * nested #if/#else type conditional compilation directives.
1119 * Specifically: Used on detection of #elif and #endif to remove
1120 * the original #if/#ifdef/#ifndef from the stack and close
1123 ******************************************************************************/
1129 DIRECTIVE_INFO *Info;
1132 /* Check for empty stack */
1134 Info = Gbl_DirectiveStack;
1140 /* Pop one item, keep globals up-to-date */
1143 Gbl_IgnoringThisCodeBlock = Info->IgnoringThisCodeBlock;
1144 Gbl_DirectiveStack = Info->Next;
1146 DbgPrint (ASL_DEBUG_OUTPUT,
1147 "Pr(%.4u) - [%u %s] %*s Popped [#%s %s]: IgnoreFlag now = %s\n",
1148 Gbl_CurrentLineNumber, Gbl_IfDepth,
1149 Gbl_IgnoringThisCodeBlock ? "I" : "E",
1150 Gbl_IfDepth * 4, " ",
1151 Gbl_DirectiveInfo[Info->Directive].Name,
1152 Info->Argument, Gbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
1159 /*******************************************************************************
1161 * FUNCTION: PrDbgPrint
1163 * PARAMETERS: Action - Action being performed
1164 * DirectiveName - Directive being processed
1168 * DESCRIPTION: Special debug print for directive processing.
1170 ******************************************************************************/
1175 char *DirectiveName)
1178 DbgPrint (ASL_DEBUG_OUTPUT, "Pr(%.4u) - [%u %s] "
1179 "%*s %s #%s, IfDepth %u\n",
1180 Gbl_CurrentLineNumber, Gbl_IfDepth,
1181 Gbl_IgnoringThisCodeBlock ? "I" : "E",
1182 Gbl_IfDepth * 4, " ",
1183 Action, DirectiveName, Gbl_IfDepth);
1187 /*******************************************************************************
1189 * FUNCTION: PrDoIncludeFile
1191 * PARAMETERS: Pathname - Name of the input file
1195 * DESCRIPTION: Open an include file, from #include.
1197 ******************************************************************************/
1206 (void) PrOpenIncludeFile (Pathname, "r", &FullPathname);
1210 /*******************************************************************************
1212 * FUNCTION: PrDoIncludeBuffer
1214 * PARAMETERS: Pathname - Name of the input binary file
1215 * BufferName - ACPI namepath of the buffer
1219 * DESCRIPTION: Create an ACPI buffer object from a binary file. The contents
1220 * of the file are emitted into the buffer object as ascii
1221 * hex data. From #includebuffer.
1223 ******************************************************************************/
1231 FILE *BinaryBufferFile;
1236 BinaryBufferFile = PrOpenIncludeFile (Pathname, "rb", &FullPathname);
1237 if (!BinaryBufferFile)
1242 /* Emit "Name (XXXX, Buffer() {" header */
1244 FlPrintFile (ASL_FILE_PREPROCESSOR, "Name (%s, Buffer()\n{", BufferName);
1246 /* Dump the entire file in ascii hex format */
1248 while (fread (&c, 1, 1, BinaryBufferFile))
1252 FlPrintFile (ASL_FILE_PREPROCESSOR, "\n ", c);
1255 FlPrintFile (ASL_FILE_PREPROCESSOR, " 0x%2.2X,", c);
1259 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
1260 "#includebuffer: read %u bytes from %s\n",
1261 Gbl_CurrentLineNumber, i, FullPathname);
1263 /* Close the Name() operator */
1265 FlPrintFile (ASL_FILE_PREPROCESSOR, "\n})\n", BufferName);
1266 fclose (BinaryBufferFile);