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