1 /******************************************************************************
3 * Module Name: prscan - Preprocessor start-up and file scan module
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2015, 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_WITHIN_COMMENT) ||
338 (Status == ASL_BLANK_LINE))
340 goto WriteEntireLine;
343 /* Need a copy of the input line for strok() */
345 strcpy (Gbl_MainTokenBuffer, Gbl_CurrentLineBuffer);
346 Token = PrGetNextToken (Gbl_MainTokenBuffer, PR_TOKEN_SEPARATORS, &Next);
349 /* All preprocessor directives must begin with '#' */
351 if (Token && (*Token == '#'))
353 if (strlen (Token) == 1)
355 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
359 Token++; /* Skip leading # */
362 /* Execute the directive, do not write line to output file */
364 PrDoDirective (Token, &Next);
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.
373 if (Gbl_IgnoringThisCodeBlock)
378 /* Match and replace all #defined names within this source line */
382 DefineInfo = PrMatchDefine (Token);
385 if (DefineInfo->Body)
387 /* This is a macro */
389 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
390 "Matched Macro: %s->%s\n",
391 Gbl_CurrentLineNumber, DefineInfo->Identifier,
392 DefineInfo->Replacement);
394 PrDoMacroInvocation (Gbl_MainTokenBuffer, Token,
399 ReplaceString = DefineInfo->Replacement;
401 /* Replace the name in the original line buffer */
403 TokenOffset = Token - Gbl_MainTokenBuffer + OffsetAdjust;
405 &Gbl_CurrentLineBuffer[TokenOffset], strlen (Token),
406 ReplaceString, strlen (ReplaceString));
408 /* Adjust for length difference between old and new name length */
410 OffsetAdjust += strlen (ReplaceString) - strlen (Token);
412 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
413 "Matched #define: %s->%s\n",
414 Gbl_CurrentLineNumber, Token,
415 *ReplaceString ? ReplaceString : "(NULL STRING)");
419 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
422 Gbl_PreprocessorLineNumber++;
427 * Now we can write the possibly modified source line to the
428 * preprocessor file(s).
430 FlWriteFile (ASL_FILE_PREPROCESSOR, Gbl_CurrentLineBuffer,
431 strlen (Gbl_CurrentLineBuffer));
436 /*******************************************************************************
438 * FUNCTION: PrDoDirective
440 * PARAMETERS: Directive - Pointer to directive name token
441 * Next - "Next" buffer from GetNextToken
445 * DESCRIPTION: Main processing for all preprocessor directives
447 ******************************************************************************/
451 char *DirectiveToken,
454 char *Token = Gbl_MainTokenBuffer;
458 ACPI_SIZE TokenOffset;
468 Directive = PrMatchDirective (DirectiveToken);
469 if (Directive == ASL_DIRECTIVE_NOT_FOUND)
471 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE,
472 THIS_TOKEN_OFFSET (DirectiveToken));
474 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
475 "#%s: Unknown directive\n",
476 Gbl_CurrentLineNumber, DirectiveToken);
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.
486 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\" // #%s\n",
487 Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename,
488 Gbl_DirectiveInfo[Directive].Name);
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
495 if (Gbl_IgnoringThisCodeBlock)
499 case PR_DIRECTIVE_ELSE:
500 case PR_DIRECTIVE_ELIF:
502 if (Gbl_DirectiveStack && 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
677 AcpiOsPrintf ("%s ERROR - line %u: #define macros are not supported yet\n",
678 Gbl_CurrentLineBuffer, Gbl_LogicalLineNumber);
681 PrAddMacro (Token, Next);
686 /* Use the remainder of the line for the #define */
691 while ((*Token2 == ' ') || (*Token2 == '\t'))
707 Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next);
713 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
714 "New #define: %s->%s\n",
715 Gbl_LogicalLineNumber, Token, Token2);
717 PrAddDefine (Token, Token2, FALSE);
721 case PR_DIRECTIVE_ERROR:
723 /* Note: No macro expansion */
725 PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE,
726 THIS_TOKEN_OFFSET (Token));
729 Gbl_NextError = Gbl_ErrorLog;
733 case PR_DIRECTIVE_INCLUDE:
735 Token = PrGetNextToken (NULL, " \"<>", Next);
741 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
742 "Start #include file \"%s\"\n", Gbl_CurrentLineNumber,
743 Token, Gbl_CurrentLineNumber);
745 PrDoIncludeFile (Token);
748 case PR_DIRECTIVE_INCLUDEBUFFER:
750 Token = PrGetNextToken (NULL, " \"<>", Next);
756 Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
762 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
763 "Start #includebuffer input from file \"%s\", buffer name %s\n",
764 Gbl_CurrentLineNumber, Token, Token2);
766 PrDoIncludeBuffer (Token, Token2);
769 case PR_DIRECTIVE_LINE:
771 TokenOffset = Token - Gbl_MainTokenBuffer;
773 Status = PrResolveIntegerExpression (
774 &Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
775 if (ACPI_FAILURE (Status))
780 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
781 "User #line invocation %s\n", Gbl_CurrentLineNumber,
784 Gbl_CurrentLineNumber = (UINT32) Value;
786 /* Emit #line into the preprocessor file */
788 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
789 Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename);
792 case PR_DIRECTIVE_PRAGMA:
794 if (!strcmp (Token, "disable"))
796 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
802 TokenOffset = Token - Gbl_MainTokenBuffer;
803 AslDisableException (&Gbl_CurrentLineBuffer[TokenOffset]);
805 else if (!strcmp (Token, "message"))
807 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
813 TokenOffset = Token - Gbl_MainTokenBuffer;
814 AcpiOsPrintf ("%s\n", &Gbl_CurrentLineBuffer[TokenOffset]);
818 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA,
819 THIS_TOKEN_OFFSET (Token));
825 case PR_DIRECTIVE_UNDEF:
827 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
828 "#undef: %s\n", Gbl_CurrentLineNumber, Token);
830 PrRemoveDefine (Token);
833 case PR_DIRECTIVE_WARNING:
835 PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE,
836 THIS_TOKEN_OFFSET (Token));
839 Gbl_NextError = Gbl_ErrorLog;
844 /* Should never get here */
845 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
846 "Unrecognized directive: %u\n",
847 Gbl_CurrentLineNumber, Directive);
855 PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX,
856 THIS_TOKEN_OFFSET (DirectiveToken));
861 /*******************************************************************************
863 * FUNCTION: PrGetNextLine, PrGetNextLineInit
865 * PARAMETERS: Handle - Open file handle for the source file
867 * RETURN: Status of the GetLine operation:
868 * AE_OK - Normal line, OK status
869 * ASL_WITHIN_COMMENT - Line is part of a multi-line comment
870 * ASL_EOF - End-of-file reached
872 * DESCRIPTION: Get the next text line from the input file. Does not strip
875 ******************************************************************************/
877 #define PR_NORMAL_TEXT 0
878 #define PR_MULTI_LINE_COMMENT 1
879 #define PR_SINGLE_LINE_COMMENT 2
880 #define PR_QUOTED_STRING 3
882 static UINT8 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
888 AcpiGbl_LineScanState = 0;
900 /* Always clear the global line buffer */
902 memset (Gbl_CurrentLineBuffer, 0, Gbl_LineBufferSize);
906 * If line is too long, expand the line buffers. Also increases
907 * Gbl_LineBufferSize.
909 if (i >= Gbl_LineBufferSize)
911 UtExpandLineBuffers ();
921 /* Update state machine as necessary */
923 switch (AcpiGbl_LineScanState)
927 /* Check for multi-line comment start */
929 if ((PreviousChar == '/') && (c == '*'))
931 AcpiGbl_LineScanState = PR_MULTI_LINE_COMMENT;
934 /* Check for single-line comment start */
936 else if ((PreviousChar == '/') && (c == '/'))
938 AcpiGbl_LineScanState = PR_SINGLE_LINE_COMMENT;
941 /* Check for quoted string start */
943 else if (PreviousChar == '"')
945 AcpiGbl_LineScanState = PR_QUOTED_STRING;
949 case PR_QUOTED_STRING:
951 if (PreviousChar == '"')
953 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
957 case PR_MULTI_LINE_COMMENT:
959 /* Check for multi-line comment end */
961 if ((PreviousChar == '*') && (c == '/'))
963 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
967 case PR_SINGLE_LINE_COMMENT: /* Just ignore text until EOL */
972 /* Always copy the character into line buffer */
974 Gbl_CurrentLineBuffer[i] = (char) c;
977 /* Always exit on end-of-line */
981 /* Handle multi-line comments */
983 if (AcpiGbl_LineScanState == PR_MULTI_LINE_COMMENT)
985 return (ASL_WITHIN_COMMENT);
988 /* End of single-line comment */
990 if (AcpiGbl_LineScanState == PR_SINGLE_LINE_COMMENT)
992 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1000 return (ASL_BLANK_LINE);
1008 /*******************************************************************************
1010 * FUNCTION: PrMatchDirective
1012 * PARAMETERS: Directive - Pointer to directive name token
1014 * RETURN: Index into command array, -1 if not found
1016 * DESCRIPTION: Lookup the incoming directive in the known directives table.
1018 ******************************************************************************/
1027 if (!Directive || Directive[0] == 0)
1029 return (ASL_DIRECTIVE_NOT_FOUND);
1032 for (i = 0; Gbl_DirectiveInfo[i].Name; i++)
1034 if (!strcmp (Gbl_DirectiveInfo[i].Name, Directive))
1040 return (ASL_DIRECTIVE_NOT_FOUND); /* Command not recognized */
1044 /*******************************************************************************
1046 * FUNCTION: PrPushDirective
1048 * PARAMETERS: Directive - Encoded directive ID
1049 * Argument - String containing argument to the
1054 * DESCRIPTION: Push an item onto the directive stack. Used for processing
1055 * nested #if/#else type conditional compilation directives.
1056 * Specifically: Used on detection of #if/#ifdef/#ifndef to open
1059 ******************************************************************************/
1066 DIRECTIVE_INFO *Info;
1069 /* Allocate and populate a stack info item */
1071 Info = ACPI_ALLOCATE (sizeof (DIRECTIVE_INFO));
1073 Info->Next = Gbl_DirectiveStack;
1074 Info->Directive = Directive;
1075 Info->IgnoringThisCodeBlock = Gbl_IgnoringThisCodeBlock;
1076 strncpy (Info->Argument, Argument, MAX_ARGUMENT_LENGTH);
1078 DbgPrint (ASL_DEBUG_OUTPUT,
1079 "Pr(%.4u) - [%u %s] %*s Pushed [#%s %s]: IgnoreFlag = %s\n",
1080 Gbl_CurrentLineNumber, Gbl_IfDepth,
1081 Gbl_IgnoringThisCodeBlock ? "I" : "E",
1082 Gbl_IfDepth * 4, " ",
1083 Gbl_DirectiveInfo[Directive].Name,
1084 Argument, Gbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
1088 Gbl_DirectiveStack = Info;
1093 /*******************************************************************************
1095 * FUNCTION: PrPopDirective
1099 * RETURN: Status. Error if the stack is empty.
1101 * DESCRIPTION: Pop an item off the directive stack. Used for processing
1102 * nested #if/#else type conditional compilation directives.
1103 * Specifically: Used on detection of #elif and #endif to remove
1104 * the original #if/#ifdef/#ifndef from the stack and close
1107 ******************************************************************************/
1113 DIRECTIVE_INFO *Info;
1116 /* Check for empty stack */
1118 Info = Gbl_DirectiveStack;
1124 /* Pop one item, keep globals up-to-date */
1127 Gbl_IgnoringThisCodeBlock = Info->IgnoringThisCodeBlock;
1128 Gbl_DirectiveStack = Info->Next;
1130 DbgPrint (ASL_DEBUG_OUTPUT,
1131 "Pr(%.4u) - [%u %s] %*s Popped [#%s %s]: IgnoreFlag now = %s\n",
1132 Gbl_CurrentLineNumber, Gbl_IfDepth,
1133 Gbl_IgnoringThisCodeBlock ? "I" : "E",
1134 Gbl_IfDepth * 4, " ",
1135 Gbl_DirectiveInfo[Info->Directive].Name,
1136 Info->Argument, Gbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
1143 /*******************************************************************************
1145 * FUNCTION: PrDbgPrint
1147 * PARAMETERS: Action - Action being performed
1148 * DirectiveName - Directive being processed
1152 * DESCRIPTION: Special debug print for directive processing.
1154 ******************************************************************************/
1159 char *DirectiveName)
1162 DbgPrint (ASL_DEBUG_OUTPUT, "Pr(%.4u) - [%u %s] "
1163 "%*s %s #%s, IfDepth %u\n",
1164 Gbl_CurrentLineNumber, Gbl_IfDepth,
1165 Gbl_IgnoringThisCodeBlock ? "I" : "E",
1166 Gbl_IfDepth * 4, " ",
1167 Action, DirectiveName, Gbl_IfDepth);
1171 /*******************************************************************************
1173 * FUNCTION: PrDoIncludeFile
1175 * PARAMETERS: Pathname - Name of the input file
1179 * DESCRIPTION: Open an include file, from #include.
1181 ******************************************************************************/
1190 (void) PrOpenIncludeFile (Pathname, "r", &FullPathname);
1194 /*******************************************************************************
1196 * FUNCTION: PrDoIncludeBuffer
1198 * PARAMETERS: Pathname - Name of the input binary file
1199 * BufferName - ACPI namepath of the buffer
1203 * DESCRIPTION: Create an ACPI buffer object from a binary file. The contents
1204 * of the file are emitted into the buffer object as ascii
1205 * hex data. From #includebuffer.
1207 ******************************************************************************/
1215 FILE *BinaryBufferFile;
1220 BinaryBufferFile = PrOpenIncludeFile (Pathname, "rb", &FullPathname);
1221 if (!BinaryBufferFile)
1226 /* Emit "Name (XXXX, Buffer() {" header */
1228 FlPrintFile (ASL_FILE_PREPROCESSOR, "Name (%s, Buffer()\n{", BufferName);
1230 /* Dump the entire file in ascii hex format */
1232 while (fread (&c, 1, 1, BinaryBufferFile))
1236 FlPrintFile (ASL_FILE_PREPROCESSOR, "\n ", c);
1239 FlPrintFile (ASL_FILE_PREPROCESSOR, " 0x%2.2X,", c);
1243 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
1244 "#includebuffer: read %u bytes from %s\n",
1245 Gbl_CurrentLineNumber, i, FullPathname);
1247 /* Close the Name() operator */
1249 FlPrintFile (ASL_FILE_PREPROCESSOR, "\n})\n", BufferName);
1250 fclose (BinaryBufferFile);