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