]> git.proxmox.com Git - mirror_edk2.git/blob - EdkCompatibilityPkg/Sample/Tools/Source/VfrCompile/VfrCompile.g
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Sync all bug fixes between EDK1.04 and EDK1.06 into EdkCompatibilityPkg.
[mirror_edk2.git] / EdkCompatibilityPkg / Sample / Tools / Source / VfrCompile / VfrCompile.g
1 /*++
2
3 Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
4 This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 VfrCompile.g
15
16 Abstract:
17
18 PCCTS parser and lexer definitions for the EFI VFR forms compiler
19
20 --*/
21
22 #header<<
23
24 #include "Tiano.h"
25 #include "EfiUtilityMsgs.h"
26 #include "EfiVfr.h"
27 #include "VfrServices.h"
28 #include EFI_PROTOCOL_DEFINITION (Hii)
29
30 #include <ctype.h>
31 #include <direct.h>
32 #include <process.h> // for spawn functions
33
34 >>
35
36 <<
37
38 //
39 // Base info for DLG-generated scanner
40 //
41 #include "DLexerBase.h"
42
43 //
44 // Include the scanner file generated by DLG
45 //
46 #include "DLGLexer.h"
47
48 class DLGLexerVfr : public DLGLexer
49 {
50 public:
51 DLGLexerVfr (DLGFileInput *F) : DLGLexer (F) {};
52 INT32 errstd (char *Text)
53 {
54 printf ("unrecognized input '%s'\n", Text);
55 }
56 };
57
58 //
59 // Base token definitions for ANTLR
60 //
61 #include "AToken.h"
62
63 //
64 // This is how we invoke the C preprocessor on the VFR source file
65 // to resolve #defines, #includes, etc. To make C source files
66 // shareable between VFR and drivers, define VFRCOMPILE so that
67 // #ifdefs can be used in shared .h files.
68 //
69 #define PREPROCESSOR_COMMAND "cl.exe "
70 #define PREPROCESSOR_OPTIONS "/nologo /E /TC /DVFRCOMPILE "
71
72 typedef ANTLRCommonToken ANTLRToken;
73
74 //
75 // Specify the filename extensions for the files we generate.
76 //
77 #define VFR_BINARY_FILENAME_EXTENSION ".c"
78 #define VFR_LIST_FILENAME_EXTENSION ".lst"
79 #define VFR_PREPROCESS_FILENAME_EXTENSION ".i"
80
81 static
82 VOID
83 Usage ();
84
85 static
86 STATUS
87 ProcessArgs (
88 int Argc,
89 char *Argv[]
90 );
91
92 static
93 VOID
94 Cleanup ();
95
96 //
97 // Globals
98 //
99 OPTIONS gOptions;
100
101 int
102 main (
103 int argc,
104 char **argv
105 )
106 /*++
107
108 Routine Description:
109 Application entry point function. Parse command-line arguments,
110 invoke the parser, clean up, and return.
111
112 Arguments:
113 argc - standard argc passed to main() per C conventions
114 argv - standard argv passed to main() per C conventions
115
116 Returns:
117 STATUS_SUCCESS - program executed with no errors or warnings
118 STATUS_WARNING - program executed with warnings
119 STATUS_ERROR - non-recoverable errors encountered while processing
120
121 --*/
122 {
123 FILE *VfrFptr;
124 char *Cmd;
125 char *Cptr;
126 int Len;
127 STATUS Status;
128
129 //
130 // Set our program name for the error printing routines.
131 // Then set printing limits.
132 //
133 SetUtilityName (UTILITY_NAME);
134 SetPrintLimits (20, 20, 30);
135 //
136 // Process the command-line arguments
137 //
138 if (ProcessArgs (argc, argv) != STATUS_SUCCESS) {
139 Usage ();
140 Cleanup();
141 return STATUS_ERROR;
142 }
143 VfrFptr = NULL;
144 //
145 // Verify the VFR script file exists
146 //
147 if ((VfrFptr = fopen (gOptions.VfrFileName, "r")) == NULL) {
148 Error (UTILITY_NAME, 0, 0, gOptions.VfrFileName, "could not open input VFR file");
149 Cleanup();
150 return STATUS_ERROR;
151 }
152 //
153 // Now close the file and make a system call to run the preprocessor
154 // on it.
155 //
156 fclose (VfrFptr);
157 Len = strlen (PREPROCESSOR_OPTIONS) + strlen (gOptions.VfrFileName) + 10 +
158 strlen (PREPROCESSOR_COMMAND) + strlen (gOptions.PreprocessorOutputFileName);
159 if (gOptions.CPreprocessorOptions != NULL) {
160 Len += strlen (gOptions.CPreprocessorOptions) + 1;
161 }
162 if (gOptions.IncludePaths != NULL) {
163 Len += strlen (gOptions.IncludePaths) + 1;
164 }
165 Cmd = (char *)malloc (Len);
166 if (Cmd == NULL) {
167 Error (UTILITY_NAME, 0, 0, NULL, "could not allocate memory");
168 Cleanup();
169 return STATUS_ERROR;
170 }
171 strcpy (Cmd, PREPROCESSOR_COMMAND PREPROCESSOR_OPTIONS);
172 if (gOptions.IncludePaths != NULL) {
173 strcat (Cmd, gOptions.IncludePaths);
174 strcat (Cmd, " ");
175 }
176 if (gOptions.CPreprocessorOptions != NULL) {
177 strcat (Cmd, gOptions.CPreprocessorOptions);
178 strcat (Cmd, " ");
179 }
180 strcat (Cmd, gOptions.VfrFileName);
181 strcat (Cmd, " > ");
182 strcat (Cmd, gOptions.PreprocessorOutputFileName);
183 Status = system (Cmd);
184 if (Status != 0) {
185 Error (UTILITY_NAME, 0, 0, gOptions.VfrFileName, "failed to spawn C preprocessor on VFR file");
186 printf ("Command: '%s %s'\n", PREPROCESSOR_COMMAND, Cmd);
187 Cleanup();
188 return STATUS_ERROR;
189 }
190 free (Cmd);
191 //
192 // Open the preprocessor output file
193 //
194 if ((VfrFptr = fopen (gOptions.PreprocessorOutputFileName, "r")) == NULL) {
195 Error (UTILITY_NAME, 0, 0, "failed to open input VFR preprocessor output file",
196 gOptions.PreprocessorOutputFileName);
197 Cleanup();
198 return STATUS_ERROR;
199 }
200 //
201 // Define input VFR file
202 //
203 DLGFileInput InputFile (VfrFptr);
204 //
205 // Define an instance of the scanner
206 //
207 DLGLexerVfr Scanner (&InputFile);
208 //
209 // Define token buffer between scanner and parser
210 //
211 ANTLRTokenBuffer Pipe (&Scanner);
212 //
213 // Create a token to use as a model
214 //
215 ANTLRToken Tok;
216 //
217 // Tell the scanner what type the token is
218 //
219 Scanner.setToken (&Tok);
220 //
221 // Create an instance of our parser
222 //
223 EfiVfrParser Parser (&Pipe);
224 //
225 // Initialize the parser
226 //
227 Parser.init ();
228 Status = GetUtilityStatus ();
229 if (Status != STATUS_SUCCESS) {
230 Cleanup();
231 return Status;
232 }
233 //
234 // Start the first rule
235 //
236 Parser.program ();
237 //
238 // Close the input script file
239 //
240 fclose (VfrFptr);
241 Parser.WriteIfrBytes ();
242 //
243 // Call cleanup, which does some extra checking of the script
244 //
245 Parser.Cleanup ();
246 Cleanup();
247 //
248 // If we had an error somewhere, delete our output files so that
249 // a subsequent build will rebuild them.
250 //
251 Status = GetUtilityStatus ();
252 if (Status == STATUS_ERROR) {
253 remove (gOptions.IfrOutputFileName);
254 }
255 return Status;
256 }
257 static
258 VOID
259 Cleanup ()
260 /*++
261
262 Routine Description:
263 Free up memory allocated during parsing.
264
265 Arguments:
266 None
267
268 Returns:
269 None
270
271 --*/
272 {
273 //
274 // Free up our string we allocated to track the include paths
275 //
276 if (gOptions.IncludePaths != NULL) {
277 free (gOptions.IncludePaths);
278 gOptions.IncludePaths = NULL;
279 }
280 //
281 // Free up our string we allocated to track preprocessor options
282 //
283 if (gOptions.CPreprocessorOptions != NULL) {
284 free (gOptions.CPreprocessorOptions);
285 gOptions.CPreprocessorOptions = NULL;
286 }
287 }
288
289 static
290 STATUS
291 ProcessArgs (
292 int Argc,
293 char *Argv[]
294 )
295 /*++
296
297 Routine Description:
298 Process the command-line arguments.
299
300 Arguments:
301 Argc - standard argc passed to main()
302 Argv - standard argv passed to main()
303
304 Returns:
305 STATUS_SUCCESS - program should continue (all args ok)
306
307 --*/
308 {
309 char *IncludePaths;
310 char *CPreprocessorOptions;
311 int Len;
312 char CopyStr[MAX_PATH];
313 char *Cptr;
314
315 //
316 // Put options in known state.
317 //
318 memset ((char *)&gOptions, 0, sizeof (OPTIONS));
319 //
320 // Go through all the arguments that start with '-'
321 //
322 Argc--;
323 Argv++;
324 while ((Argc > 0) && (Argv[0][0] == '-')) {
325 //
326 // -? or -h help option -- return an error for printing usage
327 //
328 if ((_stricmp (Argv[0], "-?") == 0) || (_stricmp (Argv[0], "-h") == 0)) {
329 return STATUS_ERROR;
330 break;
331 //
332 // -l to create a listing output file
333 //
334 } else if (_stricmp (Argv[0], "-l") == 0) {
335 gOptions.CreateListFile = 1;
336 //
337 // -I include_path option for finding include files. We'll pass this
338 // to the preprocessor. Turn them all into a single include string.
339 //
340 } else if (_stricmp (Argv[0], "-i") == 0) {
341 if ((Argc < 2) || (Argv[1][0] == '-')) {
342 Error (UTILITY_NAME, 0, 0, Argv[0], "missing path argument");
343 return STATUS_ERROR;
344 }
345 Argc--;
346 Argv++;
347 Len = strlen (" -I ");
348 Len += strlen (Argv[0]) + 2;
349 if (gOptions.IncludePaths != NULL) {
350 Len += strlen (gOptions.IncludePaths);
351 }
352 IncludePaths = (INT8 *)malloc (Len);
353 if (IncludePaths == NULL) {
354 Error (UTILITY_NAME, 0, 0, NULL, "memory allocation failure");
355 return STATUS_ERROR;
356 }
357 IncludePaths[0] = 0;
358 if (gOptions.IncludePaths != NULL) {
359 strcpy (IncludePaths, gOptions.IncludePaths);
360 free (gOptions.IncludePaths);
361 }
362 strcat (IncludePaths, " -I ");
363 strcat (IncludePaths, Argv[0]);
364 gOptions.IncludePaths = IncludePaths;
365 //
366 // -od OutputDirectory to define a common directory for output files
367 //
368 } else if (_stricmp (Argv[0], "-od") == 0) {
369 if ((Argc < 2) || (Argv[1][0] == '-')) {
370 Error (UTILITY_NAME, 0, 0, Argv[0], "missing output directory name");
371 return STATUS_ERROR;
372 }
373 Argc--;
374 Argv++;
375 strcpy (gOptions.OutputDirectory, Argv[0]);
376 } else if (_stricmp (Argv[0], "-ibin") == 0) {
377 gOptions.CreateIfrBinFile = 1;
378 } else if (_stricmp (Argv[0], "-nostrings") == 0) {
379 // deprecated option
380 //
381 // -ppflag C-preprocessor-flag option for passing options to the C preprocessor.
382 // Turn them all into a single string.
383 //
384 } else if (_stricmp (Argv[0], "-ppflag") == 0) {
385 if (Argc < 2) {
386 Error (UTILITY_NAME, 0, 0, Argv[0], "missing C-preprocessor argument");
387 return STATUS_ERROR;
388 }
389 Argc--;
390 Argv++;
391 Len = strlen (Argv[0]) + 2;
392 if (gOptions.CPreprocessorOptions != NULL) {
393 Len += strlen (gOptions.CPreprocessorOptions);
394 }
395 CPreprocessorOptions = (INT8 *)malloc (Len);
396 if (CPreprocessorOptions == NULL) {
397 Error (UTILITY_NAME, 0, 0, NULL, "memory allocation failure");
398 return STATUS_ERROR;
399 }
400 CPreprocessorOptions[0] = 0;
401 if (gOptions.CPreprocessorOptions != NULL) {
402 strcpy (CPreprocessorOptions, gOptions.CPreprocessorOptions);
403 free (gOptions.CPreprocessorOptions);
404 }
405 strcat (CPreprocessorOptions, " ");
406 strcat (CPreprocessorOptions, Argv[0]);
407 gOptions.CPreprocessorOptions = CPreprocessorOptions;
408 } else {
409 Error (UTILITY_NAME, 0, 0, Argv[0], "unrecognized option");
410 return STATUS_ERROR;
411 }
412 Argc--;
413 Argv++;
414 }
415 //
416 // Must specify at least the vfr file name
417 //
418 if (Argc > 1) {
419 Error (UTILITY_NAME, 0, 0, Argv[1], "unrecognized argument after VFR file name");
420 return STATUS_ERROR;
421 } else if (Argc < 1) {
422 Error (UTILITY_NAME, 0, 0, NULL, "must specify VFR file name");
423 return STATUS_ERROR;
424 }
425 strcpy (gOptions.VfrFileName, Argv[0]);
426
427 strcpy (CopyStr, gOptions.VfrFileName);
428 Cptr = CopyStr + strlen (CopyStr) - 1;
429 for (;(Cptr > CopyStr) && (*Cptr != '\\') && (*Cptr != ':'); Cptr--);
430 if (Cptr == CopyStr) {
431 strcpy (gOptions.VfrBaseFileName, Cptr);
432 } else {
433 strcpy (gOptions.VfrBaseFileName, Cptr+1);
434 }
435 //
436 // Terminate the vfr file basename at the extension
437 //
438 for (Cptr = gOptions.VfrBaseFileName; *Cptr && (*Cptr != '.'); Cptr++) {
439 }
440 *Cptr = 0;
441 //
442 // If they defined an output directory, prepend all output files
443 // with the working directory. Output files of interest:
444 // VfrListFileName -- list file
445 // IfrOutputFileName -- IFR bytes
446 // StringOutputFileName -- string bytes
447 // StringListFileName -- not used
448 // StringDefineFileName -- #defines of string identifiers
449 //
450 // We have two cases:
451 // 1. Output directory (-od) not specified, in which case output files
452 // go to the current working directory.
453 // 2. Output directory specified, in which case the output files
454 // go directly to the specified directory.
455 //
456 if (gOptions.OutputDirectory[0] == 0) {
457 CopyStr[0] = 0;
458 _getcwd (CopyStr, sizeof (CopyStr));
459 strcpy (gOptions.OutputDirectory, CopyStr);
460 }
461 //
462 // Make sure output directory has a trailing backslash
463 //
464 if (gOptions.OutputDirectory[strlen (gOptions.OutputDirectory) - 1] != '\\') {
465 strcat (gOptions.OutputDirectory, "\\");
466 }
467 //
468 // Create the base output file name as: path\base, copy it to all the output
469 // filenames, and then add the appropriate extension to each.
470 //
471 strcpy (gOptions.VfrListFileName, gOptions.OutputDirectory);
472 strcat (gOptions.VfrListFileName, gOptions.VfrBaseFileName);
473 strcpy (gOptions.IfrOutputFileName, gOptions.VfrListFileName);
474 strcpy (gOptions.PreprocessorOutputFileName, gOptions.VfrListFileName);
475 strcat (gOptions.VfrListFileName, VFR_LIST_FILENAME_EXTENSION);
476 strcat (gOptions.IfrOutputFileName, VFR_BINARY_FILENAME_EXTENSION);
477 strcat (gOptions.PreprocessorOutputFileName, VFR_PREPROCESS_FILENAME_EXTENSION);
478
479 //
480 // We set a default list file name, so if they do not
481 // want a list file, null out the name now.
482 //
483 if (gOptions.CreateListFile == 0) {
484 gOptions.VfrListFileName[0] = 0;
485 }
486 return STATUS_SUCCESS;
487 }
488 static
489 VOID
490 Usage ()
491 /*++
492
493 Routine Description:
494 Print utility usage instructions
495
496 Arguments:
497 None
498
499 Returns:
500 None
501
502 --*/
503 {
504 int Index;
505 const char *Str[] = {
506 UTILITY_NAME" "UTILITY_VERSION" - Intel VFR Compiler Utility",
507 " Copyright (C), 2004 - 2008 Intel Corporation",
508 #if ( defined(UTILITY_BUILD) && defined(UTILITY_VENDOR) )
509 " Built from "UTILITY_BUILD", project of "UTILITY_VENDOR,
510 #endif
511 "",
512 "Usage:",
513 " "UTILITY_NAME" [OPTION] VFRFILE",
514 "Description:",
515 " Compile VFRFILE.",
516 "Options:",
517 " -? or -h print this help",
518 " -l create an output IFR listing file",
519 " -i IncPath add IncPath to the search path for VFR included files",
520 " -od OutputDir deposit all output files to directory OutputDir (default=cwd)",
521 " -ibin create an IFR HII pack file",
522 " -ppflag CFlags pass Flags as C-preprocessor-flag",
523 " -v or -version print version information",
524 NULL
525 };
526
527 for (Index = 0; Str[Index] != NULL; Index++) {
528 fprintf (stdout, "%s\n", Str[Index]);
529 }
530 }
531
532 >>
533
534
535 #lexaction
536 <<
537
538 #include "EfiVfr.h"
539
540 PARSER_LINE_DEFINITION *gLineDefinition = NULL;
541 PARSER_LINE_DEFINITION *gLastLineDefinition = NULL;
542
543 VOID
544 AddFileLine (
545 char *TokenString,
546 UINT32 TokenLine
547 )
548 /*++
549
550 Routine Description:
551 During the lexer phase, if we encounter a #line statement output by
552 the preprocessor, this function gets called. We'll save off the info
553 for error reporting purposes. The preprocessor line information has the
554 form:
555
556 #line 3 "FileName.c"
557
558 Arguments:
559 TokenString - the parsed string as shown above
560 TokenLine - the line number in the preprocessed output file
561
562 Returns:
563 NA
564
565 --*/
566 {
567 PARSER_LINE_DEFINITION *LineDef;
568 INT8 *Cptr;
569
570 //
571 // Allocate a structure in which we can keep track of this line information.
572 //
573 LineDef = (PARSER_LINE_DEFINITION *)malloc (sizeof (PARSER_LINE_DEFINITION));
574 memset ((char *)LineDef, 0, sizeof (PARSER_LINE_DEFINITION));
575 LineDef->TokenLineNum = TokenLine;
576 LineDef->HashLineNum = atoi (TokenString + 6);
577 //
578 // Find the quotes in the filename, then allocate space in the line
579 // def structure for a copy of the filename. Finally, copy it without
580 // quotes to the line def.
581 //
582 for (Cptr = TokenString + 7; *Cptr && (*Cptr != '"'); Cptr++);
583 if (*Cptr == '"') {
584 LineDef->FileName = (INT8 *)malloc (strlen (Cptr));
585 Cptr++;
586 strcpy (LineDef->FileName, Cptr);
587 for (Cptr = LineDef->FileName; *Cptr && (*Cptr != '"'); Cptr++);
588 *Cptr = 0;
589 //
590 // Now add this new one to the list
591 //
592 if (gLineDefinition == NULL) {
593 gLineDefinition = LineDef;
594 } else {
595 gLastLineDefinition->Next = LineDef;
596 }
597 gLastLineDefinition = LineDef;
598 } else {
599 Error (UTILITY_NAME, 0, 0, "invalid line definition in preprocessor output file", TokenString);
600 free (LineDef);
601 return;
602 }
603 }
604 char *
605 ConvertLineNumber (
606 UINT32 *LineNum
607 )
608 /*++
609
610 Routine Description:
611 Given the line number in the preprocessor-output file, use the line number
612 information we've saved to determine the source file name and line number
613 where the code originally came from. This is required for error reporting.
614
615 Arguments:
616 LineNum - the line number in the preprocessor-output file.
617
618 Returns:
619 Returns a pointer to the source file name. Also returns the line number
620 in the provided LineNum argument
621
622 --*/
623 {
624 PARSER_LINE_DEFINITION *LineDef;
625 //
626 // Step through our linked list of #line information we saved off.
627 // For each one, look at its line number, and the line number of the
628 // next record, and see if the passed-in line number is in the range.
629 // If it is, then convert the line number to the appropriate line number
630 // of the original source file.
631 //
632 for (LineDef = gLineDefinition; LineDef != NULL; LineDef = LineDef->Next) {
633 //
634 // The given LineNum is the line number from the .i file.
635 // Find a line definition whose range includes this line number,
636 // convert the line number, and return the filename.
637 //
638 if (LineDef->TokenLineNum <= *LineNum) {
639 if (LineDef->Next != NULL) {
640 if (LineDef->Next->TokenLineNum > *LineNum) {
641 *LineNum = *LineNum - LineDef->TokenLineNum + LineDef->HashLineNum;
642 return LineDef->FileName;
643 }
644 } else {
645 //
646 // Last one in the list of line definitions, so has to be right
647 //
648 *LineNum = *LineNum - LineDef->TokenLineNum + LineDef->HashLineNum;
649 return LineDef->FileName;
650 }
651 }
652 }
653 return NULL;
654 }
655
656 >>
657
658 //
659 // Define a lexical class for parsing quoted strings. Basically
660 // starts with a double quote, and ends with a double quote that
661 // is not preceeded with a backslash.
662 //
663 #lexclass QUOTED_STRING
664 #token TheString "~[\"]*\"" << mode (START); >>
665
666 //
667 // Define a lexical class for parsing "#pragma pack" statements.
668 // We do this just for convenience (since we skip them here) so
669 // that users can include some minimal .h files.
670 //
671 #lexclass PRAGMA_PACK
672 #token "pack" << skip (); >>
673 #token "[\ \t]" << skip (); >>
674 #token "\(" << skip (); >>
675 #token "[0-9]*" << skip (); >>
676 #token "\)" << skip (); mode (START); >>
677
678 //
679 // Define a lexclass for skipping over C++ style comments
680 //
681 #lexclass CPP_COMMENT
682 #token "~[\n]*" << skip (); >>
683 #token "\n" << skip (); mode (START); newline (); >>
684
685 //
686 // Standard lexclass is START
687 //
688 #lexclass START
689
690 //
691 // Find start of C++ style comments
692 //
693 #token "//" << skip (); mode (CPP_COMMENT); >>
694
695 //
696 // Skip whitespace
697 //
698 #token "[\ \t]" << skip (); >>
699
700 //
701 // Skip over newlines, but count them
702 //
703 #token "\n" << skip (); newline (); >>
704
705 //
706 // Skip pragma pack statements
707 //
708 #token "\#pragma" << skip (); mode(PRAGMA_PACK); >>
709
710 //
711 // Skip over 'extern' in any included .H file
712 //
713 #token "extern" << skip (); >>
714
715 //
716 // Tokens for the different keywords. Syntax is:
717 // TokenName("ErrorMessageText") "TokenString"
718 // where:
719 // TokenName is the token name (must be capitalized) that is used in the rules
720 // ErrorMessageText is the string the compiler emits when it detects a syntax error
721 // TokenString is the actual matching string used in the user script
722 //
723 #token LineDefinition "#line\ [0-9]+\ \"~[\"]+\"[\ \t]*\n" << AddFileLine (begexpr (), line ()); skip (); >>
724 #token FormSet("formset") "formset"
725 #token EndFormSet("endformset") "endformset"
726 #token Title("title") "title"
727 #token FormId("formid") "formid"
728 #token OneOf("oneof") "oneof"
729 #token Prompt("prompt") "prompt"
730 #token OrderedList("orderedlist") "orderedlist"
731 #token EndList("endlist") "endlist"
732 #token EndForm("endform") "endform"
733 #token EndOneOf("endoneof") "endoneof"
734 #token Form("form") "form"
735 #token Subtitle("subtitle") "subtitle"
736 #token Help("help") "help"
737 #token VarId("varid") "varid"
738 #token Text("text") "text"
739 #token Option("option") "option"
740 #token Value("value") "value"
741 #token Flags("flags") "flags"
742 #token Date("date") "date"
743 #token EndDate("enddate") "enddate"
744 #token Year("year") "year"
745 #token Month("month") "month"
746 #token Day("day") "day"
747 #token Time("time") "time"
748 #token EndTime("endtime") "endtime"
749 #token Hour("hour") "hour"
750 #token Minute("minute") "minute"
751 #token Second("second") "second"
752 #token AND("AND") "AND"
753 #token OR("OR") "OR"
754 #token GrayOutIf("grayoutif") "grayoutif"
755 #token NOT("NOT") "NOT"
756 #token Label("label") "label"
757 #token Timeout("timeout") "timeout"
758 #token Inventory("inventory") "inventory"
759 #token StringToken("STRING_TOKEN") "STRING_TOKEN"
760 #token NonNvDataMap("_NON_NV_DATA_MAP") "_NON_NV_DATA_MAP"
761 #token Struct("struct") "struct"
762 #token Uint64("UINT64") "UINT64"
763 #token Uint32("UINT32") "UINT32"
764 #token Uint16("UINT16") "UINT16"
765 #token Char16("CHAR16") "CHAR16"
766 #token Uint8("UINT8") "UINT8"
767 #token Guid("guid") "guid"
768 #token CheckBox("checkbox") "checkbox"
769 #token EndCheckBox("endcheckbox") "endcheckbox"
770 #token Numeric("numeric") "numeric"
771 #token EndNumeric("endnumeric") "endnumeric"
772 #token Minimum("minimum") "minimum"
773 #token Maximum("maximum") "maximum"
774 #token Step("step") "step"
775 #token Default("default") "default"
776 #token Password("password") "password"
777 #token EndPassword("endpassword") "endpassword"
778 #token String("string") "string"
779 #token EndString("endstring") "endstring"
780 #token MinSize("minsize") "minsize"
781 #token MaxSize("maxsize") "maxsize"
782 #token Encoding("encoding") "encoding"
783 #token SuppressIf("suppressif") "suppressif"
784 #token Hidden("hidden") "hidden"
785 #token Goto("goto") "goto"
786 #token InconsistentIf "inconsistentif"
787 #token EndIf("endif") "endif"
788 #token IdEqId("ideqid") "ideqid"
789 #token IdEqVal("ideqval") "ideqval"
790 #token VarEqVal("vareqval") "vareqval"
791 #token Var("var") "var"
792 #token IdEqValList("ideqvallist") "ideqvallist"
793 #token Length("length") "length"
794 #token Values("values") "values"
795 #token Key("key") "key"
796 #token DefaultFlag("DEFAULT") "DEFAULT"
797 #token ManufacturingFlag("MANUFACTURING") "MANUFACTURING"
798 #token InteractiveFlag("INTERACTIVE") "INTERACTIVE"
799 #token NVAccessFlag("NV_ACCESS") "NV_ACCESS"
800 #token ResetRequiredFlag("RESET_REQUIRED") "RESET_REQUIRED"
801 #token LateCheckFlag("LATE_CHECK") "LATE_CHECK"
802 #token Class("class") "class"
803 #token Subclass("subclass") "subclass"
804 #token TypeDef("typedef") "typedef"
805 #token Restore("restore") "restore"
806 #token Save("save") "save"
807 #token Defaults("defaults") "defaults"
808 #token Banner("banner") "banner"
809 #token Align("align") "align"
810 #token Left("left") "left"
811 #token Right("right") "right"
812 #token Center("center") "center"
813 #token Line("line") "line"
814 #token VarStore("varstore") "varstore"
815 #token Name("name") "name"
816 #token Oem("oem") "oem"
817 #token True("TRUE") "TRUE"
818 #token False("FALSE") "FALSE"
819 #token GreaterThan(">") ">"
820 #token GreaterEqual(">=") ">="
821 #token LessThan("<") "<"
822 #token LessEqual("<=") "<="
823
824 //
825 // Define the class and subclass tokens
826 //
827 #token ClassNonDevice("NONDEVICE") "NON_DEVICE"
828 #token ClassDiskDevice("DISK_DEVICE") "DISK_DEVICE"
829 #token ClassVideoDevice("VIDEO_DEVICE") "VIDEO_DEVICE"
830 #token ClassNetworkDevice("NETWORK_DEVICE") "NETWORK_DEVICE"
831 #token ClassInputDevice("INPUT_DEVICE") "INPUT_DEVICE"
832 #token ClassOnBoardDevice("ONBOARD_DEVICE") "ONBOARD_DEVICE"
833 #token ClassOtherDevice("OTHER_DEVICE") "OTHER_DEVICE"
834
835 #token SubclassSetupApplication("SETUP_APPLICATION") "SETUP_APPLICATION"
836 #token SubclassGeneralApplication("GENERAL_APPLICATION") "GENERAL_APPLICATION"
837 #token SubclassFrontPage("FRONT_PAGE") "FRONT_PAGE"
838 #token SubclassSingleUse("SINGLE_USE") "SINGLE_USE"
839
840 #token LanguageIdentifier("language identifier") "[a-z][a-z][a-z]" // 3 lowercase characters
841 #token StringIdentifier("string identifier") "[A-Za-z_][A-Za-z_0-9]*"
842 #token Number("numeric value") "(0x[0-9A-Fa-f]+) | [0-9]+"
843 #token OpenBrace("{") "\{"
844 #token CloseBrace("}") "\}"
845 #token OpenParen("(") "\("
846 #token CloseParen(")") "\)"
847 #token OpenBracket("[") "\["
848 #token CloseBracket("]") "\]"
849
850 //
851 // Define all other invalid characters so that they get through the lexical phase
852 // and we can catch them during the parse phase. We get much better error
853 // messages then.
854 //
855 #token InvalidCharacters("invalid characters") "~[;:=,\.\|]"
856
857 //
858 // This is the overall definition of a VFR form definition script.
859 //
860 program :
861 ( dataStructDefinition )*
862 formSetStatement
863 ( vfrStatementVarStore )*
864 ( formDefinition )*
865 EFS:EndFormSet ";" << WriteOpByte (EFS->getLine(), EFI_IFR_END_FORM_SET_OP); >>
866 "@" // end of file
867 ;
868
869 formSetStatement :
870 FS:FormSet << WriteOpByte (FS->getLine(), EFI_IFR_FORM_SET_OP); >>
871 Guid "="
872 OpenBrace
873 G1:Number ","
874 G2:Number ","
875 G3:Number ","
876 G4:Number ","
877 G5:Number ","
878 G6:Number ","
879 G7:Number ","
880 G8:Number ","
881 G9:Number ","
882 G10:Number ","
883 G11:Number
884 CloseBrace << WriteGuidValue (G1->getLine (), G1->getText (), G2->getText (), G3->getText (),
885 G4->getText (), G5->getText (), G6->getText (), G7->getText (),
886 G8->getText (), G9->getText (), G10->getText (), G11->getText ()
887 );
888 >>
889 ","
890 Title "=" getStringId ","
891 Help "=" getStringId ","
892 //
893 // insert padding for an EFI_PHYSICAL_ADDRESS (UINT64)
894 //
895 << WriteDWord (0, 0); WriteDWord (0, 0); >>
896 Class "=" CVAL:classDefinition "," << WriteClass (); >>
897 Subclass "=" SVAL:subclassDefinition "," << WriteSubclass (); >>
898 << WriteWord (mNvDataStructSize); >>
899 ;
900
901 //
902 // A form can be of multiple classes, thus allow CLASS_A | CLASS_B | CLASS_C
903 //
904 classDefinition :
905 validClassNames ( "\|" validClassNames )*
906 ;
907
908 validClassNames :
909 CND:ClassNonDevice << SetClass (CND->getLine(), EFI_NON_DEVICE_CLASS); >>
910 | CDD:ClassDiskDevice << SetClass (CDD->getLine(), EFI_DISK_DEVICE_CLASS); >>
911 | CVD:ClassVideoDevice << SetClass (CVD->getLine(), EFI_VIDEO_DEVICE_CLASS); >>
912 | CNW:ClassNetworkDevice << SetClass (CNW->getLine(), EFI_NETWORK_DEVICE_CLASS); >>
913 | CID:ClassInputDevice << SetClass (CID->getLine(), EFI_INPUT_DEVICE_CLASS); >>
914 | COB:ClassOnBoardDevice << SetClass (COB->getLine(), EFI_ON_BOARD_DEVICE_CLASS); >>
915 | COD:ClassOtherDevice << SetClass (COD->getLine(), EFI_OTHER_DEVICE_CLASS); >>
916 | CNUM:Number << SetClass (CNUM->getLine(), GetNumber (CNUM->getText(), CNUM->getLine(), 4)); >>
917 ; << PrintErrorMessage (LT(1)->getLine(), LT(1)->getText(), "invalid class"); >>
918
919 //
920 // A form can only be of one subclass type.
921 //
922 subclassDefinition :
923 SSA:SubclassSetupApplication << SetSubclass (SSA->getLine(), EFI_SETUP_APPLICATION_SUBCLASS); >>
924 | SGA:SubclassGeneralApplication << SetSubclass (SGA->getLine(), EFI_GENERAL_APPLICATION_SUBCLASS); >>
925 | SFP:SubclassFrontPage << SetSubclass (SFP->getLine(), EFI_FRONT_PAGE_SUBCLASS); >>
926 | SSU:SubclassSingleUse << SetSubclass (SSU->getLine(), EFI_SINGLE_USE_SUBCLASS); >>
927 | SNUM:Number << SetSubclass (SNUM->getLine(), GetNumber (SNUM->getText(), SNUM->getLine(), 4)); >>
928 ; << PrintErrorMessage (LT(1)->getLine(), LT(1)->getText(), "invalid subclass"); >>
929
930 //
931 // Parse a C type data structure for storing VFR setup data. Allow:
932 // typedef struct _XXX_ {
933 // (fields)
934 // } MY_NV_DATA;
935 //
936 dataStructDefinition :
937 << int IsNonNV = 0; >>
938 { TypeDef }
939 S:Struct
940 (
941 NonNvDataMap << IsNonNV = 1; >>
942 |
943 { StringIdentifier }
944 ) << StartStructDefinition (IsNonNV, S->getLine()); >>
945 OpenBrace
946 dataStructFields
947 CloseBrace NAME:StringIdentifier << EndStructDefinition (NAME->getText(), NAME->getLine()); >>
948 ";"
949 ;
950
951 dataStructFields :
952 ( dataStructField64 | dataStructField32 | dataStructField16 | dataStructField8 ) *
953 ;
954
955 //*****************************************************************************
956 //
957 // PARSE:
958 // UINT64 Name[4];
959 // UINT64 Name;
960 //
961 // Used while parsing the NV data map structures.
962 //
963 dataStructField64 :
964 << int ArrayLength = 1; char IsArray = 0; >>
965 "UINT64"
966 NAME:StringIdentifier
967 ( ";" | OpenBracket IVal:Number CloseBracket ";" << ArrayLength = GetNumber (IVal->getText(), IVal->getLine(), 4); IsArray = 1; >> )
968 << AddStructField (NAME->getText(), NAME->getLine(), 8, ArrayLength, IsArray); >>
969 ;
970
971 //*****************************************************************************
972 //
973 // PARSE:
974 // UINT32 Name[4];
975 // UINT32 Name;
976 //
977 // Used while parsing the NV data map structures.
978 //
979 dataStructField32 :
980 << int ArrayLength = 1; char IsArray = 0; >>
981 "UINT32"
982 NAME:StringIdentifier
983 ( ";" | OpenBracket IVal:Number CloseBracket ";" << ArrayLength = GetNumber (IVal->getText(), IVal->getLine(), 4); IsArray = 1; >> )
984 << AddStructField (NAME->getText(), NAME->getLine(), 4, ArrayLength, IsArray); >>
985 ;
986
987 //*****************************************************************************
988 //
989 // PARSE:
990 // UINT16 Name[4];
991 // UINT16 Name;
992 //
993 // Used while parsing the NV data map structures.
994 //
995 dataStructField16 :
996 << int ArrayLength = 1; char IsArray = 0; >>
997 ( "UINT16" | "CHAR16" )
998 NAME:StringIdentifier
999 ( ";" | OpenBracket IVal:Number CloseBracket ";" << ArrayLength = GetNumber (IVal->getText(), IVal->getLine(), 4); IsArray = 1; >> )
1000 << AddStructField (NAME->getText(), NAME->getLine(), 2, ArrayLength, IsArray); >>
1001 ;
1002
1003 //*****************************************************************************
1004 //
1005 // PARSE:
1006 // UINT8 Name[4];
1007 // UINT8 Name;
1008 //
1009 // Used while parsing the NV data map structures.
1010 //
1011 dataStructField8 :
1012 << int ArrayLength = 1; char IsArray = 0; >>
1013 "UINT8"
1014 NAME:StringIdentifier
1015 ( ";" | OpenBracket IVal:Number CloseBracket ";" << ArrayLength = GetNumber (IVal->getText(), IVal->getLine(), 4); IsArray = 1; >> )
1016 << AddStructField (NAME->getText(), NAME->getLine(), 1, ArrayLength, IsArray); >>
1017 ;
1018
1019 //*****************************************************************************
1020 //
1021 // PARSE:
1022 // form formid = 1,
1023 // title = STRING_TOKEN(STR_FORM_TITLE);
1024 // -- form statements --
1025 // endform;
1026 //
1027 // The Form ID cannot be 0
1028 //
1029 formDefinition :
1030 FRM:Form FormId << WriteOpByte (FRM->getLine(), EFI_IFR_FORM_OP); >>
1031 "="
1032 VAL:Number << WriteWord (GetNumber (VAL->getText(), VAL->getLine(), 2)); AddFormId (GetNumber (VAL->getText(), VAL->getLine(), 2), VAL->getLine()); >>
1033 ","
1034 Title "=" getStringId ";" // writes string identifier
1035 ( vfrStatements )*
1036 ENDF:EndForm ";" << WriteOpByte (ENDF->getLine(), EFI_IFR_END_FORM_OP); >>
1037 ;
1038
1039 //
1040 // VFR statements in a formset
1041 //
1042 vfrStatements :
1043 vfrStatementSubTitle |
1044 vfrStatementOneOf |
1045 vfrStatementTextText |
1046 vfrStatementCheckBox |
1047 vfrStatementNumeric |
1048 vfrStatementDate |
1049 vfrStatementTime |
1050 vfrStatementPassword |
1051 vfrStatementString |
1052 vfrStatementSuppressIf |
1053 vfrStatementHidden |
1054 vfrStatementGoto |
1055 vfrStatementGrayOutIf |
1056 vfrStatementInconsistentIf |
1057 vfrStatementLabel |
1058 vfrStatementBanner |
1059 vfrStatementInventory |
1060 vfrStatementOrderedList |
1061 vfrStatementOem |
1062 vfrStatementSaveRestoreDefaults
1063 ;
1064
1065 //*****************************************************************************
1066 //
1067 // PARSE:
1068 // label 100;
1069 //
1070 vfrStatementLabel :
1071 OPID:Label << WriteOpByte (OPID->getLine(), EFI_IFR_LABEL_OP); >>
1072 VAL:Number <<
1073 WriteWord (GetNumber (VAL->getText(), VAL->getLine(), 2));
1074 AddLabel (GetNumber (VAL->getText(), VAL->getLine(), 2), VAL->getLine());
1075 >>
1076 ";"
1077 ;
1078
1079 //*****************************************************************************
1080 //
1081 // PARSE:
1082 // oem 0x12, 0x34, 0x56;
1083 //
1084 vfrStatementOem :
1085 OPID:Oem << WriteOpByte (OPID->getLine(), EFI_IFR_OEM_DEFINED_OP); >>
1086 ( VAL1:Number << WriteByte (GetNumber (VAL1->getText(), VAL1->getLine(), 1), 0); >> )
1087 ( "," VAL2:Number << WriteByte (GetNumber (VAL2->getText(), VAL2->getLine(), 1), 0); >> )*
1088 ";"
1089 ;
1090
1091 //*****************************************************************************
1092 //
1093 // PARSE:
1094 // inconsistentif NOT .... AND NOT .... OR ... endif;
1095 //
1096 vfrStatementInconsistentIf :
1097 << ResetFlags (); >>
1098 IIFOP:InconsistentIf << WriteOpByte (IIFOP->getLine(), EFI_IFR_INCONSISTENT_IF_OP); >>
1099 Prompt "=" getStringId ","
1100 {
1101 FF:Flags "=" flagsField ( "\|" flagsField )* ","
1102 }
1103 << WriteFlags (); >> // write the flags field
1104 vfrBooleanExpression
1105 EOP:EndIf ";" << WriteOpByte (EOP->getLine(), EFI_IFR_END_IF_OP); >>
1106 ;
1107
1108 //*****************************************************************************
1109 //
1110 // PARSE:
1111 // TRUE AND (ideqval SomeStruct.SomeMember >= 0x10 OR
1112 // ideqid SomeStruct.SomeMember < SomeStruct.SomeOtherMember) AND
1113 // (ideqlist SomeStruct.SomeOtherMember == 0x10, 0x20, 0x30 OR
1114 // vareqval var(VAR_EQ_TEST_NAME) == 0x1)
1115 //
1116 // For supporting complex express, divide the vfrBooleanExpression to two parts
1117 // so that pred-LL(k) parser can parse incrementally.
1118 //
1119 vfrBooleanExpression :
1120 leftPartVfrBooleanExp { rightPartVfrBooleanExp }
1121 ;
1122
1123 leftPartVfrBooleanExp :
1124 OpenParen vfrBooleanExpression CloseParen |
1125 (ideqval | ideqid | ideqvallist | vareqval | truefalse) |
1126 NOPID:NOT leftPartVfrBooleanExp << WriteOpByte (NOPID->getLine(), EFI_IFR_NOT_OP); >>
1127 ;
1128
1129 rightPartVfrBooleanExp :
1130 AOPID:AND vfrBooleanExpression << WriteOpByte (AOPID->getLine(), EFI_IFR_AND_OP); >> |
1131 OOPID:OR vfrBooleanExpression << WriteOpByte (OOPID->getLine(), EFI_IFR_OR_OP); >>
1132 ;
1133
1134 //*****************************************************************************
1135 //
1136 // PARSE:
1137 // TRUE
1138 //
1139 truefalse :
1140 TOPID:True << WriteOpByte (TOPID->getLine(), EFI_IFR_TRUE_OP); >> |
1141 FOPID:False << WriteOpByte (FOPID->getLine(), EFI_IFR_FALSE_OP); >>
1142 ;
1143
1144 //*****************************************************************************
1145 //
1146 // PARSE:
1147 // varstore MY_STRUCT_NAME, key = 0x1234, name = "MyVariableName", guid = {...};
1148 //
1149 vfrStatementVarStore :
1150 OP:VarStore << WriteOpByte (OP->getLine(), EFI_IFR_VARSTORE_OP); >>
1151 STRUCT_NAME:StringIdentifier ","
1152 Key "=" KNUM:Number ","
1153 Name "=" VAR_NAME:StringIdentifier ","
1154 Guid "="
1155 OpenBrace
1156 G1:Number ","
1157 G2:Number ","
1158 G3:Number ","
1159 G4:Number ","
1160 G5:Number ","
1161 G6:Number ","
1162 G7:Number ","
1163 G8:Number ","
1164 G9:Number ","
1165 G10:Number ","
1166 G11:Number
1167 CloseBrace << WriteGuidValue (G1->getLine (), G1->getText (), G2->getText (), G3->getText (),
1168 G4->getText (), G5->getText (), G6->getText (), G7->getText (),
1169 G8->getText (), G9->getText (), G10->getText (), G11->getText ()
1170 );
1171 WriteWord (GetNumber (KNUM->getText(), KNUM->getLine(), 2));
1172 AddVarStore (STRUCT_NAME->getText(), VAR_NAME->getText(), GetNumber (KNUM->getText(), KNUM->getLine(), 2), STRUCT_NAME->getLine());
1173 >>
1174
1175 ";"
1176 ;
1177
1178 //*****************************************************************************
1179 //
1180 // PARSE:
1181 // vareqval var(0x100) == 0x20
1182 //
1183 vareqval :
1184 OPID:VarEqVal << WriteOpByte (OPID->getLine(), EFI_IFR_EQ_VAR_VAL_OP); >>
1185 Var OpenParen
1186 VAR:Number << WriteWord (GetNumber (VAR->getText(), VAR->getLine(), 2)); >>
1187 CloseParen
1188 compareNumber
1189 ;
1190
1191 ideqval :
1192 OPID:IdEqVal << WriteOpByte (OPID->getLine(), EFI_IFR_EQ_ID_VAL_OP); >>
1193 vfrStructFieldName[0]
1194 compareNumber
1195 ;
1196
1197 //*****************************************************************************
1198 //
1199 // PARSE:
1200 // ideqid MyNVData3.Field16A == MyNVData3.Field16B
1201 //
1202 // NOTE: Before processing the second variable store in the ideqid statement, set a global flag
1203 // so that when we parse the second variable we set the secondary variable store id.
1204 //
1205 ideqid :
1206 OPID:IdEqId << WriteOpByte (OPID->getLine(), EFI_IFR_EQ_ID_ID_OP); >>
1207 vfrStructFieldName[0]
1208 compareVfrStructFieldNameNL0
1209 ;
1210
1211 //*****************************************************************************
1212 //
1213 // compareNumber is the combination of compare operation and Number
1214 //
1215 compareNumber :
1216 (
1217 "=="
1218 VAL1:Number << WriteWord (GetNumber (VAL1->getText(), VAL1->getLine(), 2)); >>
1219 ) |
1220 (
1221 GTOPID:GreaterThan
1222 VAL2:Number << WriteWord (GetNumber (VAL2->getText(), VAL2->getLine(), 2));
1223 WriteOpByte (GTOPID->getLine(), EFI_IFR_GT_OP); >>
1224 ) |
1225 (
1226 GEOPID:GreaterEqual
1227 VAL3:Number << WriteWord (GetNumber (VAL3->getText(), VAL3->getLine(), 2));
1228 WriteOpByte (GEOPID->getLine(), EFI_IFR_GE_OP); >>
1229 ) |
1230 (
1231 LTOPID:LessThan
1232 VAL4:Number << WriteWord (GetNumber (VAL4->getText(), VAL4->getLine(), 2));
1233 WriteOpByte (LTOPID->getLine(), EFI_IFR_GE_OP);
1234 WriteOpByte (LTOPID->getLine(), EFI_IFR_NOT_OP); >>
1235 ) |
1236 (
1237 LEOPID:LessEqual
1238 VAL5:Number << WriteWord (GetNumber (VAL5->getText(), VAL5->getLine(), 2));
1239 WriteOpByte (LEOPID->getLine(), EFI_IFR_GT_OP);
1240 WriteOpByte (LEOPID->getLine(), EFI_IFR_NOT_OP); >>
1241 )
1242 ;
1243
1244 //*****************************************************************************
1245 //
1246 // compareVfrStructFieldNameNL0 is the combination of compare operation and vfrStructFieldNameNL[0]
1247 //
1248 compareVfrStructFieldNameNL0 :
1249 (
1250 "==" << mIdEqIdStmt = 1; >>
1251 vfrStructFieldNameNL[0] << mIdEqIdStmt = 0; >>
1252 ) |
1253 (
1254 GTOPID:GreaterThan << mIdEqIdStmt = 1; >>
1255 vfrStructFieldNameNL[0] << mIdEqIdStmt = 0;
1256 WriteOpByte (GTOPID->getLine(), EFI_IFR_GT_OP); >>
1257 ) |
1258 (
1259 GEOPID:GreaterEqual << mIdEqIdStmt = 1; >>
1260 vfrStructFieldNameNL[0] << mIdEqIdStmt = 0;
1261 WriteOpByte (GEOPID->getLine(), EFI_IFR_GE_OP); >>
1262 ) |
1263 (
1264 LTOPID:LessThan << mIdEqIdStmt = 1; >>
1265 vfrStructFieldNameNL[0] << mIdEqIdStmt = 0;
1266 WriteOpByte (LTOPID->getLine(), EFI_IFR_GE_OP);
1267 WriteOpByte (LTOPID->getLine(), EFI_IFR_NOT_OP); >>
1268 ) |
1269 (
1270 LEOPID:LessEqual << mIdEqIdStmt = 1; >>
1271 vfrStructFieldNameNL[0] << mIdEqIdStmt = 0;
1272 WriteOpByte (LEOPID->getLine(), EFI_IFR_GT_OP);
1273 WriteOpByte (LEOPID->getLine(), EFI_IFR_NOT_OP); >>
1274 )
1275 ;
1276
1277
1278 ideqvallist :
1279 OPID:IdEqValList << WriteOpByte (OPID->getLine(), EFI_IFR_EQ_ID_LIST_OP); >>
1280 vfrStructFieldName[0]
1281 "=="
1282 ( VAL:Number << QueueIdEqValList (GetNumber (VAL->getText(), VAL->getLine(), 2)); >> ) +
1283 << FlushQueueIdEqValList(); >>
1284 ;
1285
1286 vfrStatementGoto :
1287 << UINT32 LineNum, KeyValue = 0; ResetFlags (); >>
1288 IDG:Goto << WriteOpByte (IDG->getLine(), EFI_IFR_REF_OP); >>
1289 VAL:Number "," << WriteWord (GetNumber (VAL->getText(), VAL->getLine(), 2));
1290 AddGotoReference (GetNumber (VAL->getText(), VAL->getLine(), 2), VAL->getLine());
1291 >>
1292 KP:Prompt "=" getStringId "," << LineNum = KP->getLine(); >>
1293 Help "=" getStringId
1294 {
1295 ","
1296 FF:Flags "=" flagsField ( "\|" flagsField )* << LineNum = FF->getLine(); >>
1297 }
1298 {
1299 "," Key "=" KNUM:Number << LineNum = KNUM->getLine(); KeyValue = GetNumber(KNUM->getText(), LineNum, 2); >>
1300 }
1301 << WriteFlagsKey (KeyValue, LineNum); >>
1302 ";"
1303 ;
1304
1305 vfrStatementHidden :
1306 IDH:Hidden << WriteOpByte (IDH->getLine(), EFI_IFR_HIDDEN_OP); >>
1307 Value "="
1308 VAL:Number "," << WriteWord (GetNumber (VAL->getText(), VAL->getLine(), 2)); >>
1309 Key "="
1310 KVAL:Number << WriteWord (GetNumber (KVAL->getText(), KVAL->getLine(), 2)); >>
1311 ";"
1312 ;
1313
1314 //*****************************************************************************
1315 //
1316 // PARSE:
1317 // suppressif <boolean_expression> { grayoutif } <statements>+ endif;
1318 // Note:
1319 // You can have: suppressif:grayoutif:statements:endif
1320 // suppressif:grayoutif:endif -- serves no purpose
1321 // suppressif:statements:endif
1322 // suppressif:endif -- serves no purpose
1323 //
1324 vfrStatementSuppressIf :
1325 << ResetFlags (); >>
1326 OPID:SuppressIf << WriteOpByte (OPID->getLine(), EFI_IFR_SUPPRESS_IF_OP); SetIfStart (OPID->getLine()); >>
1327 {
1328 FF:Flags "=" flagsField ( "\|" flagsField )* ","
1329 }
1330 << WriteFlags (); >> // write the flags field
1331 vfrBooleanExpression
1332 ";"
1333 { suppressIfGrayOutIf } ( suppressIfAndGrayoutIfSubstatements )+
1334 ENDOP:EndIf ";" << WriteOpByte (ENDOP->getLine(), EFI_IFR_END_IF_OP); SetIfStart (0); >>
1335 ;
1336
1337 //
1338 // This is the form for a grayoutif nested in a suppressif statement
1339 //
1340 suppressIfGrayOutIf :
1341 << ResetFlags (); >>
1342 OPID:GrayOutIf << WriteOpByte (OPID->getLine(), EFI_IFR_GRAYOUT_IF_OP); >>
1343 {
1344 FF:Flags "=" flagsField ( "\|" flagsField )* ","
1345 }
1346 << WriteFlags (); >> // write the flags field
1347 vfrBooleanExpression
1348 ";"
1349 ;
1350
1351 //*****************************************************************************
1352 //
1353 // PARSE:
1354 // grayoutif { flags = n, } <boolean_expression> endif;
1355 // Note:
1356 // You can have: grayoutif:suppressif:statements:endif
1357 // grayoutif:statements:endif
1358 //
1359 //
1360 vfrStatementGrayOutIf :
1361 << ResetFlags (); >>
1362 OPID:GrayOutIf << WriteOpByte (OPID->getLine(), EFI_IFR_GRAYOUT_IF_OP); SetIfStart (OPID->getLine()); >>
1363 {
1364 FF:Flags "=" flagsField ( "\|" flagsField )* ","
1365 }
1366 << WriteFlags (); >> // write the flags field
1367 vfrBooleanExpression
1368 ";"
1369 { grayoutIfSuppressIf } ( suppressIfAndGrayoutIfSubstatements )+
1370 ENDOP:EndIf ";" << WriteOpByte (ENDOP->getLine(), EFI_IFR_END_IF_OP); SetIfStart (0); >>
1371 ;
1372
1373 //
1374 // This is the format for a suppressif nested in a grayoutif
1375 //
1376 grayoutIfSuppressIf :
1377 << ResetFlags (); >>
1378 OPID:SuppressIf << WriteOpByte (OPID->getLine(), EFI_IFR_SUPPRESS_IF_OP); >>
1379 {
1380 FF:Flags "=" flagsField ( "\|" flagsField )* ","
1381 }
1382 << WriteFlags (); >> // write the flags field
1383 vfrBooleanExpression
1384 ";"
1385 ;
1386
1387 //
1388 // These are the VFR statements that are valid inside a suppressif or grayoutif statement.
1389 //
1390 suppressIfAndGrayoutIfSubstatements :
1391 vfrStatementOneOf |
1392 vfrStatementTextText |
1393 vfrStatementCheckBox |
1394 vfrStatementNumeric |
1395 vfrStatementDate |
1396 vfrStatementTime |
1397 vfrStatementPassword |
1398 vfrStatementString |
1399 vfrStatementHidden |
1400 vfrStatementGoto |
1401 vfrStatementLabel |
1402 vfrStatementInventory |
1403 vfrStatementOrderedList |
1404 vfrStatementSaveRestoreDefaults
1405 ;
1406
1407 //*****************************************************************************
1408 //
1409 // PARSE:
1410 //
1411 // password varid = MyNvData.Password,
1412 // prompt = STRING_TOKEN(STR_PASSWORD_PROMPT),
1413 // help = STRING_TOKEN(STR_PASSWORD_HELP),
1414 // minsize = 6,
1415 // maxsize = 20,
1416 // encoding = 1,
1417 // endpassword;
1418
1419 vfrStatementPassword :
1420 << UINT32 KeyValue = 0; UINT32 LineNum; ResetFlags (); >>
1421 IDPW:Password << WriteOpByte (IDPW->getLine(), EFI_IFR_PASSWORD_OP); >>
1422 VarId "=" vfrStructFieldNameArray[0] ","
1423 Prompt "=" getStringId ","
1424 KH:Help "=" getStringId "," << LineNum = KH->getLine(); >>
1425 {
1426 FF:Flags "=" flagsField ( "\|" flagsField )* "," << LineNum = FF->getLine(); >>
1427 }
1428 {
1429 Key "=" KNUM:Number "," << LineNum = KNUM->getLine(); KeyValue = GetNumber(KNUM->getText(), LineNum, 2); >>
1430 }
1431 << WriteFlagsKey (KeyValue, LineNum); >>
1432 MinSize "=" MIN:Number "," << WriteByte (GetNumber (MIN->getText(), MIN->getLine(), 1), 0); >>
1433 MaxSize "=" MAX:Number "," << WriteByte (GetNumber (MAX->getText(), MAX->getLine(), 1), 0); >>
1434 Encoding "=" ENC:Number "," << WriteWord (GetNumber (ENC->getText(), ENC->getLine(), 2)); >>
1435 EndPassword ";"
1436 ;
1437
1438 //*****************************************************************************
1439 //
1440 // PARSE:
1441 //
1442 // string varid = MyNv.String,
1443 // prompt = STRING_TOKEN(STR_STRING_PROMPT),
1444 // help = STRING_TOKEN(STR_STRING_HELP),
1445 // flags = INTERACTIVE,
1446 // key = 0x1234,
1447 // minsize = 6,
1448 // maxsize = 0x14,
1449 // endstring;
1450 //
1451 // Since flags and key are optional, we can't use Flags->getLine(). Therefore for error
1452 // reporting we save the line number of the "help" keyword.
1453 //
1454 vfrStatementString :
1455 << unsigned int KeyValue = 0; UINT32 LineNum; ResetFlags (); >>
1456 IDS:String << WriteOpByte (IDS->getLine(), EFI_IFR_STRING_OP); >>
1457 VarId "=" vfrStructFieldNameArray[0] ","
1458 Prompt "=" getStringId ","
1459 KH:Help "=" getStringId "," << LineNum = KH->getLine(); >>
1460 {
1461 FF:Flags "="
1462 flagsField ( "\|" flagsField )* << LineNum = FF->getLine(); >>
1463 ","
1464 }
1465 {
1466 Key "=" KNUM:Number "," << LineNum = KNUM->getLine(); KeyValue = GetNumber(KNUM->getText(), LineNum, 2); >>
1467 }
1468 << WriteFlagsKey (KeyValue, LineNum); >>
1469 MinSize "=" MIN:Number "," << WriteByte (GetNumber (MIN->getText(), MIN->getLine(), 1), 0); >>
1470 MaxSize "=" MAX:Number "," << WriteByte (GetNumber (MAX->getText(), MAX->getLine(), 1), 0); >>
1471 EndString ";"
1472 ;
1473
1474 //*****************************************************************************
1475 //
1476 // PARSE:
1477 // numeric varid = MyIfrNVData.HowOldAreYouInYears,
1478 // prompt = STRING_TOKEN(STR_NUMERIC_PROMPT),
1479 // help = STRING_TOKEN(STR_NUMERIC_HELP),
1480 // flags = INTERACTIVE, // flags is optional
1481 // key = 0x1234, // key is optional if (flags & INTERACTIVE = 0)
1482 // minimum = 0x0,
1483 // maximum = 0xf0,
1484 // step = 1, // step is option, and step=1 if not specified
1485 // default = 0; // default is optional, and default=minimum if not specified
1486 // endnumeric;
1487 //
1488 // Make flags and key optional. However if flags includes INTERACTIVE, then a key is required.
1489 // That check is done in WriteFlagsKey() function.
1490 //
1491 vfrStatementNumeric :
1492 << UINT32 LineNum, KeyValue = 0; ResetFlags (); >>
1493 IDN:Numeric << WriteOpByte (IDN->getLine(), EFI_IFR_NUMERIC_OP); >>
1494 VarId "=" vfrStructFieldName[2] ","
1495 Prompt "=" getStringId ","
1496 KH:Help "=" getStringId "," << LineNum = KH->getLine(); >>
1497 {
1498 FF:Flags "=" flagsField ( "\|" flagsField )* "," << LineNum = FF->getLine (); >>
1499 }
1500 {
1501 Key "=" KNUM:Number "," << LineNum = KNUM->getLine(); KeyValue = GetNumber(KNUM->getText(), LineNum, 2); >>
1502 }
1503 << WriteFlagsKey (KeyValue, LineNum); >>
1504 minMaxStepDefault
1505 EndNumeric ";" << WriteMinMaxStepDefault (); >>
1506 ;
1507
1508 //
1509 // Parse minimum/maximum/step/default statements. Special cases:
1510 // - if step not specified, then the value is 1
1511 // - if default not specified, then the value is the min value specified
1512 // - if max < min, print a warning and swap the values (changes default too)
1513 //
1514 minMaxStepDefault :
1515 << InitMinMaxStepDefault (); >>
1516 Minimum "=" MIN:Number "," << SetMinMaxStepDefault (GetNumber (MIN->getText(), MIN->getLine(), 2), 0, MIN->getLine()); >>
1517 Maximum "=" MAX:Number "," << SetMinMaxStepDefault (GetNumber (MAX->getText(), MAX->getLine(), 2), 1, MAX->getLine()); >>
1518 { Step "=" STEP:Number "," << SetMinMaxStepDefault (GetNumber (STEP->getText(), STEP->getLine(), 2), 2, STEP->getLine()); >> }
1519 { Default "=" DEF:Number "," << SetMinMaxStepDefault (GetNumber (DEF->getText(), DEF->getLine(), 2), 3, DEF->getLine()); >> }
1520 ;
1521
1522
1523 //*****************************************************************************
1524 //
1525 // PARSE:
1526 //
1527 // date year varid = Date.Year, // "Date.Year" is a special case we recognize
1528 // prompt = STRING_TOKEN(STR_DATE_PROMPT),
1529 // help = STRING_TOKEN(STR_DATE_YEAR_HELP),
1530 // minimum = 1939,
1531 // maximum = 2101,
1532 // step = 1,
1533 // default = 1964,
1534 //
1535 // month varid = Date.Month,
1536 // prompt = STRING_TOKEN(STR_DATE_PROMPT),
1537 // help = STRING_TOKEN(STR_DATE_MONTH_HELP),
1538 // minimum = 1,
1539 // maximum = 12,
1540 // step = 1,
1541 // default = 1,
1542 //
1543 // day varid = Date.Day,
1544 // prompt = STRING_TOKEN(STR_DATE_PROMPT),
1545 // help = STRING_TOKEN(STR_DATE_DAY_HELP),
1546 // minimum = 1,
1547 // maximum = 31,
1548 // step = 0x1,
1549 // default = 1,
1550 //
1551 // enddate;
1552 //
1553 vfrStatementDate :
1554 Date
1555 IDY:Year VarId "=" << WriteOpByte (IDY->getLine(), EFI_IFR_DATE_OP); >>
1556 vfrStructFieldName[2] ","
1557 dateTimeSubStatement
1558 IDM:Month VarId "=" << WriteOpByte (IDM->getLine(), EFI_IFR_DATE_OP); >>
1559 vfrStructFieldName[2] ","
1560 dateTimeSubStatement
1561 IDD:Day VarId "=" << WriteOpByte (IDD->getLine(), EFI_IFR_DATE_OP); >>
1562 vfrStructFieldName[2] ","
1563 dateTimeSubStatement
1564 EndDate ";"
1565 ;
1566
1567 vfrStatementTime :
1568 Time
1569 IDH:Hour VarId "=" << WriteOpByte (IDH->getLine(), EFI_IFR_TIME_OP); >>
1570 vfrStructFieldName[2] ","
1571 dateTimeSubStatement
1572 IDM:Minute VarId "=" << WriteOpByte (IDM->getLine(), EFI_IFR_TIME_OP); >>
1573 vfrStructFieldName[2] ","
1574 dateTimeSubStatement
1575 IDS:Second VarId "=" << WriteOpByte (IDS->getLine(), EFI_IFR_TIME_OP); >>
1576 vfrStructFieldName[2] ","
1577 dateTimeSubStatement
1578 EndTime ";"
1579 ;
1580
1581 //*****************************************************************************
1582 //
1583 // PARSE:
1584 //
1585 // text text = STRING_ID;
1586 // text text = STRING_ID, text = STRING_ID;
1587 // text text = STRING_ID, text = STRING_ID, flags = x, key = y;
1588 //
1589 vfrStatementTextText :
1590 << ResetFlags (); >>
1591 IDT:Text << WriteOpByte (IDT->getLine(), EFI_IFR_TEXT_OP); >>
1592 Help "=" getStringId ","
1593 Text "="
1594 getStringId // writes string identifier
1595 { "," Text "=" getStringId
1596 "," Flags "=" flagsField ( "\|" flagsField )* << WriteFlags (); >>
1597 ","
1598 Key "=" KNUM:Number << WriteWord (GetNumber(KNUM->getText(), KNUM->getLine(), 2)); >>
1599 }
1600 ";"
1601 ;
1602
1603 //*****************************************************************************
1604 //
1605 // PARSE:
1606 //
1607 // inventory help = ID, text = ID;
1608 // inventory help = ID, text = id, text = ID;
1609 //
1610 vfrStatementInventory :
1611 IDI:Inventory << WriteOpByte (IDI->getLine(), EFI_IFR_INVENTORY_OP); >>
1612 Help "=" getStringId ","
1613 Text "=" getStringId // writes string identifier
1614 { "," Text "=" getStringId
1615 }
1616 ";"
1617 ;
1618
1619 //*****************************************************************************
1620 //
1621 // PARSE:
1622 //
1623 // restore defaults,
1624 // formid = 4,
1625 // prompt = STRING_TOKEN(STR_RESTORE_DEFAULTS_PROMPT),
1626 // help = STRING_TOKEN(STR_RESTORE_DEFAULTS_HELP),
1627 // flags = 0,
1628 // key = 0;
1629 //
1630 // save defaults,
1631 // formid = 4,
1632 // prompt = STRING_TOKEN(STR_SAVE_DEFAULTS_PROMPT),
1633 // help = STRING_TOKEN(STR_SAVE_DEFAULTS_HELP),
1634 // flags = 0,
1635 // key = 0;
1636 //
1637 vfrStatementSaveRestoreDefaults :
1638 << unsigned int KeyValue = 0; UINT32 LineNum; ResetFlags (); >>
1639 ( IDS:Save << WriteOpByte (IDS->getLine(), EFI_IFR_SAVE_DEFAULTS_OP); >>
1640 | IDR:Restore << WriteOpByte (IDR->getLine(), EFI_IFR_RESTORE_DEFAULTS_OP); >>
1641 )
1642 Defaults ","
1643 FormId "=" FRMID:Number "," << WriteWord (GetNumber (FRMID->getText(), FRMID->getLine(), 2));
1644 AddGotoReference (GetNumber (FRMID->getText(), FRMID->getLine(), 2), FRMID->getLine());
1645 >>
1646 Prompt "=" getStringId ","
1647 KH:Help "=" getStringId << LineNum = KH->getLine(); >>
1648 {
1649 "," FF:Flags "=" flagsField ( "\|" flagsField )* << LineNum = FF->getLine(); >>
1650 }
1651 {
1652 "," Key "=" KNUM:Number << LineNum = KNUM->getLine(); KeyValue = GetNumber(KNUM->getText(), LineNum, 2); >>
1653 }
1654 << WriteFlagsKey (KeyValue, LineNum); >>
1655 ";"
1656 ;
1657
1658 //*****************************************************************************
1659 //
1660 // PARSE:
1661 //
1662 // flags = 0x10 | DEFAULT | MANUFACTURING | INTERACTIVE | NV_ACCESS | RESET_REQUIRED | LATE_CHECK
1663 //
1664 //
1665 flagsField :
1666 VAL:Number << SetFlags (GetNumber(VAL->getText(), VAL->getLine(), 4), VAL->getLine()); >>
1667 | IF:InteractiveFlag << SetFlags (EFI_IFR_FLAG_INTERACTIVE, IF->getLine()); >>
1668 | MF:ManufacturingFlag << SetFlags (EFI_IFR_FLAG_MANUFACTURING, MF->getLine()); >>
1669 | DF:DefaultFlag << SetFlags (EFI_IFR_FLAG_DEFAULT, DF->getLine()); >>
1670 | NV:NVAccessFlag << SetFlags (EFI_IFR_FLAG_NV_ACCESS, NV->getLine()); >>
1671 | RR:ResetRequiredFlag << SetFlags (EFI_IFR_FLAG_RESET_REQUIRED, RR->getLine()); >>
1672 | LC:LateCheckFlag << SetFlags (EFI_IFR_FLAG_LATE_CHECK, LC->getLine()); >>
1673 ;
1674
1675 dateTimeSubStatement :
1676 Prompt "=" getStringId ","
1677 Help "=" getStringId ","
1678 << WriteByte (0, 0); WriteWord (0); >> // bogus flags and key
1679 minMaxStepDefault << WriteMinMaxStepDefault (); >>
1680 ;
1681
1682 vfrStatementCheckBox :
1683 << UINT32 LineNum, KeyValue = 0; ResetFlags (); >>
1684 IDCB:CheckBox << WriteOpByte (IDCB->getLine(), EFI_IFR_CHECKBOX_OP); >>
1685 VarId "=" vfrStructFieldName[1] ","
1686 Prompt "=" getStringId ","
1687 Help "=" getStringId ","
1688 FF:Flags "=" flagsField ( "\|" flagsField )* "," << LineNum = FF->getLine(); >>
1689 {
1690 Key "=" KV:Number "," << LineNum = KV->getLine(); KeyValue = GetNumber(KV->getText(), LineNum, 2); >>
1691 }
1692 << WriteFlagsKey (KeyValue, LineNum); >>
1693 EndCheckBox ";"
1694 ;
1695
1696 vfrStatementSubTitle :
1697 IDS:Subtitle Text "=" << WriteOpByte (IDS->getLine(), EFI_IFR_SUBTITLE_OP); >>
1698 getStringId // writes string indentifier
1699 ";"
1700 ;
1701
1702 //*****************************************************************************
1703 //
1704 // PARSE:
1705 // banner
1706 // title = STRING_TOKEN(STR_BANNER_TITLE),
1707 // line 1,
1708 // align center; // or left or right
1709 //
1710 // banner,
1711 // title = STRING_TOKEN(STR_BANNER_TITLE), timeout = 100;
1712 //
1713 vfrStatementBanner :
1714 IDB:Banner { "," } << WriteOpByte (IDB->getLine(), EFI_IFR_BANNER_OP); >>
1715 Title "=" getStringId ","
1716 (
1717 Line VAL:Number "," << WriteWord (GetNumber(VAL->getText(), VAL->getLine(), 2)); >>
1718 Align
1719 ( Left << WriteByte (EFI_IFR_BANNER_ALIGN_LEFT, 0); >>
1720 | Center << WriteByte (EFI_IFR_BANNER_ALIGN_CENTER, 0); >>
1721 | Right << WriteByte (EFI_IFR_BANNER_ALIGN_RIGHT, 0); >>
1722 ) ";"
1723 |
1724 Timeout "=" TO:Number ";" << WriteWord (GetNumber(TO->getText(), TO->getLine(), 2)); >>
1725 << WriteByte (EFI_IFR_BANNER_TIMEOUT, 0); >>
1726 )
1727 ;
1728
1729 //*****************************************************************************
1730 //
1731 // PARSE:
1732 // oneof varid = MyNv.OneOfData,
1733 // prompt = STRING_TOKEN(STR_ONE_OF_PROMPT),
1734 // help = STRING_TOKEN(STR_ONE_OF_HELP),
1735 // option text = STRING_TOKEN(STR_ONE_OF_TEXT),
1736 // value = 0,
1737 // flags = DEFAULT | INTERACTIVE;
1738 //
1739 // supressif/grayoutif are supported inside oneof stmt.
1740 // We do not restrict the number of oneOfOptionText to >=2, but >=1.
1741 // The situation that all oneOfOptionText are suppressed is also possiable.
1742 //
1743 vfrStatementOneOf :
1744 << ResetFlags (); >>
1745 IDOO:OneOf << WriteOpByte (IDOO->getLine(), EFI_IFR_ONE_OF_OP); >>
1746 VarId "=" vfrStructFieldName[2] ","
1747 Prompt "=" getStringId "," // writes string identifier
1748 Help "=" getStringId "," // writes string identifier
1749 ( oneOfOptionText )+ // there must be at least 1 option to be choosed, not 2.
1750 IDEOO:EndOneOf ";" << TestOneOfFlags (IDEOO->getLine()); WriteOpByte (IDEOO->getLine(), EFI_IFR_END_ONE_OF_OP); >>
1751 ;
1752
1753 //*****************************************************************************
1754 //
1755 // PARSE:
1756 //
1757 // orderedlist varid = MyNv.OrderedListData,
1758 // prompt = STRING_TOKEN(STR_ORDERED_LIST_PROMPT),
1759 // help = STRING_TOKEN(STR_ORDERED_LIST_HELP),
1760 // option text = STRING_TOKEN(STR_ORDERED_LIST_TEXT), value = 0, flags = INTERACTIVE;
1761 // -- additional option text --
1762 // endlist;
1763 //
1764 vfrStatementOrderedList :
1765 << ResetFlags (); InitOrderedList(); >>
1766 IDOL:OrderedList << WriteOpByte (IDOL->getLine(), EFI_IFR_ORDERED_LIST_OP); >>
1767 VarId "=" vfrStructFieldNameArray[1] ","
1768 Prompt "=" getStringId "," // writes string identifier
1769 Help "=" getStringId "," // writes string identifier
1770 orderedListOptionText ( orderedListOptionText )+
1771 IDEOL:EndList ";" << WriteOpByte (IDEOL->getLine(), EFI_IFR_END_OP); EndOrderedList(IDEOL->getLine()); >>
1772 ;
1773
1774 //*****************************************************************************
1775 //
1776 // PARSE:
1777 //
1778 // option text = STRING_TOKEN(STRING_ID), value = 0 flags = 99;
1779 //
1780 // Differs from the oneOfOptionText in that we don't allow the DEFAULT flag to
1781 // be set, and value cannot be 0.
1782 //
1783 orderedListOptionText :
1784 << UINT32 KeyValue = 0; >>
1785 IDO:Option << WriteOpByte (IDO->getLine(), EFI_IFR_ONE_OF_OPTION_OP); >>
1786 Text "=" getStringId "," // writes string identifier
1787 Value "=" WVAL:Number "," <<
1788 if (GetNumber(WVAL->getText(), WVAL->getLine(), 2) == 0) {
1789 PrintErrorMessage (WVAL->getLine(), "value=0 is invalid for ordered lists", NULL);
1790 } else {
1791 WriteWord (GetNumber(WVAL->getText(), WVAL->getLine(), 2));
1792 }
1793 >>
1794 FF:Flags "=" orderedListFlagsField
1795 ("\|" orderedListFlagsField )*
1796 {
1797 "," Key "=" KV:Number << KeyValue = GetNumber (KV->getText(), KV->getLine(), 2); >>
1798 }
1799 << WriteFlagsKey (KeyValue, FF->getLine()); >>
1800 ";" << mOptionCount++; >>
1801 ;
1802
1803 //*****************************************************************************
1804 //
1805 // PARSE:
1806 //
1807 // flags = 0x10 | DEFAULT | MANUFACTURING | INTERACTIVE | NV_ACCESS | RESET_REQUIRED | LATE_CHECK
1808 //
1809 // The ordered list flags field cannot have a default.
1810 //
1811 orderedListFlagsField :
1812 VAL:Number << SetFlags (GetNumber(VAL->getText(), VAL->getLine(), 4), VAL->getLine()); >>
1813 | IF:InteractiveFlag << SetFlags (EFI_IFR_FLAG_INTERACTIVE, IF->getLine()); >>
1814 | MF:ManufacturingFlag << SetFlags (EFI_IFR_FLAG_MANUFACTURING, MF->getLine()); >>
1815 | NV:NVAccessFlag << SetFlags (EFI_IFR_FLAG_NV_ACCESS, NV->getLine()); >>
1816 | RR:ResetRequiredFlag << SetFlags (EFI_IFR_FLAG_RESET_REQUIRED, RR->getLine()); >>
1817 | LC:LateCheckFlag << SetFlags (EFI_IFR_FLAG_LATE_CHECK, LC->getLine()); >>
1818 | DF:DefaultFlag << PrintWarningMessage (DF->getLine(), "DEFAULT flag not valid for ordered lists", NULL); >>
1819 ;
1820
1821 //
1822 // Parse references to VFR structure field names of form "MyNvStructure.Field".
1823 // This implementation is specific to strings, passwords, and references in an
1824 // ordered list statement because we want to specify the size of the entire
1825 // field, rather than just one element. Then call a function to write out its
1826 // offset and length.
1827 //
1828 vfrStructFieldNameArray[int FieldWidth] :
1829 << int ArrayIndex = 1; char IsArrayIndex = 0; >>
1830 SName:StringIdentifier
1831 "."
1832 SFieldName:StringIdentifier
1833 { OpenBracket AIndex:Number CloseBracket << ArrayIndex = GetNumber(AIndex->getText(), AIndex->getLine(), 4); IsArrayIndex = 1; >> }
1834 <<
1835 WriteFieldOffset (1,
1836 SName->getText(),
1837 SName->getLine(),
1838 SFieldName->getText(),
1839 SFieldName->getLine(),
1840 ArrayIndex,
1841 IsArrayIndex,
1842 FieldWidth,
1843 1
1844 );
1845 >>
1846 ;
1847
1848 //
1849 // Parse references to VFR structure field names of form "MyNvStructure.Field",
1850 // then call a function to write out its offset and length.
1851 //
1852 vfrStructFieldName[int FieldWidth] :
1853 << int ArrayIndex = 1; char IsArrayIndex = 0; >>
1854 SName:StringIdentifier
1855 "."
1856 SFieldName:StringIdentifier
1857 { OpenBracket AIndex:Number CloseBracket << ArrayIndex = GetNumber(AIndex->getText(), AIndex->getLine(), 4); IsArrayIndex = 1; >> }
1858 <<
1859 WriteFieldOffset (1,
1860 SName->getText(),
1861 SName->getLine(),
1862 SFieldName->getText(),
1863 SFieldName->getLine(),
1864 ArrayIndex,
1865 IsArrayIndex,
1866 FieldWidth,
1867 0
1868 );
1869 >>
1870 ;
1871
1872 //*****************************************************************************
1873 //
1874 // PARSE:
1875 //
1876 // MyNvStructure.FieldName[4]
1877 //
1878 // Parse references to VFR structure field names of form "MyNvStructure.Field",
1879 // then call a function to write out the offset with no length.
1880 //
1881 vfrStructFieldNameNL[int FieldWidth] :
1882 << int ArrayIndex = 1; char IsArrayIndex = 0; >>
1883 SName:StringIdentifier
1884 "."
1885 SFieldName:StringIdentifier
1886 { OpenBracket AIndex:Number CloseBracket << ArrayIndex = GetNumber(AIndex->getText(), AIndex->getLine(), 4); IsArrayIndex = 1; >> }
1887 <<
1888 WriteFieldOffset (0,
1889 SName->getText(),
1890 SName->getLine(),
1891 SFieldName->getText(),
1892 SFieldName->getLine(),
1893 ArrayIndex,
1894 IsArrayIndex,
1895 FieldWidth,
1896 0
1897 );
1898 >>
1899 ;
1900
1901 //*****************************************************************************
1902 //
1903 // PARSE:
1904 // suppressif TRUE OR FALSE;
1905 // grayoutif FALSE OR TRUE;
1906 // option text = STRING_TOKEN(STRING_ID), value = 0 flags = 99;
1907 // option text = STRING_TOKEN(STRING_ID2), value = 1 flags = 98;
1908 // endif;
1909 //
1910 oneOfOptionText :
1911 suppressIfOptionText |
1912 grayOutIfOptionText |
1913 commonOptionText
1914 ;
1915
1916 suppressIfOptionText :
1917 << ResetFlags (); >>
1918 OPID:SuppressIf << WriteOpByte (OPID->getLine(), EFI_IFR_SUPPRESS_IF_OP); SetIfStart (OPID->getLine()); >>
1919 {
1920 FF:Flags "=" flagsField ( "\|" flagsField )* ","
1921 }
1922 << WriteFlags (); >> // write the flags field
1923 vfrBooleanExpression
1924 ";"
1925 { suppressIfGrayOutIf } ( commonOptionText )+
1926 ENDOP:EndIf ";" << WriteOpByte (ENDOP->getLine(), EFI_IFR_END_IF_OP); SetIfStart (0); >>
1927 ;
1928
1929 grayOutIfOptionText :
1930 << ResetFlags (); >>
1931 OPID:GrayOutIf << WriteOpByte (OPID->getLine(), EFI_IFR_GRAYOUT_IF_OP); SetIfStart (OPID->getLine()); >>
1932 {
1933 FF:Flags "=" flagsField ( "\|" flagsField )* ","
1934 }
1935 << WriteFlags (); >> // write the flags field
1936 vfrBooleanExpression
1937 ";"
1938 { grayoutIfSuppressIf } ( commonOptionText )+
1939 ENDOP:EndIf ";" << WriteOpByte (ENDOP->getLine(), EFI_IFR_END_IF_OP); SetIfStart (0); >>
1940 ;
1941
1942 commonOptionText :
1943 << UINT32 KeyValue = 0; >>
1944 IDO:Option << WriteOpByte (IDO->getLine(), EFI_IFR_ONE_OF_OPTION_OP); >>
1945 Text "=" getStringId "," // writes string identifier
1946 Value "=" WVal:Number "," << WriteWord (GetNumber(WVal->getText(), WVal->getLine(), 2)); >>
1947 FF:Flags "=" flagsField ("\|" flagsField )*
1948 {
1949 "," Key "=" KV:Number << KeyValue = GetNumber (KV->getText(), KV->getLine(), 2); >>
1950 }
1951 << WriteFlagsKey (KeyValue, FF->getLine()); >>
1952 ";" << mOptionCount++; >>
1953 ;
1954
1955 //
1956 // Gets a string identifier. It must be a numeric value of form:
1957 //
1958 // STRING_TOKEN(100)
1959 //
1960 getStringId :
1961 << unsigned short StrId; >>
1962 StringToken OpenParen
1963 IdVal:Number << StrId = GetNumber (IdVal->getText(), IdVal->getLine(), 2); WriteStringIdWord (StrId); >>
1964 CloseParen
1965 ;
1966
1967 //******************************************************************************
1968 //
1969 // Parser class definition.
1970 //
1971 class EfiVfrParser {
1972 <<
1973 //
1974 // Parser definitions go here
1975 //
1976 private:
1977 STRUCT_DEFINITION *mFirstStructDefinition;
1978 STRUCT_DEFINITION *mLastStructDefinition;
1979 INT32 mNvDataStructSize;
1980 INT32 mNonNvDataStructSize;
1981 //
1982 // Flag to indicate that we're processing a ideqid VFR statement so that
1983 // we can do late checks on the statement.
1984 //
1985 INT32 mIdEqIdStmt;
1986 INT32 mLastNVVariableDataSize;
1987 GOTO_REFERENCE *mGotoReferences;
1988 FORM_ID_VALUE *mFormIdValues;
1989 VfrOpcodeHandler mOpcodeHandler;
1990 UINT16_LIST *mUint16List;
1991 UINT16_LIST *mLastUint16;
1992 UINT16_LIST *mDefinedLabels;
1993 UINT16_LIST *mDefinedVarStoreId;
1994 UINT16_LIST *mLastDefinedVarStoreId;
1995 UINT32 mMinimumValue, mMaximumValue, mStepValue, mDefaultValue;
1996 UINT32 mStmtFlags;
1997 UINT32 mSubStmtFlags;
1998 UINT32 mSubStmtFlagsLineNum;
1999 EFI_GUID mFormSetGuid;
2000 UINT8 mNvDataStructDefined;
2001 UINT16 mClass, mSubclass;
2002 UINT32 mIfStart;
2003 UINT32 mOptionCount; // how many "option" fields in a given statement
2004 UINT32 mLastVarIdSize;
2005 UINT8 mOutput;
2006 public:
2007
2008 VOID
2009 EfiVfrParser::SetIfStart (
2010 UINT32 LineNum
2011 )
2012 /*++
2013
2014 Routine Description:
2015 Invoked during VFR parsing when an "if" is encountered. Save the
2016 source line number so we can point to it if we don't find a
2017 corresponding endif later.
2018
2019 Arguments:
2020 LineNum - source line number where the "if" was parsed.
2021
2022 Returns:
2023 None
2024
2025 --*/
2026 {
2027 mIfStart = LineNum;
2028 }
2029 VOID
2030 EfiVfrParser::SetClass (
2031 UINT32 LineNum,
2032 UINT32 Value
2033 )
2034 /*++
2035
2036 Routine Description:
2037 Invoked during VFR parsing when a "class" statement is found. Check the
2038 range on the class value and save it for later.
2039
2040 Arguments:
2041 LineNum - source line number where the class statement was parsed.
2042 Value - the class value
2043
2044 Returns:
2045 None
2046
2047 --*/
2048 {
2049 if (Value & 0xFFFF0000) {
2050 PrintWarningMessage (LineNum, NULL, "class value exceeds maximum allowed");
2051 }
2052 mClass |= (UINT16)Value;
2053 }
2054 VOID
2055 EfiVfrParser::SetSubclass (
2056 UINT32 LineNum,
2057 UINT32 Value
2058 )
2059 /*++
2060
2061 Routine Description:
2062 Invoked during VFR parsing when a subclass statement is found. Check the
2063 range on the value and save it for later.
2064
2065 Arguments:
2066 LineNum - source line number where the class statement was parsed.
2067 Value - the subclass value from the VFR statement
2068
2069 Returns:
2070 None
2071
2072 --*/
2073 {
2074 if (Value & 0xFFFF0000) {
2075 PrintWarningMessage (LineNum, NULL, "subclass value exceeds maximum allowed");
2076 }
2077 mSubclass |= (UINT16)Value;
2078 }
2079 VOID EfiVfrParser::WriteClass ()
2080 {
2081 WriteWord (mClass);
2082 mClass = 0;
2083 }
2084 VOID EfiVfrParser::WriteSubclass ()
2085 {
2086 WriteWord (mSubclass);
2087 mSubclass = 0;
2088 }
2089 VOID EfiVfrParser::WriteIfrBytes ()
2090 {
2091 mOpcodeHandler.WriteIfrBytes ();
2092 }
2093 VOID
2094 EfiVfrParser::WriteFlagsKey (
2095 UINT32 KeyValue,
2096 UINT32 LineNum
2097 )
2098 /*++
2099
2100 Routine Description:
2101 Write out the flags and key values from the previous VFR statement.
2102 Many statements take a flags/key pair. If not specified, then 0
2103 values are written out. However do not allow an interactive flags field
2104 to be specified if no key value is specified. Also, if NV_ACCESS flag
2105 is set but INTERACTIVE is not, then set interactive and issue a warning.
2106
2107 Arguments:
2108 KeyValue - the key value from the VFR statement
2109 LineNum - source line number where the statement was parsed
2110
2111 Returns:
2112 None
2113
2114 --*/
2115 {
2116 if ((mSubStmtFlags & EFI_IFR_FLAG_INTERACTIVE) && (KeyValue == 0)) {
2117 PrintErrorMessage (LineNum, NULL, "invalid or missing key value - required with INTERACTIVE");
2118 }
2119 if ((mSubStmtFlags & EFI_IFR_FLAG_NV_ACCESS) && !(mSubStmtFlags & EFI_IFR_FLAG_INTERACTIVE)) {
2120 PrintWarningMessage (LineNum, NULL, "NV_ACCESS without INTERACTIVE has no effect -- setting INTERACTIVE");
2121 mSubStmtFlags |= EFI_IFR_FLAG_INTERACTIVE;
2122 }
2123 WriteFlags ();
2124 WriteWord (KeyValue);
2125 }
2126 VOID
2127 EfiVfrParser::InitOrderedList ()
2128 {
2129 mOptionCount = 0;
2130 }
2131 VOID
2132 EfiVfrParser::EndOrderedList (
2133 UINT32 LineNum
2134 )
2135 {
2136 if (mLastVarIdSize < mOptionCount) {
2137 PrintErrorMessage (LineNum, NULL, "number of options exceeds the variable store size");
2138 }
2139 }
2140 VOID
2141 EfiVfrParser::ResetFlags ()
2142 /*++
2143
2144 Routine Description:
2145
2146 Flags are set for each substatement in a given one-of statement.
2147 To make sure there are no conflicts, for example setting DEFAULT on
2148 more than one substatement, we keep track of the flags at a statement
2149 level and a substatement level. This function resets the flags so
2150 we get a fresh start.
2151
2152 Arguments:
2153 None
2154
2155 Returns:
2156 None
2157
2158 --*/
2159 {
2160 mStmtFlags = 0;
2161 mSubStmtFlagsLineNum = 0;
2162 mSubStmtFlags = 0;
2163 }
2164 //
2165 // Test validity of flags value for a one-of statement.
2166 //
2167 VOID
2168 EfiVfrParser::TestOneOfFlags (
2169 UINT32 LineNum
2170 )
2171 {
2172 //
2173 // One of the fields must have had the default bit set
2174 //
2175 if ((mStmtFlags & EFI_IFR_FLAG_DEFAULT) == 0) {
2176 PrintWarningMessage (LineNum, "default value must be specified", NULL);
2177 }
2178 }
2179 VOID
2180 EfiVfrParser::SetFlags (
2181 UINT32 Flags,
2182 UINT32 LineNum
2183 )
2184 {
2185 //
2186 // Check for redefinitions and invalid combinations
2187 //
2188 if (mStmtFlags & Flags & EFI_IFR_FLAG_MANUFACTURING) {
2189 PrintErrorMessage (LineNum, "MANUFACTURING", "a field with this flag already defined");
2190 }
2191 if (mStmtFlags & Flags & EFI_IFR_FLAG_DEFAULT) {
2192 PrintErrorMessage (LineNum, "DEFAULT", "a field with this flag already defined");
2193 }
2194 mSubStmtFlags |= Flags;
2195 mSubStmtFlagsLineNum = LineNum;
2196 }
2197 VOID
2198 EfiVfrParser::WriteFlags ()
2199 {
2200 //
2201 // Check value for validity
2202 //
2203 if (mSubStmtFlags & ~(EFI_IFR_FLAG_DEFAULT |
2204 EFI_IFR_FLAG_MANUFACTURING |
2205 EFI_IFR_FLAG_INTERACTIVE |
2206 EFI_IFR_FLAG_NV_ACCESS |
2207 EFI_IFR_FLAG_RESET_REQUIRED |
2208 EFI_IFR_FLAG_LATE_CHECK )) {
2209 PrintWarningMessage (mSubStmtFlagsLineNum, "invalid bits defined in flag", NULL);
2210 }
2211 WriteByte ((UINT8)mSubStmtFlags, 'F');
2212 //
2213 // We can now clear the substatement flags
2214 //
2215 mStmtFlags |= mSubStmtFlags;
2216 mSubStmtFlags = 0;
2217 }
2218 //
2219 // When we parse a min/max/step/default sequence, save off the values for
2220 // later use. Call this first to init the values.
2221 //
2222 VOID
2223 EfiVfrParser::InitMinMaxStepDefault ()
2224 {
2225 mMinimumValue = 0;
2226 mMaximumValue = 0;
2227 mStepValue = 1;
2228 mDefaultValue = 0;
2229 }
2230 VOID
2231 EfiVfrParser::WriteMinMaxStepDefault ()
2232 {
2233 WriteWord (mMinimumValue);
2234 WriteWord (mMaximumValue);
2235 WriteWord (mStepValue);
2236 WriteWord (mDefaultValue);
2237 }
2238 VOID
2239 EfiVfrParser::SetMinMaxStepDefault (
2240 UINT16 Value,
2241 INT32 MMSD,
2242 INT32 LineNum
2243 )
2244 {
2245 UINT16 TempValue;
2246 //
2247 // Min specified
2248 //
2249 if (MMSD == 0) {
2250 mMinimumValue = Value;
2251 mDefaultValue = Value;
2252 //
2253 // Max specified
2254 //
2255 } else if (MMSD == 1) {
2256 mMaximumValue = Value;
2257 //
2258 // If min > max, then swap the values. That includes resetting the default
2259 // value as well.
2260 //
2261 if (mMinimumValue > mMaximumValue) {
2262 PrintWarningMessage (LineNum, NULL, "maximum < minimum");
2263 TempValue = Value;
2264 mMaximumValue = mMinimumValue;
2265 mMinimumValue = TempValue;
2266 mDefaultValue = mMinimumValue;
2267 }
2268 //
2269 // Step specified
2270 //
2271 } else if (MMSD == 2) {
2272 mStepValue = Value;
2273 //
2274 // Default specified. Make sure min <= default <= max.
2275 //
2276 } else if (MMSD == 3) {
2277 mDefaultValue = Value;
2278 if (mMinimumValue > Value) {
2279 PrintErrorMessage (LineNum, NULL, "default value < minimum value");
2280 } else if (Value > mMaximumValue) {
2281 PrintErrorMessage (LineNum, NULL, "default value > maximum value");
2282 }
2283 } else {
2284 PrintErrorMessage (LineNum, "application error", "internal MMSD error");
2285 }
2286 }
2287 VOID
2288 EfiVfrParser::AddLabel (
2289 UINT32 LabelNumber,
2290 UINT32 LineNum
2291 )
2292 {
2293 UINT16_LIST *Label;
2294
2295 //
2296 // Added a label from the user VFR script. Make sure they haven't already
2297 // defined the same label elsewhere
2298 //
2299 for (Label = mDefinedLabels; Label != NULL; Label = Label->Next) {
2300 if (Label->Value == LabelNumber) {
2301 PrintErrorMessage (LineNum, NULL, "label already defined");
2302 PrintErrorMessage (Label->LineNum, NULL, "previous definition of redefined label");
2303 break;
2304 }
2305 }
2306 Label = (UINT16_LIST *)malloc (sizeof (UINT16_LIST));
2307 if (Label == NULL) {
2308 PrintErrorMessage (0, NULL, "memory allocation error");
2309 return;
2310 }
2311 memset ((char *)Label, 0, sizeof (UINT16_LIST));
2312 Label->Value = LabelNumber;
2313 Label->LineNum = LineNum;
2314 Label->Next = mDefinedLabels;
2315 mDefinedLabels = Label;
2316 }
2317 VOID
2318 EfiVfrParser::QueueIdEqValList (
2319 UINT16 Value
2320 )
2321 {
2322 UINT16_LIST *U16;
2323
2324 U16 = (UINT16_LIST *)malloc (sizeof (UINT16_LIST));
2325 if (U16 == NULL) {
2326 Error (UTILITY_NAME, 0, 0, NULL, "memory allocation failed");
2327 } else {
2328 memset ((char *)U16, 0, sizeof (UINT16_LIST));
2329 U16->Value = Value;
2330 if (mUint16List == NULL) {
2331 mUint16List = U16;
2332 } else {
2333 mLastUint16->Next = U16;
2334 }
2335 mLastUint16 = U16;
2336 }
2337 }
2338 VOID
2339 EfiVfrParser::FlushQueueIdEqValList ()
2340 {
2341 UINT32 Count;
2342
2343 //
2344 // We queued up a list of IdEqValList items. The IFR requires a count
2345 // followed by the actual values. Do it.
2346 //
2347 Count = 0;
2348 mLastUint16 = mUint16List;
2349 while (mLastUint16 != NULL) {
2350 Count++;
2351 mLastUint16 = mLastUint16->Next;
2352 }
2353 // BUGBUG -- check for more than 16K items?
2354 WriteWord (Count);
2355 //
2356 // Now write the values.
2357 //
2358 mLastUint16 = mUint16List;
2359 while (mLastUint16 != NULL) {
2360 WriteWord ((UINT32)mLastUint16->Value);
2361 mLastUint16 = mLastUint16->Next;
2362 }
2363 //
2364 // Free up the list
2365 //
2366 mLastUint16 = mUint16List;
2367 while (mUint16List != NULL) {
2368 mLastUint16 = mUint16List->Next;
2369 free (mUint16List);
2370 mUint16List = mLastUint16;
2371 }
2372 }
2373 VOID
2374 EfiVfrParser::PrintErrorMessage (
2375 UINT32 LineNum,
2376 INT8 *Msg1,
2377 INT8 *Msg2
2378 )
2379 {
2380 char *FileName;
2381
2382 if (LineNum != 0) {
2383 FileName = ConvertLineNumber ((UINT32 *)&LineNum);
2384 Error (FileName, LineNum, 0, Msg1, Msg2);
2385 } else {
2386 Error (UTILITY_NAME, 0, 0, Msg1, Msg2);
2387 }
2388 }
2389 VOID
2390 EfiVfrParser::PrintWarningMessage (
2391 UINT32 LineNum,
2392 INT8 *Msg1,
2393 INT8 *Msg2
2394 )
2395 {
2396 char *FileName;
2397
2398 if (LineNum != 0) {
2399 FileName = ConvertLineNumber ((UINT32 *)&LineNum);
2400 Warning (FileName, LineNum, 0, Msg1, Msg2);
2401 } else {
2402 Warning (UTILITY_NAME, 0, 0, Msg1, Msg2);
2403 }
2404 }
2405 VOID
2406 EfiVfrParser::syn (
2407 ANTLRAbstractToken *Tok,
2408 ANTLRChar *Egroup,
2409 SetWordType *Eset,
2410 ANTLRTokenType ETok,
2411 INT32 Huh
2412 )
2413 /*++
2414
2415 Routine Description:
2416 Called by the parser base class as a result of parse syntax errors.
2417
2418 Arguments:
2419 Tok - token that caused the error
2420 Egroup - not sure
2421 Eset - index in token table of the expected token
2422 Huh - not sure
2423
2424 Returns:
2425 NA
2426
2427 --*/
2428 {
2429 char *FileName;
2430 UINT32 LineNum;
2431
2432 LineNum = Tok->getLine ();
2433 FileName = ConvertLineNumber ((UINT32 *)&LineNum);
2434 //
2435 // Sometimes the token number is 0, in which case I don't know what to
2436 // print.
2437 //
2438 if (ETok == 0) {
2439 Error (FileName, LineNum, 0, Tok->getText (), "unexpected token");
2440 } else {
2441 //
2442 // If we were expecting an endif, then report the line where the corresponding
2443 // IF began.
2444 //
2445 if ((strcmp (_token_tbl[ETok], "endif") == 0) && (mIfStart != 0)) {
2446 LineNum = mIfStart;
2447 FileName = ConvertLineNumber (&LineNum);
2448 Error (FileName, LineNum, 0, "statement missing corresponding endif", NULL);
2449 } else {
2450 Error (FileName, LineNum, 0, Tok->getText (), "expected %s", _token_tbl[ETok]);
2451 }
2452 }
2453 }
2454
2455 VOID
2456 EfiVfrParser::init()
2457 /*++
2458
2459 Routine Description:
2460 Initializations function for our parser.
2461
2462 Arguments:
2463 None.
2464
2465 Returns:
2466 None.
2467
2468 --*/
2469 {
2470 ANTLRParser::init();
2471
2472 //
2473 // Used for queuing a variable list of UINT16's
2474 //
2475 mUint16List = NULL;
2476 mLastUint16 = NULL;
2477 mFirstStructDefinition = NULL;
2478 mLastStructDefinition = NULL;
2479 mNvDataStructSize = 0;
2480 mNonNvDataStructSize = 0;
2481 mNvDataStructDefined = 0;
2482 mGotoReferences = NULL;
2483 mFormIdValues = NULL;
2484 mDefinedLabels = NULL;
2485 mClass = 0;
2486 mSubclass = 0;
2487 mIfStart = 0;
2488 mDefinedVarStoreId = NULL;
2489 mLastDefinedVarStoreId = NULL;
2490 mIdEqIdStmt = 0;
2491 mLastNVVariableDataSize = 0;
2492
2493 memset ((char *)&mFormSetGuid, 0, sizeof (EFI_GUID));
2494 }
2495 //
2496 // Destructor for the parser.
2497 //
2498 EfiVfrParser::~EfiVfrParser(VOID)
2499 {
2500 Cleanup();
2501 }
2502 VOID
2503 EfiVfrParser::Cleanup (VOID)
2504 /*++
2505
2506 Routine Description:
2507 Free memory allocated during parsing
2508
2509 Arguments:
2510 None.
2511
2512 Returns:
2513 None.
2514
2515 --*/
2516 {
2517 STRUCT_DEFINITION *NextStruct;
2518 STRUCT_FIELD_DEFINITION *NextField;
2519 UINT8 Buff[6];
2520 UINT16_LIST *NextU16List;
2521
2522 //
2523 // Free up the structure definitions if any
2524 //
2525 while (mFirstStructDefinition != NULL) {
2526 //
2527 // Free up all the fields for this struct
2528 //
2529 while (mFirstStructDefinition->Field != NULL) {
2530 NextField = mFirstStructDefinition->Field->Next;
2531 free (mFirstStructDefinition->Field->Name);
2532 free (mFirstStructDefinition->Field);
2533 mFirstStructDefinition->Field = NextField;
2534 }
2535 NextStruct = mFirstStructDefinition->Next;
2536 free (mFirstStructDefinition->Name);
2537 free (mFirstStructDefinition);
2538 mFirstStructDefinition = NextStruct;
2539 }
2540 //
2541 // Free up the goto references and form id defines
2542 //
2543 FreeGotoReferences ();
2544 //
2545 // Free up label list
2546 //
2547 while (mDefinedLabels != NULL) {
2548 NextU16List = mDefinedLabels->Next;
2549 delete (mDefinedLabels);
2550 mDefinedLabels = NextU16List;
2551 }
2552 //
2553 // Free up the list of defined variable storage IDs
2554 //
2555 while (mDefinedVarStoreId != NULL) {
2556 NextU16List = mDefinedVarStoreId->Next;
2557 delete (mDefinedVarStoreId);
2558 mDefinedVarStoreId = NextU16List;
2559 }
2560 }
2561
2562 INT32
2563 EfiVfrParser::AtoX (
2564 INT8 *HexString,
2565 INT32 NumBytes,
2566 UINT32 *HexValue
2567 )
2568 /*++
2569
2570 Routine Description:
2571 Given a pointer to a ascii hex string, convert to a number with the given
2572 number of bytes.
2573
2574 Arguments:
2575 HexString - pointer to a string of format 30BCA
2576 Size - number of bytes to convert
2577 HexValue - return result
2578
2579 Returns:
2580 The number of bytes converted.
2581
2582 --*/
2583 {
2584 INT32 Count;
2585 INT32 Value;
2586
2587 *HexValue = 0;
2588 Count = 0;
2589 while (Count < NumBytes) {
2590 if ((*HexString >= '0') && (*HexString <= '9')) {
2591 Value = *HexString - '0';
2592 } else if ((*HexString >= 'a') && (*HexString <= 'f')) {
2593 Value = *HexString - 'a' + 10;
2594 } else if ((*HexString >= 'A') && (*HexString <= 'F')) {
2595 Value = *HexString - 'A' + 10;
2596 } else {
2597 return Count;
2598 }
2599 HexString++;
2600 *HexValue = (*HexValue << 4) | Value;
2601 if ((*HexString >= '0') && (*HexString <= '9')) {
2602 Value = *HexString - '0';
2603 } else if ((*HexString >= 'a') && (*HexString <= 'f')) {
2604 Value = *HexString - 'a' + 10;
2605 } else if ((*HexString >= 'A') && (*HexString <= 'F')) {
2606 Value = *HexString - 'A' + 10;
2607 } else {
2608 return Count;
2609 }
2610 *HexValue = (*HexValue << 4) | Value;
2611 HexString++;
2612 Count++;
2613 }
2614 return Count;
2615 }
2616 VOID
2617 EfiVfrParser::WriteGuidValue (
2618 UINT32 TokenLineNum,
2619 INT8 *G1,
2620 INT8 *G2,
2621 INT8 *G3,
2622 INT8 *G4,
2623 INT8 *G5,
2624 INT8 *G6,
2625 INT8 *G7,
2626 INT8 *G8,
2627 INT8 *G9,
2628 INT8 *G10,
2629 INT8 *G11
2630 )
2631 /*++
2632
2633 Routine Description:
2634 A Guid was parsed, likely of format:
2635 #define MY_GUID { 0x12345678, 0xAABB, 0xCCDD, 0xEE, 0xFF, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }
2636
2637 Write out the value.
2638
2639 Arguments:
2640 TokenLineNum - line number where the guid was used
2641 G1-G11 - the 11 fields of the guid value
2642
2643 Returns:
2644 None.
2645
2646 --*/
2647 {
2648 UINT32 Value;
2649 INT32 Loop;
2650 INT8 *Cptr;
2651
2652 mFormSetGuid.Data1 = GetNumber (G1, TokenLineNum, 4);
2653 mFormSetGuid.Data2 = (UINT16)GetNumber (G2, TokenLineNum, 2);
2654 mFormSetGuid.Data3 = (UINT16)GetNumber (G3, TokenLineNum, 2);
2655 mFormSetGuid.Data4[0] = (UINT8)GetNumber (G4, TokenLineNum, 1);
2656 mFormSetGuid.Data4[1] = (UINT8)GetNumber (G5, TokenLineNum, 1);
2657 mFormSetGuid.Data4[2] = (UINT8)GetNumber (G6, TokenLineNum, 1);
2658 mFormSetGuid.Data4[3] = (UINT8)GetNumber (G7, TokenLineNum, 1);
2659 mFormSetGuid.Data4[4] = (UINT8)GetNumber (G8, TokenLineNum, 1);
2660 mFormSetGuid.Data4[5] = (UINT8)GetNumber (G9, TokenLineNum, 1);
2661 mFormSetGuid.Data4[6] = (UINT8)GetNumber (G10, TokenLineNum, 1);
2662 mFormSetGuid.Data4[7] = (UINT8)GetNumber (G11, TokenLineNum, 1);
2663
2664 WriteDWord (mFormSetGuid.Data1, 'G');
2665 WriteWord (mFormSetGuid.Data2);
2666 WriteWord (mFormSetGuid.Data3);
2667 WriteByte (mFormSetGuid.Data4[0], 0);
2668 WriteByte (mFormSetGuid.Data4[1], 0);
2669 WriteByte (mFormSetGuid.Data4[2], 0);
2670 WriteByte (mFormSetGuid.Data4[3], 0);
2671 WriteByte (mFormSetGuid.Data4[4], 0);
2672 WriteByte (mFormSetGuid.Data4[5], 0);
2673 WriteByte (mFormSetGuid.Data4[6], 0);
2674 WriteByte (mFormSetGuid.Data4[7], 0);
2675 }
2676 VOID
2677 EfiVfrParser::WriteFieldOffset (
2678 INT8 WriteLength,
2679 INT8 *StructName,
2680 INT32 LineNum1,
2681 INT8 *FieldName,
2682 INT32 LineNum2,
2683 INT32 ArrayIndex,
2684 INT8 IsArrayIndex,
2685 INT32 FieldWidth,
2686 INT8 WriteArraySize
2687 )
2688 /*++
2689
2690 Routine Description:
2691 A VFR script referenced the NV store structure. Given the structure's name
2692 and the field's name, write the offset of the field to the output file.
2693
2694 Arguments:
2695 WriteLength - write the field length byte out
2696 StructName - name of the NV store structure
2697 LineNum1 - line number in the VFR where we are (for error printing)
2698 FieldName - the name of the field within the NV store structure
2699 LineNum2 - line number in the VFR where FieldName is referenced
2700 ArrayIndex - the index specified, for example NV_DATA.Field[ArrayIndex]
2701 IsArrayIndex - non-zero if an array index was specified
2702 FieldWidth - expected size for the Field (1 byte? 2 bytes?)
2703 WriteArraySize - write the size of the entire field, not the size of a single element
2704
2705 Returns:
2706 None.
2707
2708 --*/
2709 {
2710 STRUCT_DEFINITION *StructDef;
2711 STRUCT_FIELD_DEFINITION *FieldDef;
2712 UINT32 Offset;
2713 UINT32 VarSize;
2714 INT8 Msg[100];
2715 //
2716 // If we're writing an array size, then they better have referenced the field without an
2717 // index.
2718 //
2719 if (WriteArraySize && IsArrayIndex) {
2720 sprintf (Msg, "array index specified where an array is required");
2721 PrintErrorMessage (LineNum2, FieldName, Msg);
2722 return;
2723 }
2724
2725 //
2726 // The reference index starts at 1 not 0
2727 //
2728 if (IsArrayIndex && (ArrayIndex < 1)) {
2729 printf ("WARNING: array index shouldn't be less than 1");
2730 }
2731 //
2732 // Look through our list of known structures for a match
2733 //
2734 for (StructDef = mFirstStructDefinition; StructDef != NULL; StructDef = StructDef->Next) {
2735 //
2736 // Check for matching structure name
2737 //
2738 if (strcmp (StructDef->Name, StructName) == 0) {
2739 //
2740 // Mark it as referenced (for debug purposes only). Check the
2741 // flag that indicates that we have already found a varstore VFR
2742 // statement for it.
2743 //
2744 StructDef->Referenced++;
2745 if (StructDef->VarStoreIdValid == 0) {
2746 //
2747 // Set it valid so we don't flag it multiple times, then emit the error
2748 //
2749 StructDef->VarStoreIdValid = 1;
2750 PrintErrorMessage (LineNum1, StructName, "varstore statement missing for this variable store");
2751 }
2752 //
2753 // Let the opcode-handler know which variable storage we're now using
2754 //
2755 if (mIdEqIdStmt) {
2756 mOpcodeHandler.SetSecondaryVarStoreId (StructDef->VarStoreId);
2757 } else {
2758 mOpcodeHandler.SetVarStoreId (StructDef->VarStoreId);
2759 }
2760 //
2761 // Found matching structure name. Now find the matching field name
2762 //
2763 for (FieldDef = StructDef->Field; FieldDef != NULL; FieldDef = FieldDef->Next) {
2764 if (strcmp (FieldDef->Name, FieldName) == 0) {
2765 //
2766 // Make sure the variable size is valid
2767 //
2768 if ((FieldWidth != 0) && (FieldDef->DataSize > FieldWidth)) {
2769 sprintf (Msg, "field width exceeds %d byte%c", FieldWidth, FieldWidth == 1 ? ' ' : 's');
2770 PrintErrorMessage (LineNum2, FieldName, Msg);
2771 }
2772 //
2773 // If they specified an index (MyVfrData.FieldX[10]), then make sure that the
2774 // data structure was declared as an array, and that the index is in bounds.
2775 // If they did not specify an index, then we'll assume 0. This is required for
2776 // strings.
2777 //
2778 if (IsArrayIndex) {
2779 VarSize = FieldDef->DataSize;
2780 if (FieldDef->IsArray == 0) {
2781 PrintErrorMessage (LineNum2, FieldName, "field is not declared as an array");
2782 return;
2783 }
2784 if (FieldDef->ArrayLength < ArrayIndex) {
2785 PrintErrorMessage (LineNum2, FieldName, "array index exceeds declared size of field");
2786 return;
2787 }
2788 } else {
2789 if (FieldDef->IsArray) {
2790 VarSize = FieldDef->DataSize * FieldDef->ArrayLength;
2791 } else {
2792 VarSize = FieldDef->DataSize;
2793 }
2794 }
2795 //
2796 // If we're in the middle of a ideqid VFR statement, then this is the second
2797 // variable ID that we're now processing. Make sure that its size is the same
2798 // as the first variable.
2799 //
2800 if (mIdEqIdStmt) {
2801 if (mLastVarIdSize != VarSize) {
2802 PrintErrorMessage (LineNum2, FieldName, "variables must have the same size");
2803 return;
2804 }
2805 }
2806 mLastVarIdSize = VarSize;
2807 //
2808 // If we're supposed to write an array size, then require it to be an array
2809 //
2810 if (WriteArraySize && !FieldDef->IsArray) {
2811 PrintErrorMessage (LineNum2, FieldName, "array required");
2812 return;
2813 }
2814 //
2815 // Write the variable offset and size. If we're in the non-NV structure, then
2816 // set the offset beyond the NV data structure size.
2817 //
2818 Offset = FieldDef->Offset + FieldDef->DataSize * (ArrayIndex - 1);
2819 if (StructDef->IsNonNV) Offset += mNvDataStructSize;
2820 WriteWord (Offset);
2821 if (WriteLength) {
2822 if (WriteArraySize) {
2823 if (FieldDef->DataSize * FieldDef->ArrayLength > 255) {
2824 PrintErrorMessage (LineNum2, FieldName, "array size exceeds 255 maximum encoding limit");
2825 return;
2826 }
2827 WriteByte (FieldDef->DataSize * FieldDef->ArrayLength, 0);
2828 } else {
2829 WriteByte (FieldDef->DataSize, 0);
2830 }
2831 }
2832 return;
2833 }
2834 }
2835 sprintf (Msg, "structure %s does not have a field named '%s'", StructName, FieldName);
2836 PrintErrorMessage (LineNum2, Msg, NULL);
2837 PrintErrorMessage (StructDef->LineNum, "see structure definition", NULL);
2838 return;
2839 }
2840 }
2841 //
2842 // The structure was not found in the defined list. See if it's the "Date" structure
2843 //
2844 if (strcmp (StructName, "Date") == 0) {
2845 //
2846 // BUGBUG -- remove support for Date and Time as valid structure
2847 // names. They should use the NON_NV_DATA_MAP structure for this.
2848 //
2849 // Someone specified Date.Years|Months|Days
2850 // BUGBUG -- define some constants for the IDs used here
2851 // Length == 0 implies that this is not user NV data storage.
2852 //
2853 if (strcmp (FieldName, "Year") == 0) {
2854 //
2855 // Write ID (offset), ID, and size
2856 //
2857 WriteWord (mNvDataStructSize + mNonNvDataStructSize + 0);
2858 if (WriteLength) {
2859 WriteByte (0, 0);
2860 }
2861 } else if (strcmp (FieldName, "Month") == 0) {
2862 //
2863 // Write ID (offset), ID, and size
2864 //
2865 WriteWord (mNvDataStructSize + mNonNvDataStructSize + 2);
2866 if (WriteLength) {
2867 WriteByte (0, 0);
2868 }
2869 } else if (strcmp (FieldName, "Day") == 0) {
2870 //
2871 // Write ID (offset), ID, and size
2872 //
2873 WriteWord (mNvDataStructSize + mNonNvDataStructSize + 4);
2874 if (WriteLength) {
2875 WriteByte (0, 0);
2876 }
2877 } else {
2878 PrintErrorMessage (LineNum1, FieldName, "expected valid field name TheYear/TheMonth/TheDay");
2879 }
2880 return;
2881 } else if (strcmp (StructName, "Time") == 0) {
2882 //
2883 // Someone specified Time.Hours|Minutes|Seconds
2884 // BUGBUG -- define some constants for the IDs used here
2885 //
2886 if (strcmp (FieldName, "Hours") == 0) {
2887 //
2888 // Write ID (offset), ID, and size
2889 //
2890 WriteWord (mNvDataStructSize + mNonNvDataStructSize + 6);
2891 if (WriteLength) {
2892 WriteByte (0, 0);
2893 }
2894 } else if (strcmp (FieldName, "Minutes") == 0) {
2895 //
2896 // Write ID (offset), ID, and size
2897 //
2898 WriteWord (mNvDataStructSize + mNonNvDataStructSize + 8);
2899 if (WriteLength) {
2900 WriteByte (0, 0);
2901 }
2902 } else if (strcmp (FieldName, "Seconds") == 0) {
2903 //
2904 // Write ID (offset), ID, and size
2905 //
2906 WriteWord (mNvDataStructSize + mNonNvDataStructSize + 10);
2907 if (WriteLength) {
2908 WriteByte (0, 0);
2909 }
2910 } else {
2911 PrintErrorMessage (LineNum1, FieldName, "expected valid field name Hours/Minutes/Seconds");
2912 }
2913 return;
2914 } else {
2915 PrintErrorMessage (LineNum1, StructName, "undefined structure");
2916 return;
2917 }
2918 }
2919 VOID
2920 EfiVfrParser::StartStructDefinition (
2921 INT32 IsNonNV,
2922 INT32 LineNum
2923 )
2924 /*++
2925
2926 Routine Description:
2927 Called when we encounter a new "struct _MY_STRUCT..." statement while parsing.
2928 Initialize internal data and structures for parsing the fields of the structure.
2929
2930 Arguments:
2931 LineNum - line number in the source file (for error reporting purposes)
2932 IsNonNv - flag indicating (if nonzero) that the variable referred to is not in
2933 the standard NV store.
2934 Returns:
2935 None
2936
2937 --*/
2938 {
2939 STRUCT_DEFINITION *StructDef;
2940 //
2941 // Allocate memory for the structure record
2942 //
2943 StructDef = (STRUCT_DEFINITION *)malloc (sizeof (STRUCT_DEFINITION));
2944 memset (StructDef, 0, sizeof (STRUCT_DEFINITION));
2945 StructDef->LineNum = LineNum;
2946 //
2947 // Set flag indicating non-NV data structure or not
2948 //
2949 StructDef->IsNonNV = IsNonNV;
2950 //
2951 // Add it to the end of our linked list. If it's the first one
2952 // defined, then it's the default varstore ID, so set it valid.
2953 //
2954 if (mFirstStructDefinition == NULL) {
2955 mFirstStructDefinition = StructDef;
2956 StructDef->VarStoreIdValid = 1;
2957 } else {
2958 mLastStructDefinition->Next = StructDef;
2959 }
2960 mLastStructDefinition = StructDef;
2961 }
2962 VOID
2963 EfiVfrParser::EndStructDefinition (
2964 INT8 *StructName,
2965 INT32 LineNum
2966 )
2967 {
2968 STRUCT_DEFINITION *StructDef;
2969 STRUCT_FIELD_DEFINITION *FieldDef;
2970 UINT32 Offset;
2971 //
2972 // Make sure they have not already defined a structure with this name
2973 //
2974 for (StructDef = mFirstStructDefinition; StructDef != NULL; StructDef = StructDef->Next) {
2975 if ((StructDef->Name != NULL) && (strcmp (StructDef->Name, StructName) == 0)) {
2976 PrintErrorMessage (LineNum, StructName, "structure with this name already defined");
2977 //
2978 // Fall through and fill in the rest of the structure information. We do
2979 // this because the structure has already been added to our global list,
2980 // so will be used elsewhere, so we want it to contain valid fields.
2981 //
2982 }
2983 }
2984 //
2985 // Allocate memory for the structure name
2986 //
2987 mLastStructDefinition->Name = (char *)malloc (strlen (StructName) + 1);
2988 strcpy (mLastStructDefinition->Name, StructName);
2989 //
2990 // Compute the structure size, and the offsets to each field
2991 //
2992 Offset = 0;
2993 for (FieldDef = mLastStructDefinition->Field; FieldDef != NULL; FieldDef = FieldDef->Next) {
2994 FieldDef->Offset = Offset;
2995 Offset += FieldDef->ArrayLength * FieldDef->DataSize;
2996 }
2997 mLastStructDefinition->Size = Offset;
2998 //
2999 // Go through all the structure we have so far and figure out (if we can)
3000 // the size of the non-NV storage. We also assume that the first structure
3001 // definition is the primary/default storage for the VFR form.
3002 //
3003 if (mNonNvDataStructSize == 0) {
3004 for (StructDef = mFirstStructDefinition; StructDef != NULL; StructDef = StructDef->Next) {
3005 if (StructDef->IsNonNV) {
3006 mNonNvDataStructSize = StructDef->Size;
3007 break;
3008 }
3009 }
3010 }
3011 if (mNvDataStructSize == 0) {
3012 for (StructDef = mFirstStructDefinition; StructDef != NULL; StructDef = StructDef->Next) {
3013 if (StructDef->IsNonNV == 0) {
3014 mNvDataStructSize = StructDef->Size;
3015 break;
3016 }
3017 }
3018 }
3019 }
3020 VOID
3021 EfiVfrParser::AddStructField (
3022 INT8 *FieldName,
3023 INT32 LineNum,
3024 INT32 DataSize,
3025 INT32 ArrayLength,
3026 INT8 IsArray
3027 )
3028 /*++
3029
3030 Routine Description:
3031 We're parsing the VFR structure definition. Add another defined field to
3032 our definition.
3033
3034 Arguments:
3035 FieldName - name of the field in the structure.
3036 LineNum - the line number from the input (preprocessor output) file
3037 DataSize - the size of the field (1, 2, or 4 bytes)
3038 ArrayLength - the number of elements (for array)
3039 IsArray - non-zero if the field is an array
3040
3041 Returns:
3042 None.
3043
3044 --*/
3045 {
3046 STRUCT_FIELD_DEFINITION *FieldDef;
3047 STRUCT_FIELD_DEFINITION *Temp;
3048 //
3049 // Make sure we don't already have a field of this name in our structure
3050 //
3051 for (FieldDef = mLastStructDefinition->Field; FieldDef != NULL; FieldDef = FieldDef->Next) {
3052 if (strcmp (FieldDef->Name, FieldName) == 0) {
3053 PrintErrorMessage (LineNum, FieldName, "field with this name already defined");
3054 return;
3055 }
3056 }
3057 //
3058 // If it's an array, then they better not have a size of 0. For example:
3059 // UINT8 MyBytes[0];
3060 //
3061 if (IsArray && (ArrayLength <= 0)) {
3062 PrintErrorMessage (LineNum, FieldName, "invalid array size");
3063 return;
3064 }
3065 //
3066 // Allocate memory for a new structure field definition
3067 //
3068 FieldDef = (STRUCT_FIELD_DEFINITION *)malloc (sizeof (STRUCT_FIELD_DEFINITION));
3069 memset ((char *)FieldDef, 0, sizeof (STRUCT_FIELD_DEFINITION));
3070 FieldDef->ArrayLength = ArrayLength;
3071 FieldDef->DataSize = DataSize;
3072 FieldDef->IsArray = IsArray;
3073 FieldDef->Name = (char *)malloc (strlen (FieldName) + 1);
3074 strcpy (FieldDef->Name, FieldName);
3075 //
3076 // Add it to the end of the field list for the currently active structure
3077 //
3078 if (mLastStructDefinition->Field == NULL) {
3079 mLastStructDefinition->Field = FieldDef;
3080 } else {
3081 mLastStructDefinition->LastField->Next = FieldDef;
3082 }
3083 mLastStructDefinition->LastField = FieldDef;
3084 }
3085 VOID
3086 EfiVfrParser::AddVarStore (
3087 INT8 *StructName, // actual name of the structure
3088 INT8 *VarName, // actual NV variable name
3089 UINT16 VarStoreId, // key value
3090 INT32 LineNum // parse line number (for error reporting)
3091 )
3092 /*++
3093
3094 Routine Description:
3095 Called while parsing a varstore statement. Add the variable store
3096 to our linked list.
3097
3098 Arguments:
3099 StructName - the name of the typedef'ed structure to use
3100 VarName - the NV variable name as specified in the varstore statement
3101 VarStoreId - the variable store ID as specified in the varstore statememt
3102 LineNum - the line number from the input (preprocessor output) file
3103
3104 Returns:
3105 None.
3106
3107 --*/
3108 {
3109 STRUCT_DEFINITION *StructDef;
3110 UINT16_LIST *L16Ptr;
3111 //
3112 // Go through our list of previously-defined variable store IDs and
3113 // make sure this one is not a duplicate in name or key value.
3114 //
3115 for (L16Ptr = mDefinedVarStoreId; L16Ptr != NULL; L16Ptr = L16Ptr->Next) {
3116 if (L16Ptr->Value == VarStoreId) {
3117 PrintErrorMessage (LineNum, "variable storage key already used", NULL);
3118 PrintErrorMessage (L16Ptr->LineNum, "previous usage of storage key", NULL);
3119 }
3120 }
3121 //
3122 // Key value of 0 is invalid since that's assigned by default to the default
3123 // variable store (the first structure parsed).
3124 //
3125 if (VarStoreId == 0) {
3126 PrintErrorMessage (LineNum, "variable storage key of 0 is invalid", NULL);
3127 }
3128 //
3129 // Create a new element to add to the list
3130 //
3131 L16Ptr = (UINT16_LIST *)malloc(sizeof (UINT16_LIST));
3132 memset (L16Ptr, 0, sizeof (UINT16_LIST));
3133 L16Ptr->LineNum = LineNum;
3134 L16Ptr->Value = VarStoreId;
3135 if (mDefinedVarStoreId == NULL) {
3136 mDefinedVarStoreId = L16Ptr;
3137 } else {
3138 mLastDefinedVarStoreId->Next = L16Ptr;
3139 }
3140 mLastDefinedVarStoreId = L16Ptr;
3141 //
3142 // Find the structure definition with this name
3143 //
3144 for (StructDef = mFirstStructDefinition; StructDef != NULL; StructDef = StructDef->Next) {
3145 if (strcmp (StructDef->Name, StructName) == 0) {
3146 //
3147 // Make sure they did not already define a variable storage ID
3148 // for this structure.
3149 //
3150 if (StructDef->VarStoreId != 0) {
3151 PrintErrorMessage (LineNum, StructName, "variable storage already defined for this structure");
3152 PrintErrorMessage (StructDef->VarStoreLineNum, StructName, "previous definition for variable storage");
3153 }
3154 StructDef->VarStoreId = VarStoreId;
3155 StructDef->VarStoreIdValid = 1;
3156 StructDef->VarStoreLineNum = LineNum;
3157 WriteWord (StructDef->Size);
3158 while (*VarName) {
3159 WriteByte(*VarName, 0);
3160 VarName++;
3161 }
3162 WriteByte(0,0);
3163 return;
3164 }
3165 }
3166 PrintErrorMessage (LineNum, StructName, "structure with this name not defined");
3167 }
3168 VOID
3169 EfiVfrParser::WriteDWord (
3170 UINT32 Value,
3171 UINT8 KeyByte
3172 )
3173 /*++
3174
3175 Routine Description:
3176 During parsing, we came upon some code that requires a 32-bit value be
3177 written to the VFR binary file. Queue up the 4 bytes.
3178
3179 Arguments:
3180 Value - the 32-bit value to write
3181 KeyByte - a single character which gets written out beside the first byte.
3182 This is used to tag the data in the output file so that during
3183 debug you have an idea what the value is.
3184
3185 Returns:
3186 None.
3187
3188 --*/
3189 {
3190 //
3191 // Write 4 bytes, little endian. Specify a key byte only on the first one
3192 //
3193 mOpcodeHandler.AddByte ((UINT8)Value, KeyByte);
3194 Value \>>= 8;
3195 mOpcodeHandler.AddByte ((UINT8)Value, 0);
3196 Value \>>= 8;
3197 mOpcodeHandler.AddByte ((UINT8)Value, 0);
3198 Value \>>= 8;
3199 mOpcodeHandler.AddByte ((UINT8)Value, 0);
3200 }
3201 VOID
3202 EfiVfrParser::WriteOpByte (
3203 UINT32 LineNum,
3204 UINT8 ByteValue
3205 )
3206 /*++
3207
3208 Routine Description:
3209
3210 During parsing, we came upon a new VFR opcode. At this point we flush
3211 the output queue and then queue up this byte (with 'O' for opcode tag).
3212
3213 Arguments:
3214
3215 ByteValue - opcode value
3216
3217 Returns:
3218
3219 None.
3220
3221 --*/
3222 {
3223 mOpcodeHandler.AddOpcodeByte (ByteValue, LineNum);
3224 }
3225 VOID
3226 EfiVfrParser::WriteByte (
3227 UINT8 ByteValue,
3228 UINT8 Key
3229 )
3230 /*++
3231
3232 Routine Description:
3233
3234 During parsing of the VFR we spoonfeed this function with bytes to write to
3235 the output VFR binary file. This function simply queues up the bytes, and
3236 the queue gets flushed each time a new VFR opcode is encountered.
3237
3238 Arguments:
3239
3240 ByteValue - raw byte to write
3241 Key - character to tag the byte with when we write ByteValue to the
3242 output file.
3243
3244 Returns:
3245
3246 None.
3247
3248 --*/
3249 {
3250 mOpcodeHandler.AddByte (ByteValue, Key);
3251 }
3252 VOID
3253 EfiVfrParser::WriteWord (
3254 UINT32 Value
3255 )
3256 /*++
3257
3258 Routine Description:
3259 During VFR parsing we came upon a case where we need to write out a
3260 16-bit value. Queue it up.
3261
3262 Arguments:
3263 Value - value to write.
3264
3265 Returns:
3266 None.
3267
3268 --*/
3269 {
3270 mOpcodeHandler.AddByte ((UINT8)Value, 0);
3271 mOpcodeHandler.AddByte ((UINT8)((Value \>> 8) & 0xFF), 0);
3272 }
3273 VOID
3274 EfiVfrParser::WriteStringIdWord (
3275 UINT16 WordValue
3276 )
3277 {
3278 mOpcodeHandler.AddByte ((UINT8)WordValue, 'S');
3279 mOpcodeHandler.AddByte ((UINT8)((WordValue \>> 8) & 0xFF), 0);
3280 }
3281 VOID
3282 EfiVfrParser::FreeGotoReferences ()
3283 /*++
3284
3285 Routine Description:
3286 Called during cleanup to free up the memory we allocated when
3287 keeping track of VFR goto statements.
3288
3289 Arguments:
3290 None
3291
3292 Returns:
3293 None
3294
3295 --*/
3296 {
3297 GOTO_REFERENCE *CurrRef;
3298 GOTO_REFERENCE *NextRef;
3299 FORM_ID_VALUE *CurrFormId;
3300 FORM_ID_VALUE *NextFormId;
3301 UINT8 Found;
3302 INT8 Name[20];
3303
3304 //
3305 // Go through all the "goto" references and make sure there was a
3306 // form ID of that value defined.
3307 //
3308 for (CurrRef = mGotoReferences; CurrRef != NULL; CurrRef = CurrRef->Next) {
3309 Found = 0;
3310 for (CurrFormId = mFormIdValues; CurrFormId != NULL; CurrFormId = CurrFormId->Next) {
3311 if (CurrRef->Value == CurrFormId->Value) {
3312 Found = 1;
3313 break;
3314 }
3315 }
3316 if (!Found) {
3317 sprintf (Name, "%d", (UINT32)CurrRef->Value);
3318 PrintErrorMessage (CurrRef->RefLineNum, Name, "undefined form ID");
3319 }
3320 }
3321 //
3322 // Now free up the form id and goto references
3323 //
3324 CurrFormId = mFormIdValues;
3325 while (CurrFormId != NULL) {
3326 NextFormId = CurrFormId->Next;
3327 free (CurrFormId);
3328 CurrFormId = NextFormId;
3329 }
3330 mFormIdValues = NULL;
3331 CurrRef = mGotoReferences;
3332 while (CurrRef != NULL) {
3333 NextRef = CurrRef->Next;
3334 free (CurrRef);
3335 CurrRef = NextRef;
3336 }
3337 mGotoReferences = NULL;
3338 }
3339 VOID
3340 EfiVfrParser::AddGotoReference (
3341 UINT32 GotoNumber,
3342 UINT32 LineNum
3343 )
3344 /*++
3345
3346 Routine Description:
3347 During VFR parsing we came upon a goto statement. Since we support
3348 forward references, save the referenced label and at the end of parsing
3349 we'll check that the label was actually defined somewhere.
3350
3351 Arguments:
3352 GotoNumber - the label number referenced
3353 LineNum - the line number where the reference was made (used for
3354 error reporting)
3355
3356 Returns:
3357 None
3358
3359 --*/
3360 {
3361 GOTO_REFERENCE *NewRef;
3362
3363 NewRef = (GOTO_REFERENCE *)malloc (sizeof (GOTO_REFERENCE));
3364 if (NewRef == NULL) {
3365 Error (UTILITY_NAME, 0, 0, NULL, "memory allocation failure");
3366 return;
3367 }
3368 memset ((char *)NewRef, 0, sizeof (GOTO_REFERENCE));
3369 NewRef->Value = (UINT16)GotoNumber;
3370 NewRef->RefLineNum = LineNum;
3371 NewRef->Next = mGotoReferences;
3372 mGotoReferences = NewRef;
3373 }
3374 VOID
3375 EfiVfrParser::AddFormId (
3376 INT32 FormIdValue,
3377 UINT32 LineNum
3378 )
3379 /*++
3380
3381 Routine Description:
3382 This function is called when we parse "form formid = 3" statements.
3383 We save the form ID valud so we can verify that duplicates are not
3384 defined. Also, these are the targets of goto statements, so when we're
3385 done parsing the script we also go through all the goto statements to
3386 check that there was a target FormId defined as referenced by each
3387 goto statement.
3388
3389 Note that formid = 0 is invalid.
3390
3391 Arguments:
3392 FormIdValue - the parsed value for the Form ID
3393 LineNum - line number of the source file we're parsing
3394
3395 Returns:
3396 NA
3397
3398 --*/
3399 {
3400 FORM_ID_VALUE *NewFormId;
3401 char *FileName;
3402 char *FileName2;
3403 UINT32 LineNum2;
3404 //
3405 // Verify that FormId != 0
3406 //
3407 if (FormIdValue == 0) {
3408 FileName = ConvertLineNumber (&LineNum);
3409 Error (FileName, LineNum, 0, "form ID cannot be 0", NULL);
3410 return;
3411 }
3412 //
3413 // First go through all previously defined form IDs and make sure they have not defined
3414 // duplicates.
3415 //
3416 for (NewFormId = mFormIdValues; NewFormId != NULL; NewFormId = NewFormId->Next) {
3417 if ((UINT16)FormIdValue == NewFormId->Value) {
3418 FileName = ConvertLineNumber (&LineNum);
3419 LineNum2 = NewFormId->LineNum;
3420 FileName2 = ConvertLineNumber (&LineNum2);
3421 Error (FileName, LineNum, 0, NULL, "form ID %d already defined", FormIdValue);
3422 Error (FileName2, LineNum2, 0, NULL, "form ID %d previous definition", FormIdValue);
3423 return;
3424 }
3425 }
3426 //
3427 // Allocate memory for a new one
3428 //
3429 NewFormId = (FORM_ID_VALUE *)malloc (sizeof (FORM_ID_VALUE));
3430 if (NewFormId == NULL) {
3431 Error (UTILITY_NAME, 0, 0, NULL, "memory allocation failure");
3432 return;
3433 }
3434 memset ((char *)NewFormId, 0, sizeof (FORM_ID_VALUE));
3435 NewFormId->LineNum = LineNum;
3436 NewFormId->Next = mFormIdValues;
3437 NewFormId->Value = (UINT16)FormIdValue;
3438 mFormIdValues = NewFormId;
3439 }
3440 UINT32
3441 EfiVfrParser::GetNumber (
3442 INT8 *NumStr,
3443 UINT32 LineNum,
3444 UINT32 NumBytes
3445 )
3446 {
3447 UINT32 Value;
3448
3449 if ((NumStr[0] == '0') && (NumStr[1] == 'x')) {
3450 AtoX (NumStr + 2, 4, &Value);
3451 } else {
3452 Value = (UINT32)atoi (NumStr);
3453 }
3454 //
3455 // Check range
3456 //
3457 if ((NumBytes < 4) && (Value & ((UINT32)0xFFFFFFFF << (NumBytes * 8)))) {
3458 PrintErrorMessage (LineNum, NumStr, "value out of range");
3459 return 0;
3460 }
3461 return Value;
3462 }
3463
3464 >>
3465
3466 } // end grammar class
3467
3468
EFI Development Kit II mirror for PVE