1 /******************************************************************************
2 *
3 * Module Name: prscan - Preprocessor start-up and file scan module
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 int
71 PrMatchDirective (
72 char *Directive);
73
74 static void
75 PrPushDirective (
76 int Directive,
77 char *Argument);
78
79 static ACPI_STATUS
80 PrPopDirective (
81 void);
82
83 static void
84 PrDbgPrint (
85 char *Action,
86 char *DirectiveName);
87
88
89 /*
90 * Supported preprocessor directives
91 */
92 static const PR_DIRECTIVE_INFO Gbl_DirectiveInfo[] =
93 {
94 {"define", 1},
95 {"elif", 0}, /* Converted to #else..#if internally */
96 {"else", 0},
97 {"endif", 0},
98 {"error", 1},
99 {"if", 1},
100 {"ifdef", 1},
101 {"ifndef", 1},
102 {"include", 0}, /* Argument is not standard format, so 0 */
103 {"line", 1},
104 {"pragma", 1},
105 {"undef", 1},
106 {"warning", 1},
107 {NULL, 0}
108 };
109
110 enum Gbl_DirectiveIndexes
111 {
112 PR_DIRECTIVE_DEFINE = 0,
113 PR_DIRECTIVE_ELIF,
114 PR_DIRECTIVE_ELSE,
115 PR_DIRECTIVE_ENDIF,
116 PR_DIRECTIVE_ERROR,
117 PR_DIRECTIVE_IF,
118 PR_DIRECTIVE_IFDEF,
119 PR_DIRECTIVE_IFNDEF,
120 PR_DIRECTIVE_INCLUDE,
121 PR_DIRECTIVE_LINE,
122 PR_DIRECTIVE_PRAGMA,
123 PR_DIRECTIVE_UNDEF,
124 PR_DIRECTIVE_WARNING,
125 };
126
127 #define ASL_DIRECTIVE_NOT_FOUND -1
128
129
130 /*******************************************************************************
131 *
132 * FUNCTION: PrInitializePreprocessor
133 *
134 * PARAMETERS: None
135 *
136 * RETURN: None
137 *
138 * DESCRIPTION: Startup initialization for the Preprocessor.
139 *
140 ******************************************************************************/
141
142 void
143 PrInitializePreprocessor (
144 void)
145 {
146 /* Init globals and the list of #defines */
147
148 PrInitializeGlobals ();
149 Gbl_DefineList = NULL;
150 }
151
152
153 /*******************************************************************************
154 *
155 * FUNCTION: PrInitializeGlobals
156 *
157 * PARAMETERS: None
158 *
159 * RETURN: None
160 *
161 * DESCRIPTION: Initialize globals for the Preprocessor. Used for startuup
162 * initialization and re-initialization between compiles during
163 * a multiple source file compile.
164 *
165 ******************************************************************************/
166
167 void
168 PrInitializeGlobals (
169 void)
170 {
171 /* Init globals */
172
173 Gbl_InputFileList = NULL;
174 Gbl_CurrentLineNumber = 0;
175 Gbl_PreprocessorLineNumber = 1;
176 Gbl_PreprocessorError = FALSE;
177
178 /* These are used to track #if/#else blocks (possibly nested) */
179
180 Gbl_IfDepth = 0;
181 Gbl_IgnoringThisCodeBlock = FALSE;
182 Gbl_DirectiveStack = NULL;
183 }
184
185
186 /*******************************************************************************
187 *
188 * FUNCTION: PrTerminatePreprocessor
189 *
190 * PARAMETERS: None
191 *
192 * RETURN: None
193 *
194 * DESCRIPTION: Termination of the preprocessor. Delete lists. Keep any
195 * defines that were specified on the command line, in order to
196 * support multiple compiles with a single compiler invocation.
197 *
198 ******************************************************************************/
199
200 void
201 PrTerminatePreprocessor (
202 void)
203 {
204 PR_DEFINE_INFO *DefineInfo;
205
206
207 /*
208 * The persistent defines (created on the command line) are always at the
209 * end of the list. We save them.
210 */
211 while ((Gbl_DefineList) && (!Gbl_DefineList->Persist))
212 {
213 DefineInfo = Gbl_DefineList;
214 Gbl_DefineList = DefineInfo->Next;
215
216 ACPI_FREE (DefineInfo->Replacement);
217 ACPI_FREE (DefineInfo->Identifier);
218 ACPI_FREE (DefineInfo);
219 }
220 }
221
222
223 /*******************************************************************************
224 *
225 * FUNCTION: PrDoPreprocess
226 *
227 * PARAMETERS: None
228 *
229 * RETURN: None
230 *
231 * DESCRIPTION: Main entry point for the iASL Preprocessor. Input file must
232 * be already open. Handles multiple input files via the
233 * #include directive.
234 *
235 ******************************************************************************/
236
237 void
238 PrDoPreprocess (
239 void)
240 {
241 BOOLEAN MoreInputFiles;
242
243
244 DbgPrint (ASL_DEBUG_OUTPUT, "Starting preprocessing phase\n\n");
245
246
247 FlSeekFile (ASL_FILE_INPUT, 0);
248 PrDumpPredefinedNames ();
249
250 /* Main preprocessor loop, handles include files */
251
252 do
253 {
254 PrPreprocessInputFile ();
255 MoreInputFiles = PrPopInputFileStack ();
256
257 } while (MoreInputFiles);
258
259 /* Point compiler input to the new preprocessor output file (.i) */
260
261 FlCloseFile (ASL_FILE_INPUT);
262 Gbl_Files[ASL_FILE_INPUT].Handle = Gbl_Files[ASL_FILE_PREPROCESSOR].Handle;
263 AslCompilerin = Gbl_Files[ASL_FILE_INPUT].Handle;
264
265 /* Reset globals to allow compiler to run */
266
267 FlSeekFile (ASL_FILE_INPUT, 0);
268 Gbl_CurrentLineNumber = 1;
269
270 DbgPrint (ASL_DEBUG_OUTPUT, "Preprocessing phase complete \n\n");
271 }
272
273
274 /*******************************************************************************
275 *
276 * FUNCTION: PrPreprocessInputFile
277 *
278 * PARAMETERS: None
279 *
280 * RETURN: None
281 *
282 * DESCRIPTION: Preprocess one entire file, line-by-line.
283 *
284 * Input: Raw user ASL from ASL_FILE_INPUT
285 * Output: Preprocessed file written to ASL_FILE_PREPROCESSOR
286 *
287 ******************************************************************************/
288
289 static void
290 PrPreprocessInputFile (
291 void)
292 {
293 UINT32 Offset;
294 char *Token;
295 char *ReplaceString;
296 PR_DEFINE_INFO *DefineInfo;
297 ACPI_SIZE TokenOffset;
298 char *Next;
299 int OffsetAdjust;
300
301
302 /* Scan line-by-line. Comments and blank lines are skipped by this function */
303
304 while ((Offset = DtGetNextLine (Gbl_Files[ASL_FILE_INPUT].Handle)) != ASL_EOF)
305 {
306 /* Need a copy of the input line for strok() */
307
308 strcpy (Gbl_MainTokenBuffer, Gbl_CurrentLineBuffer);
309 Token = PrGetNextToken (Gbl_MainTokenBuffer, PR_TOKEN_SEPARATORS, &Next);
310 OffsetAdjust = 0;
311
312 /* All preprocessor directives must begin with '#' */
313
314 if (Token && (*Token == '#'))
315 {
316 if (strlen (Token) == 1)
317 {
318 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
319 }
320 else
321 {
322 Token++; /* Skip leading # */
323 }
324
325 /* Execute the directive, do not write line to output file */
326
327 PrDoDirective (Token, &Next);
328 continue;
329 }
330
331 /*
332 * If we are currently within the part of an IF/ELSE block that is
333 * FALSE, ignore the line and do not write it to the output file.
334 * This continues until an #else or #endif is encountered.
335 */
336 if (Gbl_IgnoringThisCodeBlock)
337 {
338 continue;
339 }
340
341 /* Match and replace all #defined names within this source line */
342
343 while (Token)
344 {
345 DefineInfo = PrMatchDefine (Token);
346 if (DefineInfo)
347 {
348 if (DefineInfo->Body)
349 {
350 /* This is a macro */
351
352 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
353 "Matched Macro: %s->%s\n",
354 Gbl_CurrentLineNumber, DefineInfo->Identifier,
355 DefineInfo->Replacement);
356
357 PrDoMacroInvocation (Gbl_MainTokenBuffer, Token,
358 DefineInfo, &Next);
359 }
360 else
361 {
362 ReplaceString = DefineInfo->Replacement;
363
364 /* Replace the name in the original line buffer */
365
366 TokenOffset = Token - Gbl_MainTokenBuffer + OffsetAdjust;
367 PrReplaceData (
368 &Gbl_CurrentLineBuffer[TokenOffset], strlen (Token),
369 ReplaceString, strlen (ReplaceString));
370
371 /* Adjust for length difference between old and new name length */
372
373 OffsetAdjust += strlen (ReplaceString) - strlen (Token);
374
375 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
376 "Matched #define: %s->%s\n",
377 Gbl_CurrentLineNumber, Token,
378 *ReplaceString ? ReplaceString : "(NULL STRING)");
379 }
380 }
381
382 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
383 }
384
385 #if 0
386 /* Line prefix */
387 FlPrintFile (ASL_FILE_PREPROCESSOR, "/* %14s %.5u i:%.5u */ ",
388 Gbl_Files[ASL_FILE_INPUT].Filename,
389 Gbl_CurrentLineNumber, Gbl_PreprocessorLineNumber);
390 #endif
391
392 /*
393 * Emit a #line directive if necessary, to keep the line numbers in
394 * the (.i) file synchronized with the original source code file, so
395 * that the correct line number appears in any error messages
396 * generated by the actual compiler.
397 */
398 if (Gbl_CurrentLineNumber > (Gbl_PreviousLineNumber + 1))
399 {
400 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u\n",
401 Gbl_CurrentLineNumber);
402 }
403
404 Gbl_PreviousLineNumber = Gbl_CurrentLineNumber;
405 Gbl_PreprocessorLineNumber++;
406
407 /*
408 * Now we can write the possibly modified source line to the
409 * preprocessor (.i) file
410 */
411 FlWriteFile (ASL_FILE_PREPROCESSOR, Gbl_CurrentLineBuffer,
412 strlen (Gbl_CurrentLineBuffer));
413 }
414 }
415
416
417 /*******************************************************************************
418 *
419 * FUNCTION: PrDoDirective
420 *
421 * PARAMETERS: Directive - Pointer to directive name token
422 * Next - "Next" buffer from GetNextToken
423 *
424 * RETURN: None.
425 *
426 * DESCRIPTION: Main processing for all preprocessor directives
427 *
428 ******************************************************************************/
429
430 static void
431 PrDoDirective (
432 char *DirectiveToken,
433 char **Next)
434 {
435 char *Token = Gbl_MainTokenBuffer;
436 char *Token2;
437 char *End;
438 UINT64 Value;
439 ACPI_SIZE TokenOffset;
440 int Directive;
441 ACPI_STATUS Status;
442
443
444 if (!DirectiveToken)
445 {
446 goto SyntaxError;
447 }
448
449 Directive = PrMatchDirective (DirectiveToken);
450 if (Directive == ASL_DIRECTIVE_NOT_FOUND)
451 {
452 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_DIRECTIVE,
453 THIS_TOKEN_OFFSET (DirectiveToken));
454
455 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
456 "#%s: Unknown directive\n",
457 Gbl_CurrentLineNumber, DirectiveToken);
458 return;
459 }
460
461 /*
462 * If we are currently ignoring this block and we encounter a #else or
463 * #elif, we must ignore their blocks also if the parent block is also
464 * being ignored.
465 */
466 if (Gbl_IgnoringThisCodeBlock)
467 {
468 switch (Directive)
469 {
470 case PR_DIRECTIVE_ELSE:
471 case PR_DIRECTIVE_ELIF:
472
473 if (Gbl_DirectiveStack && Gbl_DirectiveStack->IgnoringThisCodeBlock)
474 {
475 PrDbgPrint ("Ignoring", Gbl_DirectiveInfo[Directive].Name);
476 return;
477 }
478 break;
479
480 default:
481 break;
482 }
483 }
484
485 /*
486 * Need to always check for #else, #elif, #endif regardless of
487 * whether we are ignoring the current code block, since these
488 * are conditional code block terminators.
489 */
490 switch (Directive)
491 {
492 case PR_DIRECTIVE_ELSE:
493
494 Gbl_IgnoringThisCodeBlock = !(Gbl_IgnoringThisCodeBlock);
495 PrDbgPrint ("Executing", "else block");
496 return;
497
498 case PR_DIRECTIVE_ELIF:
499
500 Gbl_IgnoringThisCodeBlock = !(Gbl_IgnoringThisCodeBlock);
501 Directive = PR_DIRECTIVE_IF;
502
503 if (Gbl_IgnoringThisCodeBlock == TRUE)
504 {
505 /* Not executing the ELSE part -- all done here */
506 PrDbgPrint ("Ignoring", "elif block");
507 return;
508 }
509
510 /*
511 * After this, we will execute the IF part further below.
512 * First, however, pop off the original #if directive.
513 */
514 if (ACPI_FAILURE (PrPopDirective ()))
515 {
516 PrError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
517 THIS_TOKEN_OFFSET (DirectiveToken));
518 }
519
520 PrDbgPrint ("Executing", "elif block");
521 break;
522
523 case PR_DIRECTIVE_ENDIF:
524
525 PrDbgPrint ("Executing", "endif");
526
527 /* Pop the owning #if/#ifdef/#ifndef */
528
529 if (ACPI_FAILURE (PrPopDirective ()))
530 {
531 PrError (ASL_ERROR, ASL_MSG_ENDIF_MISMATCH,
532 THIS_TOKEN_OFFSET (DirectiveToken));
533 }
534 return;
535
536 default:
537 break;
538 }
539
540 /* Most directives have at least one argument */
541
542 if (Gbl_DirectiveInfo[Directive].ArgCount == 1)
543 {
544 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
545 if (!Token)
546 {
547 goto SyntaxError;
548 }
549 }
550
551 /*
552 * At this point, if we are ignoring the current code block,
553 * do not process any more directives (i.e., ignore them also.)
554 * For "if" style directives, open/push a new block anyway. We
555 * must do this to keep track of #endif directives
556 */
557 if (Gbl_IgnoringThisCodeBlock)
558 {
559 switch (Directive)
560 {
561 case PR_DIRECTIVE_IF:
562 case PR_DIRECTIVE_IFDEF:
563 case PR_DIRECTIVE_IFNDEF:
564
565 PrPushDirective (Directive, Token);
566 PrDbgPrint ("Ignoring", Gbl_DirectiveInfo[Directive].Name);
567 break;
568
569 default:
570 break;
571 }
572
573 return;
574 }
575
576 /*
577 * Execute the directive
578 */
579 PrDbgPrint ("Begin execution", Gbl_DirectiveInfo[Directive].Name);
580
581 switch (Directive)
582 {
583 case PR_DIRECTIVE_IF:
584
585 TokenOffset = Token - Gbl_MainTokenBuffer;
586
587 /* Need to expand #define macros in the expression string first */
588
589 Status = PrResolveIntegerExpression (
590 &Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
591 if (ACPI_FAILURE (Status))
592 {
593 return;
594 }
595
596 PrPushDirective (Directive, Token);
597 if (!Value)
598 {
599 Gbl_IgnoringThisCodeBlock = TRUE;
600 }
601
602 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
603 "Resolved #if: %8.8X%8.8X %s\n",
604 Gbl_CurrentLineNumber, ACPI_FORMAT_UINT64 (Value),
605 Gbl_IgnoringThisCodeBlock ? "<Skipping Block>" : "<Executing Block>");
606 break;
607
608 case PR_DIRECTIVE_IFDEF:
609
610 PrPushDirective (Directive, Token);
611 if (!PrMatchDefine (Token))
612 {
613 Gbl_IgnoringThisCodeBlock = TRUE;
614 }
615
616 PrDbgPrint ("Evaluated", "ifdef");
617 break;
618
619 case PR_DIRECTIVE_IFNDEF:
620
621 PrPushDirective (Directive, Token);
622 if (PrMatchDefine (Token))
623 {
624 Gbl_IgnoringThisCodeBlock = TRUE;
625 }
626
627 PrDbgPrint ("Evaluated", "ifndef");
628 break;
629
630 case PR_DIRECTIVE_DEFINE:
631 /*
632 * By definition, if first char after the name is a paren,
633 * this is a function macro.
634 */
635 TokenOffset = Token - Gbl_MainTokenBuffer + strlen (Token);
636 if (*(&Gbl_CurrentLineBuffer[TokenOffset]) == '(')
637 {
638 #ifndef MACROS_SUPPORTED
639 AcpiOsPrintf ("%s ERROR - line %u: #define macros are not supported yet\n",
640 Gbl_CurrentLineBuffer, Gbl_CurrentLineNumber);
641 exit(1);
642 #else
643 PrAddMacro (Token, Next);
644 #endif
645 }
646 else
647 {
648 /* Use the remainder of the line for the #define */
649
650 Token2 = *Next;
651 if (Token2)
652 {
653 while ((*Token2 == ' ') || (*Token2 == '\t'))
654 {
655 Token2++;
656 }
657 End = Token2;
658 while (*End != '\n')
659 {
660 End++;
661 }
662 *End = 0;
663 }
664 else
665 {
666 Token2 = "";
667 }
668 #if 0
669 Token2 = PrGetNextToken (NULL, "\n", /*PR_TOKEN_SEPARATORS,*/ Next);
670 if (!Token2)
671 {
672 Token2 = "";
673 }
674 #endif
675 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
676 "New #define: %s->%s\n",
677 Gbl_CurrentLineNumber, Token, Token2);
678
679 PrAddDefine (Token, Token2, FALSE);
680 }
681 break;
682
683 case PR_DIRECTIVE_ERROR:
684
685 /* Note: No macro expansion */
686
687 PrError (ASL_ERROR, ASL_MSG_ERROR_DIRECTIVE,
688 THIS_TOKEN_OFFSET (Token));
689
690 Gbl_SourceLine = 0;
691 Gbl_NextError = Gbl_ErrorLog;
692 CmCleanupAndExit ();
693 exit(1);
694
695 case PR_DIRECTIVE_INCLUDE:
696
697 Token = PrGetNextToken (NULL, " \"<>", Next);
698 if (!Token)
699 {
700 goto SyntaxError;
701 }
702
703 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
704 "Start #include file \"%s\"\n", Gbl_CurrentLineNumber,
705 Token, Gbl_CurrentLineNumber);
706
707 PrOpenIncludeFile (Token);
708 break;
709
710 case PR_DIRECTIVE_LINE:
711
712 TokenOffset = Token - Gbl_MainTokenBuffer;
713
714 Status = PrResolveIntegerExpression (
715 &Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
716 if (ACPI_FAILURE (Status))
717 {
718 return;
719 }
720
721 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
722 "User #line invocation %s\n", Gbl_CurrentLineNumber,
723 Token);
724
725 /* Update local line numbers */
726
727 Gbl_CurrentLineNumber = (UINT32) Value;
728 Gbl_PreviousLineNumber = 0;
729
730 /* Emit #line into the preprocessor file */
731
732 FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
733 Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename);
734 break;
735
736 case PR_DIRECTIVE_PRAGMA:
737
738 if (!strcmp (Token, "disable"))
739 {
740 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
741 if (!Token)
742 {
743 goto SyntaxError;
744 }
745
746 TokenOffset = Token - Gbl_MainTokenBuffer;
747 AslDisableException (&Gbl_CurrentLineBuffer[TokenOffset]);
748 }
749 else if (!strcmp (Token, "message"))
750 {
751 Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, Next);
752 if (!Token)
753 {
754 goto SyntaxError;
755 }
756
757 TokenOffset = Token - Gbl_MainTokenBuffer;
758 AcpiOsPrintf ("%s\n", &Gbl_CurrentLineBuffer[TokenOffset]);
759 }
760 else
761 {
762 PrError (ASL_ERROR, ASL_MSG_UNKNOWN_PRAGMA,
763 THIS_TOKEN_OFFSET (Token));
764 return;
765 }
766
767 break;
768
769 case PR_DIRECTIVE_UNDEF:
770
771 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
772 "#undef: %s\n", Gbl_CurrentLineNumber, Token);
773
774 PrRemoveDefine (Token);
775 break;
776
777 case PR_DIRECTIVE_WARNING:
778
779 PrError (ASL_WARNING, ASL_MSG_WARNING_DIRECTIVE,
780 THIS_TOKEN_OFFSET (Token));
781 break;
782
783 default:
784
785 /* Should never get here */
786 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
787 "Unrecognized directive: %u\n",
788 Gbl_CurrentLineNumber, Directive);
789 break;
790 }
791
792 return;
793
794 SyntaxError:
795
796 PrError (ASL_ERROR, ASL_MSG_DIRECTIVE_SYNTAX,
797 THIS_TOKEN_OFFSET (DirectiveToken));
798 return;
799 }
800
801
802 /*******************************************************************************
803 *
804 * FUNCTION: PrMatchDirective
805 *
806 * PARAMETERS: Directive - Pointer to directive name token
807 *
808 * RETURN: Index into command array, -1 if not found
809 *
810 * DESCRIPTION: Lookup the incoming directive in the known directives table.
811 *
812 ******************************************************************************/
813
814 static int
815 PrMatchDirective (
816 char *Directive)
817 {
818 int i;
819
820
821 if (!Directive || Directive[0] == 0)
822 {
823 return (ASL_DIRECTIVE_NOT_FOUND);
824 }
825
826 for (i = 0; Gbl_DirectiveInfo[i].Name; i++)
827 {
828 if (!strcmp (Gbl_DirectiveInfo[i].Name, Directive))
829 {
830 return (i);
831 }
832 }
833
834 return (ASL_DIRECTIVE_NOT_FOUND); /* Command not recognized */
835 }
836
837
838 /*******************************************************************************
839 *
840 * FUNCTION: PrPushDirective
841 *
842 * PARAMETERS: Directive - Encoded directive ID
843 * Argument - String containing argument to the
844 * directive
845 *
846 * RETURN: None
847 *
848 * DESCRIPTION: Push an item onto the directive stack. Used for processing
849 * nested #if/#else type conditional compilation directives.
850 * Specifically: Used on detection of #if/#ifdef/#ifndef to open
851 * a block.
852 *
853 ******************************************************************************/
854
855 static void
856 PrPushDirective (
857 int Directive,
858 char *Argument)
859 {
860 DIRECTIVE_INFO *Info;
861
862
863 /* Allocate and populate a stack info item */
864
865 Info = ACPI_ALLOCATE (sizeof (DIRECTIVE_INFO));
866
867 Info->Next = Gbl_DirectiveStack;
868 Info->Directive = Directive;
869 Info->IgnoringThisCodeBlock = Gbl_IgnoringThisCodeBlock;
870 strncpy (Info->Argument, Argument, MAX_ARGUMENT_LENGTH);
871
872 DbgPrint (ASL_DEBUG_OUTPUT,
873 "Pr(%.4u) - [%u %s] %*s Pushed [#%s %s]: IgnoreFlag = %s\n",
874 Gbl_CurrentLineNumber, Gbl_IfDepth,
875 Gbl_IgnoringThisCodeBlock ? "I" : "E",
876 Gbl_IfDepth * 4, " ",
877 Gbl_DirectiveInfo[Directive].Name,
878 Argument, Gbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
879
880 /* Push new item */
881
882 Gbl_DirectiveStack = Info;
883 Gbl_IfDepth++;
884 }
885
886
887 /*******************************************************************************
888 *
889 * FUNCTION: PrPopDirective
890 *
891 * PARAMETERS: None
892 *
893 * RETURN: Status. Error if the stack is empty.
894 *
895 * DESCRIPTION: Pop an item off the directive stack. Used for processing
896 * nested #if/#else type conditional compilation directives.
897 * Specifically: Used on detection of #elif and #endif to remove
898 * the original #if/#ifdef/#ifndef from the stack and close
899 * the block.
900 *
901 ******************************************************************************/
902
903 static ACPI_STATUS
904 PrPopDirective (
905 void)
906 {
907 DIRECTIVE_INFO *Info;
908
909
910 /* Check for empty stack */
911
912 Info = Gbl_DirectiveStack;
913 if (!Info)
914 {
915 return (AE_ERROR);
916 }
917
918 /* Pop one item, keep globals up-to-date */
919
920 Gbl_IfDepth--;
921 Gbl_IgnoringThisCodeBlock = Info->IgnoringThisCodeBlock;
922 Gbl_DirectiveStack = Info->Next;
923
924 DbgPrint (ASL_DEBUG_OUTPUT,
925 "Pr(%.4u) - [%u %s] %*s Popped [#%s %s]: IgnoreFlag now = %s\n",
926 Gbl_CurrentLineNumber, Gbl_IfDepth,
927 Gbl_IgnoringThisCodeBlock ? "I" : "E",
928 Gbl_IfDepth * 4, " ",
929 Gbl_DirectiveInfo[Info->Directive].Name,
930 Info->Argument, Gbl_IgnoringThisCodeBlock ? "TRUE" : "FALSE");
931
932 ACPI_FREE (Info);
933 return (AE_OK);
934 }
935
936
937 /*******************************************************************************
938 *
939 * FUNCTION: PrDbgPrint
940 *
941 * PARAMETERS: Action - Action being performed
942 * DirectiveName - Directive being processed
943 *
944 * RETURN: None
945 *
946 * DESCRIPTION: Special debug print for directive processing.
947 *
948 ******************************************************************************/
949
950 static void
951 PrDbgPrint (
952 char *Action,
953 char *DirectiveName)
954 {
955
956 DbgPrint (ASL_DEBUG_OUTPUT, "Pr(%.4u) - [%u %s] "
957 "%*s %s #%s, Depth %u\n",
958 Gbl_CurrentLineNumber, Gbl_IfDepth,
959 Gbl_IgnoringThisCodeBlock ? "I" : "E",
960 Gbl_IfDepth * 4, " ",
961 Action, DirectiveName, Gbl_IfDepth);
962 }