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 - 2023, 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 AslGbl_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
PrInitializePreprocessor(void)272 PrInitializePreprocessor (
273 void)
274 {
275 /* Init globals and the list of #defines */
276
277 PrInitializeGlobals ();
278 AslGbl_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
PrInitializeGlobals(void)297 PrInitializeGlobals (
298 void)
299 {
300 /* Init globals */
301
302 AslGbl_InputFileList = NULL;
303 AslGbl_CurrentLineNumber = 1;
304 AslGbl_PreprocessorLineNumber = 1;
305 AslGbl_PreprocessorError = FALSE;
306
307 /* These are used to track #if/#else blocks (possibly nested) */
308
309 AslGbl_IfDepth = 0;
310 AslGbl_IgnoringThisCodeBlock = FALSE;
311 AslGbl_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
PrTerminatePreprocessor(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 ((AslGbl_DefineList) && (!AslGbl_DefineList->Persist))
341 {
342 DefineInfo = AslGbl_DefineList;
343 AslGbl_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
PrDoPreprocess(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 AslGbl_Files[ASL_FILE_INPUT].Handle = AslGbl_Files[ASL_FILE_PREPROCESSOR].Handle;
392 AslCompilerin = AslGbl_Files[ASL_FILE_INPUT].Handle;
393
394 /* Reset globals to allow compiler to run */
395
396 FlSeekFile (ASL_FILE_INPUT, 0);
397 if (!AslGbl_PreprocessOnly)
398 {
399 AslGbl_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
PrPreprocessInputFile(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 (AslGbl_Files[ASL_FILE_INPUT].Handle)) != ASL_EOF)
440 {
441 AslGbl_CurrentLineNumber++;
442 AslGbl_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 (AslGbl_MainTokenBuffer, AslGbl_CurrentLineBuffer);
452 Token = PrGetNextToken (AslGbl_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 (AslGbl_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 AslGbl_CurrentLineNumber, DefineInfo->Identifier,
498 DefineInfo->Replacement);
499
500 PrDoMacroInvocation (AslGbl_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 - AslGbl_MainTokenBuffer + OffsetAdjust;
510 PrReplaceData (
511 &AslGbl_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 AslGbl_CurrentLineNumber, Token,
521 *ReplaceString ? ReplaceString : "(NULL STRING)");
522 }
523 }
524
525 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
526 }
527
528 AslGbl_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, AslGbl_CurrentLineBuffer,
537 strlen (AslGbl_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
PrDoDirective(char * DirectiveToken,char ** Next)556 PrDoDirective (
557 char *DirectiveToken,
558 char **Next)
559 {
560 char *Token = AslGbl_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 AslGbl_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 AslGbl_CurrentLineNumber, AslGbl_Files[ASL_FILE_INPUT].Filename,
594 AslGbl_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 (AslGbl_IgnoringThisCodeBlock)
602 {
603 switch (Directive)
604 {
605 case PR_DIRECTIVE_ELSE:
606 case PR_DIRECTIVE_ELIF:
607
608 if (AslGbl_DirectiveStack &&
609 AslGbl_DirectiveStack->IgnoringThisCodeBlock)
610 {
611 PrDbgPrint ("Ignoring", AslGbl_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 AslGbl_IgnoringThisCodeBlock = !(AslGbl_IgnoringThisCodeBlock);
631 PrDbgPrint ("Executing", "else block");
632 return;
633
634 case PR_DIRECTIVE_ELIF:
635
636 AslGbl_IgnoringThisCodeBlock = !(AslGbl_IgnoringThisCodeBlock);
637 Directive = PR_DIRECTIVE_IF;
638
639 if (AslGbl_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 (AslGbl_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 (AslGbl_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 (AslGbl_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", AslGbl_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", AslGbl_DirectiveInfo[Directive].Name);
725
726 switch (Directive)
727 {
728 case PR_DIRECTIVE_IF:
729
730 TokenOffset = Token - AslGbl_MainTokenBuffer;
731
732 /* Need to expand #define macros in the expression string first */
733
734 Status = PrResolveIntegerExpression (
735 &AslGbl_CurrentLineBuffer[TokenOffset-1], &Value);
736 if (ACPI_FAILURE (Status))
737 {
738 return;
739 }
740
741 PrPushDirective (Directive, Token);
742 if (!Value)
743 {
744 AslGbl_IgnoringThisCodeBlock = TRUE;
745 }
746
747 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
748 "Resolved #if: %8.8X%8.8X %s\n",
749 AslGbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value),
750 AslGbl_IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>");
751 break;
752
753 case PR_DIRECTIVE_IFDEF:
754
755 PrPushDirective (Directive, Token);
756 if (!PrMatchDefine (Token))
757 {
758 AslGbl_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 AslGbl_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 - AslGbl_MainTokenBuffer + strlen (Token);
781 if (*(&AslGbl_CurrentLineBuffer[TokenOffset]) == '(')
782 {
783
784 #ifdef MACROS_SUPPORTED
785 AcpiOsPrintf(
786 "%s ERROR - line %u: #define macros are not supported yet\n",
787 AslGbl_CurrentLineBuffer, AslGbl_LogicalLineNumber);
788 exit(1);
789 #else
790 PrAddMacro (Token, Next);
791 #endif
792 }
793
794
795 else
796 {
797 /* Use the remainder of the line for the #define */
798
799 Token2 = *Next;
800 if (Token2)
801 {
802 while ((*Token2 == ' ') || (*Token2 == '\t'))
803 {
804 Token2++;
805 }
806
807 End = Token2;
808 while (*End != '\n')
809 {
810 End++;
811 }
812
813 *End = 0;
814 }
815 else
816 {
817 Token2 = "";
818 }
819 #if 0
820 Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next);
821 if (!Token2)
822 {
823 Token2 = "";
824 }
825 #endif
826 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
827 "New #define: %s->%s\n",
828 AslGbl_LogicalLineNumber, Token, Token2);
829
830 PrAddDefine (Token, Token2, FALSE);
831 }
832 break;
833
834 case PR_DIRECTIVE_ERROR:
835
836 /* Note: No macro expansion */
837
838 PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE,
839 THIS_TOKEN_OFFSET (Token));
840
841 AslGbl_SourceLine = 0;
842 AslGbl_NextError = AslGbl_ErrorLog;
843 CmCleanupAndExit ();
844 exit(1);
845
846 case PR_DIRECTIVE_INCLUDE:
847
848 Token = PrGetNextToken (NULL, " \"<>", Next);
849 if (!Token)
850 {
851 goto SyntaxError;
852 }
853
854 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
855 "Start #include file \"%s\"\n", AslGbl_CurrentLineNumber,
856 Token);
857
858 PrDoIncludeFile (Token);
859 break;
860
861 case PR_DIRECTIVE_INCLUDEBUFFER:
862
863 Token = PrGetNextToken (NULL, " \"<>", Next);
864 if (!Token)
865 {
866 goto SyntaxError;
867 }
868
869 Token2 = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
870 if (!Token2)
871 {
872 goto SyntaxError;
873 }
874
875 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
876 "Start #includebuffer input from file \"%s\", buffer name %s\n",
877 AslGbl_CurrentLineNumber, Token, Token2);
878
879 PrDoIncludeBuffer (Token, Token2);
880 break;
881
882 case PR_DIRECTIVE_LINE:
883
884 TokenOffset = Token - AslGbl_MainTokenBuffer;
885
886 Status = PrResolveIntegerExpression (
887 &AslGbl_CurrentLineBuffer[TokenOffset-1], &Value);
888 if (ACPI_FAILURE (Status))
889 {
890 return;
891 }
892
893 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
894 "User #line invocation %s\n", AslGbl_CurrentLineNumber,
895 Token);
896
897 AslGbl_CurrentLineNumber = (UINT32) Value;
898
899 /* Emit #line into the preprocessor file */
900
901 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
902 AslGbl_CurrentLineNumber, AslGbl_Files[ASL_FILE_INPUT].Filename);
903 break;
904
905 case PR_DIRECTIVE_PRAGMA:
906
907 if (!strcmp (Token, "disable"))
908 {
909 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
910 if (!Token)
911 {
912 goto SyntaxError;
913 }
914
915 TokenOffset = Token - AslGbl_MainTokenBuffer;
916 AslDisableException (&AslGbl_CurrentLineBuffer[TokenOffset]);
917 }
918 else if (!strcmp (Token, "message"))
919 {
920 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
921 if (!Token)
922 {
923 goto SyntaxError;
924 }
925
926 TokenOffset = Token - AslGbl_MainTokenBuffer;
927 AcpiOsPrintf ("%s\n", &AslGbl_CurrentLineBuffer[TokenOffset]);
928 }
929 else
930 {
931 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA,
932 THIS_TOKEN_OFFSET (Token));
933 return;
934 }
935
936 break;
937
938 case PR_DIRECTIVE_UNDEF:
939
940 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
941 "#undef: %s\n", AslGbl_CurrentLineNumber, Token);
942
943 PrRemoveDefine (Token);
944 break;
945
946 case PR_DIRECTIVE_WARNING:
947
948 PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE,
949 THIS_TOKEN_OFFSET (Token));
950
951 AslGbl_SourceLine = 0;
952 AslGbl_NextError = AslGbl_ErrorLog;
953 break;
954
955 default:
956
957 /* Should never get here */
958 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
959 "Unrecognized directive: %u\n",
960 AslGbl_CurrentLineNumber, Directive);
961 break;
962 }
963
964 return;
965
966 SyntaxError:
967
968 PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX,
969 THIS_TOKEN_OFFSET (DirectiveToken));
970 return;
971 }
972
973
974 /*******************************************************************************
975 *
976 * FUNCTION: PrGetNextLine, PrGetNextLineInit
977 *
978 * PARAMETERS: Handle - Open file handle for the source file
979 *
980 * RETURN: Status of the GetLine operation:
981 * AE_OK - Normal line, OK status
982 * ASL_IGNORE_LINE - Line is blank or part of a multi-line
983 * comment
984 * ASL_EOF - End-of-file reached
985 *
986 * DESCRIPTION: Get the next text line from the input file. Does not strip
987 * comments.
988 *
989 ******************************************************************************/
990
991 #define PR_NORMAL_TEXT 0
992 #define PR_MULTI_LINE_COMMENT 1
993 #define PR_SINGLE_LINE_COMMENT 2
994 #define PR_QUOTED_STRING 3
995
996 static UINT8 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
997
998 static void
PrGetNextLineInit(void)999 PrGetNextLineInit (
1000 void)
1001 {
1002 AcpiGbl_LineScanState = 0;
1003 }
1004
1005 static UINT32
PrGetNextLine(FILE * Handle)1006 PrGetNextLine (
1007 FILE *Handle)
1008 {
1009 UINT32 i;
1010 int c = 0;
1011 int PreviousChar;
1012
1013
1014 /* Always clear the global line buffer */
1015
1016 memset (AslGbl_CurrentLineBuffer, 0, AslGbl_LineBufferSize);
1017 for (i = 0; ;)
1018 {
1019 /*
1020 * If line is too long, expand the line buffers. Also increases
1021 * AslGbl_LineBufferSize.
1022 */
1023 if (i >= AslGbl_LineBufferSize)
1024 {
1025 UtExpandLineBuffers ();
1026 }
1027
1028 PreviousChar = c;
1029 c = getc (Handle);
1030 if (c == EOF)
1031 {
1032 /*
1033 * On EOF: If there is anything in the line buffer, terminate
1034 * it with a newline, and catch the EOF on the next call
1035 * to this function.
1036 */
1037 if (i > 0)
1038 {
1039 AslGbl_CurrentLineBuffer[i] = '\n';
1040 return (AE_OK);
1041 }
1042
1043 return (ASL_EOF);
1044 }
1045
1046 /* Update state machine as necessary */
1047
1048 switch (AcpiGbl_LineScanState)
1049 {
1050 case PR_NORMAL_TEXT:
1051
1052 /* Check for multi-line comment start */
1053
1054 if ((PreviousChar == '/') && (c == '*'))
1055 {
1056 AcpiGbl_LineScanState = PR_MULTI_LINE_COMMENT;
1057 }
1058
1059 /* Check for single-line comment start */
1060
1061 else if ((PreviousChar == '/') && (c == '/'))
1062 {
1063 AcpiGbl_LineScanState = PR_SINGLE_LINE_COMMENT;
1064 }
1065
1066 /* Check for quoted string start */
1067
1068 else if (PreviousChar == '"')
1069 {
1070 AcpiGbl_LineScanState = PR_QUOTED_STRING;
1071 }
1072 break;
1073
1074 case PR_QUOTED_STRING:
1075
1076 if (PreviousChar == '"')
1077 {
1078 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1079 }
1080 break;
1081
1082 case PR_MULTI_LINE_COMMENT:
1083
1084 /* Check for multi-line comment end */
1085
1086 if ((PreviousChar == '*') && (c == '/'))
1087 {
1088 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1089 }
1090 break;
1091
1092 case PR_SINGLE_LINE_COMMENT: /* Just ignore text until EOL */
1093 default:
1094 break;
1095 }
1096
1097 /* Always copy the character into line buffer */
1098
1099 AslGbl_CurrentLineBuffer[i] = (char) c;
1100 i++;
1101
1102 /* Always exit on end-of-line */
1103
1104 if (c == '\n')
1105 {
1106 /* Handle multi-line comments */
1107
1108 if (AcpiGbl_LineScanState == PR_MULTI_LINE_COMMENT)
1109 {
1110 return (ASL_IGNORE_LINE);
1111 }
1112
1113 /* End of single-line comment */
1114
1115 if (AcpiGbl_LineScanState == PR_SINGLE_LINE_COMMENT)
1116 {
1117 AcpiGbl_LineScanState = PR_NORMAL_TEXT;
1118 return (AE_OK);
1119 }
1120
1121 /* Blank line */
1122
1123 if (i == 1)
1124 {
1125 return (ASL_IGNORE_LINE);
1126 }
1127
1128 return (AE_OK);
1129 }
1130 }
1131 }
1132
1133
1134 /*******************************************************************************
1135 *
1136 * FUNCTION: PrMatchDirective
1137 *
1138 * PARAMETERS: Directive - Pointer to directive name token
1139 *
1140 * RETURN: Index into command array, -1 if not found
1141 *
1142 * DESCRIPTION: Lookup the incoming directive in the known directives table.
1143 *
1144 ******************************************************************************/
1145
1146 static int
PrMatchDirective(char * Directive)1147 PrMatchDirective (
1148 char *Directive)
1149 {
1150 int i;
1151
1152
1153 if (!Directive || Directive[0] == 0)
1154 {
1155 return (ASL_DIRECTIVE_NOT_FOUND);
1156 }
1157
1158 for (i = 0; AslGbl_DirectiveInfo[i].Name; i++)
1159 {
1160 if (!strcmp (AslGbl_DirectiveInfo[i].Name, Directive))
1161 {
1162 return (i);
1163 }
1164 }
1165
1166 return (ASL_DIRECTIVE_NOT_FOUND); /* Command not recognized */
1167 }
1168
1169
1170 /*******************************************************************************
1171 *
1172 * FUNCTION: PrPushDirective
1173 *
1174 * PARAMETERS: Directive - Encoded directive ID
1175 * Argument - String containing argument to the
1176 * directive
1177 *
1178 * RETURN: None
1179 *
1180 * DESCRIPTION: Push an item onto the directive stack. Used for processing
1181 * nested #if/#else type conditional compilation directives.
1182 * Specifically: Used on detection of #if/#ifdef/#ifndef to open
1183 * a block.
1184 *
1185 ******************************************************************************/
1186
1187 static void
PrPushDirective(int Directive,char * Argument)1188 PrPushDirective (
1189 int Directive,
1190 char *Argument)
1191 {
1192 DIRECTIVE_INFO *Info;
1193
1194
1195 /* Allocate and populate a stack info item */
1196
1197 Info = ACPI_CAST_PTR (DIRECTIVE_INFO,
1198 UtLocalCacheCalloc (sizeof (DIRECTIVE_INFO)));
1199
1200 Info->Next = AslGbl_DirectiveStack;
1201 Info->Directive = Directive;
1202 Info->IgnoringThisCodeBlock = AslGbl_IgnoringThisCodeBlock;
1203 AcpiUtSafeStrncpy (Info->Argument, Argument, MAX_ARGUMENT_LENGTH);
1204
1205 DbgPrint (ASL_DEBUG_OUTPUT,
1206 "Pr(%.4u) - [%u %s] %*s Pushed [#%s %s]: IgnoreFlag = %s\n",
1207 AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1208 AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1209 AslGbl_IfDepth * 4, " ",
1210 AslGbl_DirectiveInfo[Directive].Name,
1211 Argument, AslGbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
1212
1213 /* Push new item */
1214
1215 AslGbl_DirectiveStack = Info;
1216 AslGbl_IfDepth++;
1217 }
1218
1219
1220 /*******************************************************************************
1221 *
1222 * FUNCTION: PrPopDirective
1223 *
1224 * PARAMETERS: None
1225 *
1226 * RETURN: Status. Error if the stack is empty.
1227 *
1228 * DESCRIPTION: Pop an item off the directive stack. Used for processing
1229 * nested #if/#else type conditional compilation directives.
1230 * Specifically: Used on detection of #elif and #endif to remove
1231 * the original #if/#ifdef/#ifndef from the stack and close
1232 * the block.
1233 *
1234 ******************************************************************************/
1235
1236 static ACPI_STATUS
PrPopDirective(void)1237 PrPopDirective (
1238 void)
1239 {
1240 DIRECTIVE_INFO *Info;
1241
1242
1243 /* Check for empty stack */
1244
1245 Info = AslGbl_DirectiveStack;
1246 if (!Info)
1247 {
1248 return (AE_ERROR);
1249 }
1250
1251 /* Pop one item, keep globals up-to-date */
1252
1253 AslGbl_IfDepth--;
1254 AslGbl_IgnoringThisCodeBlock = Info->IgnoringThisCodeBlock;
1255 AslGbl_DirectiveStack = Info->Next;
1256
1257 DbgPrint (ASL_DEBUG_OUTPUT,
1258 "Pr(%.4u) - [%u %s] %*s Popped [#%s %s]: IgnoreFlag now = %s\n",
1259 AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1260 AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1261 AslGbl_IfDepth * 4, " ",
1262 AslGbl_DirectiveInfo[Info->Directive].Name,
1263 Info->Argument, AslGbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
1264
1265 return (AE_OK);
1266 }
1267
1268
1269 /*******************************************************************************
1270 *
1271 * FUNCTION: PrDbgPrint
1272 *
1273 * PARAMETERS: Action - Action being performed
1274 * DirectiveName - Directive being processed
1275 *
1276 * RETURN: None
1277 *
1278 * DESCRIPTION: Special debug print for directive processing.
1279 *
1280 ******************************************************************************/
1281
1282 static void
PrDbgPrint(char * Action,char * DirectiveName)1283 PrDbgPrint (
1284 char *Action,
1285 char *DirectiveName)
1286 {
1287
1288 DbgPrint (ASL_DEBUG_OUTPUT, "Pr(%.4u) - [%u %s] "
1289 "%*s %s #%s, IfDepth %u\n",
1290 AslGbl_CurrentLineNumber, AslGbl_IfDepth,
1291 AslGbl_IgnoringThisCodeBlock ? "I" : "E",
1292 AslGbl_IfDepth * 4, " ",
1293 Action, DirectiveName, AslGbl_IfDepth);
1294 }
1295
1296
1297 /*******************************************************************************
1298 *
1299 * FUNCTION: PrDoIncludeFile
1300 *
1301 * PARAMETERS: Pathname - Name of the input file
1302 *
1303 * RETURN: None.
1304 *
1305 * DESCRIPTION: Open an include file, from #include.
1306 *
1307 ******************************************************************************/
1308
1309 static void
PrDoIncludeFile(char * Pathname)1310 PrDoIncludeFile (
1311 char *Pathname)
1312 {
1313 char *FullPathname;
1314
1315
1316 (void) PrOpenIncludeFile (Pathname, "r", &FullPathname);
1317 }
1318
1319
1320 /*******************************************************************************
1321 *
1322 * FUNCTION: PrDoIncludeBuffer
1323 *
1324 * PARAMETERS: Pathname - Name of the input binary file
1325 * BufferName - ACPI namepath of the buffer
1326 *
1327 * RETURN: None.
1328 *
1329 * DESCRIPTION: Create an ACPI buffer object from a binary file. The contents
1330 * of the file are emitted into the buffer object as ascii
1331 * hex data. From #includebuffer.
1332 *
1333 ******************************************************************************/
1334
1335 static void
PrDoIncludeBuffer(char * Pathname,char * BufferName)1336 PrDoIncludeBuffer (
1337 char *Pathname,
1338 char *BufferName)
1339 {
1340 char *FullPathname;
1341 FILE *BinaryBufferFile;
1342 UINT32 i = 0;
1343 UINT8 c;
1344
1345
1346 BinaryBufferFile = PrOpenIncludeFile (Pathname, "rb", &FullPathname);
1347 if (!BinaryBufferFile)
1348 {
1349 return;
1350 }
1351
1352 /* Emit "Name (XXXX, Buffer() {" header */
1353
1354 FlPrintFile (ASL_FILE_PREPROCESSOR, "Name (%s, Buffer()\n{", BufferName);
1355
1356 /* Dump the entire file in ascii hex format */
1357
1358 while (fread (&c, 1, 1, BinaryBufferFile))
1359 {
1360 if (!(i % 8))
1361 {
1362 FlPrintFile (ASL_FILE_PREPROCESSOR, "\n ");
1363 }
1364
1365 FlPrintFile (ASL_FILE_PREPROCESSOR, " 0x%2.2X,", c);
1366 i++;
1367 }
1368
1369 DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
1370 "#includebuffer: read %u bytes from %s\n",
1371 AslGbl_CurrentLineNumber, i, FullPathname);
1372
1373 /* Close the Name() operator */
1374
1375 FlPrintFile (ASL_FILE_PREPROCESSOR, "\n})\n");
1376 fclose (BinaryBufferFile);
1377 }
1378
