]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/C/VfrCompile/VfrSyntax.g
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
BaseTool/VfrCompile: Support Union type in VFR
[mirror_edk2.git] / BaseTools / Source / C / VfrCompile / VfrSyntax.g
1 /*++ @file
2 Vfr Syntax
3
4 Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 --*/
14
15 #header<<
16
17 #include "EfiVfr.h"
18 #include "VfrFormPkg.h"
19 #include "VfrError.h"
20 #include "VfrUtilityLib.h"
21 #include "AToken.h"
22 #include "ATokPtr.h"
23 >>
24
25 <<
26 #ifdef UINT8_MAX
27 #undef UINT8_MAX
28 #endif
29 #include "stdio.h"
30 #include "PBlackBox.h"
31 #include "DLexerBase.h"
32 #include "VfrLexer.h"
33 #include "AToken.h"
34
35 #define GET_LINENO(Obj) ((Obj)->getLine())
36 #define SET_LINE_INFO(Obj, L) do {(Obj).SetLineNo((L)->getLine());} while (0)
37 #define CRT_END_OP(Obj) do {CIfrEnd EObj; if (Obj != NULL) EObj.SetLineNo ((Obj)->getLine());} while (0)
38
39 typedef ANTLRCommonToken ANTLRToken;
40
41 class CVfrDLGLexer : public VfrLexer
42 {
43 public:
44 CVfrDLGLexer (DLGFileInput *F) : VfrLexer (F) {};
45 INT32 errstd (char *Text)
46 {
47 printf ("unrecognized input '%s'\n", Text);
48 }
49 };
50
51 UINT8
52 VfrParserStart (
53 IN FILE *File,
54 IN INPUT_INFO_TO_SYNTAX *InputInfo
55 )
56 {
57 ParserBlackBox<CVfrDLGLexer, EfiVfrParser, ANTLRToken> VfrParser(File);
58 VfrParser.parser()->SetCompatibleMode (InputInfo->CompatibleMode);
59 VfrParser.parser()->SetOverrideClassGuid (InputInfo->OverrideClassGuid);
60 return VfrParser.parser()->vfrProgram();
61 }
62 >>
63
64 //
65 // Define a lexical class for parsing quoted strings. Basically
66 // starts with a double quote, and ends with a double quote that
67 // is not preceeded with a backslash.
68 //
69 #lexclass QUOTED_STRING
70 #token TheString "~[\"]*\"" << mode (START); >>
71
72 //
73 // Define a lexclass for skipping over C++ style comments
74 //
75 #lexclass CPP_COMMENT
76 #token "~[\n]*" << skip (); >>
77 #token "\n" << skip (); mode (START); newline (); >>
78
79 //
80 // Standard lexclass is START
81 //
82 #lexclass START
83
84 //
85 // Find start of C++ style comments
86 //
87 #token "//" << skip (); mode (CPP_COMMENT); >>
88
89 //
90 // Skip whitespace
91 //
92 #token "[\ \t]" << skip (); >>
93
94 //
95 // Skip over newlines, but count them
96 //
97 #token "\n" << skip (); newline (); >>
98
99 //
100 // Skip over 'extern' in any included .H file
101 //
102 #token "extern" << skip (); mode (CPP_COMMENT); >>
103
104 //
105 // Tokens for the different keywords. Syntax is:
106 // TokenName("ErrorMessageText") "TokenString"
107 // where:
108 // TokenName is the token name (must be capitalized) that is used in the rules
109 // ErrorMessageText is the string the compiler emits when it detects a syntax error
110 // TokenString is the actual matching string used in the user script
111 //
112 #token FormPkgType("formpkgtype") "formpkgtype"
113 #token OpenBrace("{") "\{"
114 #token CloseBrace("}") "\}"
115 #token OpenParen("(") "\("
116 #token CloseParen(")") "\)"
117 #token OpenBracket("[") "\["
118 #token CloseBracket("]") "\]"
119
120 #token LineDefinition "#line\ [0-9]+\ \"~[\"]+\"[\ \t]*\n" << gCVfrErrorHandle.ParseFileScopeRecord (begexpr (), line ()); skip (); newline (); >>
121 #token DevicePath("devicepath") "devicepath"
122 #token FormSet("formset") "formset"
123 #token FormSetId("formsetid") "formsetid"
124 #token EndFormSet("endformset") "endformset"
125 #token Title("title") "title"
126 #token FormId("formid") "formid"
127 #token OneOf("oneof") "oneof"
128 #token EndOneOf("endoneof") "endoneof"
129 #token Prompt("prompt") "prompt"
130 #token OrderedList("orderedlist") "orderedlist"
131 #token MaxContainers("maxcontainers") "maxcontainers"
132 #token EndList("endlist") "endlist"
133 #token EndForm("endform") "endform"
134 #token Form("form") "form"
135 #token FormMap("formmap") "formmap"
136 #token MapTitle("maptitle") "maptitle"
137 #token MapGuid("mapguid") "mapguid"
138 #token Subtitle("subtitle") "subtitle"
139 #token EndSubtitle("endsubtitle") "endsubtitle"
140 #token Help("help") "help"
141 #token Text("text") "text"
142 #token Option("option") "option"
143 #token FLAGS("flags") "flags"
144 #token Date("date") "date"
145 #token EndDate("enddate") "enddate"
146 #token Year("year") "year"
147 #token Month("month") "month"
148 #token Day("day") "day"
149 #token Time("time") "time"
150 #token EndTime("endtime") "endtime"
151 #token Hour("hour") "hour"
152 #token Minute("minute") "minute"
153 #token Second("second") "second"
154 #token GrayOutIf("grayoutif") "grayoutif"
155 #token Label("label") "label"
156 #token Timeout("timeout") "timeout"
157 #token Inventory("inventory") "inventory"
158 #token NonNvDataMap("_NON_NV_DATA_MAP") "_NON_NV_DATA_MAP"
159 #token Struct("struct") "struct"
160 #token Union("union") "union"
161 #token Boolean("BOOLEAN") "BOOLEAN"
162 #token Uint64("UINT64") "UINT64"
163 #token Uint32("UINT32") "UINT32"
164 #token Uint16("UINT16") "UINT16"
165 #token Char16("CHAR16") "CHAR16"
166 #token Uint8("UINT8") "UINT8"
167 #token Uuid("guid") "guid"
168 #token CheckBox("checkbox") "checkbox"
169 #token EndCheckBox("endcheckbox") "endcheckbox"
170 #token Numeric("numeric") "numeric"
171 #token EndNumeric("endnumeric") "endnumeric"
172 #token Minimum("minimum") "minimum"
173 #token Maximum("maximum") "maximum"
174 #token STEP("step") "step"
175 #token Default("default") "default"
176 #token Password("password") "password"
177 #token EndPassword("endpassword") "endpassword"
178 #token String("string") "string"
179 #token EndString("endstring") "endstring"
180 #token MinSize("minsize") "minsize"
181 #token MaxSize("maxsize") "maxsize"
182 #token Encoding("encoding") "encoding"
183 #token SuppressIf("suppressif") "suppressif"
184 #token DisableIf("disableif") "disableif"
185 #token Hidden("hidden") "hidden"
186 #token Goto("goto") "goto"
187 #token FormSetGuid("formsetguid") "formsetguid"
188 #token InconsistentIf("inconsistentif") "inconsistentif"
189 #token WarningIf("warningif") "warningif"
190 #token NoSubmitIf("nosubmitif") "nosubmitif"
191 #token EndIf("endif") "endif"
192 #token Key("key") "key"
193 #token DefaultFlag("DEFAULT") "DEFAULT"
194 #token ManufacturingFlag("MANUFACTURING") "MANUFACTURING"
195 #token InteractiveFlag("INTERACTIVE") "INTERACTIVE"
196 #token NVAccessFlag("NV_ACCESS") "NV_ACCESS"
197 #token ResetRequiredFlag("RESET_REQUIRED") "RESET_REQUIRED"
198 #token ReconnectRequiredFlag("RECONNECT_REQUIRED") "RECONNECT_REQUIRED"
199 #token LateCheckFlag("LATE_CHECK") "LATE_CHECK"
200 #token ReadOnlyFlag("READ_ONLY") "READ_ONLY"
201 #token OptionOnlyFlag("OPTIONS_ONLY") "OPTIONS_ONLY"
202 #token Class("class") "class"
203 #token Subclass("subclass") "subclass"
204 #token ClassGuid("classguid") "classguid"
205 #token TypeDef("typedef") "typedef"
206 #token Restore("restore") "restore"
207 #token Save("save") "save"
208 #token Defaults("defaults") "defaults"
209 #token Banner("banner") "banner"
210 #token Align("align") "align"
211 #token Left("left") "left"
212 #token Right("right") "right"
213 #token Center("center") "center"
214 #token Line("line") "line"
215 #token Name("name") "name"
216
217 #token VarId("varid") "varid"
218 #token Question("question") "question"
219 #token QuestionId("questionid") "questionid"
220 #token Image("image") "image"
221 #token Locked("locked") "locked"
222 #token Rule("rule") "rule"
223 #token EndRule("endrule") "endrule"
224 #token Value("value") "value"
225 #token Read("read") "read"
226 #token Write("write") "write"
227 #token ResetButton("resetbutton") "resetbutton"
228 #token EndResetButton("endresetbutton") "endresetbutton"
229 #token DefaultStore("defaultstore") "defaultstore"
230 #token Attribute("attribute") "attribute"
231 #token Varstore("varstore") "varstore"
232 #token Efivarstore("efivarstore") "efivarstore"
233 #token VarSize("varsize") "varsize"
234 #token NameValueVarStore("namevaluevarstore") "namevaluevarstore"
235 #token Action("action") "action"
236 #token Config("config") "config"
237 #token EndAction("endaction") "endaction"
238 #token Refresh("refresh") "refresh"
239 #token Interval("interval") "interval"
240 #token VarstoreDevice("varstoredevice") "varstoredevice"
241 #token GuidOp("guidop") "guidop"
242 #token EndGuidOp("endguidop") "endguidop"
243 #token DataType("datatype") "datatype"
244 #token Data("data") "data"
245 #token Modal("modal") "modal"
246
247 //
248 // Define the class and subclass tokens
249 //
250 #token ClassNonDevice("NONDEVICE") "NON_DEVICE"
251 #token ClassDiskDevice("DISK_DEVICE") "DISK_DEVICE"
252 #token ClassVideoDevice("VIDEO_DEVICE") "VIDEO_DEVICE"
253 #token ClassNetworkDevice("NETWORK_DEVICE") "NETWORK_DEVICE"
254 #token ClassInputDevice("INPUT_DEVICE") "INPUT_DEVICE"
255 #token ClassOnBoardDevice("ONBOARD_DEVICE") "ONBOARD_DEVICE"
256 #token ClassOtherDevice("OTHER_DEVICE") "OTHER_DEVICE"
257
258 #token SubclassSetupApplication("SETUP_APPLICATION") "SETUP_APPLICATION"
259 #token SubclassGeneralApplication("GENERAL_APPLICATION") "GENERAL_APPLICATION"
260 #token SubclassFrontPage("FRONT_PAGE") "FRONT_PAGE"
261 #token SubclassSingleUse("SINGLE_USE") "SINGLE_USE"
262
263 //
264 // This is the overall definition of a VFR form definition script.
265 //
266
267 vfrProgram > [UINT8 Return] :
268 <<
269 mParserStatus = 0;
270 mCIfrOpHdrIndex = 0;
271 mConstantOnlyInExpression = FALSE;
272 >>
273 (
274 vfrPragmaPackDefinition
275 | vfrDataStructDefinition
276 | vfrDataUnionDefinition
277 )*
278 vfrFormSetDefinition
279 << $Return = mParserStatus; >>
280 ;
281
282 pragmaPackShowDef :
283 L:"show" << gCVfrVarDataTypeDB.Pack (L->getLine(), VFR_PACK_SHOW); >>
284 ;
285
286 pragmaPackStackDef :
287 <<
288 UINT32 LineNum;
289 UINT8 PackAction;
290 CHAR8 *Identifier = NULL;
291 UINT32 PackNumber = DEFAULT_PACK_ALIGN;
292 >>
293 (
294 L1:"push" << LineNum = L1->getLine(); PackAction = VFR_PACK_PUSH; >>
295 | L2:"pop" << LineNum = L2->getLine(); PackAction = VFR_PACK_POP; >>
296 )
297 {
298 "," ID:StringIdentifier << Identifier = ID->getText(); >>
299 }
300 {
301 "," N:Number << PackAction |= VFR_PACK_ASSIGN; PackNumber = _STOU32(N->getText(), N->getLine()); >>
302 }
303 << gCVfrVarDataTypeDB.Pack (LineNum, PackAction, Identifier, PackNumber); >>
304 ;
305
306 pragmaPackNumber :
307 <<
308 UINT32 LineNum;
309 UINT32 PackNumber = DEFAULT_PACK_ALIGN;
310 >>
311 N:Number << LineNum = N->getLine(); PackNumber = _STOU32(N->getText(), N->getLine()); >>
312 << gCVfrVarDataTypeDB.Pack (LineNum, VFR_PACK_ASSIGN, NULL, PackNumber); >>
313 ;
314
315 vfrPragmaPackDefinition :
316 "\#pragma" "pack" "\("
317 {
318 pragmaPackShowDef
319 | pragmaPackStackDef
320 | pragmaPackNumber
321 }
322 "\)"
323 ;
324
325 vfrDataUnionDefinition :
326 { TypeDef } Union << gCVfrVarDataTypeDB.DeclareDataTypeBegin (); >>
327 { NonNvDataMap }
328 {
329 N1:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N1->getText()), N1); >>
330 }
331 OpenBrace
332 vfrDataStructFields[TRUE]
333 CloseBrace
334 {
335 N2:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N2->getText()), N2); >>
336 }
337 ";" << gCVfrVarDataTypeDB.DeclareDataTypeEnd ();>>
338 ;
339
340 vfrDataStructDefinition :
341 { TypeDef } Struct << gCVfrVarDataTypeDB.DeclareDataTypeBegin (); >>
342 { NonNvDataMap }
343 {
344 N1:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N1->getText()), N1); >>
345 }
346 OpenBrace
347 vfrDataStructFields[FALSE]
348 CloseBrace
349 {
350 N2:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N2->getText()), N2); >>
351 }
352 ";" << gCVfrVarDataTypeDB.DeclareDataTypeEnd (); >>
353 ;
354
355 vfrDataStructFields [BOOLEAN FieldInUnion]:
356 (
357 dataStructField64 [FieldInUnion] |
358 dataStructField32 [FieldInUnion] |
359 dataStructField16 [FieldInUnion] |
360 dataStructField8 [FieldInUnion] |
361 dataStructFieldBool [FieldInUnion] |
362 dataStructFieldString [FieldInUnion]|
363 dataStructFieldDate [FieldInUnion] |
364 dataStructFieldTime [FieldInUnion] |
365 dataStructFieldRef [FieldInUnion] |
366 dataStructFieldUser [FieldInUnion]
367 )*
368 ;
369
370 dataStructField64 [BOOLEAN FieldInUnion]:
371 << UINT32 ArrayNum = 0; >>
372 D:"UINT64"
373 N:StringIdentifier
374 {
375 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
376 }
377 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
378 ;
379
380 dataStructField32 [BOOLEAN FieldInUnion]:
381 << UINT32 ArrayNum = 0; >>
382 D:"UINT32"
383 N:StringIdentifier
384 {
385 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
386 }
387 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
388 ;
389
390 dataStructField16 [BOOLEAN FieldInUnion]:
391 <<
392 UINT32 ArrayNum = 0;
393 >>
394 ("UINT16" | "CHAR16")
395 N:StringIdentifier
396 {
397 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
398 }
399 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), (CHAR8 *) "UINT16", ArrayNum, FieldInUnion), N); >>
400 ;
401
402 dataStructField8 [BOOLEAN FieldInUnion]:
403 << UINT32 ArrayNum = 0; >>
404 D:"UINT8"
405 N:StringIdentifier
406 {
407 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
408 }
409 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
410 ;
411
412 dataStructFieldBool [BOOLEAN FieldInUnion]:
413 << UINT32 ArrayNum = 0; >>
414 D:"BOOLEAN"
415 N:StringIdentifier
416 {
417 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
418 }
419 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
420 ;
421
422 dataStructFieldString [BOOLEAN FieldInUnion]:
423 << UINT32 ArrayNum = 0; >>
424 D:"EFI_STRING_ID"
425 N:StringIdentifier
426 {
427 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
428 }
429 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
430 ;
431
432 dataStructFieldDate [BOOLEAN FieldInUnion]:
433 << UINT32 ArrayNum = 0; >>
434 D:"EFI_HII_DATE"
435 N:StringIdentifier
436 {
437 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
438 }
439 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
440 ;
441
442 dataStructFieldTime [BOOLEAN FieldInUnion]:
443 << UINT32 ArrayNum = 0; >>
444 D:"EFI_HII_TIME"
445 N:StringIdentifier
446 {
447 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
448 }
449 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
450 ;
451
452 dataStructFieldRef [BOOLEAN FieldInUnion]:
453 << UINT32 ArrayNum = 0; >>
454 D:"EFI_HII_REF"
455 N:StringIdentifier
456 {
457 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
458 }
459 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
460 ;
461
462 dataStructFieldUser [BOOLEAN FieldInUnion]:
463 << UINT32 ArrayNum = 0; >>
464 T:StringIdentifier
465 N:StringIdentifier
466 {
467 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
468 }
469 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), T->getText(), ArrayNum, FieldInUnion), T); >>
470 ;
471
472 //*****************************************************************************
473 //
474 // the syntax of GUID definition
475 //
476 guidSubDefinition [EFI_GUID &Guid] :
477 G4:Number "," G5:Number "," G6:Number "," G7:Number "," G8:Number "," G9:Number "," G10:Number "," G11:Number
478 <<
479 Guid.Data4[0] = _STOU8(G4->getText(), G4->getLine());
480 Guid.Data4[1] = _STOU8(G5->getText(), G5->getLine());
481 Guid.Data4[2] = _STOU8(G6->getText(), G6->getLine());
482 Guid.Data4[3] = _STOU8(G7->getText(), G7->getLine());
483 Guid.Data4[4] = _STOU8(G8->getText(), G8->getLine());
484 Guid.Data4[5] = _STOU8(G9->getText(), G9->getLine());
485 Guid.Data4[6] = _STOU8(G10->getText(), G10->getLine());
486 Guid.Data4[7] = _STOU8(G11->getText(), G11->getLine());
487 >>
488 ;
489
490 guidDefinition [EFI_GUID &Guid] :
491 OpenBrace
492 G1:Number "," G2:Number "," G3:Number ","
493 <<
494 Guid.Data1 = _STOU32 (G1->getText(), G1->getLine());
495 Guid.Data2 = _STOU16 (G2->getText(), G2->getLine());
496 Guid.Data3 = _STOU16 (G3->getText(), G3->getLine());
497 >>
498 (
499 OpenBrace guidSubDefinition[Guid] CloseBrace
500 | guidSubDefinition[Guid]
501 )
502 CloseBrace
503 ;
504
505 //*****************************************************************************
506 //
507 // the syntax of form set definition
508 //
509 vfrFormSetDefinition :
510 <<
511 EFI_GUID Guid;
512 EFI_GUID DefaultClassGuid = EFI_HII_PLATFORM_SETUP_FORMSET_GUID;
513 EFI_GUID ClassGuid1, ClassGuid2, ClassGuid3;
514 UINT8 ClassGuidNum = 0;
515 CIfrFormSet *FSObj = NULL;
516 UINT16 C, SC;
517 CHAR8* InsertOpcodeAddr = NULL;
518 >>
519 L:FormSet
520 Uuid "=" guidDefinition[Guid] ","
521 Title "=" "STRING_TOKEN" "\(" S1:Number "\)" ","
522 Help "=" "STRING_TOKEN" "\(" S2:Number "\)" ","
523 {
524 ClassGuid "=" guidDefinition[ClassGuid1] << ++ClassGuidNum; >>
525 {
526 "\|" guidDefinition[ClassGuid2] << ++ClassGuidNum; >>
527 {
528 "\|" guidDefinition[ClassGuid3] << ++ClassGuidNum; >>
529 }
530 }
531 ","
532 }
533 <<
534 if (mOverrideClassGuid != NULL && ClassGuidNum >= 3) {
535 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Already has 3 class guids, can't add extra class guid!");
536 }
537 switch (ClassGuidNum) {
538 case 0:
539 if (mOverrideClassGuid != NULL) {
540 ClassGuidNum = 2;
541 } else {
542 ClassGuidNum = 1;
543 }
544 FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID));
545 FSObj->SetClassGuid(&DefaultClassGuid);
546 if (mOverrideClassGuid != NULL) {
547 FSObj->SetClassGuid(mOverrideClassGuid);
548 }
549 break;
550 case 1:
551 if (mOverrideClassGuid != NULL) {
552 ClassGuidNum ++;
553 }
554 FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID));
555 FSObj->SetClassGuid(&ClassGuid1);
556 if (mOverrideClassGuid != NULL) {
557 FSObj->SetClassGuid(mOverrideClassGuid);
558 }
559 break;
560 case 2:
561 if (mOverrideClassGuid != NULL) {
562 ClassGuidNum ++;
563 }
564 FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID));
565 FSObj->SetClassGuid(&ClassGuid1);
566 FSObj->SetClassGuid(&ClassGuid2);
567 if (mOverrideClassGuid != NULL) {
568 FSObj->SetClassGuid(mOverrideClassGuid);
569 }
570 break;
571 case 3:
572 FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID));
573 FSObj->SetClassGuid(&ClassGuid1);
574 FSObj->SetClassGuid(&ClassGuid2);
575 FSObj->SetClassGuid(&ClassGuid3);
576 break;
577 default:
578 break;
579 }
580
581 SET_LINE_INFO (*FSObj, L);
582 FSObj->SetGuid (&Guid);
583 //
584 // for framework vfr to store formset guid used by varstore and efivarstore
585 //
586 if (mCompatibleMode) {
587 memcpy (&mFormsetGuid, &Guid, sizeof (EFI_GUID));
588 }
589 FSObj->SetFormSetTitle (_STOSID(S1->getText(), S1->getLine()));
590 FSObj->SetHelp (_STOSID(S2->getText(), S2->getLine()));
591 >>
592 {
593 FC:Class "=" classDefinition[C] "," << {CIfrClass CObj;SET_LINE_INFO (CObj, FC); CObj.SetClass(C);} >>
594 }
595 {
596 FSC:Subclass "=" subclassDefinition[SC] "," << {CIfrSubClass SCObj; SET_LINE_INFO (SCObj, FSC); SCObj.SetSubClass(SC);} >>
597 }
598 <<
599 _DeclareStandardDefaultStorage (GET_LINENO (L));
600 >>
601 vfrFormSetList
602 E:EndFormSet <<
603 if (mCompatibleMode) {
604 //
605 // declare all undefined varstore and efivarstore
606 //
607 _DeclareDefaultFrameworkVarStore (GET_LINENO(E));
608 }
609
610 //
611 // Declare undefined Question so that they can be used in expression.
612 //
613 if (gCFormPkg.HavePendingUnassigned()) {
614 mParserStatus += gCFormPkg.DeclarePendingQuestion (
615 gCVfrVarDataTypeDB,
616 gCVfrDataStorage,
617 mCVfrQuestionDB,
618 &mFormsetGuid,
619 E->getLine(),
620 &InsertOpcodeAddr
621 );
622 gNeedAdjustOpcode = TRUE;
623 }
624
625 CRT_END_OP (E);
626
627 //
628 // Adjust the pending question position.
629 // Move the position from current to before the end of the last form in the form set.
630 //
631 if (gNeedAdjustOpcode) {
632 gCFormPkg.AdjustDynamicInsertOpcode (
633 mLastFormEndAddr,
634 InsertOpcodeAddr,
635 FALSE
636 );
637 }
638
639 if (FSObj != NULL) {
640 delete FSObj;
641 }
642 >>
643 ";"
644 ;
645
646 vfrFormSetList :
647 (
648 vfrFormDefinition |
649 vfrFormMapDefinition |
650 vfrStatementImage |
651 vfrStatementVarStoreLinear |
652 vfrStatementVarStoreEfi |
653 vfrStatementVarStoreNameValue |
654 vfrStatementDefaultStore |
655 vfrStatementDisableIfFormSet |
656 vfrStatementSuppressIfFormSet |
657 vfrStatementExtension
658 )*
659 ;
660
661 vfrStatementExtension:
662 <<
663 EFI_GUID Guid;
664 CIfrGuid *GuidObj = NULL;
665 CHAR8 *TypeName = NULL;
666 UINT32 TypeSize = 0;
667 UINT8 *DataBuff = NULL;
668 UINT32 Size = 0;
669 UINT8 Idx = 0;
670 UINT32 LineNum;
671 BOOLEAN IsStruct = FALSE;
672 UINT32 ArrayNum = 0;
673 >>
674 L:GuidOp
675 Uuid "=" guidDefinition[Guid]
676 {"," DataType "="
677 (
678 U64:"UINT64" {OpenBracket AN1:Number CloseBracket <<ArrayNum = _STOU32(AN1->getText(), AN1->getLine());>>}
679 << TypeName = U64->getText(); LineNum = U64->getLine(); >>
680 | U32:"UINT32" {OpenBracket AN2:Number CloseBracket <<ArrayNum = _STOU32(AN2->getText(), AN2->getLine());>>}
681 << TypeName = U32->getText(); LineNum = U32->getLine(); >>
682 | U16:"UINT16" {OpenBracket AN3:Number CloseBracket <<ArrayNum = _STOU32(AN3->getText(), AN3->getLine());>>}
683 << TypeName = U16->getText(); LineNum = U16->getLine(); >>
684 | U8:"UINT8" {OpenBracket AN4:Number CloseBracket <<ArrayNum = _STOU32(AN4->getText(), AN4->getLine());>>}
685 << TypeName = U8->getText(); LineNum = U8->getLine(); >>
686 | BL:"BOOLEAN" {OpenBracket AN5:Number CloseBracket <<ArrayNum = _STOU32(AN5->getText(), AN5->getLine());>>}
687 << TypeName = BL->getText(); LineNum = BL->getLine(); >>
688 | SI:"EFI_STRING_ID" {OpenBracket AN6:Number CloseBracket <<ArrayNum = _STOU32(AN6->getText(), AN6->getLine());>>}
689 << TypeName = SI->getText(); LineNum = SI->getLine(); >>
690 | D:"EFI_HII_DATE" {OpenBracket AN7:Number CloseBracket <<ArrayNum = _STOU32(AN7->getText(), AN7->getLine());>>}
691 << TypeName = D->getText(); LineNum = D->getLine(); IsStruct = TRUE;>>
692 | T:"EFI_HII_TIME" {OpenBracket AN8:Number CloseBracket <<ArrayNum = _STOU32(AN8->getText(), AN8->getLine());>>}
693 << TypeName = T->getText(); LineNum = T->getLine(); IsStruct = TRUE;>>
694 | R:"EFI_HII_REF" {OpenBracket AN9:Number CloseBracket <<ArrayNum = _STOU32(AN9->getText(), AN9->getLine());>>}
695 << TypeName = R->getText(); LineNum = R->getLine(); IsStruct = TRUE;>>
696 | TN:StringIdentifier {OpenBracket AN10:Number CloseBracket <<ArrayNum = _STOU32(AN10->getText(), AN10->getLine());>>}
697 << TypeName = TN->getText(); LineNum = TN->getLine(); IsStruct = TRUE;>>
698 )
699 <<
700 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &TypeSize), LineNum);
701 if (ArrayNum > 0) {
702 Size = TypeSize*ArrayNum;
703 } else {
704 Size = TypeSize;
705 }
706 if (Size > (128 - sizeof (EFI_IFR_GUID))) return;
707 DataBuff = (UINT8 *)malloc(Size);
708 for (Idx = 0; Idx < Size; Idx++) {
709 DataBuff[Idx] = 0;
710 }
711 >>
712 vfrExtensionData [DataBuff, Size, TypeName, TypeSize, IsStruct, ArrayNum]
713 }
714 <<
715 {
716 GuidObj = new CIfrGuid(Size);
717 if (GuidObj != NULL) {
718 GuidObj->SetLineNo(L->getLine());
719 GuidObj->SetGuid (&Guid);
720 }
721 }
722 if (TypeName != NULL) {
723 GuidObj->SetData(DataBuff, Size);
724 }
725 >>
726 {","
727 (
728 vfrStatementExtension
729 )*
730 E:EndGuidOp << GuidObj->SetScope(1); CRT_END_OP (E); >>
731 }
732 <<
733 if (GuidObj != NULL) delete GuidObj;
734 if (DataBuff != NULL) free(DataBuff);
735 >>
736 ";"
737 ;
738
739 vfrExtensionData[UINT8 *DataBuff, UINT32 Size, CHAR8 *TypeName, UINT32 TypeSize, BOOLEAN IsStruct, UINT32 ArrayNum]:
740 <<
741 CHAR8 *TFName = NULL;
742 UINT32 ArrayIdx = 0;
743 UINT16 FieldOffset;
744 UINT8 FieldType;
745 UINT32 FieldSize;
746 UINT64 Data_U64 = 0;
747 UINT32 Data_U32 = 0;
748 UINT16 Data_U16 = 0;
749 UINT8 Data_U8 = 0;
750 BOOLEAN Data_BL = 0;
751 EFI_STRING_ID Data_SID = 0;
752 BOOLEAN IsArray = FALSE;
753 UINT8 *ByteOffset = NULL;
754 >>
755 (
756 ("," "data" {OpenBracket IDX1:Number CloseBracket <<IsArray = TRUE;>>}
757 <<
758 ArrayIdx = 0;
759 if (IsArray == TRUE) {
760 ArrayIdx = _STOU8(IDX1->getText(), IDX1->getLine());
761 if (ArrayIdx >= ArrayNum) return;
762 IsArray = FALSE;
763 }
764 ByteOffset = DataBuff + (ArrayIdx * TypeSize);
765 if (IsStruct == TRUE) {
766 _STRCAT(&TFName, TypeName);
767 }
768 >>
769 ("." FN:StringIdentifier
770 <<
771 if (IsStruct == TRUE) {
772 _STRCAT(&TFName, ".");
773 _STRCAT(&TFName, FN->getText());
774 }
775 >>
776 {
777 OpenBracket IDX2:Number CloseBracket
778 <<
779 if (IsStruct == TRUE) {
780 _STRCAT(&TFName, "[");
781 _STRCAT(&TFName, IDX2->getText());
782 _STRCAT(&TFName, "]");
783 }
784 >>
785 }
786 )*
787 "=" RD:Number
788 <<
789 if (IsStruct == FALSE) {
790 if (strcmp ("UINT64", TypeName) == 0) {
791 Data_U64 = _STOU64(RD->getText(), RD->getLine());
792 memcpy (ByteOffset, &Data_U64, TypeSize);
793 }else if (strcmp ("UINT32", TypeName) == 0) {
794 Data_U32 = _STOU32(RD->getText(), RD->getLine());
795 memcpy (ByteOffset, &Data_U32, TypeSize);
796 }else if (strcmp ("UINT16", TypeName) == 0) {
797 Data_U16 = _STOU16(RD->getText(), RD->getLine());
798 memcpy (ByteOffset, &Data_U16, TypeSize);
799 }else if (strcmp ("UINT8", TypeName) == 0) {
800 Data_U8 = _STOU8(RD->getText(), RD->getLine());
801 memcpy (ByteOffset, &Data_U8, TypeSize);
802 }else if (strcmp ("BOOLEAN", TypeName)== 0) {
803 Data_BL = _STOU8(RD->getText(), RD->getLine());
804 memcpy (ByteOffset, &Data_BL, TypeSize);
805 }else if (strcmp ("EFI_STRING_ID", TypeName) == 0) {
806 Data_SID = _STOSID(RD->getText(), RD->getLine());
807 memcpy (ByteOffset, &Data_SID, TypeSize);
808 }
809 } else {
810 gCVfrVarDataTypeDB.GetDataFieldInfo(TFName, FieldOffset, FieldType, FieldSize);
811 switch (FieldType) {
812 case EFI_IFR_TYPE_NUM_SIZE_8:
813 Data_U8 = _STOU8(RD->getText(), RD->getLine());
814 memcpy (ByteOffset + FieldOffset, &Data_U8, FieldSize);
815 break;
816 case EFI_IFR_TYPE_NUM_SIZE_16:
817 Data_U16 = _STOU16(RD->getText(), RD->getLine());
818 memcpy (ByteOffset + FieldOffset, &Data_U16, FieldSize);
819 break;
820 case EFI_IFR_TYPE_NUM_SIZE_32:
821 Data_U32 = _STOU32(RD->getText(), RD->getLine());
822 memcpy (ByteOffset + FieldOffset, &Data_U32, FieldSize);
823 break;
824 case EFI_IFR_TYPE_NUM_SIZE_64:
825 Data_U64 = _STOU64(RD->getText(), RD->getLine());
826 memcpy (ByteOffset + FieldOffset, &Data_U64, FieldSize);
827 break;
828 case EFI_IFR_TYPE_BOOLEAN:
829 Data_BL = _STOU8(RD->getText(), RD->getLine());
830 memcpy (ByteOffset + FieldOffset, &Data_BL, FieldSize);
831 break;
832 case EFI_IFR_TYPE_STRING:
833 Data_SID = _STOSID(RD->getText(), RD->getLine());
834 memcpy (ByteOffset + FieldOffset, &Data_SID, FieldSize);
835 break;
836 default:
837 break;
838 }
839 }
840 if (TFName != NULL) { delete TFName; TFName = NULL; }
841 >>
842 )*
843 )
844 ;
845
846
847 vfrStatementDefaultStore :
848 << UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD; >>
849 D:DefaultStore N:StringIdentifier ","
850 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)"
851 {
852 "," Attribute "=" A:Number << DefaultId = _STOU16(A->getText(), A->getLine()); >>
853 }
854 <<
855 if (gCVfrDefaultStore.DefaultIdRegistered (DefaultId) == FALSE) {
856 CIfrDefaultStore DSObj;
857 _PCATCH(gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), N->getText(), _STOSID(S->getText(), S->getLine()), DefaultId)), D->getLine();
858 DSObj.SetLineNo(D->getLine());
859 DSObj.SetDefaultName (_STOSID(S->getText(), S->getLine()));
860 DSObj.SetDefaultId (DefaultId);
861 } else {
862 _PCATCH(gCVfrDefaultStore.ReRegisterDefaultStoreById (DefaultId, N->getText(), _STOSID(S->getText(), S->getLine()))), D->getLine();
863 }
864 >>
865 ";"
866 ;
867
868 vfrStatementVarStoreLinear :
869 <<
870 EFI_GUID Guid;
871 CIfrVarStore VSObj;
872 CHAR8 *TypeName;
873 CHAR8 *StoreName;
874 UINT32 LineNum;
875 EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
876 UINT32 Size;
877 >>
878 V:Varstore << VSObj.SetLineNo(V->getLine()); >>
879 (
880 TN:StringIdentifier "," << TypeName = TN->getText(); LineNum = TN->getLine(); >>
881 | U8:"UINT8" "," << TypeName = U8->getText(); LineNum = U8->getLine(); >>
882 | U16:"UINT16" "," << TypeName = U16->getText(); LineNum = U16->getLine(); >>
883 | C16:"CHAR16" "," << TypeName = (CHAR8 *) "UINT16"; LineNum = C16->getLine(); >>
884 | U32:"UINT32" "," << TypeName = U32->getText(); LineNum = U32->getLine(); >>
885 | U64:"UINT64" "," << TypeName = U64->getText(); LineNum = U64->getLine(); >>
886 | D:"EFI_HII_DATE" "," << TypeName = D->getText(); LineNum = D->getLine(); >>
887 | T:"EFI_HII_TIME" "," << TypeName = T->getText(); LineNum = T->getLine(); >>
888 | R:"EFI_HII_REF" "," << TypeName = R->getText(); LineNum = R->getLine(); >>
889 )
890 { Key "=" FID:Number "," << // Key is used to assign Varid in Framework VFR but no use in UEFI2.1 VFR
891 if (mCompatibleMode) {
892 VarStoreId = _STOU16(FID->getText(), FID->getLine());
893 }
894 >>
895 }
896 {
897 VarId "=" ID:Number "," <<
898 _PCATCH(
899 (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0,
900 (INTN)TRUE,
901 ID,
902 "varid 0 is not allowed."
903 );
904 >>
905 }
906 Name "=" SN:StringIdentifier ","
907 Uuid "=" guidDefinition[Guid]
908 <<
909 if (mCompatibleMode) {
910 StoreName = TypeName;
911 } else {
912 StoreName = SN->getText();
913 }
914 _PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
915 StoreName,
916 &Guid,
917 &gCVfrVarDataTypeDB,
918 TypeName,
919 VarStoreId
920 ), LineNum);
921 VSObj.SetGuid (&Guid);
922 _PCATCH(gCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN);
923 VSObj.SetVarStoreId (VarStoreId);
924 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);
925 VSObj.SetSize ((UINT16) Size);
926 VSObj.SetName (SN->getText());
927 >>
928 ";"
929 ;
930
931 vfrStatementVarStoreEfi :
932 <<
933 BOOLEAN IsUEFI23EfiVarstore = TRUE;
934 EFI_GUID Guid;
935 CIfrVarStoreEfi VSEObj;
936 EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
937 UINT32 Attr = 0;
938 UINT32 Size;
939 CHAR8 *TypeName;
940 UINT32 LineNum;
941 CHAR8 *StoreName = NULL;
942 BOOLEAN CustomizedName = FALSE;
943 >>
944 E:Efivarstore << VSEObj.SetLineNo(E->getLine()); >>
945 (
946 TN:StringIdentifier "," << TypeName = TN->getText(); LineNum = TN->getLine(); CustomizedName = TRUE; >>
947 | U8:"UINT8" "," << TypeName = U8->getText(); LineNum = U8->getLine(); >>
948 | U16:"UINT16" "," << TypeName = U16->getText(); LineNum = U16->getLine(); >>
949 | C16:"CHAR16" "," << TypeName = (CHAR8 *) "UINT16"; LineNum = C16->getLine(); >>
950 | U32:"UINT32" "," << TypeName = U32->getText(); LineNum = U32->getLine(); >>
951 | U64:"UINT64" "," << TypeName = U64->getText(); LineNum = U64->getLine(); >>
952 | D:"EFI_HII_DATE" "," << TypeName = D->getText(); LineNum = D->getLine(); >>
953 | T:"EFI_HII_TIME" "," << TypeName = T->getText(); LineNum = T->getLine(); >>
954 | R:"EFI_HII_REF" "," << TypeName = R->getText(); LineNum = R->getLine(); >>
955 )
956 {
957 VarId "=" ID:Number "," <<
958 _PCATCH(
959 (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0,
960 (INTN)TRUE,
961 ID,
962 "varid 0 is not allowed."
963 );
964 >>
965 }
966 Attribute "=" vfrVarStoreEfiAttr[Attr] ( "\|" vfrVarStoreEfiAttr[Attr] )* ","
967 << VSEObj.SetAttributes (Attr); >>
968
969 (
970 Name "=" SN:StringIdentifier "," << StoreName = SN->getText(); >>
971 |
972 Name "=" "STRING_TOKEN" "\(" VN:Number "\)" ","
973 VarSize "=" N:Number "," <<
974 IsUEFI23EfiVarstore = FALSE;
975 StoreName = gCVfrStringDB.GetVarStoreNameFormStringId(_STOSID(VN->getText(), VN->getLine()));
976 if (StoreName == NULL) {
977 _PCATCH (VFR_RETURN_UNSUPPORTED, VN->getLine(), "Can't get varstore name for this StringId!");
978 }
979 if (!CustomizedName) {
980 _PCATCH (VFR_RETURN_UNSUPPORTED, E->getLine(), "Old style efivarstore must have String Identifier!");
981 return;
982 }
983 Size = _STOU32(N->getText(), N->getLine());
984 switch (Size) {
985 case 1:
986 TypeName = (CHAR8 *) "UINT8";
987 break;
988 case 2:
989 TypeName = (CHAR8 *) "UINT16";
990 break;
991 case 4:
992 TypeName = (CHAR8 *) "UINT32";
993 break;
994 case 8:
995 TypeName = (CHAR8 *) "UINT64";
996 break;
997 default:
998 _PCATCH (VFR_RETURN_UNSUPPORTED, N);
999 break;
1000 }
1001 >>
1002 )
1003
1004 Uuid "=" guidDefinition[Guid] <<
1005 if (IsUEFI23EfiVarstore) {
1006 _PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
1007 StoreName,
1008 &Guid,
1009 &gCVfrVarDataTypeDB,
1010 TypeName,
1011 VarStoreId
1012 ), LineNum);
1013 _PCATCH(gCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN);
1014 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);
1015 } else {
1016 _PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
1017 TN->getText(),
1018 &Guid,
1019 &gCVfrVarDataTypeDB,
1020 TypeName,
1021 VarStoreId
1022 ), LineNum);
1023 _PCATCH(gCVfrDataStorage.GetVarStoreId(TN->getText(), &VarStoreId, &Guid), VN);
1024 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), N->getLine());
1025 }
1026 VSEObj.SetGuid (&Guid);
1027 VSEObj.SetVarStoreId (VarStoreId);
1028
1029 VSEObj.SetSize ((UINT16) Size);
1030 VSEObj.SetName (StoreName);
1031 if (IsUEFI23EfiVarstore == FALSE && StoreName != NULL) {
1032 delete StoreName;
1033 }
1034 >>
1035 ";"
1036 ;
1037
1038 vfrVarStoreEfiAttr [UINT32 & Attr] :
1039 N:Number << $Attr |= _STOU32(N->getText(), N->getLine()); >>
1040 ;
1041
1042 vfrStatementVarStoreNameValue :
1043 <<
1044 EFI_GUID Guid;
1045 CIfrVarStoreNameValue VSNVObj;
1046 EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
1047 BOOLEAN Created = FALSE;
1048 >>
1049 L:NameValueVarStore << VSNVObj.SetLineNo(L->getLine()); >>
1050 SN:StringIdentifier ","
1051 {
1052 VarId "=" ID:Number "," <<
1053 _PCATCH(
1054 (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0,
1055 (INTN)TRUE,
1056 ID,
1057 "varid 0 is not allowed."
1058 );
1059 >>
1060 }
1061 (
1062 Name "=" "STRING_TOKEN" "\(" N:Number "\)" "," <<
1063 if (!Created) {
1064 _PCATCH(gCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText(), VarStoreId), SN);
1065 Created = TRUE;
1066 }
1067 _PCATCH(gCVfrDataStorage.NameTableAddItem (_STOSID(N->getText(), N->getLine())), SN);
1068 >>
1069 )+
1070 Uuid "=" guidDefinition[Guid] << _PCATCH(gCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >>
1071 <<
1072 VSNVObj.SetGuid (&Guid);
1073 _PCATCH(gCVfrDataStorage.GetVarStoreId(SN->getText(), &VarStoreId, &Guid), SN);
1074 VSNVObj.SetVarStoreId (VarStoreId);
1075 >>
1076 ";"
1077 ;
1078
1079 //
1080 // keep classDeinition and validClassNames for compatibility but not generate
1081 // any IFR object
1082 //
1083 classDefinition[UINT16 & Class] :
1084 << $Class = 0; >>
1085 validClassNames[$Class] ( "\|" validClassNames[$Class] )*
1086 ;
1087
1088 validClassNames[UINT16 & Class] :
1089 ClassNonDevice << $Class |= EFI_NON_DEVICE_CLASS; >>
1090 | ClassDiskDevice << $Class |= EFI_DISK_DEVICE_CLASS; >>
1091 | ClassVideoDevice << $Class |= EFI_VIDEO_DEVICE_CLASS; >>
1092 | ClassNetworkDevice << $Class |= EFI_NETWORK_DEVICE_CLASS; >>
1093 | ClassInputDevice << $Class |= EFI_INPUT_DEVICE_CLASS; >>
1094 | ClassOnBoardDevice << $Class |= EFI_ON_BOARD_DEVICE_CLASS; >>
1095 | ClassOtherDevice << $Class |= EFI_OTHER_DEVICE_CLASS; >>
1096 | N:Number << $Class |= _STOU16(N->getText(), N->getLine()); >>
1097 ;
1098
1099 subclassDefinition[UINT16 & SubClass] :
1100 << $SubClass = 0; >>
1101 SubclassSetupApplication << $SubClass |= EFI_SETUP_APPLICATION_SUBCLASS; >>
1102 | SubclassGeneralApplication << $SubClass |= EFI_GENERAL_APPLICATION_SUBCLASS; >>
1103 | SubclassFrontPage << $SubClass |= EFI_FRONT_PAGE_SUBCLASS; >>
1104 | SubclassSingleUse << $SubClass |= EFI_SINGLE_USE_SUBCLASS; >>
1105 | N:Number << $SubClass |= _STOU16(N->getText(), N->getLine()); >>
1106 ;
1107
1108 vfrStatementDisableIfFormSet :
1109 <<
1110 CIfrDisableIf DIObj;
1111 mConstantOnlyInExpression = TRUE;
1112 >>
1113 D:DisableIf << DIObj.SetLineNo(D->getLine()); >>
1114 vfrStatementExpression[0] ";" << mConstantOnlyInExpression = FALSE; >>
1115 vfrFormSetList
1116 E:EndIf << CRT_END_OP (E); >>
1117 ";"
1118 ;
1119
1120 vfrStatementSuppressIfFormSet :
1121 << CIfrSuppressIf SIObj;>>
1122 L:SuppressIf <<
1123 if (mCompatibleMode) {
1124 _PCATCH (VFR_RETURN_UNSUPPORTED, L);
1125 }
1126 SIObj.SetLineNo(L->getLine());
1127 >>
1128 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
1129 vfrStatementExpression[0] ";"
1130 vfrFormSetList
1131 E: EndIf
1132 ";" << CRT_END_OP (E); >>
1133 ;
1134
1135 //*****************************************************************************
1136 //
1137 // the syntax of question header and statement header
1138 //
1139 vfrStatementHeader[CIfrStatementHeader *SHObj] :
1140 Prompt "=" "STRING_TOKEN" "\(" S1:Number "\)" "," << $SHObj->SetPrompt (_STOSID(S1->getText(), S1->getLine())); >>
1141 Help "=" "STRING_TOKEN" "\(" S2:Number "\)" << $SHObj->SetHelp (_STOSID(S2->getText(), S2->getLine())); >>
1142 ;
1143
1144 vfrQuestionHeader[CIfrQuestionHeader & QHObj, EFI_QUESION_TYPE QType = QUESTION_NORMAL]:
1145 <<
1146 EFI_VARSTORE_INFO Info;
1147 Info.mVarType = EFI_IFR_TYPE_OTHER;
1148 Info.mVarTotalSize = 0;
1149 Info.mInfo.mVarOffset = EFI_VAROFFSET_INVALID;
1150 Info.mVarStoreId = EFI_VARSTORE_ID_INVALID;
1151 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
1152 CHAR8 *QName = NULL;
1153 CHAR8 *VarIdStr = NULL;
1154 mUsedDefaultCount = 0;
1155 >>
1156 {
1157 Name "=" QN:StringIdentifier "," <<
1158 QName = QN->getText();
1159 _PCATCH(mCVfrQuestionDB.FindQuestion (QName), VFR_RETURN_UNDEFINED, QN, "has already been used please used anther name");
1160 >>
1161 }
1162 { V:VarId "=" vfrStorageVarId[Info, VarIdStr] "," }
1163 {
1164 QuestionId "=" ID:Number "," <<
1165 QId = _STOQID(ID->getText(), ID->getLine());
1166 _PCATCH(mCVfrQuestionDB.FindQuestion (QId), VFR_RETURN_UNDEFINED, ID, "has already been used please assign another number");
1167 >>
1168 }
1169 <<
1170 switch (QType) {
1171 case QUESTION_NORMAL:
1172 mCVfrQuestionDB.RegisterQuestion (QName, VarIdStr, QId);
1173 break;
1174 case QUESTION_DATE:
1175 mCVfrQuestionDB.RegisterNewDateQuestion (QName, VarIdStr, QId);
1176 break;
1177 case QUESTION_TIME:
1178 mCVfrQuestionDB.RegisterNewTimeQuestion (QName, VarIdStr, QId);
1179 break;
1180 case QUESTION_REF:
1181 //
1182 // VarIdStr != NULL stand for question with storagae.
1183 //
1184 if (VarIdStr != NULL) {
1185 mCVfrQuestionDB.RegisterRefQuestion (QName, VarIdStr, QId);
1186 } else {
1187 mCVfrQuestionDB.RegisterQuestion (QName, NULL, QId);
1188 }
1189 break;
1190 default:
1191 _PCATCH(VFR_RETURN_FATAL_ERROR);
1192 }
1193 $QHObj.SetQuestionId (QId);
1194 if (VarIdStr != NULL) {
1195 $QHObj.SetVarStoreInfo (&Info);
1196 }
1197 >>
1198 vfrStatementHeader[&$QHObj]
1199 <<
1200 if (VarIdStr != NULL) {
1201 delete VarIdStr;
1202 }
1203 _SAVE_CURRQEST_VARINFO (Info);
1204 >>
1205 ;
1206
1207 questionheaderFlagsField[UINT8 & Flags] :
1208 ReadOnlyFlag << $Flags |= 0x01; >>
1209 | InteractiveFlag << $Flags |= 0x04; >>
1210 | ResetRequiredFlag << $Flags |= 0x10; >>
1211 | ReconnectRequiredFlag << $Flags |= 0x40; >>
1212 | O:OptionOnlyFlag <<
1213 if (mCompatibleMode) {
1214 $Flags |= 0x80;
1215 } else {
1216 gCVfrErrorHandle.HandleWarning (
1217 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
1218 O->getLine(),
1219 O->getText()
1220 );
1221 }
1222 >>
1223 | N:NVAccessFlag <<
1224 if (!mCompatibleMode) {
1225 gCVfrErrorHandle.HandleWarning (
1226 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
1227 N->getLine(),
1228 N->getText()
1229 );
1230 }
1231 >>
1232 | L:LateCheckFlag <<
1233 if (!mCompatibleMode) {
1234 gCVfrErrorHandle.HandleWarning (
1235 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
1236 L->getLine(),
1237 L->getText()
1238 );
1239 }
1240 >>
1241 ;
1242
1243 vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFlag = TRUE] :
1244 <<
1245 UINT32 Idx;
1246 UINT32 LineNo;
1247 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
1248 CHAR8 *VarIdStr = NULL;
1249 CHAR8 *VarStr = NULL;
1250 CHAR8 *SName = NULL;
1251 CHAR8 *TName = NULL;
1252 EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS;
1253 EFI_IFR_TYPE_VALUE Dummy = gZeroEfiIfrTypeValue;
1254 EFI_GUID *VarGuid = NULL;
1255 >>
1256 (
1257 SN1:StringIdentifier << SName = SN1->getText(); _STRCAT(&VarIdStr, SN1->getText()); >>
1258 OpenBracket I1:Number CloseBracket <<
1259 Idx = _STOU32(I1->getText(), I1->getLine());
1260 _STRCAT(&VarIdStr, "[");
1261 _STRCAT(&VarIdStr, I1->getText());
1262 _STRCAT(&VarIdStr, "]");
1263 >>
1264 <<
1265 VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId);
1266 if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) {
1267 gCVfrDataStorage.DeclareBufferVarStore (
1268 SName,
1269 &mFormsetGuid,
1270 &gCVfrVarDataTypeDB,
1271 SName,
1272 EFI_VARSTORE_ID_INVALID,
1273 FALSE
1274 );
1275 VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid);
1276 }
1277 if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {
1278 _PCATCH(VfrReturnCode, SN1);
1279 _PCATCH(gCVfrDataStorage.GetNameVarStoreInfo (&$Info, Idx), SN1);
1280 }
1281
1282 QuestVarIdStr = VarIdStr;
1283 >>
1284 )
1285 |
1286 (
1287 SN2:StringIdentifier << SName = SN2->getText(); _STRCAT(&VarIdStr, SName); >>
1288 <<
1289 VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId);
1290 if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) {
1291 gCVfrDataStorage.DeclareBufferVarStore (
1292 SName,
1293 &mFormsetGuid,
1294 &gCVfrVarDataTypeDB,
1295 SName,
1296 EFI_VARSTORE_ID_INVALID,
1297 FALSE
1298 );
1299 VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid);
1300 }
1301 if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {
1302 _PCATCH(VfrReturnCode, SN2);
1303 VarStoreType = gCVfrDataStorage.GetVarStoreType ($Info.mVarStoreId);
1304 if (VarStoreType == EFI_VFR_VARSTORE_BUFFER) {
1305 _PCATCH(gCVfrDataStorage.GetBufferVarStoreDataTypeName(Info.mVarStoreId, &TName), SN2);
1306 _STRCAT(&VarStr, TName);
1307 }
1308 }
1309 >>
1310
1311 (
1312 "." <<
1313 if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {
1314 _PCATCH(((VarStoreType != EFI_VFR_VARSTORE_BUFFER) ? VFR_RETURN_EFIVARSTORE_USE_ERROR : VFR_RETURN_SUCCESS), SN2);
1315 }
1316 _STRCAT(&VarIdStr, "."); _STRCAT(&VarStr, ".");
1317 >>
1318 SF:StringIdentifier << _STRCAT(&VarIdStr, SF->getText()); _STRCAT(&VarStr, SF->getText()); >>
1319 {
1320 OpenBracket I2:Number CloseBracket <<
1321 Idx = _STOU32(I2->getText(), I2->getLine());
1322 if (mCompatibleMode) Idx --;
1323 if (Idx > 0) {
1324 //
1325 // Idx == 0, [0] can be ignored.
1326 // Array[0] is same to Array for unify the varid name to cover [0]
1327 //
1328 _STRCAT(&VarIdStr, "[");
1329 _STRCAT(&VarIdStr, I2->getText());
1330 _STRCAT(&VarIdStr, "]");
1331 }
1332 _STRCAT(&VarStr, "[");
1333 _STRCAT(&VarStr, I2->getText());
1334 _STRCAT(&VarStr, "]");
1335 >>
1336 }
1337 )* <<
1338 switch (VarStoreType) {
1339 case EFI_VFR_VARSTORE_EFI:
1340 _PCATCH(gCVfrDataStorage.GetEfiVarStoreInfo (&$Info), SN2);
1341 break;
1342 case EFI_VFR_VARSTORE_BUFFER:
1343 _PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, $Info.mVarType, $Info.mVarTotalSize), SN2->getLine(), VarStr);
1344 VarGuid = gCVfrDataStorage.GetVarStoreGuid($Info.mVarStoreId);
1345 _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register (
1346 SName,
1347 VarGuid,
1348 NULL),
1349 SN2->getLine());
1350 _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Write (
1351 'a',
1352 SName,
1353 VarGuid,
1354 NULL,
1355 $Info.mVarType,
1356 $Info.mInfo.mVarOffset,
1357 $Info.mVarTotalSize,
1358 Dummy),
1359 SN2->getLine());
1360 _PCATCH(gCVfrDataStorage.AddBufferVarStoreFieldInfo(&$Info ),SN2->getLine());
1361 break;
1362 case EFI_VFR_VARSTORE_NAME:
1363 default: break;
1364 }
1365
1366 QuestVarIdStr = VarIdStr;
1367 if (VarStr != NULL) {delete VarStr;}
1368 >>
1369 )
1370 ;
1371
1372 vfrQuestionDataFieldName [EFI_QUESTION_ID &QId, UINT32 &Mask, CHAR8 *&VarIdStr, UINT32 &LineNo] :
1373 <<
1374 UINT32 Idx;
1375 VarIdStr = NULL; LineNo = 0;
1376 >>
1377 (
1378 SN1:StringIdentifier << _STRCAT(&VarIdStr, SN1->getText()); LineNo = SN1->getLine(); >>
1379 OpenBracket I1:Number CloseBracket <<
1380 _STRCAT(&VarIdStr, "[");
1381 _STRCAT(&VarIdStr, I1->getText());
1382 _STRCAT(&VarIdStr, "]");
1383 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, $QId, $Mask);
1384 if (mConstantOnlyInExpression) {
1385 _PCATCH(VFR_RETURN_CONSTANT_ONLY, LineNo);
1386 }
1387 >>
1388 )
1389 |
1390 (
1391 SN2:StringIdentifier << _STRCAT (&VarIdStr, SN2->getText()); LineNo = SN2->getLine(); >>
1392 (
1393 "." <<
1394 _STRCAT (&VarIdStr, ".");
1395 if (mConstantOnlyInExpression) {
1396 _PCATCH(VFR_RETURN_CONSTANT_ONLY, LineNo);
1397 }
1398 >>
1399 SF:StringIdentifier << _STRCAT (&VarIdStr, SF->getText()); >>
1400 {
1401 OpenBracket I2:Number CloseBracket <<
1402 Idx = _STOU32(I2->getText(), I2->getLine());
1403 if (mCompatibleMode) Idx --;
1404 if (Idx > 0) {
1405 //
1406 // Idx == 0, [0] can be ignored.
1407 // Array[0] is same to Array
1408 //
1409 _STRCAT(&VarIdStr, "[");
1410 _STRCAT(&VarIdStr, I2->getText());
1411 _STRCAT(&VarIdStr, "]");
1412 }
1413 >>
1414 }
1415 )*
1416 << mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, $QId, $Mask); >>
1417 )
1418 ;
1419
1420 vfrConstantValueField[UINT8 Type, EFI_IFR_TYPE_VALUE &Value, BOOLEAN &ListType] :
1421 <<
1422 EFI_GUID Guid;
1423 BOOLEAN Negative = FALSE;
1424 BOOLEAN IntDecStyle = FALSE;
1425 CIfrNumeric *NumericQst = NULL;
1426 if (gCurrentMinMaxData != NULL && gCurrentMinMaxData->IsNumericOpcode()) {
1427 NumericQst = (CIfrNumeric *) gCurrentQuestion;
1428 IntDecStyle = (NumericQst->GetNumericFlags() & EFI_IFR_DISPLAY) == 0 ? TRUE : FALSE;
1429 }
1430 UINT8 *Type8 = (UINT8 *) &Value;
1431 UINT16 *Type16 = (UINT16 *) &Value;
1432 UINT32 *Type32 = (UINT32 *) &Value;
1433 UINT64 *Type64 = (UINT64 *) &Value;
1434 UINT16 Index = 0;
1435 ListType = FALSE;
1436 >>
1437 {
1438 "\-" << Negative = TRUE; >>
1439 }
1440 N1:Number <<
1441 switch ($Type) {
1442 case EFI_IFR_TYPE_NUM_SIZE_8 :
1443 $Value.u8 = _STOU8(N1->getText(), N1->getLine());
1444 if (IntDecStyle) {
1445 if (Negative) {
1446 if ($Value.u8 > 0x80) {
1447 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT8 type can't big than 0x7F, small than -0x80");
1448 }
1449 } else {
1450 if ($Value.u8 > 0x7F) {
1451 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT8 type can't big than 0x7F, small than -0x80");
1452 }
1453 }
1454 }
1455 if (Negative) {
1456 $Value.u8 = ~$Value.u8 + 1;
1457 }
1458 break;
1459 case EFI_IFR_TYPE_NUM_SIZE_16 :
1460 $Value.u16 = _STOU16(N1->getText(), N1->getLine());
1461 if (IntDecStyle) {
1462 if (Negative) {
1463 if ($Value.u16 > 0x8000) {
1464 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT16 type can't big than 0x7FFF, small than -0x8000");
1465 }
1466 } else {
1467 if ($Value.u16 > 0x7FFF) {
1468 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT16 type can't big than 0x7FFF, small than -0x8000");
1469 }
1470 }
1471 }
1472 if (Negative) {
1473 $Value.u16 = ~$Value.u16 + 1;
1474 }
1475 break;
1476 case EFI_IFR_TYPE_NUM_SIZE_32 :
1477 $Value.u32 = _STOU32(N1->getText(), N1->getLine());
1478 if (IntDecStyle) {
1479 if (Negative) {
1480 if ($Value.u32 > 0x80000000) {
1481 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT32 type can't big than 0x7FFFFFFF, small than -0x80000000");
1482 }
1483 } else {
1484 if ($Value.u32 > 0X7FFFFFFF) {
1485 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT32 type can't big than 0x7FFFFFFF, small than -0x80000000");
1486 }
1487 }
1488 }
1489 if (Negative) {
1490 $Value.u32 = ~$Value.u32 + 1;
1491 }
1492 break;
1493 case EFI_IFR_TYPE_NUM_SIZE_64 :
1494 $Value.u64 = _STOU64(N1->getText(), N1->getLine());
1495 if (IntDecStyle) {
1496 if (Negative) {
1497 if ($Value.u64 > 0x8000000000000000) {
1498 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT64 type can't big than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000");
1499 }
1500 } else {
1501 if ($Value.u64 > 0x7FFFFFFFFFFFFFFF) {
1502 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT64 type can't big than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000");
1503 }
1504 }
1505 }
1506 if (Negative) {
1507 $Value.u64 = ~$Value.u64 + 1;
1508 }
1509 break;
1510 case EFI_IFR_TYPE_BOOLEAN :
1511 $Value.b = _STOU8(N1->getText(), N1->getLine());
1512 break;
1513 case EFI_IFR_TYPE_STRING :
1514 $Value.string = _STOU16(N1->getText(), N1->getLine());
1515 break;
1516 case EFI_IFR_TYPE_TIME :
1517 case EFI_IFR_TYPE_DATE :
1518 case EFI_IFR_TYPE_REF :
1519 default :
1520 break;
1521 }
1522 >>
1523 | B1:True << $Value.b = TRUE; >>
1524 | B2:False << $Value.b = FALSE; >>
1525 | O1:One << $Value.u8 = _STOU8(O1->getText(), O1->getLine()); >>
1526 | O2:Ones << $Value.u64 = _STOU64(O2->getText(), O2->getLine()); >>
1527 | Z:Zero << $Value.u8 = _STOU8(Z->getText(), Z->getLine()); >>
1528 | HOUR:Number ":" MINUTE:Number ":" SECOND:Number << $Value.time = _STOT(HOUR->getText(), MINUTE->getText(),SECOND->getText(), HOUR->getLine()); >>
1529 | YEAR:Number "/" MONTH:Number "/" DAY:Number << $Value.date = _STOD(YEAR->getText(), MONTH->getText(), DAY->getText(), YEAR->getLine()); >>
1530 | QI:Number";" FI:Number";" guidDefinition[Guid] ";" "STRING_TOKEN" "\(" DP:Number "\)"
1531 << $Value.ref = _STOR(QI->getText(), FI->getText(), &Guid, DP->getText(), QI->getLine()); >>
1532 | "STRING_TOKEN" "\(" S1:Number "\)" << $Value.string = _STOSID(S1->getText(), S1->getLine()); >>
1533 | "\{" << ListType = TRUE; >>
1534 L1:Number <<
1535 switch (Type) {
1536 case EFI_IFR_TYPE_NUM_SIZE_8 :
1537 Type8[Index] = _STOU8(L1->getText(), L1->getLine());
1538 break;
1539 case EFI_IFR_TYPE_NUM_SIZE_16 :
1540 Type16[Index] = _STOU16(L1->getText(), L1->getLine());
1541 break;
1542 case EFI_IFR_TYPE_NUM_SIZE_32 :
1543 Type32[Index] = _STOU32(L1->getText(), L1->getLine());
1544 break;
1545 case EFI_IFR_TYPE_NUM_SIZE_64 :
1546 Type64[Index] = _STOU64(L1->getText(), L1->getLine());
1547 break;
1548 default:
1549 break;
1550 }
1551 Index++;
1552 >>
1553 (
1554 ","
1555 L2:Number <<
1556 switch (Type) {
1557 case EFI_IFR_TYPE_NUM_SIZE_8 :
1558 Type8[Index] = _STOU8(L2->getText(), L2->getLine());
1559 break;
1560 case EFI_IFR_TYPE_NUM_SIZE_16 :
1561 Type16[Index] = _STOU16(L2->getText(), L2->getLine());
1562 break;
1563 case EFI_IFR_TYPE_NUM_SIZE_32 :
1564 Type32[Index] = _STOU32(L2->getText(), L2->getLine());
1565 break;
1566 case EFI_IFR_TYPE_NUM_SIZE_64 :
1567 Type64[Index] = _STOU64(L2->getText(), L2->getLine());
1568 break;
1569 default:
1570 break;
1571 }
1572 Index++;
1573 >>
1574 )*
1575 "\}"
1576 ;
1577
1578 //*****************************************************************************
1579 //
1580 // the syntax of form definition
1581 //
1582 vfrFormDefinition :
1583 << CIfrForm FObj; >>
1584 F:Form << FObj.SetLineNo(F->getLine()); >>
1585 FormId "=" S1:Number "," << _PCATCH(FObj.SetFormId (_STOFID(S1->getText(), S1->getLine())), S1); >>
1586 Title "=" "STRING_TOKEN" "\(" S2:Number "\)" ";" << FObj.SetFormTitle (_STOSID(S2->getText(), S2->getLine())); >>
1587 (
1588 vfrStatementImage |
1589 vfrStatementLocked |
1590 vfrStatementRules |
1591 vfrStatementDefault |
1592 vfrStatementStat |
1593 vfrStatementQuestions |
1594 vfrStatementConditional |
1595 vfrStatementLabel |
1596 vfrStatementBanner |
1597 // Just for framework vfr compatibility
1598 vfrStatementInvalid |
1599 vfrStatementExtension |
1600 vfrStatementModal |
1601 vfrStatementRefreshEvent ";"
1602 )*
1603 E:EndForm <<
1604 if (mCompatibleMode) {
1605 //
1606 // Add Label for Framework Vfr
1607 //
1608 CIfrLabel LObj1;
1609 LObj1.SetLineNo(E->getLine());
1610 LObj1.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff
1611 CIfrLabel LObj2;
1612 LObj2.SetLineNo(E->getLine());
1613 LObj2.SetNumber (0x0); //add dummy label for UEFI, label number hardcode 0x0
1614 CIfrLabel LObj3;
1615 LObj3.SetLineNo(E->getLine());
1616 LObj3.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff
1617 }
1618
1619 {CIfrEnd EObj; EObj.SetLineNo (E->getLine()); mLastFormEndAddr = EObj.GetObjBinAddr (); gAdjustOpcodeOffset = EObj.GetObjBinOffset ();}
1620 >>
1621 ";"
1622 ;
1623
1624 vfrFormMapDefinition :
1625 <<
1626 CIfrFormMap *FMapObj = NULL;
1627 UINT32 FormMapMethodNumber = 0;
1628 EFI_GUID Guid;
1629 >>
1630 F:FormMap << FMapObj = new CIfrFormMap(); FMapObj->SetLineNo(F->getLine()); >>
1631 FormId "=" S1:Number "," << _PCATCH(FMapObj->SetFormId (_STOFID(S1->getText(), S1->getLine())), S1); >>
1632 (
1633 MapTitle "=" "STRING_TOKEN" "\(" S2:Number "\)" ";"
1634 MapGuid "=" guidDefinition[Guid] ";" << FMapObj->SetFormMapMethod (_STOFID(S2->getText(), S2->getLine()), &Guid); FormMapMethodNumber ++; >>
1635 )* << if (FormMapMethodNumber == 0) {_PCATCH (VFR_RETURN_INVALID_PARAMETER, F->getLine(), "No MapMethod is set for FormMap!");} delete FMapObj;>>
1636 (
1637 vfrStatementImage |
1638 vfrStatementLocked |
1639 vfrStatementRules |
1640 vfrStatementDefault |
1641 vfrStatementStat |
1642 vfrStatementQuestions |
1643 vfrStatementConditional |
1644 vfrStatementLabel |
1645 vfrStatementBanner |
1646 vfrStatementExtension |
1647 vfrStatementModal |
1648 vfrStatementRefreshEvent ";"
1649 )*
1650 E:EndForm << CRT_END_OP (E); >>
1651 ";"
1652 ;
1653
1654 vfrStatementRules :
1655 << CIfrRule RObj; >>
1656 R:Rule << RObj.SetLineNo(R->getLine()); >>
1657 S1:StringIdentifier "," <<
1658 mCVfrRulesDB.RegisterRule (S1->getText());
1659 RObj.SetRuleId (mCVfrRulesDB.GetRuleId(S1->getText()));
1660 >>
1661 vfrStatementExpression[0]
1662 E:EndRule << CRT_END_OP (E); >>
1663 ";"
1664 ;
1665
1666 vfrStatementDefault :
1667 <<
1668 BOOLEAN IsExp = FALSE;
1669 UINT64 ValueList[EFI_IFR_MAX_LENGTH] = {0,};
1670 EFI_IFR_TYPE_VALUE *Val = (EFI_IFR_TYPE_VALUE *) ValueList;
1671 CIfrDefault *DObj = NULL;
1672 CIfrDefault2 *DObj2 = NULL;
1673 EFI_DEFAULT_ID DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
1674 CHAR8 *VarStoreName = NULL;
1675 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
1676 UINT32 Size = 0;
1677 EFI_GUID *VarGuid = NULL;
1678 BOOLEAN ArrayType = FALSE;
1679 UINT8 *Type8 = (UINT8 *) ValueList;
1680 UINT16 *Type16 = (UINT16 *) ValueList;
1681 UINT32 *Type32 = (UINT32 *) ValueList;
1682 UINT64 *Type64 = (UINT64 *) ValueList;
1683 CIfrNumeric *NumericQst = NULL;
1684
1685 >>
1686 D:Default
1687 (
1688 (
1689 "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE(), *Val, ArrayType] ","
1690 <<
1691 if (gCurrentMinMaxData != NULL && gCurrentMinMaxData->IsNumericOpcode()) {
1692 //check default value is valid for Numeric Opcode
1693 NumericQst = (CIfrNumeric *) gCurrentQuestion;
1694 if ((NumericQst->GetNumericFlags() & EFI_IFR_DISPLAY) == 0) {
1695 switch (_GET_CURRQEST_DATATYPE()) {
1696 case EFI_IFR_TYPE_NUM_SIZE_8:
1697 if (((INT8) Val->u8 < (INT8) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) ||
1698 ((INT8) Val->u8 > (INT8) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) {
1699 _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");
1700 }
1701 break;
1702 case EFI_IFR_TYPE_NUM_SIZE_16:
1703 if (((INT16) Val->u16 < (INT16) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) ||
1704 ((INT16) Val->u16 > (INT16) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) {
1705 _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");
1706 }
1707 break;
1708 case EFI_IFR_TYPE_NUM_SIZE_32:
1709 if (((INT32) Val->u32 < (INT32) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) ||
1710 ((INT32) Val->u32 > (INT32) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) {
1711 _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");
1712 }
1713 break;
1714 case EFI_IFR_TYPE_NUM_SIZE_64:
1715 if (((INT64) Val->u64 < (INT64) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) ||
1716 ((INT64) Val->u64 > (INT64) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) {
1717 _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");
1718 }
1719 break;
1720 default:
1721 break;
1722 }
1723 } else {
1724 if (Val->u64 < gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE()) || Val->u64 > gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE())) {
1725 _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");
1726 }
1727 }
1728 }
1729 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
1730 _PCATCH (VFR_RETURN_FATAL_ERROR, D->getLine(), "Default data type error.");
1731 Size = sizeof (EFI_IFR_TYPE_VALUE);
1732 } else if (ArrayType) {
1733 switch (_GET_CURRQEST_DATATYPE()) {
1734 case EFI_IFR_TYPE_NUM_SIZE_8 :
1735 while (Type8[Size] != 0) {
1736 Size++;
1737 }
1738 break;
1739 case EFI_IFR_TYPE_NUM_SIZE_16 :
1740 while (Type16[Size] != 0) {
1741 Size++;
1742 }
1743 Size *= sizeof (UINT16);
1744 break;
1745
1746 case EFI_IFR_TYPE_NUM_SIZE_32 :
1747 while (Type32[Size] != 0) {
1748 Size++;
1749 }
1750 Size *= sizeof (UINT32);
1751 break;
1752
1753 case EFI_IFR_TYPE_NUM_SIZE_64 :
1754 while (Type64[Size] != 0) {
1755 Size++;
1756 }
1757 Size *= sizeof (UINT64);
1758 break;
1759
1760 default:
1761 break;
1762 }
1763 } else {
1764 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size), D->getLine());
1765 }
1766 Size += OFFSET_OF (EFI_IFR_DEFAULT, Value);
1767 DObj = new CIfrDefault ((UINT8)Size);
1768 DObj->SetLineNo(D->getLine());
1769 if (ArrayType) {
1770 DObj->SetType (EFI_IFR_TYPE_BUFFER);
1771 } else if (gIsStringOp) {
1772 DObj->SetType (EFI_IFR_TYPE_STRING);
1773 } else {
1774 DObj->SetType (_GET_CURRQEST_DATATYPE());
1775 }
1776 DObj->SetValue(*Val);
1777 >>
1778 | << IsExp = TRUE; DObj2 = new CIfrDefault2; DObj2->SetLineNo(D->getLine()); DObj2->SetScope (1); >>
1779 vfrStatementValue "," << CIfrEnd EndObj1; EndObj1.SetLineNo(D->getLine()); >>
1780 )
1781 {
1782 DefaultStore "=" SN:StringIdentifier "," <<
1783 _PCATCH(gCVfrDefaultStore.GetDefaultId (SN->getText(), &DefaultId), SN);
1784 if (DObj != NULL) {
1785 DObj->SetDefaultId (DefaultId);
1786 }
1787
1788 if (DObj2 != NULL) {
1789 DObj2->SetDefaultId (DefaultId);
1790 }
1791 >>
1792 }
1793 <<
1794 CheckDuplicateDefaultValue (DefaultId, D);
1795 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
1796 _PCATCH(gCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), D->getLine());
1797 VarGuid = gCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);
1798 VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
1799 if ((IsExp == FALSE) && (VarStoreType == EFI_VFR_VARSTORE_BUFFER)) {
1800 _PCATCH(gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
1801 DefaultId,
1802 _GET_CURRQEST_VARTINFO(),
1803 VarStoreName,
1804 VarGuid,
1805 _GET_CURRQEST_DATATYPE (),
1806 *Val),
1807 D->getLine()
1808 );
1809 }
1810 }
1811 if (DObj != NULL) {delete DObj;}
1812 if (DObj2 != NULL) {delete DObj2;}
1813 >>
1814 )
1815 ;
1816
1817 vfrStatementStat :
1818 vfrStatementSubTitle |
1819 vfrStatementStaticText |
1820 vfrStatementCrossReference
1821 ;
1822
1823 vfrStatementQuestions :
1824 vfrStatementBooleanType |
1825 vfrStatementDate |
1826 vfrStatementNumericType |
1827 vfrStatementStringType |
1828 vfrStatementOrderedList |
1829 vfrStatementTime
1830 ;
1831
1832 vfrStatementConditional :
1833 vfrStatementDisableIfStat |
1834 vfrStatementSuppressIfStat | //enhance to be compatible for framework endif
1835 vfrStatementGrayOutIfStat |
1836 vfrStatementInconsistentIfStat //to be compatible for framework
1837 ;
1838
1839 vfrStatementConditionalNew :
1840 vfrStatementDisableIfStat |
1841 vfrStatementSuppressIfStatNew |
1842 vfrStatementGrayOutIfStatNew |
1843 vfrStatementInconsistentIfStat //to be compatible for framework
1844 ;
1845
1846 vfrStatementSuppressIfStat :
1847 <<mCompatibleMode>>? vfrStatementSuppressIfStatOld
1848 | vfrStatementSuppressIfStatNew
1849 ;
1850
1851 vfrStatementGrayOutIfStat :
1852 <<mCompatibleMode>>? vfrStatementGrayOutIfStatOld
1853 | vfrStatementGrayOutIfStatNew
1854 ;
1855
1856 vfrStatementInvalid :
1857 (
1858 vfrStatementInvalidHidden |
1859 vfrStatementInvalidInventory |
1860 vfrStatementInvalidSaveRestoreDefaults
1861 )
1862 << _CRT_OP (TRUE); >>
1863 ;
1864
1865 flagsField :
1866 Number
1867 | InteractiveFlag
1868 | ManufacturingFlag
1869 | DefaultFlag
1870 | ResetRequiredFlag
1871 | ReconnectRequiredFlag
1872 | N:NVAccessFlag <<
1873 if (!mCompatibleMode) {
1874 gCVfrErrorHandle.HandleWarning (
1875 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
1876 N->getLine(),
1877 N->getText()
1878 );
1879 }
1880 >>
1881 | L:LateCheckFlag <<
1882 if (!mCompatibleMode) {
1883 gCVfrErrorHandle.HandleWarning (
1884 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
1885 L->getLine(),
1886 L->getText()
1887 );
1888 }
1889 >>
1890 ;
1891
1892 vfrStatementValue :
1893 << CIfrValue VObj; >>
1894 V:Value << VObj.SetLineNo(V->getLine()); >>
1895 "=" vfrStatementExpression[0] << {CIfrEnd EndObj; EndObj.SetLineNo(V->getLine());} >>
1896 ;
1897
1898 vfrStatementRead :
1899 << CIfrRead RObj; >>
1900 R:Read << RObj.SetLineNo(R->getLine()); >>
1901 vfrStatementExpression[0] ";"
1902 ;
1903
1904 vfrStatementWrite :
1905 << CIfrWrite WObj; >>
1906 W:Write << WObj.SetLineNo(W->getLine()); >>
1907 vfrStatementExpression[0] ";"
1908 ;
1909
1910 vfrStatementSubTitle :
1911 << CIfrSubtitle SObj; >>
1912 L:Subtitle << SObj.SetLineNo(L->getLine()); >>
1913 Text "=" "STRING_TOKEN" "\(" S:Number "\)" << SObj.SetPrompt (_STOSID(S->getText(), S->getLine())); >>
1914 {
1915 "," FLAGS "=" vfrSubtitleFlags[SObj]
1916 }
1917 (
1918 {vfrStatementStatTagList "," }
1919 E:";" << CRT_END_OP (E); >>
1920 |
1921 { "," vfrStatementStatTagList}
1922 { "," (vfrStatementStat | vfrStatementQuestions)*}
1923 D: EndSubtitle ";" << CRT_END_OP (D); >>
1924 )
1925 ;
1926
1927 vfrSubtitleFlags [CIfrSubtitle & SObj] :
1928 << UINT8 LFlags = 0; >>
1929 subtitleFlagsField[LFlags] ( "\|" subtitleFlagsField[LFlags] )*
1930 << _PCATCH(SObj.SetFlags (LFlags)); >>
1931 ;
1932
1933 subtitleFlagsField [UINT8 & Flags] :
1934 N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >>
1935 | "HORIZONTAL" << $Flags |= 0x01; >>
1936 ;
1937
1938 vfrStatementStaticText :
1939 <<
1940 UINT8 Flags = 0;
1941 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
1942 EFI_STRING_ID TxtTwo = EFI_STRING_ID_INVALID;
1943 >>
1944 T:Text
1945 Help "=" "STRING_TOKEN" "\(" S1:Number "\)" ","
1946 Text "=" "STRING_TOKEN" "\(" S2:Number "\)"
1947 {
1948 "," Text "=" "STRING_TOKEN" "\(" S3:Number "\)" << TxtTwo = _STOSID(S3->getText(), S3->getLine()); >>
1949 }
1950 {
1951 "," F:FLAGS "=" staticTextFlagsField[Flags] ( "\|" staticTextFlagsField[Flags] )*
1952 "," Key "=" KN:Number
1953 }
1954 <<
1955 if (Flags & EFI_IFR_FLAG_CALLBACK) {
1956 if (TxtTwo != EFI_STRING_ID_INVALID) {
1957 gCVfrErrorHandle.HandleWarning (
1958 VFR_WARNING_ACTION_WITH_TEXT_TWO,
1959 S3->getLine(),
1960 S3->getText()
1961 );
1962 }
1963 CIfrAction AObj;
1964 mCVfrQuestionDB.RegisterQuestion (NULL, NULL, QId);
1965 AObj.SetLineNo (F->getLine());
1966 AObj.SetQuestionId (QId);
1967 AObj.SetPrompt (_STOSID(S2->getText(), S2->getLine()));
1968 AObj.SetHelp (_STOSID(S1->getText(), S1->getLine()));
1969 _PCATCH(AObj.SetFlags (Flags), F->getLine());
1970 AssignQuestionKey (AObj, KN);
1971 CRT_END_OP (KN);
1972 } else {
1973 CIfrText TObj;
1974 TObj.SetLineNo (T->getLine());
1975 TObj.SetHelp (_STOSID(S1->getText(), S1->getLine()));
1976 TObj.SetPrompt (_STOSID(S2->getText(), S2->getLine()));
1977 TObj.SetTextTwo (TxtTwo);
1978 }
1979 >>
1980 { "," vfrStatementStatTagList }
1981 ";"
1982 ;
1983
1984 staticTextFlagsField[UINT8 & HFlags] :
1985 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
1986 | questionheaderFlagsField[HFlags]
1987 ;
1988
1989 vfrStatementCrossReference :
1990 vfrStatementGoto |
1991 vfrStatementResetButton
1992 ;
1993
1994 vfrStatementGoto :
1995 <<
1996 UINT8 RefType = 5;
1997 EFI_STRING_ID DevPath = EFI_STRING_ID_INVALID;
1998 EFI_GUID FSId = {0,};
1999 EFI_FORM_ID FId;
2000 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
2001 UINT32 BitMask;
2002 CIfrQuestionHeader *QHObj = NULL;
2003 CIfrOpHeader *OHObj = NULL;
2004 CIfrRef *R1Obj = NULL;
2005 CIfrRef2 *R2Obj = NULL;
2006 CIfrRef3 *R3Obj = NULL;
2007 CIfrRef4 *R4Obj = NULL;
2008 CIfrRef5 *R5Obj = NULL;
2009 >>
2010 G:Goto
2011 {
2012 (
2013 DevicePath "=" "STRING_TOKEN" "\(" P:Number "\)" ","
2014 FormSetGuid "=" guidDefinition[FSId] ","
2015 FormId "=" F1:Number ","
2016 Question "=" QN1:Number ","
2017 <<
2018 RefType = 4;
2019 DevPath = _STOSID(P->getText(), P->getLine());
2020 FId = _STOFID(F1->getText(), F1->getLine());
2021 QId = _STOQID(QN1->getText(), QN1->getLine());
2022 >>
2023 )
2024 |
2025 (
2026 FormSetGuid "=" guidDefinition[FSId] ","
2027 FormId "=" F2:Number ","
2028 Question "=" QN2:Number ","
2029 <<
2030 RefType = 3;
2031 FId = _STOFID(F2->getText(), F2->getLine());
2032 QId = _STOQID(QN2->getText(), QN2->getLine());
2033 >>
2034 )
2035 |
2036 (
2037 FormId "=" F3:Number "," << RefType = 2; FId = _STOFID(F3->getText(), F3->getLine()); >>
2038 Question "="
2039 (
2040 QN3:StringIdentifier "," <<
2041 mCVfrQuestionDB.GetQuestionId (QN3->getText (), NULL, QId, BitMask);
2042 if (QId == EFI_QUESTION_ID_INVALID) {
2043 _PCATCH(VFR_RETURN_UNDEFINED, QN3);
2044 }
2045 >>
2046 | QN4:Number "," << QId = _STOQID(QN4->getText(), QN4->getLine()); >>
2047 )
2048 )
2049 |
2050 (
2051 F4:Number "," <<
2052 RefType = 1;
2053 FId = _STOFID(F4->getText(), F4->getLine());
2054 >>
2055 )
2056 }
2057 <<
2058 switch (RefType) {
2059 case 5:
2060 {
2061 R5Obj = new CIfrRef5;
2062 QHObj = R5Obj;
2063 OHObj = R5Obj;
2064 R5Obj->SetLineNo(G->getLine());
2065 break;
2066 }
2067 case 4:
2068 {
2069 R4Obj = new CIfrRef4;
2070 QHObj = R4Obj;
2071 OHObj = R4Obj;
2072 R4Obj->SetLineNo(G->getLine());
2073 R4Obj->SetDevicePath (DevPath);
2074 R4Obj->SetFormSetId (FSId);
2075 R4Obj->SetFormId (FId);
2076 R4Obj->SetQuestionId (QId);
2077 break;
2078 }
2079 case 3:
2080 {
2081 R3Obj = new CIfrRef3;
2082 QHObj = R3Obj;
2083 OHObj = R3Obj;
2084 R3Obj->SetLineNo(G->getLine());
2085 R3Obj->SetFormSetId (FSId);
2086 R3Obj->SetFormId (FId);
2087 R3Obj->SetQuestionId (QId);
2088 break;
2089 }
2090 case 2:
2091 {
2092 R2Obj = new CIfrRef2;
2093 QHObj = R2Obj;
2094 OHObj = R2Obj;
2095 R2Obj->SetLineNo(G->getLine());
2096 R2Obj->SetFormId (FId);
2097 R2Obj->SetQuestionId (QId);
2098 break;
2099 }
2100 case 1:
2101 {
2102 R1Obj = new CIfrRef;
2103 QHObj = R1Obj;
2104 OHObj = R1Obj;
2105 R1Obj->SetLineNo(G->getLine());
2106 R1Obj->SetFormId (FId);
2107 break;
2108 }
2109 default: break;
2110 }
2111 >>
2112 vfrQuestionHeader[*QHObj, QUESTION_REF] <<
2113 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
2114 _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_REF;
2115 }
2116 >>
2117 { "," F:FLAGS "=" vfrGotoFlags[QHObj, F->getLine()] }
2118 {
2119 "," Key "=" KN:Number << AssignQuestionKey (*QHObj, KN); >>
2120 }
2121 {
2122 E:","
2123 vfrStatementQuestionOptionList << OHObj->SetScope(1); CRT_END_OP (E);>>
2124 }
2125 ";" << if (R1Obj != NULL) {delete R1Obj;} if (R2Obj != NULL) {delete R2Obj;} if (R3Obj != NULL) {delete R3Obj;} if (R4Obj != NULL) {delete R4Obj;} if (R5Obj != NULL) {delete R5Obj;}>>
2126 ;
2127
2128 vfrGotoFlags [CIfrQuestionHeader *QHObj, UINT32 LineNum] :
2129 << UINT8 HFlags = 0; >>
2130 gotoFlagsField[HFlags] ( "\|" gotoFlagsField[HFlags] )*
2131 << _PCATCH(QHObj->SetFlags (HFlags), LineNum); >>
2132 ;
2133
2134 gotoFlagsField[UINT8 & HFlags] :
2135 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
2136 | questionheaderFlagsField[HFlags]
2137 ;
2138
2139 getStringId :
2140 "STRING_TOKEN" "\("
2141 IdVal:Number
2142 "\)"
2143 ;
2144
2145 vfrStatementResetButton :
2146 <<
2147 CIfrResetButton RBObj;
2148 UINT16 DefaultId;
2149 >>
2150 L:ResetButton << RBObj.SetLineNo(L->getLine()); >>
2151 DefaultStore
2152 "=" N:StringIdentifier "," <<
2153 _PCATCH(gCVfrDefaultStore.GetDefaultId (N->getText(), &DefaultId), N->getLine());
2154 RBObj.SetDefaultId (DefaultId);
2155 >>
2156 vfrStatementHeader[&RBObj] ","
2157 { vfrStatementStatTagList "," }
2158 E:EndResetButton << CRT_END_OP (E); >>
2159 ";"
2160 ;
2161
2162 vfrStatementBooleanType :
2163 vfrStatementCheckBox |
2164 vfrStatementAction
2165 ;
2166
2167 //*****************************************************
2168 // Syntax of checkbox
2169 //
2170 // Example:
2171 // checkbox
2172 // varid = MySTestData.mField1,
2173 // prompt = STRING_TOKEN(STR_CHECK_BOX_PROMPT),
2174 // help = STRING_TOKEN(STR_CHECK_BOX_HELP),
2175 // flags = CHECKBOX_DEFAULT | CALLBACK,
2176 // default value = TRUE, defaultstore = MyDefaultStore,
2177 // endcheckbox;
2178 //
2179 vfrStatementCheckBox :
2180 <<
2181 CIfrCheckBox CBObj;
2182 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;
2183 CHAR8 *VarStoreName = NULL;
2184 UINT32 DataTypeSize;
2185 EFI_GUID *VarStoreGuid = NULL;
2186 >>
2187 L:CheckBox << CBObj.SetLineNo(L->getLine()); >>
2188 vfrQuestionHeader[CBObj] "," << //check data type
2189 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
2190 _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_BOOLEAN;
2191 }
2192 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
2193 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "CheckBox varid is not the valid data type");
2194 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
2195 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid doesn't support array");
2196 } else if ((gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == EFI_VFR_VARSTORE_BUFFER) &&
2197 (_GET_CURRQEST_VARSIZE() != sizeof (BOOLEAN))) {
2198 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only support BOOLEAN data type");
2199 }
2200 }
2201 >>
2202 {
2203 F:FLAGS "=" vfrCheckBoxFlags[CBObj, F->getLine()] ","
2204 <<
2205 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
2206 _PCATCH(gCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), VFR_RETURN_SUCCESS, L, "Failed to retrieve varstore name");
2207 VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);
2208 Val.b = TRUE;
2209 if (CBObj.GetFlags () & 0x01) {
2210 CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_STANDARD, F);
2211 _PCATCH(
2212 gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
2213 EFI_HII_DEFAULT_CLASS_STANDARD,
2214 _GET_CURRQEST_VARTINFO(),
2215 VarStoreName,
2216 VarStoreGuid,
2217 _GET_CURRQEST_DATATYPE (),
2218 Val
2219 ),
2220 VFR_RETURN_SUCCESS,
2221 L,
2222 "No standard default storage found"
2223 );
2224 }
2225 if (CBObj.GetFlags () & 0x02) {
2226 CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_MANUFACTURING, F);
2227 _PCATCH(
2228 gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
2229 EFI_HII_DEFAULT_CLASS_MANUFACTURING,
2230 _GET_CURRQEST_VARTINFO(),
2231 VarStoreName,
2232 VarStoreGuid,
2233 _GET_CURRQEST_DATATYPE (),
2234 Val
2235 ),
2236 VFR_RETURN_SUCCESS,
2237 L,
2238 "No manufacturing default storage found"
2239 );
2240 }
2241 }
2242 >>
2243 }
2244 {
2245 Key "=" KN:Number "," << AssignQuestionKey (CBObj, KN); >>
2246 }
2247 vfrStatementQuestionOptionList
2248 E:EndCheckBox << CRT_END_OP (E); >>
2249 ";"
2250 ;
2251
2252 vfrCheckBoxFlags [CIfrCheckBox & CBObj, UINT32 LineNum] :
2253 <<
2254 UINT8 LFlags = 0;
2255 UINT8 HFlags = 0;
2256 >>
2257 checkboxFlagsField[LFlags, HFlags] ( "\|" checkboxFlagsField[LFlags, HFlags] )*
2258 << _PCATCH(CBObj.SetFlags (HFlags, LFlags), LineNum); >>
2259 ;
2260
2261 checkboxFlagsField[UINT8 & LFlags, UINT8 & HFlags] :
2262 N:Number <<
2263 if (mCompatibleMode) {
2264 //
2265 // set question flag
2266 //
2267 $LFlags |= _STOU8(N->getText(), N->getLine());
2268 } else {
2269 _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine());
2270 }
2271 >>
2272 | D:"DEFAULT" <<
2273 if (mCompatibleMode) {
2274 //
2275 // set question Default flag
2276 //
2277 $LFlags |= 0x01;
2278 } else {
2279 _PCATCH (VFR_RETURN_UNSUPPORTED, D);
2280 }
2281 >>
2282 | M:"MANUFACTURING" <<
2283 if (mCompatibleMode) {
2284 //
2285 // set question MFG flag
2286 //
2287 $LFlags |= 0x02;
2288 } else {
2289 _PCATCH (VFR_RETURN_UNSUPPORTED, M);
2290 }
2291 >>
2292 | "CHECKBOX_DEFAULT" << $LFlags |= 0x01; >>
2293 | "CHECKBOX_DEFAULT_MFG" << $LFlags |= 0x02; >>
2294 | questionheaderFlagsField[HFlags]
2295 ;
2296
2297 //*****************************************************
2298 // Syntax of action
2299 //
2300 // Example:
2301 // action
2302 // prompt = STRING_TOKEN(STR_ACTION_PROMPT),
2303 // help = STRING_TOKEN(STR_ACTION_HELP),
2304 // flags = CALLBACK,
2305 // config = STRING_TOKEN(STR_ACTION_CONFIG),
2306 // endaction;
2307 //
2308 vfrStatementAction :
2309 << CIfrAction AObj; >>
2310 L:Action << AObj.SetLineNo(L->getLine()); >>
2311 vfrQuestionHeader[AObj] ","
2312 { F:FLAGS "=" vfrActionFlags[AObj, F->getLine()] "," }
2313 Config "=" "STRING_TOKEN" "\(" S:Number "\)" "," << AObj.SetQuestionConfig (_STOSID(S->getText(), S->getLine())); >>
2314 vfrStatementQuestionTagList
2315 E:EndAction << CRT_END_OP (E); >>
2316 ";"
2317 ;
2318
2319 vfrActionFlags[CIfrAction & AObj, UINT32 LineNum] :
2320 << UINT8 HFlags = 0; >>
2321 actionFlagsField[HFlags] ( "\|" actionFlagsField[HFlags] )*
2322 << _PCATCH(AObj.SetFlags (HFlags), LineNum); >>
2323 ;
2324
2325 actionFlagsField[UINT8 & HFlags] :
2326 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
2327 | questionheaderFlagsField[HFlags]
2328 ;
2329
2330 vfrStatementDate :
2331 <<
2332 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
2333 CHAR8 *VarIdStr[3] = {NULL, };
2334 CIfrDate DObj;
2335 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;
2336 UINT8 Size = OFFSET_OF (EFI_IFR_DEFAULT, Value) + sizeof (EFI_HII_DATE);
2337 >>
2338 L:Date << DObj.SetLineNo(L->getLine()); >>
2339 (
2340 (
2341 vfrQuestionHeader[DObj, QUESTION_DATE] "," <<
2342 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
2343 _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_DATE;
2344 }
2345 >>
2346 { F:FLAGS "=" vfrDateFlags[DObj, F->getLine()] "," }
2347 vfrStatementQuestionOptionList
2348 )
2349 |
2350 (
2351 Year VarId "=" D1:StringIdentifier "." D1Y:StringIdentifier ","
2352 << _STRCAT(&VarIdStr[0], D1->getText()); _STRCAT(&VarIdStr[0], "."); _STRCAT(&VarIdStr[0], D1Y->getText()); >>
2353 Prompt "=" "STRING_TOKEN" "\(" YP:Number "\)" ","
2354 Help "=" "STRING_TOKEN" "\(" YH:Number "\)" ","
2355 minMaxDateStepDefault[Val.date, 0]
2356
2357 Month VarId "=" D2:StringIdentifier "." D2M:StringIdentifier ","
2358 << _STRCAT(&VarIdStr[1], D2->getText()); _STRCAT(&VarIdStr[1], "."); _STRCAT(&VarIdStr[1], D2M->getText()); >>
2359 Prompt "=" "STRING_TOKEN" "\(" MP:Number "\)" ","
2360 Help "=" "STRING_TOKEN" "\(" MH:Number "\)" ","
2361 minMaxDateStepDefault[Val.date, 1]
2362
2363 Day VarId "=" D3:StringIdentifier "." D3D:StringIdentifier ","
2364 << _STRCAT(&VarIdStr[2], D3->getText()); _STRCAT(&VarIdStr[2], "."); _STRCAT(&VarIdStr[2], D3D->getText()); >>
2365 Prompt "=" "STRING_TOKEN" "\(" DP:Number "\)" ","
2366 Help "=" "STRING_TOKEN" "\(" DH:Number "\)" ","
2367 minMaxDateStepDefault[Val.date, 2]
2368 { G:FLAGS "=" vfrDateFlags[DObj, G->getLine()] "," }
2369 <<
2370 mCVfrQuestionDB.RegisterOldDateQuestion (VarIdStr[0], VarIdStr[1], VarIdStr[2], QId);
2371 DObj.SetQuestionId (QId);
2372 DObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, QF_DATE_STORAGE_TIME);
2373 DObj.SetPrompt (_STOSID(YP->getText(), YP->getLine()));
2374 DObj.SetHelp (_STOSID(YH->getText(), YH->getLine()));
2375 if (VarIdStr[0] != NULL) { delete VarIdStr[0]; } if (VarIdStr[1] != NULL) { delete VarIdStr[1]; } if (VarIdStr[2] != NULL) { delete VarIdStr[2]; }
2376 >>
2377 << {CIfrDefault DefaultObj(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_DATE, Val); DefaultObj.SetLineNo(L->getLine());} >>
2378 )
2379 ( vfrStatementInconsistentIf )*
2380 )
2381 E:EndDate << CRT_END_OP (E); >>
2382 ";"
2383 ;
2384
2385 minMaxDateStepDefault[EFI_HII_DATE & D, UINT8 KeyValue] :
2386 Minimum "=" MinN:Number ","
2387 Maximum "=" MaxN:Number ","
2388 { "step" "=" Number "," }
2389 {
2390 "default" "=" N:Number "," <<
2391 switch (KeyValue) {
2392 case 0:
2393 D.Year = _STOU16(N->getText(), N->getLine());
2394 if (D.Year < _STOU16 (MinN->getText(), MinN->getLine()) || D.Year > _STOU16 (MaxN->getText(), MaxN->getLine())) {
2395 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Year default value must be between Min year and Max year.");
2396 }
2397 break;
2398 case 1:
2399 D.Month = _STOU8(N->getText(), N->getLine());
2400 if (D.Month < 1 || D.Month > 12) {
2401 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Month default value must be between 1 and 12.");
2402 }
2403 break;
2404 case 2:
2405 D.Day = _STOU8(N->getText(), N->getLine());
2406 if (D.Day < 1 || D.Day > 31) {
2407 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Day default value must be between 1 and 31.");
2408 }
2409 break;
2410 }
2411 >>
2412 }
2413 ;
2414
2415 vfrDateFlags [CIfrDate & DObj, UINT32 LineNum] :
2416 << UINT8 LFlags = 0; >>
2417 dateFlagsField[LFlags] ( "\|" dateFlagsField[LFlags] )*
2418 << _PCATCH(DObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, LFlags), LineNum); >>
2419 ;
2420
2421 dateFlagsField [UINT8 & Flags] :
2422 N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >>
2423 | "YEAR_SUPPRESS" << $Flags |= 0x01; >>
2424 | "MONTH_SUPPRESS" << $Flags |= 0x02; >>
2425 | "DAY_SUPPRESS" << $Flags |= 0x04; >>
2426 | "STORAGE_NORMAL" << $Flags |= 0x00; >>
2427 | "STORAGE_TIME" << $Flags |= 0x10; >>
2428 | "STORAGE_WAKEUP" << $Flags |= 0x20; >>
2429 ;
2430
2431 vfrStatementNumericType :
2432 vfrStatementNumeric |
2433 vfrStatementOneOf
2434 ;
2435
2436 vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :
2437 <<
2438 UINT64 MaxU8 = 0, MinU8 = 0, StepU8 = 0;
2439 UINT32 MaxU4 = 0, MinU4 = 0, StepU4 = 0;
2440 UINT16 MaxU2 = 0, MinU2 = 0, StepU2 = 0;
2441 UINT8 MaxU1 = 0, MinU1 = 0, StepU1 = 0;
2442 BOOLEAN IntDecStyle = FALSE;
2443 CIfrNumeric *NObj = (CIfrNumeric *) (&MMSDObj);
2444 if ((NObj->GetOpCode() == EFI_IFR_NUMERIC_OP) && ((NObj->GetNumericFlags() & EFI_IFR_DISPLAY) == 0)) {
2445 IntDecStyle = TRUE;
2446 }
2447 BOOLEAN MinNegative = FALSE;
2448 BOOLEAN MaxNegative = FALSE;
2449 >>
2450 Minimum "="
2451 {
2452 "\-" << MinNegative = TRUE; >>
2453 }
2454 I:Number "," <<
2455 if (!IntDecStyle && MinNegative) {
2456 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "\"-\" can't be used when not in int decimal type. ");
2457 }
2458 switch (_GET_CURRQEST_DATATYPE()) {
2459 case EFI_IFR_TYPE_NUM_SIZE_64 :
2460 MinU8 = _STOU64(I->getText(), I->getLine());
2461 if (IntDecStyle) {
2462 if (MinNegative) {
2463 if (MinU8 > 0x8000000000000000) {
2464 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT64 type minimum can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
2465 }
2466 } else {
2467 if (MinU8 > 0x7FFFFFFFFFFFFFFF) {
2468 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT64 type minimum can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
2469 }
2470 }
2471 }
2472 if (MinNegative) {
2473 MinU8 = ~MinU8 + 1;
2474 }
2475 break;
2476 case EFI_IFR_TYPE_NUM_SIZE_32 :
2477 MinU4 = _STOU32(I->getText(), I->getLine());
2478 if (IntDecStyle) {
2479 if (MinNegative) {
2480 if (MinU4 > 0x80000000) {
2481 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT32 type minimum can't small than -0x80000000, big than 0x7FFFFFFF");
2482 }
2483 } else {
2484 if (MinU4 > 0x7FFFFFFF) {
2485 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT32 type minimum can't small than -0x80000000, big than 0x7FFFFFFF");
2486 }
2487 }
2488 }
2489 if (MinNegative) {
2490 MinU4 = ~MinU4 + 1;
2491 }
2492 break;
2493 case EFI_IFR_TYPE_NUM_SIZE_16 :
2494 MinU2 = _STOU16(I->getText(), I->getLine());
2495 if (IntDecStyle) {
2496 if (MinNegative) {
2497 if (MinU2 > 0x8000) {
2498 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT16 type minimum can't small than -0x8000, big than 0x7FFF");
2499 }
2500 } else {
2501 if (MinU2 > 0x7FFF) {
2502 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT16 type minimum can't small than -0x8000, big than 0x7FFF");
2503 }
2504 }
2505 }
2506 if (MinNegative) {
2507 MinU2 = ~MinU2 + 1;
2508 }
2509 break;
2510 case EFI_IFR_TYPE_NUM_SIZE_8 :
2511 MinU1 = _STOU8(I->getText(), I->getLine());
2512 if (IntDecStyle) {
2513 if (MinNegative) {
2514 if (MinU1 > 0x80) {
2515 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT8 type minimum can't small than -0x80, big than 0x7F");
2516 }
2517 } else {
2518 if (MinU1 > 0x7F) {
2519 _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT8 type minimum can't small than -0x80, big than 0x7F");
2520 }
2521 }
2522 }
2523 if (MinNegative) {
2524 MinU1 = ~MinU1 + 1;
2525 }
2526 break;
2527 }
2528 >>
2529 Maximum "="
2530 {
2531 "\-" << MaxNegative = TRUE; >>
2532 }
2533 A:Number "," <<
2534 if (!IntDecStyle && MaxNegative) {
2535 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "\"-\" can't be used when not in int decimal type. ");
2536 }
2537
2538 switch (_GET_CURRQEST_DATATYPE()) {
2539 case EFI_IFR_TYPE_NUM_SIZE_64 :
2540 MaxU8 = _STOU64(A->getText(), A->getLine());
2541 if (IntDecStyle) {
2542 if (MaxNegative) {
2543 if (MaxU8 > 0x8000000000000000) {
2544 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT64 type maximum can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
2545 }
2546 } else {
2547 if (MaxU8 > 0x7FFFFFFFFFFFFFFF) {
2548 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT64 type maximum can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
2549 }
2550 }
2551 }
2552 if (MaxNegative) {
2553 MaxU8 = ~MaxU8 + 1;
2554 }
2555 if (IntDecStyle) {
2556 if ((INT64) MaxU8 < (INT64) MinU8) {
2557 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
2558 }
2559 } else {
2560 if (MaxU8 < MinU8) {
2561 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
2562 }
2563 }
2564 break;
2565 case EFI_IFR_TYPE_NUM_SIZE_32 :
2566 MaxU4 = _STOU32(A->getText(), A->getLine());
2567 if (IntDecStyle) {
2568 if (MaxNegative) {
2569 if (MaxU4 > 0x80000000) {
2570 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT32 type maximum can't small than -0x80000000, big than 0x7FFFFFFF");
2571 }
2572 } else {
2573 if (MaxU4 > 0x7FFFFFFF) {
2574 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT32 type maximum can't small than -0x80000000, big than 0x7FFFFFFF");
2575 }
2576 }
2577 }
2578 if (MaxNegative) {
2579 MaxU4 = ~MaxU4 + 1;
2580 }
2581 if (IntDecStyle) {
2582 if ((INT32) MaxU4 < (INT32) MinU4) {
2583 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
2584 }
2585 } else {
2586 if (MaxU4 < MinU4) {
2587 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
2588 }
2589 }
2590 break;
2591 case EFI_IFR_TYPE_NUM_SIZE_16 :
2592 MaxU2 = _STOU16(A->getText(), A->getLine());
2593 if (IntDecStyle) {
2594 if (MaxNegative) {
2595 if (MaxU2 > 0x8000) {
2596 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT16 type maximum can't small than -0x8000, big than 0x7FFF");
2597 }
2598 } else {
2599 if (MaxU2 > 0x7FFF) {
2600 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT16 type maximum can't small than -0x8000, big than 0x7FFF");
2601 }
2602 }
2603 }
2604 if (MaxNegative) {
2605 MaxU2 = ~MaxU2 + 1;
2606 }
2607 if (IntDecStyle) {
2608 if ((INT16) MaxU2 < (INT16) MinU2) {
2609 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
2610 }
2611 } else {
2612 if (MaxU2 < MinU2) {
2613 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
2614 }
2615 }
2616 break;
2617 case EFI_IFR_TYPE_NUM_SIZE_8 :
2618 MaxU1 = _STOU8(A->getText(), A->getLine());
2619 if (IntDecStyle) {
2620 if (MaxNegative) {
2621 if (MaxU1 > 0x80) {
2622 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT8 type maximum can't small than -0x80, big than 0x7F");
2623 }
2624 } else {
2625 if (MaxU1 > 0x7F) {
2626 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT8 type maximum can't small than -0x80, big than 0x7F");
2627 }
2628 }
2629 }
2630 if (MaxNegative) {
2631 MaxU1 = ~MaxU1 + 1;
2632 }
2633 if (IntDecStyle) {
2634 if ((INT8) MaxU1 < (INT8) MinU1) {
2635 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
2636 }
2637 } else {
2638 if (MaxU1 < MinU1) {
2639 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
2640 }
2641 }
2642 break;
2643 }
2644 >>
2645 {
2646 STEP "=" S:Number ","
2647 <<
2648 switch (_GET_CURRQEST_DATATYPE()) {
2649 case EFI_IFR_TYPE_NUM_SIZE_64 : StepU8 = _STOU64(S->getText(), S->getLine()); break;
2650 case EFI_IFR_TYPE_NUM_SIZE_32 : StepU4 = _STOU32(S->getText(), S->getLine()); break;
2651 case EFI_IFR_TYPE_NUM_SIZE_16 : StepU2 = _STOU16(S->getText(), S->getLine()); break;
2652 case EFI_IFR_TYPE_NUM_SIZE_8 : StepU1 = _STOU8(S->getText(), S->getLine()); break;
2653 }
2654 >>
2655 }
2656 <<
2657 switch (_GET_CURRQEST_DATATYPE()) {
2658 case EFI_IFR_TYPE_NUM_SIZE_64 : $MMSDObj.SetMinMaxStepData (MinU8, MaxU8, StepU8); break;
2659 case EFI_IFR_TYPE_NUM_SIZE_32 : $MMSDObj.SetMinMaxStepData (MinU4, MaxU4, StepU4); break;
2660 case EFI_IFR_TYPE_NUM_SIZE_16 : $MMSDObj.SetMinMaxStepData (MinU2, MaxU2, StepU2); break;
2661 case EFI_IFR_TYPE_NUM_SIZE_8 : $MMSDObj.SetMinMaxStepData (MinU1, MaxU1, StepU1); break;
2662 }
2663 >>
2664 ;
2665
2666 vfrStatementNumeric :
2667 <<
2668 CIfrNumeric NObj;
2669 UINT32 DataTypeSize;
2670 BOOLEAN IsSupported = TRUE;
2671 UINT8 ShrinkSize = 0;
2672 >>
2673 L:Numeric << NObj.SetLineNo(L->getLine()); >>
2674 vfrQuestionHeader[NObj] "," << // check data type
2675 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
2676 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "Numeric varid is not the valid data type");
2677 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
2678 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric varid doesn't support array");
2679 }
2680 _PCATCH(NObj.SetFlags (NObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());
2681 }
2682 >>
2683 { F:FLAGS "=" vfrNumericFlags[NObj, F->getLine()] "," }
2684 {
2685 Key "=" KN:Number "," << AssignQuestionKey (NObj, KN); >>
2686 }
2687 vfrSetMinMaxStep[NObj] <<
2688 switch (_GET_CURRQEST_DATATYPE()) {
2689 //
2690 // Base on the type to know the actual used size,shrink the buffer
2691 // size allocate before.
2692 //
2693 case EFI_IFR_TYPE_NUM_SIZE_8: ShrinkSize = 21;break;
2694 case EFI_IFR_TYPE_NUM_SIZE_16:ShrinkSize = 18;break;
2695 case EFI_IFR_TYPE_NUM_SIZE_32:ShrinkSize = 12;break;
2696 case EFI_IFR_TYPE_NUM_SIZE_64:break;
2697 default:
2698 IsSupported = FALSE;
2699 break;
2700 }
2701 NObj.ShrinkBinSize (ShrinkSize);
2702 if (!IsSupported) {
2703 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric question only support UINT8, UINT16, UINT32 and UINT64 data type.");
2704 }
2705 >>
2706 vfrStatementQuestionOptionList
2707 E:EndNumeric <<
2708 CRT_END_OP (E);
2709 >>
2710 ";"
2711 ;
2712
2713 vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] :
2714 <<
2715 UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
2716 UINT8 HFlags = 0;
2717 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
2718 BOOLEAN IsSetType = FALSE;
2719 BOOLEAN IsDisplaySpecified = FALSE;
2720 >>
2721 numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified ] )*
2722 <<
2723 //check data type flag
2724 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
2725 VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
2726 if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {
2727 if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {
2728 _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type");
2729 }
2730 } else {
2731 // update data type for name/value store
2732 UINT32 DataTypeSize;
2733 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
2734 gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);
2735 _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;
2736 }
2737 } else if (IsSetType){
2738 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
2739 }
2740 _PCATCH(NObj.SetFlags (HFlags, LFlags, IsDisplaySpecified), LineNum);
2741 >>
2742 ;
2743
2744 numericFlagsField [UINT8 & HFlags, UINT8 & LFlags, BOOLEAN & IsSetType, BOOLEAN & IsDisplaySpecified] :
2745 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
2746 | "NUMERIC_SIZE_1" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1; IsSetType = TRUE;>>
2747 | "NUMERIC_SIZE_2" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2; IsSetType = TRUE;>>
2748 | "NUMERIC_SIZE_4" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4; IsSetType = TRUE;>>
2749 | "NUMERIC_SIZE_8" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8; IsSetType = TRUE;>>
2750 | "DISPLAY_INT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC; IsDisplaySpecified = TRUE;>>
2751 | "DISPLAY_UINT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC; IsDisplaySpecified = TRUE;>>
2752 | "DISPLAY_UINT_HEX" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX; IsDisplaySpecified = TRUE;>>
2753 | questionheaderFlagsField[HFlags]
2754 ;
2755
2756 vfrStatementOneOf :
2757 <<
2758 CIfrOneOf OObj;
2759 UINT32 DataTypeSize;
2760 BOOLEAN IsSupported = TRUE;
2761 UINT8 ShrinkSize = 0;
2762 >>
2763 L:OneOf << OObj.SetLineNo(L->getLine()); >>
2764 vfrQuestionHeader[OObj] "," << //check data type
2765 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
2766 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "OneOf varid is not the valid data type");
2767 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
2768 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf varid doesn't support array");
2769 }
2770 _PCATCH(OObj.SetFlags (OObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());
2771 }
2772 >>
2773 { F:FLAGS "=" vfrOneofFlagsField[OObj, F->getLine()] "," }
2774 {
2775 vfrSetMinMaxStep[OObj]
2776 }
2777 <<
2778 switch (_GET_CURRQEST_DATATYPE()) {
2779 //
2780 // Base on the type to know the actual used size,shrink the buffer
2781 // size allocate before.
2782 //
2783 case EFI_IFR_TYPE_NUM_SIZE_8: ShrinkSize = 21;break;
2784 case EFI_IFR_TYPE_NUM_SIZE_16:ShrinkSize = 18;break;
2785 case EFI_IFR_TYPE_NUM_SIZE_32:ShrinkSize = 12;break;
2786 case EFI_IFR_TYPE_NUM_SIZE_64:break;
2787 default:
2788 IsSupported = FALSE;
2789 break;
2790 }
2791 OObj.ShrinkBinSize (ShrinkSize);
2792 if (!IsSupported) {
2793 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf question only support UINT8, UINT16, UINT32 and UINT64 data type.");
2794 }
2795 >>
2796 vfrStatementQuestionOptionList
2797 E:EndOneOf <<
2798 CRT_END_OP (E);
2799 >>
2800 ";"
2801 ;
2802
2803 vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] :
2804 <<
2805 UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
2806 UINT8 HFlags = 0;
2807 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
2808 BOOLEAN IsSetType = FALSE;
2809 BOOLEAN IsDisplaySpecified = FALSE;
2810 >>
2811 numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] )*
2812 <<
2813 //check data type flag
2814 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
2815 VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
2816 if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {
2817 if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {
2818 _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type");
2819 }
2820 } else {
2821 // update data type for Name/Value store
2822 UINT32 DataTypeSize;
2823 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
2824 gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);
2825 _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;
2826 }
2827 } else if (IsSetType){
2828 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
2829 }
2830 _PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum);
2831 >>
2832 ;
2833
2834 vfrStatementStringType :
2835 vfrStatementString |
2836 vfrStatementPassword
2837 ;
2838
2839 vfrStatementString :
2840 <<
2841 CIfrString SObj;
2842 UINT32 VarArraySize;
2843 UINT8 StringMinSize;
2844 UINT8 StringMaxSize;
2845 >>
2846 L:String << SObj.SetLineNo(L->getLine()); gIsStringOp = TRUE;>>
2847 vfrQuestionHeader[SObj] ","
2848 { F:FLAGS "=" vfrStringFlagsField[SObj, F->getLine()] "," }
2849 {
2850 Key "=" KN:Number "," << AssignQuestionKey (SObj, KN); >>
2851 }
2852 MinSize "=" MIN:Number "," <<
2853 VarArraySize = _GET_CURRQEST_ARRAY_SIZE();
2854 StringMinSize = _STOU8(MIN->getText(), MIN->getLine());
2855 if (_STOU64(MIN->getText(), MIN->getLine()) > StringMinSize) {
2856 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "String MinSize takes only one byte, which can't be larger than 0xFF.");
2857 } else if (VarArraySize != 0 && StringMinSize > VarArraySize) {
2858 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "String MinSize can't be larger than the max number of elements in string array.");
2859 }
2860 SObj.SetMinSize (StringMinSize);
2861 >>
2862 MaxSize "=" MAX:Number "," <<
2863 StringMaxSize = _STOU8(MAX->getText(), MAX->getLine());
2864 if (_STOU64(MAX->getText(), MAX->getLine()) > StringMaxSize) {
2865 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize takes only one byte, which can't be larger than 0xFF.");
2866 } else if (VarArraySize != 0 && StringMaxSize > VarArraySize) {
2867 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize can't be larger than the max number of elements in string array.");
2868 } else if (StringMaxSize < StringMinSize) {
2869 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize can't be less than String MinSize.");
2870 }
2871 SObj.SetMaxSize (StringMaxSize);
2872 >>
2873 vfrStatementQuestionOptionList
2874 E:EndString << CRT_END_OP (E); gIsStringOp = FALSE;>>
2875 ";"
2876 ;
2877
2878 vfrStringFlagsField [CIfrString & SObj, UINT32 LineNum] :
2879 <<
2880 UINT8 LFlags = 0;
2881 UINT8 HFlags = 0;
2882 >>
2883 stringFlagsField[HFlags, LFlags] ( "\|" stringFlagsField[HFlags, LFlags] )*
2884 << _PCATCH(SObj.SetFlags (HFlags, LFlags), LineNum); >>
2885 ;
2886
2887 stringFlagsField [UINT8 & HFlags, UINT8 & LFlags] :
2888 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
2889 | "MULTI_LINE" << $LFlags = 0x01; >>
2890 | questionheaderFlagsField[HFlags]
2891 ;
2892
2893 vfrStatementPassword :
2894 <<
2895 CIfrPassword PObj;
2896 UINT32 VarArraySize;
2897 UINT16 PasswordMinSize;
2898 UINT16 PasswordMaxSize;
2899 >>
2900 L:Password << PObj.SetLineNo(L->getLine()); >>
2901 vfrQuestionHeader[PObj] ","
2902 { F:FLAGS "=" vfrPasswordFlagsField[PObj, F->getLine()] "," }
2903 {
2904 Key "=" KN:Number "," << AssignQuestionKey (PObj, KN); >>
2905 }
2906 MinSize "=" MIN:Number "," <<
2907 VarArraySize = _GET_CURRQEST_ARRAY_SIZE();
2908 PasswordMinSize = _STOU16(MIN->getText(), MIN->getLine());
2909 if (_STOU64(MIN->getText(), MIN->getLine()) > PasswordMinSize) {
2910 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "Password MinSize takes only two byte, which can't be larger than 0xFFFF.");
2911 } else if (VarArraySize != 0 && PasswordMinSize > VarArraySize) {
2912 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "Password MinSize can't be larger than the max number of elements in password array.");
2913 }
2914 PObj.SetMinSize (PasswordMinSize);
2915 >>
2916 MaxSize "=" MAX:Number "," <<
2917 PasswordMaxSize = _STOU16(MAX->getText(), MAX->getLine());
2918 if (_STOU64(MAX->getText(), MAX->getLine()) > PasswordMaxSize) {
2919 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize takes only two byte, which can't be larger than 0xFFFF.");
2920 } else if (VarArraySize != 0 && PasswordMaxSize > VarArraySize) {
2921 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize can't be larger than the max number of elements in password array.");
2922 } else if (PasswordMaxSize < PasswordMinSize) {
2923 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize can't be less than Password MinSize.");
2924 }
2925 PObj.SetMaxSize (PasswordMaxSize);
2926 >>
2927 { Encoding "=" Number "," }
2928 vfrStatementQuestionOptionList
2929 E:EndPassword << CRT_END_OP (E); >>
2930 ";"
2931 ;
2932
2933 vfrPasswordFlagsField [CIfrPassword & PObj, UINT32 LineNum] :
2934 << UINT8 HFlags = 0; >>
2935 passwordFlagsField[HFlags] ( "\|" passwordFlagsField[HFlags] )*
2936 << _PCATCH(PObj.SetFlags(HFlags), LineNum); >>
2937 ;
2938
2939 passwordFlagsField [UINT8 & HFlags] :
2940 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
2941 | questionheaderFlagsField[HFlags]
2942 ;
2943
2944 vfrStatementOrderedList :
2945 <<
2946 CIfrOrderedList OLObj;
2947 UINT32 VarArraySize;
2948 >>
2949 L:OrderedList << OLObj.SetLineNo(L->getLine()); gIsOrderedList = TRUE;>>
2950 vfrQuestionHeader[OLObj] ","
2951 <<
2952 VarArraySize = _GET_CURRQEST_ARRAY_SIZE();
2953 OLObj.SetMaxContainers ((UINT8) (VarArraySize > 0xFF ? 0xFF : VarArraySize));
2954 >>
2955 {
2956 MaxContainers "=" M:Number "," <<
2957 if (_STOU64(M->getText(), M->getLine()) > _STOU8(M->getText(), M->getLine())) {
2958 _PCATCH (VFR_RETURN_INVALID_PARAMETER, M->getLine(), "OrderedList MaxContainers takes only one byte, which can't be larger than 0xFF.");
2959 } else if (VarArraySize != 0 && _STOU8(M->getText(), M->getLine()) > VarArraySize) {
2960 _PCATCH (VFR_RETURN_INVALID_PARAMETER, M->getLine(), "OrderedList MaxContainers can't be larger than the max number of elements in array.");
2961 }
2962 OLObj.SetMaxContainers (_STOU8(M->getText(), M->getLine()));
2963 >>
2964 }
2965 { F:FLAGS "=" vfrOrderedListFlags[OLObj, F->getLine()] {","}}
2966 vfrStatementQuestionOptionList
2967 E:EndList << CRT_END_OP (E); gIsOrderedList = FALSE;>>
2968 ";"
2969 ;
2970
2971 vfrOrderedListFlags [CIfrOrderedList & OLObj, UINT32 LineNum] :
2972 <<
2973 UINT8 HFlags = 0;
2974 UINT8 LFlags = 0;
2975 >>
2976 orderedlistFlagsField[HFlags, LFlags] ( "\|" orderedlistFlagsField[HFlags, LFlags] )*
2977 << _PCATCH(OLObj.SetFlags (HFlags, LFlags), LineNum); >>
2978 ;
2979
2980 orderedlistFlagsField [UINT8 & HFlags, UINT8 & LFlags] :
2981 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
2982 | "UNIQUE" << $LFlags |= 0x01; >>
2983 | "NOEMPTY" << $LFlags |= 0x02; >>
2984 | questionheaderFlagsField[HFlags]
2985 ;
2986
2987 vfrStatementTime :
2988 <<
2989 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
2990 CHAR8 *VarIdStr[3] = {NULL, };
2991 CIfrTime TObj;
2992 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;
2993 UINT8 Size = OFFSET_OF (EFI_IFR_DEFAULT, Value) + sizeof (EFI_HII_TIME);
2994 >>
2995 L:Time << TObj.SetLineNo(L->getLine()); >>
2996 (
2997 (
2998 vfrQuestionHeader[TObj, QUESTION_TIME] "," <<
2999 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
3000 _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_TIME;
3001 }
3002 >>
3003 { F:FLAGS "=" vfrTimeFlags[TObj, F->getLine()] "," }
3004 vfrStatementQuestionOptionList
3005 )
3006 |
3007 (
3008 Hour VarId "=" T1:StringIdentifier "." T1H:StringIdentifier ","
3009 << _STRCAT(&VarIdStr[0], T1->getText()); _STRCAT(&VarIdStr[0], "."); _STRCAT(&VarIdStr[0], T1H->getText()); >>
3010 Prompt "=" "STRING_TOKEN" "\(" HP:Number "\)" ","
3011 Help "=" "STRING_TOKEN" "\(" HH:Number "\)" ","
3012 minMaxTimeStepDefault[Val.time, 0]
3013
3014 Minute VarId "=" T2:StringIdentifier "." T2M:StringIdentifier ","
3015 << _STRCAT(&VarIdStr[1], T2->getText()); _STRCAT(&VarIdStr[1], "."); _STRCAT(&VarIdStr[1], T2M->getText()); >>
3016 Prompt "=" "STRING_TOKEN" "\(" MP:Number "\)" ","
3017 Help "=" "STRING_TOKEN" "\(" MH:Number "\)" ","
3018 minMaxTimeStepDefault[Val.time, 1]
3019
3020 Second VarId "=" T3:StringIdentifier "." T3S:StringIdentifier ","
3021 << _STRCAT(&VarIdStr[2], T3->getText()); _STRCAT(&VarIdStr[2], "."); _STRCAT(&VarIdStr[2], T3S->getText()); >>
3022 Prompt "=" "STRING_TOKEN" "\(" SP:Number "\)" ","
3023 Help "=" "STRING_TOKEN" "\(" SH:Number "\)" ","
3024 minMaxTimeStepDefault[Val.time, 2]
3025 { G:FLAGS "=" vfrTimeFlags[TObj, G->getLine()] "," }
3026 <<
3027 mCVfrQuestionDB.RegisterOldTimeQuestion (VarIdStr[0], VarIdStr[1], VarIdStr[2], QId);
3028 TObj.SetQuestionId (QId);
3029 TObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, QF_TIME_STORAGE_TIME);
3030 TObj.SetPrompt (_STOSID(HP->getText(), HP->getLine()));
3031 TObj.SetHelp (_STOSID(HH->getText(), HH->getLine()));
3032 if (VarIdStr[0] != NULL) { delete VarIdStr[0]; } if (VarIdStr[1] != NULL) { delete VarIdStr[1]; } if (VarIdStr[2] != NULL) { delete VarIdStr[2]; }
3033 >>
3034 << {CIfrDefault DefaultObj(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_TIME, Val); DefaultObj.SetLineNo(L->getLine());} >>
3035 )
3036 ( vfrStatementInconsistentIf )*
3037 )
3038 E:EndTime << CRT_END_OP (E); >>
3039 ";"
3040 ;
3041
3042 minMaxTimeStepDefault[EFI_HII_TIME & T, UINT8 KeyValue] :
3043 Minimum "=" Number ","
3044 Maximum "=" Number ","
3045 { "step" "=" Number "," }
3046 {
3047 "default" "=" N:Number "," <<
3048 switch (KeyValue) {
3049 case 0:
3050 T.Hour = _STOU8(N->getText(), N->getLine());
3051 if (T.Hour > 23) {
3052 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Hour default value must be between 0 and 23.");
3053 }
3054 break;
3055 case 1:
3056 T.Minute = _STOU8(N->getText(), N->getLine());
3057 if (T.Minute > 59) {
3058 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Minute default value must be between 0 and 59.");
3059 }
3060 break;
3061 case 2:
3062 T.Second = _STOU8(N->getText(), N->getLine());
3063 if (T.Second > 59) {
3064 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Second default value must be between 0 and 59.");
3065 }
3066 break;
3067 }
3068 >>
3069 }
3070 ;
3071
3072 vfrTimeFlags [CIfrTime & TObj, UINT32 LineNum] :
3073 << UINT8 LFlags = 0; >>
3074 timeFlagsField[LFlags] ( "\|" timeFlagsField[LFlags] )*
3075 << _PCATCH(TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, LFlags), LineNum); >>
3076 ;
3077
3078 timeFlagsField [UINT8 & Flags] :
3079 N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >>
3080 | "HOUR_SUPPRESS" << $Flags |= 0x01; >>
3081 | "MINUTE_SUPPRESS" << $Flags |= 0x02; >>
3082 | "SECOND_SUPPRESS" << $Flags |= 0x04; >>
3083 | "STORAGE_NORMAL" << $Flags |= 0x00; >>
3084 | "STORAGE_TIME" << $Flags |= 0x10; >>
3085 | "STORAGE_WAKEUP" << $Flags |= 0x20; >>
3086 ;
3087
3088 vfrStatementQuestionTag :
3089 vfrStatementStatTag "," |
3090 vfrStatementInconsistentIf |
3091 vfrStatementNoSubmitIf |
3092 vfrStatementDisableIfQuest |
3093 vfrStatementRefresh |
3094 vfrStatementVarstoreDevice |
3095 vfrStatementExtension |
3096 vfrStatementRefreshEvent "," |
3097 vfrStatementWarningIf
3098 ;
3099
3100 vfrStatementQuestionTagList :
3101 ( vfrStatementQuestionTag )*
3102 ;
3103
3104 vfrStatementQuestionOptionTag :
3105 vfrStatementSuppressIfQuest |
3106 vfrStatementGrayOutIfQuest |
3107 vfrStatementValue |
3108 vfrStatementDefault |
3109 vfrStatementRead |
3110 vfrStatementWrite |
3111 vfrStatementOptions
3112 ;
3113
3114 vfrStatementQuestionOptionList :
3115 (
3116 vfrStatementQuestionTag |
3117 vfrStatementQuestionOptionTag
3118 )*
3119 ;
3120
3121 vfrStatementStatList :
3122 vfrStatementStat |
3123 vfrStatementQuestions |
3124 vfrStatementConditionalNew |
3125 vfrStatementLabel |
3126 vfrStatementExtension |
3127 // Just for framework vfr compatibility
3128 vfrStatementInvalid
3129 ;
3130
3131 vfrStatementStatListOld :
3132 vfrStatementStat |
3133 vfrStatementQuestions |
3134 vfrStatementLabel |
3135 // Just for framework vfr compatibility
3136 vfrStatementInvalid
3137 ;
3138
3139 vfrStatementDisableIfStat :
3140 <<
3141 CIfrDisableIf DIObj;
3142 >>
3143 L:DisableIf << DIObj.SetLineNo(L->getLine()); >>
3144 vfrStatementExpression[0] ";"
3145 ( vfrStatementStatList )*
3146 E:EndIf << CRT_END_OP (E); >>
3147 ";"
3148 ;
3149
3150 vfrStatementInconsistentIfStat :
3151 << CIfrInconsistentIf IIObj; >>
3152 L:InconsistentIf <<
3153 if (!mCompatibleMode) {
3154 _PCATCH (VFR_RETURN_UNSUPPORTED, L);
3155 }
3156 IIObj.SetLineNo(L->getLine());
3157 >>
3158 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText(), S->getLine())); >>
3159 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3160 vfrStatementExpression[0]
3161 E:EndIf << CRT_END_OP (E); >>
3162 ";"
3163 ;
3164
3165 //
3166 // Compatible for framework vfr file
3167 //
3168 vfrStatementgrayoutIfSuppressIf:
3169 << CIfrSuppressIf SIObj; >>
3170 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >>
3171 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3172 vfrStatementExpression[0]
3173 ";"
3174 ;
3175
3176 vfrStatementsuppressIfGrayOutIf:
3177 << CIfrGrayOutIf GOIObj; >>
3178 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >>
3179 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3180 vfrStatementExpression[0]
3181 ";"
3182 ;
3183
3184 vfrStatementSuppressIfStatNew :
3185 << CIfrSuppressIf SIObj;>>
3186 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >>
3187 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3188 vfrStatementExpression[0]
3189 ";"
3190 ( vfrStatementStatList )*
3191 E: EndIf ";" << CRT_END_OP (E); >>
3192 ;
3193
3194 vfrStatementGrayOutIfStatNew :
3195 << CIfrGrayOutIf GOIObj;>>
3196 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >>
3197 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3198 vfrStatementExpression[0]
3199 ";"
3200 ( vfrStatementStatList )*
3201 E: EndIf ";" << CRT_END_OP (E); >>
3202 ;
3203
3204 vfrStatementSuppressIfStatOld :
3205 <<
3206 CIfrSuppressIf SIObj;
3207 BOOLEAN GrayOutExist = FALSE;
3208 >>
3209 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >>
3210 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3211 vfrStatementExpression[0]
3212 ";"
3213 {
3214 vfrStatementsuppressIfGrayOutIf
3215 << GrayOutExist = TRUE; >>
3216 }
3217 ( vfrStatementStatListOld )*
3218 E: EndIf ";" << if (GrayOutExist) CRT_END_OP (E); CRT_END_OP (E);>>
3219 ;
3220
3221 vfrStatementGrayOutIfStatOld :
3222 <<
3223 CIfrGrayOutIf GOIObj;
3224 BOOLEAN SuppressExist = FALSE;
3225 >>
3226 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >>
3227 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3228 vfrStatementExpression[0]
3229 ";"
3230 {
3231 vfrStatementgrayoutIfSuppressIf
3232 << SuppressExist = TRUE; >>
3233 }
3234 ( vfrStatementStatListOld )*
3235 E: EndIf ";" << if (SuppressExist) CRT_END_OP (E); CRT_END_OP (E); >>
3236 ;
3237
3238 vfrImageTag :
3239 << CIfrImage IObj; >>
3240 L:Image "=" "IMAGE_TOKEN" "\(" S1:Number "\)" << IObj.SetImageId (_STOSID(S1->getText(), S1->getLine())); IObj.SetLineNo(L->getLine()); >>
3241 ;
3242
3243 vfrLockedTag :
3244 << CIfrLocked LObj; >>
3245 L:Locked << LObj.SetLineNo(L->getLine()); >>
3246 ;
3247
3248 vfrModalTag :
3249 << CIfrModal MObj; >>
3250 L:Modal << MObj.SetLineNo(L->getLine()); >>
3251 ;
3252
3253 vfrStatementStatTag :
3254 vfrImageTag |
3255 vfrLockedTag
3256 ;
3257
3258 vfrStatementStatTagList :
3259 vfrStatementStatTag ( "," vfrStatementStatTag )*
3260 ;
3261
3262 vfrStatementImage :
3263 vfrImageTag
3264 ";"
3265 ;
3266
3267 vfrStatementModal :
3268 vfrModalTag
3269 ";"
3270 ;
3271
3272 vfrStatementLocked :
3273 vfrLockedTag
3274 ";"
3275 ;
3276
3277 vfrStatementInconsistentIf :
3278 << CIfrInconsistentIf IIObj; >>
3279 L:InconsistentIf << IIObj.SetLineNo(L->getLine()); >>
3280 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText(), S->getLine())); >>
3281 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3282 vfrStatementExpression[0]
3283 E:EndIf {";"} << CRT_END_OP (E); >>
3284 ;
3285
3286 vfrStatementNoSubmitIf :
3287 << CIfrNoSubmitIf NSIObj; >>
3288 L:NoSubmitIf << NSIObj.SetLineNo(L->getLine()); >>
3289 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << NSIObj.SetError (_STOSID(S->getText(), S->getLine())); >>
3290 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3291 vfrStatementExpression[0]
3292 E:EndIf {";"} << CRT_END_OP (E); >>
3293 ;
3294
3295 vfrStatementWarningIf :
3296 << CIfrWarningIf WIObj; >>
3297 L:WarningIf << WIObj.SetLineNo(L->getLine()); >>
3298 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << WIObj.SetWarning (_STOSID(S->getText(), S->getLine())); >>
3299 {Timeout "=" T:Number "," << WIObj.SetTimeOut (_STOU8(T->getText(), T->getLine())); >>}
3300 vfrStatementExpression[0]
3301 E:EndIf {";"} << CRT_END_OP (E); >>
3302 ;
3303
3304 vfrStatementDisableIfQuest :
3305 <<
3306 CIfrDisableIf DIObj;
3307 >>
3308 L:DisableIf << DIObj.SetLineNo(L->getLine()); >>
3309 vfrStatementExpression[0] ";"
3310 vfrStatementQuestionOptionList
3311 E:EndIf {";"} << CRT_END_OP (E); >>
3312 ;
3313
3314 vfrStatementRefresh :
3315 << CIfrRefresh RObj; >>
3316 L:Refresh << RObj.SetLineNo(L->getLine()); >>
3317 Interval "=" I:Number << RObj.SetRefreshInterval (_STOU8(I->getText(), I->getLine())); >>
3318 ;
3319
3320 vfrStatementRefreshEvent :
3321 <<
3322 CIfrRefreshId RiObj;
3323 EFI_GUID Guid;
3324 >>
3325 L:RefreshGuid << RiObj.SetLineNo(L->getLine()); >>
3326 "=" guidDefinition[Guid] << RiObj.SetRefreshEventGroutId (&Guid); >>
3327 ;
3328
3329 vfrStatementVarstoreDevice :
3330 << CIfrVarStoreDevice VDObj; >>
3331 L:VarstoreDevice << VDObj.SetLineNo(L->getLine()); >>
3332 "=" "STRING_TOKEN" "\(" S:Number "\)" "," << VDObj.SetDevicePath (_STOSID(S->getText(), S->getLine())); >>
3333 ;
3334
3335 vfrStatementSuppressIfQuest :
3336 << CIfrSuppressIf SIObj; >>
3337 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >>
3338 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3339 vfrStatementExpression[0] ";"
3340 vfrStatementQuestionOptionList
3341 E:EndIf {";"} << CRT_END_OP (E); >>
3342 ;
3343
3344 vfrStatementGrayOutIfQuest :
3345 << CIfrGrayOutIf GOIObj; >>
3346 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >>
3347 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3348 vfrStatementExpression[0] ";"
3349 vfrStatementQuestionOptionList
3350 E:EndIf {";"} << CRT_END_OP (E); >>
3351 ;
3352
3353 vfrStatementOptions :
3354 vfrStatementOneOfOption
3355 ;
3356
3357 vfrStatementOneOfOption :
3358 <<
3359 UINT8 ValueList[EFI_IFR_MAX_LENGTH] = {0,};
3360 EFI_IFR_TYPE_VALUE *Val = (EFI_IFR_TYPE_VALUE *) ValueList;
3361 CHAR8 *VarStoreName = NULL;
3362 UINT32 Size = 0;
3363 BOOLEAN TypeError = FALSE;
3364 EFI_VFR_RETURN_CODE ReturnCode = VFR_RETURN_SUCCESS;
3365 EFI_GUID *VarStoreGuid = NULL;
3366 BOOLEAN ArrayType = FALSE;
3367 CIfrOneOfOption *OOOObj;
3368 UINT8 *Type8 = (UINT8 *) ValueList;
3369 UINT16 *Type16 = (UINT16 *) ValueList;
3370 UINT32 *Type32 = (UINT32 *) ValueList;
3371 UINT64 *Type64 = (UINT64 *) ValueList;
3372 >>
3373 L:Option <<
3374 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
3375 _PCATCH (VFR_RETURN_FATAL_ERROR, L->getLine(), "Get data type error.");
3376 }
3377
3378 >>
3379 Text "=" "STRING_TOKEN" "\(" S:Number "\)" ","
3380 Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE(), *Val, ArrayType] ","
3381 <<
3382 if (gCurrentMinMaxData != NULL) {
3383 //set min/max value for oneof opcode
3384 UINT64 Step = gCurrentMinMaxData->GetStepData(_GET_CURRQEST_DATATYPE());
3385 switch (_GET_CURRQEST_DATATYPE()) {
3386 case EFI_IFR_TYPE_NUM_SIZE_64:
3387 gCurrentMinMaxData->SetMinMaxStepData(Val->u64, Val->u64, Step);
3388 break;
3389 case EFI_IFR_TYPE_NUM_SIZE_32:
3390 gCurrentMinMaxData->SetMinMaxStepData(Val->u32, Val->u32, (UINT32) Step);
3391 break;
3392 case EFI_IFR_TYPE_NUM_SIZE_16:
3393 gCurrentMinMaxData->SetMinMaxStepData(Val->u16, Val->u16, (UINT16) Step);
3394 break;
3395 case EFI_IFR_TYPE_NUM_SIZE_8:
3396 gCurrentMinMaxData->SetMinMaxStepData(Val->u8, Val->u8, (UINT8) Step);
3397 break;
3398 default:
3399 break;
3400 }
3401 }
3402 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
3403 Size = sizeof (EFI_IFR_TYPE_VALUE);
3404 } else if (ArrayType) {
3405 switch (_GET_CURRQEST_DATATYPE()) {
3406 case EFI_IFR_TYPE_NUM_SIZE_8 :
3407 while (Type8[Size] != 0) {
3408 Size++;
3409 }
3410 break;
3411 case EFI_IFR_TYPE_NUM_SIZE_16 :
3412 while (Type16[Size] != 0) {
3413 Size++;
3414 }
3415 Size *= sizeof (UINT16);
3416 break;
3417 case EFI_IFR_TYPE_NUM_SIZE_32 :
3418 while (Type32[Size] != 0) {
3419 Size++;
3420 }
3421 Size *= sizeof (UINT32);
3422 break;
3423 case EFI_IFR_TYPE_NUM_SIZE_64 :
3424 while (Type64[Size] != 0) {
3425 Size++;
3426 }
3427 Size *= sizeof (UINT64);
3428 break;
3429 default:
3430 break;
3431 }
3432 } else {
3433 ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size);
3434 }
3435 if (ReturnCode != VFR_RETURN_SUCCESS) {
3436 _PCATCH (ReturnCode, L->getLine());
3437 }
3438
3439 Size += OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value);
3440 OOOObj = new CIfrOneOfOption((UINT8)Size);
3441 OOOObj->SetLineNo(L->getLine());
3442 OOOObj->SetOption (_STOSID(S->getText(), S->getLine()));
3443 if (ArrayType) {
3444 OOOObj->SetType (EFI_IFR_TYPE_BUFFER);
3445 } else {
3446 OOOObj->SetType (_GET_CURRQEST_DATATYPE());
3447 }
3448 OOOObj->SetValue (*Val);
3449 >>
3450 F:FLAGS "=" vfrOneOfOptionFlags[*OOOObj, F->getLine()]
3451 <<
3452 //
3453 // Array type only for default type OneOfOption.
3454 //
3455 if ((OOOObj->GetFlags () & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG)) == 0 && ArrayType) {
3456 _PCATCH (VFR_RETURN_FATAL_ERROR, L->getLine(), "Default keyword should with array value type!");
3457 }
3458
3459 //
3460 // Clear the default flag if the option not use array value but has default flag.
3461 //
3462 if ((OOOObj->GetFlags () & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG)) != 0 && !ArrayType && gIsOrderedList) {
3463 OOOObj->SetFlags(OOOObj->GetFlags () & ~(EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG));
3464 }
3465
3466 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
3467 _PCATCH(gCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), L->getLine());
3468 VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);
3469 if (OOOObj->GetFlags () & EFI_IFR_OPTION_DEFAULT) {
3470 CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_STANDARD, F);
3471 _PCATCH(gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
3472 EFI_HII_DEFAULT_CLASS_STANDARD,
3473 _GET_CURRQEST_VARTINFO(),
3474 VarStoreName,
3475 VarStoreGuid,
3476 _GET_CURRQEST_DATATYPE (),
3477 *Val
3478 ), L->getLine());
3479 }
3480 if (OOOObj->GetFlags () & EFI_IFR_OPTION_DEFAULT_MFG) {
3481 CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_MANUFACTURING, F);
3482 _PCATCH(gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
3483 EFI_HII_DEFAULT_CLASS_MANUFACTURING,
3484 _GET_CURRQEST_VARTINFO(),
3485 VarStoreName,
3486 VarStoreGuid,
3487 _GET_CURRQEST_DATATYPE (),
3488 *Val
3489 ), L->getLine());
3490 }
3491 }
3492 >>
3493 {
3494 "," Key "=" KN:Number <<
3495 if (!mCompatibleMode) {
3496 _PCATCH (VFR_RETURN_UNSUPPORTED, KN);
3497 }
3498 //
3499 // Guid Option Key
3500 //
3501 CIfrOptionKey IfrOptionKey (
3502 gCurrentQuestion->QUESTION_ID(),
3503 *Val,
3504 _STOQID(KN->getText(), KN->getLine())
3505 );
3506 SET_LINE_INFO (IfrOptionKey, KN);
3507 >>
3508 }
3509 (
3510 T:"," vfrImageTag << OOOObj->SetScope (1); CRT_END_OP (T); >>
3511 )*
3512 ";" << if (OOOObj != NULL) {delete OOOObj;} >>
3513 ;
3514
3515 vfrOneOfOptionFlags [CIfrOneOfOption & OOOObj, UINT32 LineNum] :
3516 <<
3517 UINT8 LFlags = _GET_CURRQEST_DATATYPE();
3518 UINT8 HFlags = 0;
3519 >>
3520 oneofoptionFlagsField[HFlags, LFlags] ( "\|" oneofoptionFlagsField[HFlags, LFlags] )*
3521 << _PCATCH(gCurrentQuestion->SetFlags(HFlags), LineNum); >>
3522 << _PCATCH(OOOObj.SetFlags(LFlags), LineNum); >>
3523 ;
3524
3525 oneofoptionFlagsField [UINT8 & HFlags, UINT8 & LFlags] :
3526 N:Number << $LFlags |= _STOU8(N->getText(), N->getLine()); >>
3527 | "OPTION_DEFAULT" << $LFlags |= 0x10; >>
3528 | "OPTION_DEFAULT_MFG" << $LFlags |= 0x20; >>
3529 | InteractiveFlag << $HFlags |= 0x04; >>
3530 | ResetRequiredFlag << $HFlags |= 0x10; >>
3531 | ReconnectRequiredFlag << $HFlags |= 0x40; >>
3532 | ManufacturingFlag << $LFlags |= 0x20; >>
3533 | DefaultFlag << $LFlags |= 0x10; >>
3534 | A:NVAccessFlag <<
3535 if (mCompatibleMode) {
3536 $HFlags |= 0x08;
3537 } else {
3538 gCVfrErrorHandle.HandleWarning (
3539 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
3540 A->getLine(),
3541 A->getText()
3542 );
3543 }
3544 >>
3545 | L:LateCheckFlag <<
3546 if (mCompatibleMode) {
3547 $HFlags |= 0x20;
3548 } else {
3549 gCVfrErrorHandle.HandleWarning (
3550 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
3551 L->getLine(),
3552 L->getText()
3553 );
3554 }
3555 >>
3556 ;
3557
3558 vfrStatementLabel :
3559 L:Label
3560 N:Number <<
3561 if (mCompatibleMode) {
3562 //
3563 // Add end Label for Framework Vfr
3564 //
3565 CIfrLabel LObj1;
3566 LObj1.SetLineNo(L->getLine());
3567 LObj1.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff
3568 }
3569
3570 {
3571 CIfrLabel LObj2;
3572 LObj2.SetLineNo(L->getLine());
3573 LObj2.SetNumber (_STOU16(N->getText(), N->getLine()));
3574 }
3575 >>
3576 ";"
3577 ;
3578
3579 vfrStatementBanner :
3580 << CIfrBanner BObj; >>
3581 B:Banner { "," } << BObj.SetLineNo(B->getLine()); >>
3582 Title "=" "STRING_TOKEN" "\(" S:Number "\)" "," << BObj.SetTitle (_STOSID(S->getText(), S->getLine())); >>
3583 (
3584 (
3585 Line L:Number "," << BObj.SetLine (_STOU16(L->getText(), L->getLine())); >>
3586 Align
3587 (
3588 Left << BObj.SetAlign (0); >>
3589 | Center << BObj.SetAlign (1); >>
3590 | Right << BObj.SetAlign (2); >>
3591 ) ";"
3592 )
3593 |
3594 (
3595 Timeout "=" T:Number ";" << {CIfrTimeout TObj(_STOU16(T->getText(), T->getLine()));} >>
3596 )
3597 )
3598 ;
3599
3600 //******************************************************************************
3601 //
3602 // keep some syntax for compatibility but not generate any IFR object
3603 //
3604 vfrStatementInvalidHidden :
3605 L:Hidden <<
3606 if (!mCompatibleMode) {
3607 _PCATCH (VFR_RETURN_UNSUPPORTED, L);
3608 }
3609 >>
3610 Value "=" Number ","
3611 Key "=" Number ";"
3612 ;
3613
3614 vfrStatementInvalidInconsistentIf :
3615 InconsistentIf
3616 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" ","
3617 { FLAGS "=" flagsField ( "\|" flagsField )* "," }
3618 vfrStatementExpression[0]
3619 EndIf
3620 ";"
3621 ;
3622
3623 vfrStatementInvalidInventory :
3624 L:Inventory <<
3625 if (!mCompatibleMode) {
3626 _PCATCH (VFR_RETURN_UNSUPPORTED, L);
3627 }
3628 >>
3629 Help "=" "STRING_TOKEN" "\(" Number "\)" ","
3630 Text "=" "STRING_TOKEN" "\(" Number "\)" ","
3631 {
3632 Text "=" "STRING_TOKEN" "\(" Number "\)"
3633 }
3634 ";"
3635 ;
3636
3637 vfrStatementInvalidSaveRestoreDefaults :
3638 (
3639 L:Save <<
3640 if (!mCompatibleMode) {
3641 _PCATCH (VFR_RETURN_UNSUPPORTED, L);
3642 }
3643 >>
3644 |
3645 K:Restore <<
3646 if (!mCompatibleMode) {
3647 _PCATCH (VFR_RETURN_UNSUPPORTED, K);
3648 }
3649 >>
3650 )
3651 Defaults ","
3652 FormId "=" Number ","
3653 Prompt "=" "STRING_TOKEN" "\(" Number "\)" ","
3654 Help "=" "STRING_TOKEN" "\(" Number "\)"
3655 { "," FLAGS "=" flagsField ( "\|" flagsField )* }
3656 { "," Key "=" Number }
3657 ";"
3658 ;
3659
3660 //******************************************************************************
3661 //
3662 // The syntax of expression
3663 //
3664 #token Dup("dup") "dup"
3665 #token VarEqVal("vareqval") "vareqval"
3666 #token Var("var") "var"
3667 #token IdEqVal("ideqval") "ideqval"
3668 #token IdEqId("ideqid") "ideqid"
3669 #token IdEqValList("ideqvallist") "ideqvallist"
3670 #token QuestionRef("questionref") "questionref"
3671 #token RuleRef("ruleref") "ruleref"
3672 #token StringRef("stringref") "stringref"
3673 #token PushThis("pushthis") "pushthis"
3674 #token Security("security") "security"
3675 #token Get("get") "get"
3676 #token True("TRUE") "TRUE"
3677 #token False("FALSE") "FALSE"
3678 #token One("ONE") "ONE"
3679 #token Ones("ONES") "ONES"
3680 #token Zero("ZERO") "ZERO"
3681 #token Undefined("UNDEFINED") "UNDEFINED"
3682 #token Version("VERSION") "VERSION"
3683 #token Length("length") "length"
3684 #token AND("AND") "AND"
3685 #token OR("OR") "OR"
3686 #token NOT("NOT") "NOT"
3687 #token Set("set") "set"
3688 #token BitWiseNot("~") "\~"
3689 #token BoolVal("boolval") "boolval"
3690 #token StringVal("stringval") "stringval"
3691 #token UnIntVal("unintval") "unintval"
3692 #token ToUpper("toupper") "toupper"
3693 #token ToLower("tolower") "tolower"
3694 #token Match("match") "match"
3695 #token Match2("match2") "match2"
3696 #token Catenate("catenate") "catenate"
3697 #token QuestionRefVal("questionrefval") "questionrefval"
3698 #token StringRefVal("stringrefval") "stringrefval"
3699 #token Map("map") "map"
3700 #token RefreshGuid("refreshguid") "refreshguid"
3701
3702 //
3703 // Root expression extension function called by other function.
3704 //
3705 vfrStatementExpression [UINT32 RootLevel, UINT32 ExpOpCount = 0] :
3706 << if ($RootLevel == 0) {mCIfrOpHdrIndex ++; if (mCIfrOpHdrIndex >= MAX_IFR_EXPRESSION_DEPTH) _PCATCH (VFR_RETURN_INVALID_PARAMETER, 0, "The depth of expression exceeds the max supported level 8!"); _CLEAR_SAVED_OPHDR ();} >>
3707 andTerm[$RootLevel, $ExpOpCount]
3708 (
3709 L:OR andTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrOr OObj(L->getLine()); >>
3710 )*
3711 <<
3712 //
3713 // Extend OpCode Scope only for the root expression.
3714 //
3715 if ($ExpOpCount > 1 && $RootLevel == 0) {
3716 if (_SET_SAVED_OPHDR_SCOPE()) {
3717 CIfrEnd EObj;
3718 if (mCIfrOpHdrLineNo[mCIfrOpHdrIndex] != 0) {
3719 EObj.SetLineNo (mCIfrOpHdrLineNo[mCIfrOpHdrIndex]);
3720 }
3721 }
3722 }
3723
3724 if ($RootLevel == 0) {
3725 mCIfrOpHdrIndex --;
3726 }
3727 >>
3728 ;
3729
3730 //
3731 // Add new sub function for the sub expression extension to remember the ExpOpCount
3732 // This funciton is only called by sub expression.
3733 //
3734 vfrStatementExpressionSub [UINT32 RootLevel, UINT32 & ExpOpCount] :
3735 andTerm[$RootLevel, $ExpOpCount]
3736 (
3737 L:OR andTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrOr OObj(L->getLine()); >>
3738 )*
3739 ;
3740
3741 andTerm[UINT32 & RootLevel, UINT32 & ExpOpCount] :
3742 bitwiseorTerm[$RootLevel, $ExpOpCount]
3743 (
3744 L:AND bitwiseorTerm [$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrAnd AObj(L->getLine()); >>
3745 )*
3746 ;
3747
3748 bitwiseorTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3749 bitwiseandTerm[$RootLevel, $ExpOpCount]
3750 (
3751 L:"\|" bitwiseandTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrBitWiseOr BWOObj(L->getLine()); >>
3752 )*
3753 ;
3754
3755 bitwiseandTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3756 equalTerm[$RootLevel, $ExpOpCount]
3757 (
3758 L:"&" equalTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrBitWiseAnd BWAObj(L->getLine()); >>
3759 )*
3760 ;
3761
3762 equalTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3763 compareTerm[$RootLevel, $ExpOpCount]
3764 (
3765 (
3766 L1:"==" compareTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrEqual EObj(L1->getLine()); >>
3767 )
3768 |
3769 (
3770 L2:"!=" compareTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrNotEqual NEObj(L2->getLine()); >>
3771 )
3772 )*
3773 ;
3774
3775 compareTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3776 shiftTerm[$RootLevel, $ExpOpCount]
3777 (
3778 (
3779 L1:"<" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrLessThan LTObj(L1->getLine()); >>
3780 )
3781 |
3782 (
3783 L2:"<=" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrLessEqual LEObj(L2->getLine()); >>
3784 )
3785 |
3786 (
3787 L3:">" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrGreaterThan GTObj(L3->getLine()); >>
3788 )
3789 |
3790 (
3791 L4:">=" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrGreaterEqual GEObj(L4->getLine()); >>
3792 )
3793 )*
3794 ;
3795
3796 shiftTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3797 addMinusTerm[$RootLevel, $ExpOpCount]
3798 (
3799 (
3800 L1:"\<<" addMinusTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrShiftLeft SLObj(L1->getLine()); >>
3801 )
3802 |
3803 (
3804 L2:"\>>" addMinusTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrShiftRight SRObj(L2->getLine()); >>
3805 )
3806 )*
3807 ;
3808
3809 addMinusTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3810 multdivmodTerm[$RootLevel, $ExpOpCount]
3811 (
3812 (
3813 L1:"\+" multdivmodTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrAdd AObj(L1->getLine()); >>
3814 )
3815 |
3816 (
3817 L2:"\-" multdivmodTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrSubtract SObj(L2->getLine()); >>
3818 )
3819 )*
3820 ;
3821
3822 multdivmodTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3823 castTerm[$RootLevel, $ExpOpCount]
3824 (
3825 (
3826 L1:"\*" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrMultiply MObj(L1->getLine()); >>
3827 )
3828 |
3829 (
3830 L2:"/" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrDivide DObj(L2->getLine()); >>
3831 )
3832 |
3833 (
3834 L3:"%" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrModulo MObj(L3->getLine()); >>
3835 )
3836 )*
3837 ;
3838
3839 castTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3840 << UINT8 CastType = 0xFF; >>
3841 (
3842 L:"\("
3843 (
3844 Boolean << CastType = 0; >>
3845 | Uint64 << CastType = 1; >>
3846 | Uint32 << CastType = 1; >>
3847 | Uint16 << CastType = 1; >>
3848 | Uint8 << CastType = 1; >>
3849 )
3850 "\)"
3851 )*
3852 atomTerm[$RootLevel, $ExpOpCount]
3853 <<
3854 switch (CastType) {
3855 case 0: { CIfrToBoolean TBObj(L->getLine()); $ExpOpCount++; } break;
3856 case 1: { CIfrToUint TUObj(L->getLine()); $ExpOpCount++; } break;
3857 }
3858 >>
3859 ;
3860
3861 atomTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3862 vfrExpressionCatenate[$RootLevel, $ExpOpCount]
3863 | vfrExpressionMatch[$RootLevel, $ExpOpCount]
3864 | vfrExpressionMatch2[$RootLevel, $ExpOpCount]
3865 | vfrExpressionParen[$RootLevel, $ExpOpCount]
3866 | vfrExpressionBuildInFunction[$RootLevel, $ExpOpCount]
3867 | vfrExpressionConstant[$RootLevel, $ExpOpCount]
3868 | vfrExpressionUnaryOp[$RootLevel, $ExpOpCount]
3869 | vfrExpressionTernaryOp[$RootLevel, $ExpOpCount]
3870 | vfrExpressionMap[$RootLevel, $ExpOpCount]
3871 | (
3872 L:NOT
3873 atomTerm[$RootLevel, $ExpOpCount] << { CIfrNot NObj(L->getLine()); $ExpOpCount++; } >>
3874 )
3875 ;
3876
3877 vfrExpressionCatenate [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3878 L:Catenate
3879 "\("
3880 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
3881 ","
3882 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
3883 "\)" << { CIfrCatenate CObj(L->getLine()); $ExpOpCount++; } >>
3884 ;
3885
3886 vfrExpressionMatch [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3887 L:Match
3888 "\("
3889 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
3890 ","
3891 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
3892 "\)" << { CIfrMatch MObj(L->getLine()); $ExpOpCount++; } >>
3893 ;
3894
3895 vfrExpressionMatch2 [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3896 <<
3897 EFI_GUID Guid;
3898 >>
3899 L:Match2
3900 "\("
3901 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
3902 ","
3903 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
3904 ","
3905 guidDefinition[Guid]
3906 "\)" << { CIfrMatch2 M2Obj(L->getLine(), &Guid); $ExpOpCount++; } >>
3907 ;
3908
3909 vfrExpressionParen [UINT32 & RootLevel, UINT32 & ExpOpCount]:
3910 "\("
3911 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
3912 "\)"
3913 ;
3914
3915 vfrExpressionBuildInFunction [UINT32 & RootLevel, UINT32 & ExpOpCount] :
3916 dupExp[$RootLevel, $ExpOpCount]
3917 | vareqvalExp[$RootLevel, $ExpOpCount] //Compatible for Framework vareqval
3918 | ideqvalExp[$RootLevel, $ExpOpCount]
3919 | ideqidExp[$RootLevel, $ExpOpCount]
3920 | ideqvallistExp[$RootLevel, $ExpOpCount]
3921 | questionref1Exp[$RootLevel, $ExpOpCount]
3922 | rulerefExp[$RootLevel, $ExpOpCount]
3923 | stringref1Exp[$RootLevel, $ExpOpCount]
3924 | pushthisExp[$RootLevel, $ExpOpCount]
3925 | securityExp[$RootLevel, $ExpOpCount]
3926 | getExp[$RootLevel, $ExpOpCount]
3927 ;
3928
3929 dupExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
3930 L:Dup << { CIfrDup DObj(L->getLine()); _SAVE_OPHDR_COND(DObj, ($ExpOpCount == 0), L->getLine()); $ExpOpCount++; } >>
3931 ;
3932
3933 vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
3934 <<
3935 EFI_QUESTION_ID QId;
3936 UINT32 Mask;
3937 UINT16 ConstVal;
3938 CHAR8 *VarIdStr;
3939 UINT32 LineNo;
3940 EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS;
3941 EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
3942 >>
3943 L:VarEqVal <<
3944 if (!mCompatibleMode) {
3945 _PCATCH (VFR_RETURN_UNSUPPORTED, L);
3946 }
3947 >>
3948 VK:Var
3949 OpenParen
3950 VN:Number <<
3951 VarIdStr = NULL; _STRCAT(&VarIdStr, VK->getText()); _STRCAT(&VarIdStr, VN->getText());
3952 VfrReturnCode = gCVfrDataStorage.GetVarStoreId (VarIdStr, &VarStoreId);
3953 if (VfrReturnCode == VFR_RETURN_UNDEFINED) {
3954 _PCATCH (gCVfrDataStorage.DeclareEfiVarStore (
3955 VarIdStr,
3956 &mFormsetGuid,
3957 _STOSID(VN->getText(), VN->getLine()),
3958 0x2, //default type is UINT16
3959 FALSE
3960 ), VN);
3961 } else {
3962 _PCATCH (VfrReturnCode, VN);
3963 }
3964 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask);
3965 LineNo = GET_LINENO(VN);
3966 >>
3967 CloseParen
3968 (
3969 (
3970 "=="
3971 V1:Number << ConstVal = _STOU16(V1->getText(), V1->getLine()); >>
3972 <<
3973 if (Mask == 0) {
3974 CIfrEqIdVal EIVObj (L->getLine());
3975 _SAVE_OPHDR_COND (EIVObj, ($ExpOpCount == 0), L->getLine());
3976 EIVObj.SetQuestionId (QId, VarIdStr, LineNo);
3977 EIVObj.SetValue (ConstVal);
3978 $ExpOpCount++;
3979 } else {
3980 IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, EQUAL);
3981 }
3982 >>
3983 )
3984 |
3985 (
3986 "<="
3987 V2:Number << ConstVal = _STOU16(V2->getText(), V2->getLine()); >>
3988 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_EQUAL); >>
3989 )
3990 |
3991 (
3992 "<"
3993 V3:Number << ConstVal = _STOU16(V3->getText(), V3->getLine()); >>
3994 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_THAN); >>
3995 )
3996 |
3997 (
3998 ">="
3999 V4:Number << ConstVal = _STOU16(V4->getText(), V4->getLine()); >>
4000 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_EQUAL); >>
4001 )
4002 |
4003 (
4004 ">"
4005 V5:Number << ConstVal = _STOU16(V5->getText(), V5->getLine()); >>
4006 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_THAN); >>
4007 )
4008 )
4009 ;
4010
4011 ideqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
4012 <<
4013 EFI_QUESTION_ID QId;
4014 UINT32 Mask;
4015 UINT16 ConstVal;
4016 CHAR8 *VarIdStr;
4017 UINT32 LineNo;
4018 >>
4019 L:IdEqVal
4020 vfrQuestionDataFieldName[QId, Mask, VarIdStr, LineNo]
4021 (
4022 (
4023 "=="
4024 V1:Number << ConstVal = _STOU16(V1->getText(), V1->getLine()); >>
4025 <<
4026 if (Mask == 0) {
4027 CIfrEqIdVal EIVObj (L->getLine());
4028 _SAVE_OPHDR_COND (EIVObj, ($ExpOpCount == 0), L->getLine());
4029 EIVObj.SetQuestionId (QId, VarIdStr, LineNo);
4030 EIVObj.SetValue (ConstVal);
4031 $ExpOpCount++;
4032 } else {
4033 IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, EQUAL);
4034 }
4035 >>
4036 )
4037 |
4038 (
4039 "<="
4040 V2:Number << ConstVal = _STOU16(V2->getText(), V2->getLine()); >>
4041 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_EQUAL); >>
4042 )
4043 |
4044 (
4045 "<"
4046 V3:Number << ConstVal = _STOU16(V3->getText(), V3->getLine()); >>
4047 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_THAN); >>
4048 )
4049 |
4050 (
4051 ">="
4052 V4:Number << ConstVal = _STOU16(V4->getText(), V4->getLine()); >>
4053 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_EQUAL); >>
4054 )
4055 |
4056 (
4057 ">"
4058 V5:Number << ConstVal = _STOU16(V5->getText(), V5->getLine()); >>
4059 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_THAN); >>
4060 )
4061 )
4062 ;
4063
4064 ideqidExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4065 <<
4066 EFI_QUESTION_ID QId[2];
4067 UINT32 Mask[2];
4068 CHAR8 *VarIdStr[2];
4069 UINT32 LineNo[2];
4070 >>
4071 L:IdEqId
4072 vfrQuestionDataFieldName[QId[0], Mask[0], VarIdStr[0], LineNo[0]]
4073 (
4074 (
4075 "=="
4076 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]
4077 <<
4078 if (Mask[0] & Mask[1]) {
4079 IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], EQUAL);
4080 } else {
4081 CIfrEqIdId EIIObj(L->getLine());
4082 _SAVE_OPHDR_COND (EIIObj, ($ExpOpCount == 0), L->getLine());
4083 EIIObj.SetQuestionId1 (QId[0], VarIdStr[0], LineNo[0]);
4084 EIIObj.SetQuestionId2 (QId[1], VarIdStr[1], LineNo[1]);
4085 $ExpOpCount++;
4086 }
4087 >>
4088 )
4089 |
4090 (
4091 "<="
4092 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]
4093 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], LESS_EQUAL); >>
4094 )
4095 |
4096 (
4097 "<"
4098 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]
4099 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], LESS_THAN); >>
4100 )
4101 |
4102 (
4103 ">="
4104 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]
4105 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], GREATER_EQUAL); >>
4106 )
4107 |
4108 (
4109 ">"
4110 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]
4111 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], GREATER_THAN); >>
4112 )
4113 )
4114 ;
4115
4116 ideqvallistExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4117 <<
4118 UINT16 ListLen = 0;
4119 EFI_QUESTION_ID QId;
4120 UINT32 Mask;
4121 UINT16 ValueList[EFI_IFR_MAX_LENGTH] = {0,};
4122 CHAR8 *VarIdStr;
4123 UINT32 LineNo;
4124 >>
4125 L:IdEqValList
4126 vfrQuestionDataFieldName[QId, Mask, VarIdStr, LineNo]
4127 "=="
4128 (
4129 V:Number << ValueList[ListLen] = _STOU16(V->getText(), V->getLine()); ListLen++; >>
4130 )+
4131 <<
4132 if (Mask != 0) {
4133 IdEqListDoSpecial ($ExpOpCount, LineNo, QId, VarIdStr, Mask, ListLen, ValueList);
4134 } else {
4135 UINT16 Index;
4136 CIfrEqIdList EILObj(L->getLine());
4137 if (QId != EFI_QUESTION_ID_INVALID) {
4138 EILObj.SetQuestionId (QId, VarIdStr, LineNo);
4139 }
4140 EILObj.SetListLength (ListLen);
4141 for (Index = 0; Index < ListLen; Index++) {
4142 EILObj.SetValueList (Index, ValueList[Index]);
4143 }
4144
4145 EILObj.UpdateIfrBuffer();
4146 _SAVE_OPHDR_COND (EILObj, ($ExpOpCount == 0), L->getLine());
4147
4148 if (QId == EFI_QUESTION_ID_INVALID) {
4149 EILObj.SetQuestionId (QId, VarIdStr, LineNo);
4150 }
4151 $ExpOpCount++;
4152 }
4153 >>
4154 ;
4155
4156 questionref1Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4157 <<
4158 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
4159 UINT32 BitMask;
4160 CHAR8 *QName = NULL;
4161 UINT32 LineNo = 0;
4162 >>
4163 L:QuestionRef
4164 "\("
4165 (
4166 QN:StringIdentifier <<
4167 QName = QN->getText();
4168 LineNo = QN->getLine();
4169 mCVfrQuestionDB.GetQuestionId (QN->getText(), NULL, QId, BitMask);
4170 >>
4171 | ID:Number << QId = _STOQID(ID->getText(), ID->getLine()); >>
4172 )
4173 "\)"
4174 <<
4175 { CIfrQuestionRef1 QR1Obj(L->getLine()); _SAVE_OPHDR_COND (QR1Obj, ($ExpOpCount == 0), L->getLine()); QR1Obj.SetQuestionId (QId, QName, LineNo); } $ExpOpCount++; >>
4176 ;
4177
4178 rulerefExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4179 L:RuleRef
4180 "\(" RN:StringIdentifier "\)" << { CIfrRuleRef RRObj(L->getLine()); _SAVE_OPHDR_COND (RRObj, ($ExpOpCount == 0), L->getLine()); RRObj.SetRuleId (mCVfrRulesDB.GetRuleId (RN->getText())); } $ExpOpCount++; >>
4181 ;
4182
4183 //******************************************************
4184 // PARSE:
4185 // stringref (STR_FORM_SET_TITLE)
4186 //
4187 stringref1Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4188 <<
4189 EFI_STRING_ID RefStringId = EFI_STRING_ID_INVALID;
4190 >>
4191 L:StringRef
4192 "\("
4193 (
4194 "STRING_TOKEN"
4195 "\("
4196 S:Number << RefStringId = _STOSID(S->getText(), S->getLine()); >>
4197 "\)"
4198 | I:Number << RefStringId = _STOSID(I->getText(), I->getLine()); >>
4199 )
4200 "\)" << { CIfrStringRef1 SR1Obj(L->getLine()); _SAVE_OPHDR_COND (SR1Obj, ($ExpOpCount == 0), L->getLine()); SR1Obj.SetStringId (RefStringId); $ExpOpCount++; } >>
4201 ;
4202
4203 pushthisExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4204 L:PushThis << { CIfrThis TObj(L->getLine()); _SAVE_OPHDR_COND (TObj, ($ExpOpCount == 0), L->getLine()); $ExpOpCount++; } >>
4205 ;
4206
4207 securityExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4208 <<
4209 EFI_GUID Guid;
4210 >>
4211 L:Security
4212 "\(" guidDefinition[Guid] "\)" << { CIfrSecurity SObj(L->getLine()); _SAVE_OPHDR_COND (SObj, ($ExpOpCount == 0), L->getLine()); SObj.SetPermissions (&Guid); } $ExpOpCount++; >>
4213 ;
4214
4215 numericVarStoreType [UINT8 & VarType] :
4216 "NUMERIC_SIZE_1" << $VarType = EFI_IFR_NUMERIC_SIZE_1; >>
4217 | "NUMERIC_SIZE_2" << $VarType = EFI_IFR_NUMERIC_SIZE_2; >>
4218 | "NUMERIC_SIZE_4" << $VarType = EFI_IFR_NUMERIC_SIZE_4; >>
4219 | "NUMERIC_SIZE_8" << $VarType = EFI_IFR_NUMERIC_SIZE_8; >>
4220 ;
4221
4222 getExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4223 <<
4224 EFI_VARSTORE_INFO Info;
4225 CHAR8 *VarIdStr = NULL;
4226 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
4227 UINT32 Mask = 0;
4228 EFI_QUESION_TYPE QType = QUESTION_NORMAL;
4229 UINT8 VarType = EFI_IFR_TYPE_UNDEFINED;
4230 UINT32 VarSize = 0;
4231 Info.mVarStoreId = 0;
4232 >>
4233 L:Get
4234 "\("
4235 vfrStorageVarId[Info, VarIdStr, FALSE]
4236 {"\|" FLAGS "=" numericVarStoreType [VarType] }
4237 "\)" <<
4238 {
4239 if (Info.mVarStoreId == 0) {
4240 // support Date/Time question
4241 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask, &QType);
4242 if (QId == EFI_QUESTION_ID_INVALID || Mask == 0 || QType == QUESTION_NORMAL) {
4243 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");
4244 }
4245 if (QType == QUESTION_DATE) {
4246 Info.mVarType = EFI_IFR_TYPE_DATE;
4247 } else if (QType == QUESTION_TIME) {
4248 Info.mVarType = EFI_IFR_TYPE_TIME;
4249 }
4250 switch (Mask) {
4251 case DATE_YEAR_BITMASK:
4252 Info.mInfo.mVarOffset = 0;
4253 break;
4254 case DATE_DAY_BITMASK:
4255 Info.mInfo.mVarOffset = 3;
4256 break;
4257 case TIME_HOUR_BITMASK:
4258 Info.mInfo.mVarOffset = 0;
4259 break;
4260 case TIME_MINUTE_BITMASK:
4261 Info.mInfo.mVarOffset = 1;
4262 break;
4263 case TIME_SECOND_BITMASK:
4264 Info.mInfo.mVarOffset = 2;
4265 break;
4266 default:
4267 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");
4268 break;
4269 }
4270 } else {
4271 if ((gCVfrDataStorage.GetVarStoreType(Info.mVarStoreId) == EFI_VFR_VARSTORE_NAME) && (VarType == EFI_IFR_TYPE_UNDEFINED)) {
4272 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support name string");
4273 }
4274 if (VarType != EFI_IFR_TYPE_UNDEFINED) {
4275 Info.mVarType = VarType;
4276 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");
4277 Info.mVarTotalSize = VarSize;
4278 }
4279 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");
4280 if (VarSize != Info.mVarTotalSize) {
4281 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support data array");
4282 }
4283 }
4284 CIfrGet GObj(L->getLine());
4285 _SAVE_OPHDR_COND (GObj, ($ExpOpCount == 0), L->getLine());
4286 GObj.SetVarInfo (&Info);
4287 delete VarIdStr;
4288 $ExpOpCount++;
4289 }
4290 >>
4291 ;
4292
4293 vfrExpressionConstant[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4294 L1:True << CIfrTrue TObj(L1->getLine()); _SAVE_OPHDR_COND (TObj, ($ExpOpCount == 0), L1->getLine()); $ExpOpCount++; >>
4295 | L2:False << CIfrFalse FObj(L2->getLine()); _SAVE_OPHDR_COND (FObj, ($ExpOpCount == 0), L2->getLine()); $ExpOpCount++; >>
4296 | L3:One << CIfrOne OObj(L3->getLine()); _SAVE_OPHDR_COND (OObj, ($ExpOpCount == 0), L3->getLine()); $ExpOpCount++; >>
4297 | L4:Ones << CIfrOnes OObj(L4->getLine()); _SAVE_OPHDR_COND (OObj, ($ExpOpCount == 0), L4->getLine()); $ExpOpCount++; >>
4298 | L5:Zero << CIfrZero ZObj(L5->getLine()); _SAVE_OPHDR_COND (ZObj, ($ExpOpCount == 0), L5->getLine()); $ExpOpCount++; >>
4299 | L6:Undefined << CIfrUndefined UObj(L6->getLine()); _SAVE_OPHDR_COND (UObj, ($ExpOpCount == 0), L6->getLine()); $ExpOpCount++; >>
4300 | L7:Version << CIfrVersion VObj(L7->getLine()); _SAVE_OPHDR_COND (VObj, ($ExpOpCount == 0), L7->getLine()); $ExpOpCount++; >>
4301 | V:Number << CIfrUint64 U64Obj(V->getLine()); U64Obj.SetValue (_STOU64(V->getText(), V->getLine())); _SAVE_OPHDR_COND (U64Obj, ($ExpOpCount == 0), V->getLine()); $ExpOpCount++; >>
4302 ;
4303
4304 vfrExpressionUnaryOp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4305 lengthExp[$RootLevel, $ExpOpCount]
4306 | bitwisenotExp[$RootLevel, $ExpOpCount]
4307 | question23refExp[$RootLevel, $ExpOpCount]
4308 | stringref2Exp[$RootLevel, $ExpOpCount]
4309 | toboolExp[$RootLevel, $ExpOpCount]
4310 | tostringExp[$RootLevel, $ExpOpCount]
4311 | unintExp[$RootLevel, $ExpOpCount]
4312 | toupperExp[$RootLevel, $ExpOpCount]
4313 | tolwerExp[$RootLevel, $ExpOpCount]
4314 | setExp[$RootLevel, $ExpOpCount]
4315 ;
4316
4317 lengthExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4318 L:Length
4319 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
4320 << { CIfrLength LObj(L->getLine()); $ExpOpCount++; } >>
4321 ;
4322
4323 bitwisenotExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4324 L:BitWiseNot
4325 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
4326 << { CIfrBitWiseNot BWNObj(L->getLine()); $ExpOpCount++; } >>
4327 ;
4328
4329 question23refExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4330 <<
4331 UINT8 Type = 0x1;
4332 EFI_STRING_ID DevPath = EFI_STRING_ID_INVALID;
4333 EFI_GUID Guid = {0,};
4334 >>
4335 L:QuestionRefVal
4336 "\("
4337 {
4338 DevicePath "=" "STRING_TOKEN" "\(" S:Number "\)" "," << Type = 0x2; DevPath = _STOSID(S->getText(), S->getLine()); >>
4339 }
4340 {
4341 Uuid "=" guidDefinition[Guid] "," << Type = 0x3; >>
4342 }
4343 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4344 "\)"
4345 <<
4346 switch (Type) {
4347 case 0x1: {CIfrQuestionRef2 QR2Obj(L->getLine()); _SAVE_OPHDR_COND (QR2Obj, ($ExpOpCount == 0), L->getLine()); break;}
4348 case 0x2: {CIfrQuestionRef3_2 QR3_2Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_2Obj, ($ExpOpCount == 0), L->getLine()); QR3_2Obj.SetDevicePath (DevPath); break;}
4349 case 0x3: {CIfrQuestionRef3_3 QR3_3Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_3Obj, ($ExpOpCount == 0), L->getLine()); QR3_3Obj.SetDevicePath (DevPath); QR3_3Obj.SetGuid (&Guid); break;}
4350 }
4351 $ExpOpCount++;
4352 >>
4353 ;
4354
4355 stringref2Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4356 L:StringRefVal
4357 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
4358 << { CIfrStringRef2 SR2Obj(L->getLine()); $ExpOpCount++; } >>
4359 ;
4360
4361 toboolExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4362 L:BoolVal
4363 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
4364 << { CIfrToBoolean TBObj(L->getLine()); $ExpOpCount++; } >>
4365 ;
4366
4367 tostringExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4368 << UINT8 Fmt = 0; >>
4369 L:StringVal
4370 {
4371 Format "=" F:Number "," << Fmt = _STOU8(F->getText(), F->getLine()); >>
4372 }
4373 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
4374 << { CIfrToString TSObj(L->getLine()); TSObj.SetFormat (Fmt); $ExpOpCount++; } >>
4375 ;
4376
4377 unintExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4378 L:UnIntVal
4379 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
4380 << { CIfrToUint TUObj(L->getLine()); $ExpOpCount++; } >>
4381 ;
4382
4383 toupperExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4384 L:ToUpper
4385 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
4386 << { CIfrToUpper TUObj(L->getLine()); $ExpOpCount++; } >>
4387 ;
4388
4389 tolwerExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4390 L:ToLower
4391 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
4392 << { CIfrToLower TLObj(L->getLine()); $ExpOpCount++; } >>
4393 ;
4394
4395 setExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4396 <<
4397 EFI_VARSTORE_INFO Info;
4398 CHAR8 *VarIdStr = NULL;
4399 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
4400 UINT32 Mask = 0;
4401 EFI_QUESION_TYPE QType = QUESTION_NORMAL;
4402 UINT8 VarType = EFI_IFR_TYPE_UNDEFINED;
4403 UINT32 VarSize = 0;
4404 Info.mVarStoreId = 0;
4405 >>
4406 L:Set
4407 "\("
4408 vfrStorageVarId[Info, VarIdStr, FALSE]
4409 {"\|" FLAG "=" numericVarStoreType [VarType] }
4410 "," vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4411 "\)"
4412 <<
4413 {
4414 if (Info.mVarStoreId == 0) {
4415 // support Date/Time question
4416 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask, &QType);
4417 if (QId == EFI_QUESTION_ID_INVALID || Mask == 0 || QType == QUESTION_NORMAL) {
4418 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");
4419 }
4420 if (QType == QUESTION_DATE) {
4421 Info.mVarType = EFI_IFR_TYPE_DATE;
4422 } else if (QType == QUESTION_TIME) {
4423 Info.mVarType = EFI_IFR_TYPE_TIME;
4424 }
4425 switch (Mask) {
4426 case DATE_YEAR_BITMASK:
4427 Info.mInfo.mVarOffset = 0;
4428 break;
4429 case DATE_DAY_BITMASK:
4430 Info.mInfo.mVarOffset = 3;
4431 break;
4432 case TIME_HOUR_BITMASK:
4433 Info.mInfo.mVarOffset = 0;
4434 break;
4435 case TIME_MINUTE_BITMASK:
4436 Info.mInfo.mVarOffset = 1;
4437 break;
4438 case TIME_SECOND_BITMASK:
4439 Info.mInfo.mVarOffset = 2;
4440 break;
4441 default:
4442 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");
4443 break;
4444 }
4445 } else {
4446 if ((gCVfrDataStorage.GetVarStoreType(Info.mVarStoreId) == EFI_VFR_VARSTORE_NAME) && (VarType == EFI_IFR_TYPE_UNDEFINED)) {
4447 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support name string");
4448 }
4449 if (VarType != EFI_IFR_TYPE_UNDEFINED) {
4450 Info.mVarType = VarType;
4451 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");
4452 Info.mVarTotalSize = VarSize;
4453 }
4454 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");
4455 if (VarSize != Info.mVarTotalSize) {
4456 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support data array");
4457 }
4458 }
4459 CIfrSet TSObj(L->getLine());
4460 TSObj.SetVarInfo (&Info);
4461 delete VarIdStr;
4462 $ExpOpCount++;
4463 }
4464 >>
4465 ;
4466
4467 vfrExpressionTernaryOp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4468 conditionalExp[$RootLevel, $ExpOpCount]
4469 | findExp[$RootLevel, $ExpOpCount]
4470 | midExp[$RootLevel, $ExpOpCount]
4471 | tokenExp[$RootLevel, $ExpOpCount]
4472 | spanExp[$RootLevel, $ExpOpCount]
4473 ;
4474
4475 #token Cond("cond") "cond"
4476 #token Find("find") "find"
4477 #token Mid("mid") "mid"
4478 #token Tok("token") "token"
4479 #token Span("span") "span"
4480
4481 conditionalExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4482 L:Cond "\("
4483 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4484 "?"
4485 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4486 ":"
4487 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4488 "\)" << { CIfrConditional CObj(L->getLine()); $ExpOpCount++; } >>
4489 ;
4490
4491 findExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4492 << UINT8 Format; >>
4493 L:Find "\("
4494 findFormat[Format] ( "\|" findFormat[Format] )*
4495 ","
4496 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4497 ","
4498 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4499 ","
4500 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4501 "\)" << { CIfrFind FObj(L->getLine()); FObj.SetFormat (Format); $ExpOpCount++; } >>
4502 ;
4503
4504 findFormat [UINT8 & Format] :
4505 "SENSITIVE" << $Format = 0x00; >>
4506 | "INSENSITIVE" << $Format = 0x01; >>
4507 ;
4508
4509 midExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4510 L:Mid "\("
4511 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4512 ","
4513 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4514 ","
4515 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4516 "\)" << { CIfrMid MObj(L->getLine()); $ExpOpCount++; } >>
4517 ;
4518
4519 tokenExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4520 L:Tok "\("
4521 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4522 ","
4523 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4524 ","
4525 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4526 "\)" << { CIfrToken TObj(L->getLine()); $ExpOpCount++; } >>
4527 ;
4528
4529 spanExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
4530 << UINT8 Flags = 0; >>
4531 S:Span "\("
4532 FLAGS "=" spanFlags[Flags] ( "\|" spanFlags[Flags] )*
4533 ","
4534 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4535 ","
4536 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4537 ","
4538 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4539 "\)" << { CIfrSpan SObj(S->getLine()); SObj.SetFlags(Flags); $ExpOpCount++; } >>
4540 ;
4541
4542 vfrExpressionMap [UINT32 & RootLevel, UINT32 & ExpOpCount]:
4543 L:Map
4544 "\("
4545 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
4546 ":" << { CIfrMap MObj(L->getLine()); } >>
4547 (
4548 vfrStatementExpression[0]
4549 ","
4550 vfrStatementExpression[0]
4551 ";"
4552 ) *
4553 E:"\)" << { CIfrEnd EObj; EObj.SetLineNo(E->getLine()); $ExpOpCount++; } >>
4554 ;
4555
4556 spanFlags [UINT8 & Flags] :
4557 N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >>
4558 | "LAST_NON_MATCH" << $Flags |= 0x00; >>
4559 | "FIRST_NON_MATCH" << $Flags |= 0x01; >>
4560 ;
4561
4562 #token StringIdentifier("string identifier") "[A-Za-z_][A-Za-z_0-9]*"
4563 #token Number("numeric value") "(0x[0-9A-Fa-f]+) | [0-9]+"
4564
4565 //******************************************************************************
4566 //
4567 // Parser class definition.
4568 //
4569 class EfiVfrParser {
4570 <<
4571 private:
4572 UINT8 mParserStatus;
4573 BOOLEAN mConstantOnlyInExpression;
4574
4575 CVfrQuestionDB mCVfrQuestionDB;
4576 CVfrRulesDB mCVfrRulesDB;
4577
4578 CIfrOpHeader * mCIfrOpHdr[MAX_IFR_EXPRESSION_DEPTH];
4579 UINT32 mCIfrOpHdrLineNo[MAX_IFR_EXPRESSION_DEPTH];
4580 UINT8 mCIfrOpHdrIndex;
4581 VOID _SAVE_OPHDR_COND (IN CIfrOpHeader &, IN BOOLEAN, UINT32 LineNo = 0);
4582 VOID _CLEAR_SAVED_OPHDR (VOID);
4583 BOOLEAN _SET_SAVED_OPHDR_SCOPE (VOID);
4584
4585
4586 EFI_VARSTORE_INFO mCurrQestVarInfo;
4587 EFI_GUID *mOverrideClassGuid;
4588 CHAR8* mLastFormEndAddr;
4589
4590 //
4591 // Whether the question already has default value.
4592 //
4593 UINT16 mUsedDefaultArray[EFI_IFR_MAX_DEFAULT_TYPE];
4594 UINT16 mUsedDefaultCount;
4595
4596 //
4597 // For framework vfr compatibility
4598 //
4599 BOOLEAN mCompatibleMode;
4600 EFI_GUID mFormsetGuid;
4601
4602 VOID _CRT_OP (IN BOOLEAN);
4603
4604 VOID _SAVE_CURRQEST_VARINFO (IN EFI_VARSTORE_INFO &);
4605 EFI_VARSTORE_INFO & _GET_CURRQEST_VARTINFO (VOID);
4606
4607 UINT8 _GET_CURRQEST_DATATYPE ();
4608 UINT32 _GET_CURRQEST_VARSIZE ();
4609 UINT32 _GET_CURRQEST_ARRAY_SIZE();
4610 VOID CheckDuplicateDefaultValue (IN EFI_DEFAULT_ID, IN ANTLRTokenPtr);
4611
4612 public:
4613 VOID _PCATCH (IN INTN, IN INTN, IN ANTLRTokenPtr, IN CONST CHAR8 *);
4614 VOID _PCATCH (IN EFI_VFR_RETURN_CODE);
4615 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN ANTLRTokenPtr);
4616 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32);
4617 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32, IN CONST CHAR8 *);
4618
4619 VOID syn (ANTLRAbstractToken *, ANTLRChar *, SetWordType *, ANTLRTokenType, INT32);
4620
4621 CHAR8* TrimHex (IN CHAR8 *, OUT BOOLEAN *);
4622 CHAR8* _U32TOS (IN UINT32);
4623 UINT8 _STOU8 (IN CHAR8 *, IN UINT32);
4624 UINT16 _STOU16 (IN CHAR8 *, IN UINT32);
4625 UINT32 _STOU32 (IN CHAR8 *, IN UINT32);
4626 UINT64 _STOU64 (IN CHAR8 *, IN UINT32);
4627 EFI_HII_DATE _STOD (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN UINT32);
4628 EFI_HII_TIME _STOT (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN UINT32);
4629 EFI_HII_REF _STOR (IN CHAR8 *, IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT32);
4630
4631 EFI_STRING_ID _STOSID (IN CHAR8 *, IN UINT32);
4632 EFI_FORM_ID _STOFID (IN CHAR8 *, IN UINT32);
4633 EFI_QUESTION_ID _STOQID (IN CHAR8 *, IN UINT32);
4634
4635 VOID _STRCAT (IN OUT CHAR8 **, IN CONST CHAR8 *);
4636
4637 VOID _DeclareDefaultLinearVarStore (IN UINT32);
4638 VOID _DeclareStandardDefaultStorage (IN UINT32);
4639 VOID _DeclareDefaultFrameworkVarStore (IN UINT32);
4640
4641 VOID AssignQuestionKey (IN CIfrQuestionHeader &, IN ANTLRTokenPtr);
4642
4643 VOID ConvertIdExpr (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32);
4644 VOID IdEqValDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN UINT16, IN EFI_COMPARE_TYPE);
4645 VOID IdEqIdDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN EFI_COMPARE_TYPE);
4646 VOID IdEqListDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN UINT16, IN UINT16 *);
4647 VOID SetOverrideClassGuid (IN EFI_GUID *);
4648 //
4649 // For framework vfr compatibility
4650 //
4651 VOID SetCompatibleMode (IN BOOLEAN);
4652 >>
4653 }
4654
4655 <<
4656 VOID
4657 EfiVfrParser::_SAVE_OPHDR_COND (
4658 IN CIfrOpHeader &OpHdr,
4659 IN BOOLEAN Cond,
4660 IN UINT32 LineNo
4661 )
4662 {
4663 if (Cond == TRUE) {
4664 if (mCIfrOpHdr[mCIfrOpHdrIndex] != NULL) {
4665 return ;
4666 }
4667 mCIfrOpHdr[mCIfrOpHdrIndex] = new CIfrOpHeader(OpHdr);
4668 mCIfrOpHdrLineNo[mCIfrOpHdrIndex] = LineNo;
4669 }
4670 }
4671
4672 VOID
4673 EfiVfrParser::_CLEAR_SAVED_OPHDR (
4674 VOID
4675 )
4676 {
4677 mCIfrOpHdr[mCIfrOpHdrIndex] = NULL;
4678 mCIfrOpHdrLineNo[mCIfrOpHdrIndex] = 0;
4679 }
4680
4681 BOOLEAN
4682 EfiVfrParser::_SET_SAVED_OPHDR_SCOPE (
4683 VOID
4684 )
4685 {
4686 if (mCIfrOpHdr[mCIfrOpHdrIndex] != NULL) {
4687 mCIfrOpHdr[mCIfrOpHdrIndex]->SetScope (1);
4688 return TRUE;
4689 }
4690
4691 //
4692 // IfrOpHdr is not set, FALSE is return.
4693 //
4694 return FALSE;
4695 }
4696
4697 VOID
4698 EfiVfrParser::_CRT_OP (
4699 IN BOOLEAN Crt
4700 )
4701 {
4702 gCreateOp = Crt;
4703 }
4704
4705 VOID
4706 EfiVfrParser::_SAVE_CURRQEST_VARINFO (
4707 IN EFI_VARSTORE_INFO &Info
4708 )
4709 {
4710 mCurrQestVarInfo = Info;
4711 }
4712
4713 EFI_VARSTORE_INFO &
4714 EfiVfrParser::_GET_CURRQEST_VARTINFO (
4715 VOID
4716 )
4717 {
4718 return mCurrQestVarInfo;
4719 }
4720
4721 UINT32
4722 EfiVfrParser::_GET_CURRQEST_ARRAY_SIZE (
4723 VOID
4724 )
4725 {
4726 UINT8 Size = 1;
4727
4728 switch (mCurrQestVarInfo.mVarType) {
4729 case EFI_IFR_TYPE_NUM_SIZE_8:
4730 Size = 1;
4731 break;
4732
4733 case EFI_IFR_TYPE_NUM_SIZE_16:
4734 Size = 2;
4735 break;
4736
4737 case EFI_IFR_TYPE_NUM_SIZE_32:
4738 Size = 4;
4739 break;
4740
4741 case EFI_IFR_TYPE_NUM_SIZE_64:
4742 Size = 8;
4743 break;
4744
4745 default:
4746 break;
4747 }
4748
4749 return (mCurrQestVarInfo.mVarTotalSize / Size);
4750 }
4751
4752 UINT8
4753 EfiVfrParser::_GET_CURRQEST_DATATYPE (
4754 VOID
4755 )
4756 {
4757 return mCurrQestVarInfo.mVarType;
4758 }
4759
4760 UINT32
4761 EfiVfrParser::_GET_CURRQEST_VARSIZE (
4762 VOID
4763 )
4764 {
4765 return mCurrQestVarInfo.mVarTotalSize;
4766 }
4767
4768 VOID
4769 EfiVfrParser::_PCATCH (
4770 IN INTN ReturnCode,
4771 IN INTN ExpectCode,
4772 IN ANTLRTokenPtr Tok,
4773 IN CONST CHAR8 *ErrorMsg
4774 )
4775 {
4776 if (ReturnCode != ExpectCode) {
4777 mParserStatus++;
4778 gCVfrErrorHandle.PrintMsg (Tok->getLine(), Tok->getText(), "Error", ErrorMsg);
4779 }
4780 }
4781
4782 VOID
4783 EfiVfrParser::_PCATCH (
4784 IN EFI_VFR_RETURN_CODE ReturnCode
4785 )
4786 {
4787 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode);
4788 }
4789
4790 VOID
4791 EfiVfrParser::_PCATCH (
4792 IN EFI_VFR_RETURN_CODE ReturnCode,
4793 IN ANTLRTokenPtr Tok
4794 )
4795 {
4796 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, Tok->getLine(), Tok->getText());
4797 }
4798
4799 VOID
4800 EfiVfrParser::_PCATCH (
4801 IN EFI_VFR_RETURN_CODE ReturnCode,
4802 IN UINT32 LineNum
4803 )
4804 {
4805 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, LineNum);
4806 }
4807
4808 VOID
4809 EfiVfrParser::_PCATCH (
4810 IN EFI_VFR_RETURN_CODE ReturnCode,
4811 IN UINT32 LineNum,
4812 IN CONST CHAR8 *ErrorMsg
4813 )
4814 {
4815 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, LineNum, (CHAR8 *) ErrorMsg);
4816 }
4817
4818 VOID
4819 EfiVfrParser::syn (
4820 ANTLRAbstractToken *Tok,
4821 ANTLRChar *Egroup,
4822 SetWordType *Eset,
4823 ANTLRTokenType ETok,
4824 INT32 Huh
4825 )
4826 {
4827 gCVfrErrorHandle.HandleError (VFR_RETURN_MISMATCHED, Tok->getLine(), Tok->getText());
4828
4829 mParserStatus += 1;
4830 }
4831
4832 CHAR8 *
4833 EfiVfrParser::TrimHex (
4834 IN CHAR8 *Str,
4835 OUT BOOLEAN *IsHex
4836 )
4837 {
4838 *IsHex = FALSE;
4839
4840 while (*Str && *Str == ' ') {
4841 Str++;
4842 }
4843 while (*Str && *Str == '0') {
4844 Str++;
4845 }
4846 if (*Str && (*Str == 'x' || *Str == 'X')) {
4847 Str++;
4848 *IsHex = TRUE;
4849 }
4850
4851 return Str;
4852 }
4853
4854 CHAR8 *
4855 EfiVfrParser::_U32TOS (
4856 IN UINT32 Value
4857 )
4858 {
4859 CHAR8 *Str;
4860 Str = new CHAR8[20];
4861 sprintf (Str, "%d", Value);
4862 return Str;
4863 }
4864
4865 UINT8
4866 EfiVfrParser::_STOU8 (
4867 IN CHAR8 *Str,
4868 IN UINT32 LineNum
4869 )
4870 {
4871 BOOLEAN IsHex;
4872 UINT8 Value;
4873 CHAR8 c;
4874
4875 UINT8 PreviousValue;
4876 CHAR8 *OrigString = Str;
4877 CHAR8 ErrorMsg[100];
4878
4879 Str = TrimHex (Str, &IsHex);
4880 for (Value = 0; (c = *Str) != '\0'; Str++) {
4881 PreviousValue = Value;
4882 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
4883
4884 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
4885 Value += (c - 'a' + 10);
4886 }
4887 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {
4888 Value += (c - 'A' + 10);
4889 }
4890 if (c >= '0' && c <= '9') {
4891 Value += (c - '0');
4892 }
4893 if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue))) {
4894 sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT8", OrigString);
4895 gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg);
4896 }
4897 }
4898
4899 return Value;
4900 }
4901
4902 UINT16
4903 EfiVfrParser::_STOU16 (
4904 IN CHAR8 *Str,
4905 IN UINT32 LineNum
4906 )
4907 {
4908 BOOLEAN IsHex;
4909 UINT16 Value;
4910 CHAR8 c;
4911
4912 UINT16 PreviousValue;
4913 CHAR8 *OrigString = Str;
4914 CHAR8 ErrorMsg[100];
4915
4916 Str = TrimHex (Str, &IsHex);
4917 for (Value = 0; (c = *Str) != '\0'; Str++) {
4918 PreviousValue = Value;
4919 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
4920
4921 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
4922 Value += (c - 'a' + 10);
4923 }
4924 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {
4925 Value += (c - 'A' + 10);
4926 }
4927 if (c >= '0' && c <= '9') {
4928 Value += (c - '0');
4929 }
4930 if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue))) {
4931 sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT16", OrigString);
4932 gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg);
4933 }
4934 }
4935
4936 return Value;
4937 }
4938
4939 UINT32
4940 EfiVfrParser::_STOU32 (
4941 IN CHAR8 *Str,
4942 IN UINT32 LineNum
4943 )
4944 {
4945 BOOLEAN IsHex;
4946 UINT32 Value;
4947 CHAR8 c;
4948
4949 UINT32 PreviousValue;
4950 CHAR8 *OrigString = Str;
4951 CHAR8 ErrorMsg[100];
4952
4953 Str = TrimHex (Str, &IsHex);
4954 for (Value = 0; (c = *Str) != '\0'; Str++) {
4955 PreviousValue = Value;
4956 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
4957
4958 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
4959 Value += (c - 'a' + 10);
4960 }
4961 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {
4962 Value += (c - 'A' + 10);
4963 }
4964 if (c >= '0' && c <= '9') {
4965 Value += (c - '0');
4966 }
4967 if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue ))) {
4968 sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT32", OrigString);
4969 gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg);
4970 }
4971 }
4972
4973 return Value;
4974 }
4975
4976 UINT64
4977 EfiVfrParser::_STOU64 (
4978 IN CHAR8 *Str,
4979 IN UINT32 LineNum
4980 )
4981 {
4982 BOOLEAN IsHex;
4983 UINT64 Value;
4984 CHAR8 c;
4985 UINT64 PreviousValue;
4986 CHAR8 *OrigString = Str;
4987 CHAR8 ErrorMsg[100];
4988
4989 Str = TrimHex (Str, &IsHex);
4990 for (Value = 0; (c = *Str) != '\0'; Str++) {
4991 PreviousValue = Value;
4992 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
4993
4994 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
4995 Value += (c - 'a' + 10);
4996 }
4997 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {
4998 Value += (c - 'A' + 10);
4999 }
5000 if (c >= '0' && c <= '9') {
5001 Value += (c - '0');
5002 }
5003 if((IsHex && ((Value/16) != PreviousValue)) || ((!IsHex && (Value/10) != PreviousValue))) {
5004 sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT64", OrigString);
5005 gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg);
5006 }
5007 }
5008
5009 return Value;
5010 }
5011
5012 EFI_HII_DATE
5013 EfiVfrParser::_STOD (
5014 IN CHAR8 *Year,
5015 IN CHAR8 *Month,
5016 IN CHAR8 *Day,
5017 IN UINT32 LineNum
5018 )
5019 {
5020 EFI_HII_DATE Date;
5021
5022 Date.Year = _STOU16 (Year, LineNum);
5023 Date.Month = _STOU8 (Month, LineNum);
5024 Date.Day = _STOU8 (Day, LineNum);
5025
5026 return Date;
5027 }
5028
5029 EFI_HII_TIME
5030 EfiVfrParser::_STOT (
5031 IN CHAR8 *Hour,
5032 IN CHAR8 *Minute,
5033 IN CHAR8 *Second,
5034 IN UINT32 LineNum
5035 )
5036 {
5037 EFI_HII_TIME Time;
5038
5039 Time.Hour = _STOU8 (Hour, LineNum);
5040 Time.Minute = _STOU8 (Minute, LineNum);
5041 Time.Second = _STOU8 (Second, LineNum);
5042
5043 return Time;
5044 }
5045
5046 EFI_STRING_ID
5047 EfiVfrParser::_STOSID (
5048 IN CHAR8 *Str,
5049 IN UINT32 LineNum
5050 )
5051 {
5052 return (EFI_STRING_ID)_STOU16(Str, LineNum);
5053 }
5054
5055 EFI_FORM_ID
5056 EfiVfrParser::_STOFID (
5057 IN CHAR8 *Str,
5058 IN UINT32 LineNum
5059 )
5060 {
5061 return (EFI_FORM_ID)_STOU16(Str, LineNum);
5062 }
5063
5064 EFI_QUESTION_ID
5065 EfiVfrParser::_STOQID (
5066 IN CHAR8 *Str,
5067 IN UINT32 LineNum
5068 )
5069 {
5070 return (EFI_QUESTION_ID)_STOU16(Str, LineNum);
5071 }
5072
5073 VOID
5074 EfiVfrParser::_STRCAT (
5075 IN OUT CHAR8 **Dest,
5076 IN CONST CHAR8 *Src
5077 )
5078 {
5079 CHAR8 *NewStr;
5080 UINT32 Len;
5081
5082 if ((Dest == NULL) || (Src == NULL)) {
5083 return;
5084 }
5085
5086 Len = (*Dest == NULL) ? 0 : strlen (*Dest);
5087 Len += strlen (Src);
5088 if ((NewStr = new CHAR8[Len + 1]) == NULL) {
5089 return;
5090 }
5091 NewStr[0] = '\0';
5092 if (*Dest != NULL) {
5093 strcpy (NewStr, *Dest);
5094 delete *Dest;
5095 }
5096 strcat (NewStr, Src);
5097
5098 *Dest = NewStr;
5099 }
5100
5101 EFI_HII_REF
5102 EfiVfrParser::_STOR (
5103 IN CHAR8 *QuestionId,
5104 IN CHAR8 *FormId,
5105 IN EFI_GUID *FormSetGuid,
5106 IN CHAR8 *DevicePath,
5107 IN UINT32 LineNum
5108 )
5109 {
5110 EFI_HII_REF Ref;
5111 UINT32 Index;
5112
5113 memcpy (&Ref.FormSetGuid, FormSetGuid, sizeof (EFI_GUID));
5114 Ref.QuestionId = _STOQID (QuestionId, LineNum);
5115 Ref.FormId = _STOFID (FormId, LineNum);
5116 Ref.DevicePath = _STOSID (DevicePath, LineNum);
5117
5118 return Ref;
5119 }
5120
5121 //
5122 // framework vfr to default declare varstore for each structure
5123 //
5124 VOID
5125 EfiVfrParser::_DeclareDefaultFrameworkVarStore (
5126 IN UINT32 LineNo
5127 )
5128 {
5129 SVfrVarStorageNode *pNode;
5130 UINT32 TypeSize;
5131 BOOLEAN FirstNode;
5132 CONST CHAR8 VarName[] = "Setup";
5133
5134 FirstNode = TRUE;
5135 pNode = gCVfrDataStorage.GetBufferVarStoreList();
5136 if (pNode == NULL && gCVfrVarDataTypeDB.mFirstNewDataTypeName != NULL) {
5137 //
5138 // Create the default Buffer Var Store when no VarStore is defined.
5139 // its name should be "Setup"
5140 //
5141 gCVfrVarDataTypeDB.GetDataTypeSize (gCVfrVarDataTypeDB.mFirstNewDataTypeName, &TypeSize);
5142 CIfrVarStore VSObj;
5143 VSObj.SetLineNo (LineNo);
5144 VSObj.SetVarStoreId (0x1); //the first and only one Buffer Var Store
5145 VSObj.SetSize ((UINT16) TypeSize);
5146 //VSObj.SetName (gCVfrVarDataTypeDB.mFirstNewDataTypeName);
5147 VSObj.SetName ((CHAR8 *) VarName);
5148 VSObj.SetGuid (&mFormsetGuid);
5149 #ifdef VFREXP_DEBUG
5150 printf ("Create the default VarStoreName is %s\n", gCVfrVarDataTypeDB.mFirstNewDataTypeName);
5151 #endif
5152 } else {
5153 for (; pNode != NULL; pNode = pNode->mNext) {
5154 //
5155 // create the default varstore opcode for not declared varstore
5156 // the first varstore name should be "Setup"
5157 //
5158 if (!pNode->mAssignedFlag) {
5159 CIfrVarStore VSObj;
5160 VSObj.SetLineNo (LineNo);
5161 VSObj.SetVarStoreId (pNode->mVarStoreId);
5162 VSObj.SetSize ((UINT16) pNode->mStorageInfo.mDataType->mTotalSize);
5163 if (FirstNode) {
5164 VSObj.SetName ((CHAR8 *) VarName);
5165 FirstNode = FALSE;
5166 } else {
5167 VSObj.SetName (pNode->mVarStoreName);
5168 }
5169 VSObj.SetGuid (&pNode->mGuid);
5170 #ifdef VFREXP_DEBUG
5171 printf ("undefined VarStoreName is %s and Id is 0x%x\n", pNode->mVarStoreName, pNode->mVarStoreId);
5172 #endif
5173 }
5174 }
5175 }
5176
5177 pNode = gCVfrDataStorage.GetEfiVarStoreList();
5178 for (; pNode != NULL; pNode = pNode->mNext) {
5179 //
5180 // create the default efi varstore opcode for not exist varstore
5181 //
5182 if (!pNode->mAssignedFlag) {
5183 CIfrVarStoreEfi VSEObj;
5184 VSEObj.SetLineNo (LineNo);
5185 VSEObj.SetAttributes (0x00000002); //hardcode EFI_VARIABLE_BOOTSERVICE_ACCESS attribute
5186 VSEObj.SetGuid (&pNode->mGuid);
5187 VSEObj.SetVarStoreId (pNode->mVarStoreId);
5188 // Generate old efi varstore storage structure for compatiable with old "VarEqVal" opcode,
5189 // which is 3 bytes less than new structure define in UEFI Spec 2.3.1.
5190 VSEObj.SetBinaryLength (sizeof (EFI_IFR_VARSTORE_EFI) - 3);
5191 #ifdef VFREXP_DEBUG
5192 printf ("undefined Efi VarStoreName is %s and Id is 0x%x\n", pNode->mVarStoreName, pNode->mVarStoreId);
5193 #endif
5194 }
5195 }
5196
5197 }
5198
5199 VOID
5200 EfiVfrParser::_DeclareDefaultLinearVarStore (
5201 IN UINT32 LineNo
5202 )
5203 {
5204 UINT32 Index;
5205 CHAR8 **TypeNameList;
5206 UINT32 ListSize;
5207 CONST CHAR8 DateName[] = "Date";
5208 CONST CHAR8 TimeName[] = "Time";
5209 CONST CHAR8 DateType[] = "EFI_HII_DATE";
5210 CONST CHAR8 TimeType[] = "EFI_HII_TIME";
5211
5212 gCVfrVarDataTypeDB.GetUserDefinedTypeNameList (&TypeNameList, &ListSize);
5213
5214 for (Index = 0; Index < ListSize; Index++) {
5215 UINT32 Size;
5216 EFI_VARSTORE_ID VarStoreId;
5217 CIfrVarStore VSObj;
5218
5219 VSObj.SetLineNo (LineNo);
5220 gCVfrDataStorage.DeclareBufferVarStore (
5221 TypeNameList[Index],
5222 &mFormsetGuid,
5223 &gCVfrVarDataTypeDB,
5224 TypeNameList[Index],
5225 EFI_VARSTORE_ID_INVALID
5226 );
5227 gCVfrDataStorage.GetVarStoreId(TypeNameList[Index], &VarStoreId, &mFormsetGuid);
5228 VSObj.SetVarStoreId (VarStoreId);
5229 gCVfrVarDataTypeDB.GetDataTypeSize(TypeNameList[Index], &Size);
5230 VSObj.SetSize ((UINT16) Size);
5231 VSObj.SetName (TypeNameList[Index]);
5232 VSObj.SetGuid (&mFormsetGuid);
5233 }
5234
5235 //
5236 // not required to declare Date and Time VarStore,
5237 // because code to support old format Data and Time
5238 //
5239 if (gCVfrVarDataTypeDB.IsTypeNameDefined ((CHAR8 *) DateName) == FALSE) {
5240 UINT32 Size;
5241 EFI_VARSTORE_ID VarStoreId;
5242 CIfrVarStore VSObj;
5243
5244 VSObj.SetLineNo (LineNo);
5245 gCVfrDataStorage.DeclareBufferVarStore (
5246 (CHAR8 *) DateName,
5247 &mFormsetGuid,
5248 &gCVfrVarDataTypeDB,
5249 (CHAR8 *) DateType,
5250 EFI_VARSTORE_ID_INVALID
5251 );
5252 gCVfrDataStorage.GetVarStoreId((CHAR8 *) DateName, &VarStoreId, &mFormsetGuid);
5253 VSObj.SetVarStoreId (VarStoreId);
5254 gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) DateType, &Size);
5255 VSObj.SetSize ((UINT16) Size);
5256 VSObj.SetName ((CHAR8 *) DateName);
5257 VSObj.SetGuid (&mFormsetGuid);
5258 }
5259
5260 if (gCVfrVarDataTypeDB.IsTypeNameDefined ((CHAR8 *) TimeName) == FALSE) {
5261 UINT32 Size;
5262 EFI_VARSTORE_ID VarStoreId;
5263 CIfrVarStore VSObj;
5264
5265 VSObj.SetLineNo (LineNo);
5266 gCVfrDataStorage.DeclareBufferVarStore (
5267 (CHAR8 *) TimeName,
5268 &mFormsetGuid,
5269 &gCVfrVarDataTypeDB,
5270 (CHAR8 *) TimeType,
5271 EFI_VARSTORE_ID_INVALID
5272 );
5273 gCVfrDataStorage.GetVarStoreId((CHAR8 *) TimeName, &VarStoreId, &mFormsetGuid);
5274 VSObj.SetVarStoreId (VarStoreId);
5275 gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) TimeType, &Size);
5276 VSObj.SetSize ((UINT16) Size);
5277 VSObj.SetName ((CHAR8 *) TimeName);
5278 VSObj.SetGuid (&mFormsetGuid);
5279 }
5280 }
5281
5282 VOID
5283 EfiVfrParser::_DeclareStandardDefaultStorage (
5284 IN UINT32 LineNo
5285 )
5286 {
5287 //
5288 // Default Store is declared.
5289 //
5290 CIfrDefaultStore DSObj;
5291
5292 gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), (CHAR8 *) "Standard Defaults", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_STANDARD);
5293 DSObj.SetLineNo (LineNo);
5294 DSObj.SetDefaultName (EFI_STRING_ID_INVALID);
5295 DSObj.SetDefaultId (EFI_HII_DEFAULT_CLASS_STANDARD);
5296
5297 //
5298 // Default MANUFACTURING Store is declared.
5299 //
5300 CIfrDefaultStore DSObjMF;
5301
5302 gCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr(), (CHAR8 *) "Standard ManuFacturing", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING);
5303 DSObjMF.SetLineNo (LineNo);
5304 DSObjMF.SetDefaultName (EFI_STRING_ID_INVALID);
5305 DSObjMF.SetDefaultId (EFI_HII_DEFAULT_CLASS_MANUFACTURING);
5306 }
5307
5308 VOID
5309 EfiVfrParser::AssignQuestionKey (
5310 IN CIfrQuestionHeader &QHObj,
5311 IN ANTLRTokenPtr KeyTok
5312 )
5313 {
5314 UINT16 KeyValue;
5315
5316 if (KeyTok == NULL) {
5317 return;
5318 }
5319
5320 KeyValue = _STOU16 (KeyTok->getText(), KeyTok->getLine());
5321
5322 if (QHObj.FLAGS () & EFI_IFR_FLAG_CALLBACK) {
5323 /*
5324 * if the question is not CALLBACK ignore the key.
5325 */
5326 _PCATCH(mCVfrQuestionDB.UpdateQuestionId (QHObj.QUESTION_ID(), KeyValue), KeyTok);
5327 QHObj.SetQuestionId (KeyValue);
5328 }
5329 }
5330
5331 VOID
5332 EfiVfrParser::ConvertIdExpr (
5333 IN UINT32 &ExpOpCount,
5334 IN UINT32 LineNo,
5335 IN EFI_QUESTION_ID QId,
5336 IN CHAR8 *VarIdStr,
5337 IN UINT32 BitMask
5338 )
5339 {
5340 CIfrQuestionRef1 QR1Obj(LineNo);
5341 QR1Obj.SetQuestionId (QId, VarIdStr, LineNo);
5342 _SAVE_OPHDR_COND (QR1Obj, (ExpOpCount == 0));
5343
5344 if (BitMask != 0) {
5345 CIfrUint32 U32Obj(LineNo);
5346 U32Obj.SetValue (BitMask);
5347
5348 CIfrBitWiseAnd BWAObj(LineNo);
5349
5350 CIfrUint8 U8Obj(LineNo);
5351 switch (BitMask) {
5352 case DATE_YEAR_BITMASK : U8Obj.SetValue (0); break;
5353 case TIME_SECOND_BITMASK : U8Obj.SetValue (0x10); break;
5354 case DATE_DAY_BITMASK : U8Obj.SetValue (0x18); break;
5355 case TIME_HOUR_BITMASK : U8Obj.SetValue (0); break;
5356 case TIME_MINUTE_BITMASK : U8Obj.SetValue (0x8); break;
5357 }
5358
5359 CIfrShiftRight SRObj(LineNo);
5360 }
5361
5362 ExpOpCount += 4;
5363 }
5364
5365 VOID
5366 EfiVfrParser::IdEqValDoSpecial (
5367 IN UINT32 &ExpOpCount,
5368 IN UINT32 LineNo,
5369 IN EFI_QUESTION_ID QId,
5370 IN CHAR8 *VarIdStr,
5371 IN UINT32 BitMask,
5372 IN UINT16 ConstVal,
5373 IN EFI_COMPARE_TYPE CompareType
5374 )
5375 {
5376 ConvertIdExpr (ExpOpCount, LineNo, QId, VarIdStr, BitMask);
5377
5378 if (ConstVal > 0xFF) {
5379 CIfrUint16 U16Obj(LineNo);
5380 U16Obj.SetValue (ConstVal);
5381 } else {
5382 CIfrUint8 U8Obj(LineNo);
5383 U8Obj.SetValue ((UINT8)ConstVal);
5384 }
5385
5386 switch (CompareType) {
5387 case EQUAL :
5388 {
5389 CIfrEqual EObj(LineNo);
5390 break;
5391 }
5392 case LESS_EQUAL :
5393 {
5394 CIfrLessEqual LEObj(LineNo);
5395 break;
5396 }
5397 case LESS_THAN :
5398 {
5399 CIfrLessThan LTObj(LineNo);
5400 break;
5401 }
5402 case GREATER_EQUAL :
5403 {
5404 CIfrGreaterEqual GEObj(LineNo);
5405 break;
5406 }
5407 case GREATER_THAN :
5408 {
5409 CIfrGreaterThan GTObj(LineNo);
5410 break;
5411 }
5412 }
5413
5414 ExpOpCount += 2;
5415 }
5416
5417 VOID
5418 EfiVfrParser::IdEqIdDoSpecial (
5419 IN UINT32 &ExpOpCount,
5420 IN UINT32 LineNo,
5421 IN EFI_QUESTION_ID QId1,
5422 IN CHAR8 *VarId1Str,
5423 IN UINT32 BitMask1,
5424 IN EFI_QUESTION_ID QId2,
5425 IN CHAR8 *VarId2Str,
5426 IN UINT32 BitMask2,
5427 IN EFI_COMPARE_TYPE CompareType
5428 )
5429 {
5430 ConvertIdExpr (ExpOpCount, LineNo, QId1, VarId1Str, BitMask1);
5431 ConvertIdExpr (ExpOpCount, LineNo, QId2, VarId2Str, BitMask2);
5432
5433 switch (CompareType) {
5434 case EQUAL :
5435 {
5436 CIfrEqual EObj(LineNo);
5437 break;
5438 }
5439 case LESS_EQUAL :
5440 {
5441 CIfrLessEqual LEObj(LineNo);
5442 break;
5443 }
5444 case LESS_THAN :
5445 {
5446 CIfrLessThan LTObj(LineNo);
5447 break;
5448 }
5449 case GREATER_EQUAL :
5450 {
5451 CIfrGreaterEqual GEObj(LineNo);
5452 break;
5453 }
5454 case GREATER_THAN :
5455 {
5456 CIfrGreaterThan GTObj(LineNo);
5457 break;
5458 }
5459 }
5460
5461 ExpOpCount++;
5462 }
5463
5464 VOID
5465 EfiVfrParser::IdEqListDoSpecial (
5466 IN UINT32 &ExpOpCount,
5467 IN UINT32 LineNo,
5468 IN EFI_QUESTION_ID QId,
5469 IN CHAR8 *VarIdStr,
5470 IN UINT32 BitMask,
5471 IN UINT16 ListLen,
5472 IN UINT16 *ValueList
5473 )
5474 {
5475 UINT16 Index;
5476
5477 if (ListLen == 0) {
5478 return;
5479 }
5480
5481 IdEqValDoSpecial (ExpOpCount, LineNo, QId, VarIdStr, BitMask, ValueList[0], EQUAL);
5482 for (Index = 1; Index < ListLen; Index++) {
5483 IdEqValDoSpecial (ExpOpCount, LineNo, QId, VarIdStr, BitMask, ValueList[Index], EQUAL);
5484 CIfrOr OObj (LineNo);
5485 ExpOpCount++;
5486 }
5487 }
5488
5489 VOID
5490 EfiVfrParser::SetOverrideClassGuid (IN EFI_GUID *OverrideClassGuid)
5491 {
5492 mOverrideClassGuid = OverrideClassGuid;
5493 }
5494
5495 //
5496 // For framework vfr compatibility
5497 //
5498 VOID
5499 EfiVfrParser::SetCompatibleMode (IN BOOLEAN Mode)
5500 {
5501 mCompatibleMode = Mode;
5502 mCVfrQuestionDB.SetCompatibleMode (Mode);
5503 }
5504
5505 VOID
5506 EfiVfrParser::CheckDuplicateDefaultValue (
5507 IN EFI_DEFAULT_ID DefaultId,
5508 IN ANTLRTokenPtr Tok
5509 )
5510 {
5511 UINT16 Index;
5512
5513 for(Index = 0; Index < mUsedDefaultCount; Index++) {
5514 if (mUsedDefaultArray[Index] == DefaultId) {
5515 gCVfrErrorHandle.HandleWarning (VFR_WARNING_DEFAULT_VALUE_REDEFINED, Tok->getLine(), Tok->getText());
5516 }
5517 }
5518
5519 if (mUsedDefaultCount >= EFI_IFR_MAX_DEFAULT_TYPE - 1) {
5520 gCVfrErrorHandle.HandleError (VFR_RETURN_FATAL_ERROR, Tok->getLine(), Tok->getText());
5521 }
5522
5523 mUsedDefaultArray[mUsedDefaultCount++] = DefaultId;
5524 }
5525 >>
EFI Development Kit II mirror for PVE