]> 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
CryptoPkg: Fix GCC build break for BaseCryptLib.
[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 CIfrRef *R1Obj = NULL;\r
1650 CIfrRef2 *R2Obj = NULL;\r
1651 CIfrRef3 *R3Obj = NULL;\r
1652 CIfrRef4 *R4Obj = NULL;\r
1653 CIfrRef5 *R5Obj = NULL;\r
1654 >>\r
1655 G:Goto\r
1656 {\r
1657 (\r
1658 DevicePath "=" "STRING_TOKEN" "\(" P:Number "\)" ","\r
1659 FormSetGuid "=" guidDefinition[FSId] ","\r
1660 FormId "=" F1:Number ","\r
1661 Question "=" QN1:Number ","\r
1662 <<\r
1663 RefType = 4;\r
1664 DevPath = _STOSID(P->getText());\r
1665 FId = _STOFID(F1->getText());\r
1666 QId = _STOQID(QN1->getText());\r
1667 >>\r
1668 )\r
1669 |\r
1670 (\r
1671 FormSetGuid "=" guidDefinition[FSId] ","\r
1672 FormId "=" F2:Number ","\r
1673 Question "=" QN2:Number ","\r
1674 <<\r
1675 RefType = 3;\r
1676 FId = _STOFID(F2->getText());\r
1677 QId = _STOQID(QN2->getText());\r
1678 >>\r
1679 )\r
1680 |\r
1681 (\r
1682 FormId "=" F3:Number "," << RefType = 2; FId = _STOFID(F3->getText()); >>\r
1683 Question "="\r
1684 (\r
1685 QN3:StringIdentifier "," << mCVfrQuestionDB.GetQuestionId (QN3->getText (), NULL, QId, BitMask); >>\r
1686 | QN3:Number "," << QId = _STOQID(QN3->getText()); >>\r
1687 )\r
1688 )\r
1689 |\r
1690 (\r
1691 F4:Number "," <<\r
1692 RefType = 1;\r
1693 FId = _STOFID(F4->getText());\r
1694 >>\r
1695 )\r
1696 }\r
1697 <<\r
1698 switch (RefType) {\r
1699 case 5:\r
1700 {\r
1701 R5Obj = new CIfrRef5;\r
1702 QHObj = R5Obj;\r
1703 R5Obj->SetLineNo(G->getLine());\r
1704 break;\r
1705 }\r
1706 case 4:\r
1707 {\r
1708 R4Obj = new CIfrRef4;\r
1709 QHObj = R4Obj;\r
1710 R4Obj->SetLineNo(G->getLine());\r
1711 R4Obj->SetDevicePath (DevPath);\r
1712 R4Obj->SetFormSetId (FSId);\r
1713 R4Obj->SetFormId (FId);\r
1714 R4Obj->SetQuestionId (QId);\r
1715 break;\r
1716 }\r
1717 case 3:\r
1718 {\r
1719 R3Obj = new CIfrRef3;\r
1720 QHObj = R3Obj;\r
1721 R3Obj->SetLineNo(G->getLine());\r
1722 R3Obj->SetFormSetId (FSId);\r
1723 R3Obj->SetFormId (FId);\r
1724 R3Obj->SetQuestionId (QId);\r
1725 break;\r
1726 }\r
1727 case 2:\r
1728 {\r
1729 R2Obj = new CIfrRef2;\r
1730 QHObj = R2Obj;\r
1731 R2Obj->SetLineNo(G->getLine());\r
1732 R2Obj->SetFormId (FId);\r
1733 _PCATCH(R2Obj->SetQuestionId (QId), QN3);\r
1734 break;\r
1735 }\r
1736 case 1:\r
1737 {\r
1738 R1Obj = new CIfrRef;\r
1739 QHObj = R1Obj;\r
1740 R1Obj->SetLineNo(G->getLine());\r
1741 R1Obj->SetFormId (FId);\r
1742 break;\r
1743 }\r
1744 default: break;\r
1745 }\r
1746 >>\r
1747 vfrQuestionHeader[*QHObj, QUESTION_REF]\r
1748 { "," vfrStatementStatTagList }\r
1749 { "," F:FLAGS "=" vfrGotoFlags[QHObj, F->getLine()] }\r
1750 {\r
1751 "," Key "=" KN:Number << AssignQuestionKey (*QHObj, KN); >>\r
1752 }\r
1753 ";" << 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
1754 ;\r
1755\r
1756vfrGotoFlags [CIfrQuestionHeader *QHObj, UINT32 LineNum] :\r
1757 << UINT8 HFlags = 0; >>\r
1758 gotoFlagsField[HFlags] ( "\|" gotoFlagsField[HFlags] )*\r
1759 << _PCATCH(QHObj->SetFlags (HFlags), LineNum); >>\r
1760 ;\r
1761\r
1762gotoFlagsField[UINT8 & HFlags] :\r
1763 N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>\r
1764 | questionheaderFlagsField[HFlags]\r
1765 ;\r
1766\r
1767getStringId :\r
1768 "STRING_TOKEN" "\("\r
1769 IdVal:Number\r
1770 "\)"\r
1771 ;\r
1772\r
1773vfrStatementResetButton :\r
1774 <<\r
1775 CIfrResetButton RBObj;\r
1776 UINT16 DefaultId;\r
1777 >>\r
1778 L:ResetButton << RBObj.SetLineNo(L->getLine()); >>\r
1779 DefaultStore\r
1780 "=" N:StringIdentifier "," <<\r
1781 _PCATCH(mCVfrDefaultStore.GetDefaultId (N->getText(), &DefaultId), N->getLine());\r
1782 RBObj.SetDefaultId (DefaultId);\r
1783 >>\r
1784 vfrStatementHeader[&RBObj] ","\r
1785 { vfrStatementStatTagList "," }\r
1786 E:EndResetButton << CRT_END_OP (E); >>\r
1787 ";"\r
1788 ;\r
1789\r
1790vfrStatementBooleanType :\r
1791 vfrStatementCheckBox |\r
1792 vfrStatementAction\r
1793 ;\r
1794\r
1795//*****************************************************\r
1796// Syntax of checkbox\r
1797//\r
1798// Example:\r
1799// checkbox\r
1800// varid = MySTestData.mField1,\r
1801// prompt = STRING_TOKEN(STR_CHECK_BOX_PROMPT),\r
1802// help = STRING_TOKEN(STR_CHECK_BOX_HELP),\r
1803// flags = CHECKBOX_DEFAULT | CALLBACK,\r
1804// default value = TRUE, defaultstore = MyDefaultStore,\r
1805// endcheckbox;\r
1806//\r
1807vfrStatementCheckBox :\r
1808 <<\r
1809 CIfrCheckBox CBObj;\r
1810 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;\r
1811 CHAR8 *VarStoreName = NULL;\r
1812 UINT32 DataTypeSize;\r
1813 >>\r
1814 L:CheckBox << CBObj.SetLineNo(L->getLine()); >>\r
1815 vfrQuestionHeader[CBObj] "," << //check data type\r
1816 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "CheckBox varid is not the valid data type");\r
1817 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {\r
1818 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid doesn't support array");\r
1819 } else if ((mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == EFI_VFR_VARSTORE_BUFFER) &&\r
1820 (_GET_CURRQEST_VARSIZE() != sizeof (BOOLEAN))) {\r
1821 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only support BOOLEAN data type");\r
1822 }\r
1823 >>\r
1824 {\r
1825 F:FLAGS "=" vfrCheckBoxFlags[CBObj, F->getLine()] ","\r
1826 <<\r
1827 _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), VFR_RETURN_SUCCESS, L, "Failed to retrieve varstore name");\r
1828 Val.b = TRUE;\r
1829 if (CBObj.GetFlags () & 0x01) {\r
1830 _PCATCH(\r
1831 mCVfrDefaultStore.BufferVarStoreAltConfigAdd (\r
1832 EFI_HII_DEFAULT_CLASS_STANDARD,\r
1833 _GET_CURRQEST_VARTINFO(),\r
1834 VarStoreName,\r
1835 _GET_CURRQEST_DATATYPE (),\r
1836 Val\r
1837 ),\r
1838 VFR_RETURN_SUCCESS,\r
1839 L,\r
1840 "No standard default storage found"\r
1841 );\r
1842 }\r
1843 if (CBObj.GetFlags () & 0x02) {\r
1844 _PCATCH(\r
1845 mCVfrDefaultStore.BufferVarStoreAltConfigAdd (\r
1846 EFI_HII_DEFAULT_CLASS_MANUFACTURING,\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 manufacturing default storage found"\r
1855 );\r
1856 }\r
1857 >>\r
1858 }\r
1859 {\r
1860 Key "=" KN:Number "," << AssignQuestionKey (CBObj, KN); >>\r
1861 }\r
1862 vfrStatementQuestionOptionList\r
1863 E:EndCheckBox << CRT_END_OP (E); >>\r
1864 ";"\r
1865 ;\r
1866\r
1867vfrCheckBoxFlags [CIfrCheckBox & CBObj, UINT32 LineNum] :\r
1868 <<\r
1869 UINT8 LFlags = 0;\r
1870 UINT8 HFlags = 0;\r
1871 >>\r
1872 checkboxFlagsField[LFlags, HFlags] ( "\|" checkboxFlagsField[LFlags, HFlags] )*\r
1873 << _PCATCH(CBObj.SetFlags (HFlags, LFlags), LineNum); >>\r
1874 ;\r
1875\r
1876checkboxFlagsField[UINT8 & LFlags, UINT8 & HFlags] :\r
1877 N:Number <<\r
1878 if (mCompatibleMode) {\r
1879 //\r
1880 // set question flag\r
1881 //\r
1882 $LFlags |= _STOU8(N->getText());\r
1883 } else {\r
1884 _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine());\r
1885 }\r
1886 >>\r
1887 | D:"DEFAULT" <<\r
1888 if (mCompatibleMode) {\r
1889 //\r
1890 // set question Default flag\r
1891 //\r
1892 $LFlags |= 0x01;\r
1893 } else {\r
1894 _PCATCH (VFR_RETURN_UNSUPPORTED, D);\r
1895 }\r
1896 >>\r
1897 | M:"MANUFACTURING" <<\r
1898 if (mCompatibleMode) {\r
1899 //\r
1900 // set question MFG flag\r
1901 //\r
1902 $LFlags |= 0x02;\r
1903 } else {\r
1904 _PCATCH (VFR_RETURN_UNSUPPORTED, M);\r
1905 }\r
1906 >>\r
1907 | "CHECKBOX_DEFAULT" << $LFlags |= 0x01; >>\r
1908 | "CHECKBOX_DEFAULT_MFG" << $LFlags |= 0x02; >>\r
1909 | questionheaderFlagsField[HFlags]\r
1910 ;\r
1911\r
1912//*****************************************************\r
1913// Syntax of action\r
1914//\r
1915// Example:\r
1916// action\r
1917// prompt = STRING_TOKEN(STR_ACTION_PROMPT),\r
1918// help = STRING_TOKEN(STR_ACTION_HELP),\r
1919// flags = CALLBACK,\r
1920// config = STRING_TOKEN(STR_ACTION_CONFIG),\r
1921// endaction;\r
1922//\r
1923vfrStatementAction :\r
1924 << CIfrAction AObj; >>\r
1925 L:Action << AObj.SetLineNo(L->getLine()); >>\r
1926 vfrQuestionHeader[AObj] ","\r
1927 { F:FLAGS "=" vfrActionFlags[AObj, F->getLine()] "," }\r
1928 Config "=" "STRING_TOKEN" "\(" S:Number "\)" "," << AObj.SetQuestionConfig (_STOSID(S->getText())); >>\r
1929 vfrStatementQuestionTagList\r
1930 E:EndAction << CRT_END_OP (E); >>\r
1931 ";"\r
1932 ;\r
1933\r
1934vfrActionFlags[CIfrAction & AObj, UINT32 LineNum] :\r
1935 << UINT8 HFlags = 0; >>\r
1936 actionFlagsField[HFlags] ( "\|" actionFlagsField[HFlags] )*\r
1937 << _PCATCH(AObj.SetFlags (HFlags), LineNum); >>\r
1938 ;\r
1939\r
1940actionFlagsField[UINT8 & HFlags] :\r
1941 N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>\r
1942 | questionheaderFlagsField[HFlags]\r
1943 ;\r
1944\r
1945vfrStatementDate :\r
1946 <<\r
1947 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;\r
1948 CHAR8 *VarIdStr[3] = {NULL, };\r
1949 CIfrDate DObj;\r
1950 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;\r
1951 >>\r
1952 L:Date << DObj.SetLineNo(L->getLine()); >>\r
1953 (\r
1954 (\r
1955 vfrQuestionHeader[DObj, QUESTION_DATE] ","\r
1956 { F:FLAGS "=" vfrDateFlags[DObj, F->getLine()] "," }\r
1957 vfrStatementQuestionOptionList\r
1958 )\r
1959 |\r
1960 (\r
1961 Year VarId "=" D1:StringIdentifier "." D1Y:StringIdentifier ","\r
1962 << _STRCAT(&VarIdStr[0], D1->getText()); _STRCAT(&VarIdStr[0], "."); _STRCAT(&VarIdStr[0], D1Y->getText()); >>\r
1963 Prompt "=" "STRING_TOKEN" "\(" YP:Number "\)" ","\r
1964 Help "=" "STRING_TOKEN" "\(" YH:Number "\)" ","\r
1965 minMaxDateStepDefault[Val.date, 0]\r
1966\r
1967 Month VarId "=" D2:StringIdentifier "." D2M:StringIdentifier ","\r
1968 << _STRCAT(&VarIdStr[1], D2->getText()); _STRCAT(&VarIdStr[1], "."); _STRCAT(&VarIdStr[1], D2M->getText()); >>\r
1969 Prompt "=" "STRING_TOKEN" "\(" MP:Number "\)" ","\r
1970 Help "=" "STRING_TOKEN" "\(" MH:Number "\)" ","\r
1971 minMaxDateStepDefault[Val.date, 1]\r
1972\r
1973 Day VarId "=" D3:StringIdentifier "." D3D:StringIdentifier ","\r
1974 << _STRCAT(&VarIdStr[2], D3->getText()); _STRCAT(&VarIdStr[2], "."); _STRCAT(&VarIdStr[2], D3D->getText()); >>\r
1975 Prompt "=" "STRING_TOKEN" "\(" DP:Number "\)" ","\r
1976 Help "=" "STRING_TOKEN" "\(" DH:Number "\)" ","\r
1977 minMaxDateStepDefault[Val.date, 2]\r
1978 <<\r
1979 mCVfrQuestionDB.RegisterOldDateQuestion (VarIdStr[0], VarIdStr[1], VarIdStr[2], QId);\r
1980 DObj.SetQuestionId (QId);\r
1981 DObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, QF_DATE_STORAGE_TIME);\r
1982 DObj.SetPrompt (_STOSID(YP->getText()));\r
1983 DObj.SetHelp (_STOSID(YH->getText()));\r
1984 if (VarIdStr[0] != NULL) { delete VarIdStr[0]; } if (VarIdStr[1] != NULL) { delete VarIdStr[1]; } if (VarIdStr[2] != NULL) { delete VarIdStr[2]; }\r
1985 >>\r
1986 << {CIfrDefault DefaultObj(EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_DATE, Val); DefaultObj.SetLineNo(L->getLine());} >>\r
1987 )\r
1988 ( vfrStatementInconsistentIf )*\r
1989 )\r
1990 E:EndDate << CRT_END_OP (E); >>\r
1991 ";"\r
1992 ;\r
1993\r
1994minMaxDateStepDefault[EFI_HII_DATE & D, UINT8 KeyValue] :\r
1995 Minimum "=" MinN:Number ","\r
1996 Maximum "=" MaxN:Number ","\r
1997 { "step" "=" Number "," }\r
1998 {\r
1999 "default" "=" N:Number "," <<\r
2000 switch (KeyValue) {\r
2001 case 0: \r
2002 D.Year = _STOU16(N->getText());\r
2003 if (D.Year < _STOU16 (MinN->getText()) || D.Year > _STOU16 (MaxN->getText())) {\r
2004 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Year default value must be between Min year and Max year.");\r
2005 }\r
2006 break;\r
2007 case 1: \r
2008 D.Month = _STOU8(N->getText()); \r
2009 if (D.Month < 1 || D.Month > 12) {\r
2010 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Month default value must be between 1 and 12.");\r
2011 }\r
2012 break;\r
2013 case 2: \r
2014 D.Day = _STOU8(N->getText()); \r
2015 if (D.Day < 1 || D.Day > 31) {\r
2016 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Day default value must be between 1 and 31.");\r
2017 }\r
2018 break;\r
2019 }\r
2020 >>\r
2021 }\r
2022 ;\r
2023\r
2024vfrDateFlags [CIfrDate & DObj, UINT32 LineNum] :\r
2025 << UINT8 LFlags = 0; >>\r
2026 dateFlagsField[LFlags] ( "\|" dateFlagsField[LFlags] )*\r
2027 << _PCATCH(DObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, LFlags), LineNum); >>\r
2028 ;\r
2029\r
2030dateFlagsField [UINT8 & Flags] :\r
2031 N:Number << $Flags |= _STOU8(N->getText()); >>\r
2032 | "YEAR_SUPPRESS" << $Flags |= 0x01; >>\r
2033 | "MONTH_SUPPRESS" << $Flags |= 0x02; >>\r
2034 | "DAY_SUPPRESS" << $Flags |= 0x04; >>\r
2035 | "STORAGE_NORMAL" << $Flags |= 0x00; >>\r
2036 | "STORAGE_TIME" << $Flags |= 0x10; >>\r
2037 | "STORAGE_WAKEUP" << $Flags |= 0x20; >>\r
2038 ;\r
2039\r
2040vfrStatementNumericType :\r
2041 vfrStatementNumeric |\r
2042 vfrStatementOneOf\r
2043 ;\r
2044\r
2045vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :\r
2046 <<\r
2047 UINT64 MaxU8 = 0, MinU8 = 0, StepU8 = 0;\r
2048 UINT32 MaxU4 = 0, MinU4 = 0, StepU4 = 0;\r
2049 UINT16 MaxU2 = 0, MinU2 = 0, StepU2 = 0;\r
2050 UINT8 MaxU1 = 0, MinU1 = 0, StepU1 = 0;\r
2051 >>\r
2052 Minimum "=" I:Number ","\r
2053 <<\r
2054 switch (_GET_CURRQEST_DATATYPE()) {\r
2055 case EFI_IFR_TYPE_NUM_SIZE_64 : MinU8 = _STOU64(I->getText()); break;\r
2056 case EFI_IFR_TYPE_NUM_SIZE_32 : MinU4 = _STOU32(I->getText()); break;\r
2057 case EFI_IFR_TYPE_NUM_SIZE_16 : MinU2 = _STOU16(I->getText()); break;\r
2058 case EFI_IFR_TYPE_NUM_SIZE_8 : MinU1 = _STOU8(I->getText()); break;\r
2059 }\r
2060 >>\r
2061 Maximum "=" A:Number ","\r
2062 <<\r
2063 switch (_GET_CURRQEST_DATATYPE()) {\r
2064 case EFI_IFR_TYPE_NUM_SIZE_64 : \r
2065 MaxU8 = _STOU64(A->getText()); \r
2066 if (MaxU8 < MinU8) {\r
2067 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");\r
2068 }\r
2069 break;\r
2070 case EFI_IFR_TYPE_NUM_SIZE_32 : \r
2071 MaxU4 = _STOU32(A->getText()); \r
2072 if (MaxU4 < MinU4) {\r
2073 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");\r
2074 }\r
2075 break;\r
2076 case EFI_IFR_TYPE_NUM_SIZE_16 : \r
2077 MaxU2 = _STOU16(A->getText()); \r
2078 if (MaxU2 < MinU2) {\r
2079 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");\r
2080 }\r
2081 break;\r
2082 case EFI_IFR_TYPE_NUM_SIZE_8 : \r
2083 MaxU1 = _STOU8(A->getText()); \r
2084 if (MaxU1 < MinU1) {\r
2085 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");\r
2086 }\r
2087 break;\r
2088 }\r
2089 >>\r
2090 {\r
2091 STEP "=" S:Number ","\r
2092 <<\r
2093 switch (_GET_CURRQEST_DATATYPE()) {\r
2094 case EFI_IFR_TYPE_NUM_SIZE_64 : StepU8 = _STOU64(S->getText()); break;\r
2095 case EFI_IFR_TYPE_NUM_SIZE_32 : StepU4 = _STOU32(S->getText()); break;\r
2096 case EFI_IFR_TYPE_NUM_SIZE_16 : StepU2 = _STOU16(S->getText()); break;\r
2097 case EFI_IFR_TYPE_NUM_SIZE_8 : StepU1 = _STOU8(S->getText()); break;\r
2098 }\r
2099 >>\r
2100 }\r
2101 <<\r
2102 switch (_GET_CURRQEST_DATATYPE()) {\r
2103 case EFI_IFR_TYPE_NUM_SIZE_64 : $MMSDObj.SetMinMaxStepData (MinU8, MaxU8, StepU8); break;\r
2104 case EFI_IFR_TYPE_NUM_SIZE_32 : $MMSDObj.SetMinMaxStepData (MinU4, MaxU4, StepU4); break;\r
2105 case EFI_IFR_TYPE_NUM_SIZE_16 : $MMSDObj.SetMinMaxStepData (MinU2, MaxU2, StepU2); break;\r
2106 case EFI_IFR_TYPE_NUM_SIZE_8 : $MMSDObj.SetMinMaxStepData (MinU1, MaxU1, StepU1); break;\r
2107 }\r
2108 >>\r
2109 ;\r
2110\r
2111vfrStatementNumeric :\r
2112 <<\r
2113 CIfrNumeric NObj;\r
2114 UINT32 DataTypeSize;\r
2115 BOOLEAN IsSupported;\r
2116 >>\r
2117 L:Numeric << NObj.SetLineNo(L->getLine()); >>\r
2118 vfrQuestionHeader[NObj] "," << // check data type\r
2119 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "Numeric varid is not the valid data type");\r
2120 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {\r
2121 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric varid doesn't support array");\r
2122 }\r
2123 _PCATCH(NObj.SetFlags (NObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());\r
2124 >>\r
2125 { F:FLAGS "=" vfrNumericFlags[NObj, F->getLine()] "," }\r
2126 {\r
2127 Key "=" KN:Number "," << AssignQuestionKey (NObj, KN); >>\r
2128 }\r
2129 vfrSetMinMaxStep[NObj]\r
2130 vfrStatementQuestionOptionList\r
2131 E:EndNumeric << \r
2132 IsSupported = FALSE;\r
2133 switch (_GET_CURRQEST_DATATYPE()) {\r
2134 case EFI_IFR_TYPE_NUM_SIZE_8:\r
2135 case EFI_IFR_TYPE_NUM_SIZE_16:\r
2136 case EFI_IFR_TYPE_NUM_SIZE_32:\r
2137 case EFI_IFR_TYPE_NUM_SIZE_64:\r
2138 IsSupported = TRUE;\r
2139 break;\r
2140 default:\r
2141 break;\r
2142 }\r
2143 if (!IsSupported) {\r
2144 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric question only support UINT8, UINT16, UINT32 and UINT64 data type.");\r
2145 }\r
2146 CRT_END_OP (E); \r
2147 >>\r
2148 ";"\r
2149 ;\r
2150\r
2151vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] :\r
2152 <<\r
2153 UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;\r
2154 UINT8 HFlags = 0;\r
2155 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;\r
2156 >>\r
2157 numericFlagsField[HFlags, LFlags] ( "\|" numericFlagsField[HFlags, LFlags] )*\r
2158 <<\r
2159 //check data type flag\r
2160 VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);\r
2161 if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {\r
2162 if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {\r
2163 _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type");\r
2164 }\r
2165 } else {\r
2166 // update data type for name/value store\r
2167 UINT32 DataTypeSize;\r
2168 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;\r
2169 gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);\r
2170 _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;\r
2171 }\r
2172 _PCATCH(NObj.SetFlags (HFlags, LFlags), LineNum);\r
2173 >>\r
2174 ;\r
2175\r
2176numericFlagsField [UINT8 & HFlags, UINT8 & LFlags] :\r
2177 N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>\r
2178 | "NUMERIC_SIZE_1" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1; >>\r
2179 | "NUMERIC_SIZE_2" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2; >>\r
2180 | "NUMERIC_SIZE_4" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4; >>\r
2181 | "NUMERIC_SIZE_8" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8; >>\r
2182 | "DISPLAY_INT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC; >>\r
2183 | "DISPLAY_UINT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC; >>\r
2184 | "DISPLAY_UINT_HEX" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX; >>\r
2185 | questionheaderFlagsField[HFlags]\r
2186 ;\r
2187\r
2188vfrStatementOneOf :\r
2189 <<\r
2190 CIfrOneOf OObj;\r
2191 UINT32 DataTypeSize;\r
2192 BOOLEAN IsSupported;\r
2193 >>\r
2194 L:OneOf << OObj.SetLineNo(L->getLine()); >>\r
2195 vfrQuestionHeader[OObj] "," << //check data type\r
2196 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "OneOf varid is not the valid data type");\r
2197 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {\r
2198 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf varid doesn't support array");\r
2199 }\r
2200 _PCATCH(OObj.SetFlags (OObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());\r
2201 >>\r
2202 { F:FLAGS "=" vfrOneofFlagsField[OObj, F->getLine()] "," }\r
2203 {\r
2204 vfrSetMinMaxStep[OObj]\r
2205 }\r
2206 vfrStatementQuestionOptionList\r
2207 E:EndOneOf << \r
2208 IsSupported = FALSE;\r
2209 switch (_GET_CURRQEST_DATATYPE()) {\r
2210 case EFI_IFR_TYPE_NUM_SIZE_8:\r
2211 case EFI_IFR_TYPE_NUM_SIZE_16:\r
2212 case EFI_IFR_TYPE_NUM_SIZE_32:\r
2213 case EFI_IFR_TYPE_NUM_SIZE_64:\r
2214 IsSupported = TRUE;\r
2215 break;\r
2216 default:\r
2217 break;\r
2218 }\r
2219 if (!IsSupported) {\r
2220 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf question only support UINT8, UINT16, UINT32 and UINT64 data type.");\r
2221 }\r
2222 CRT_END_OP (E); \r
2223 >>\r
2224 ";"\r
2225 ;\r
2226\r
2227vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] :\r
2228 <<\r
2229 UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;\r
2230 UINT8 HFlags = 0;\r
2231 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;\r
2232 >>\r
2233 numericFlagsField[HFlags, LFlags] ( "\|" numericFlagsField[HFlags, LFlags] )*\r
2234 <<\r
2235 //check data type flag\r
2236 VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);\r
2237 if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {\r
2238 if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {\r
2239 _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type");\r
2240 }\r
2241 } else {\r
2242 // update data type for Name/Value store\r
2243 UINT32 DataTypeSize;\r
2244 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;\r
2245 gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);\r
2246 _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;\r
2247 }\r
2248 _PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum);\r
2249 >>\r
2250 ;\r
2251\r
2252vfrStatementStringType :\r
2253 vfrStatementString |\r
2254 vfrStatementPassword\r
2255 ;\r
2256\r
2257vfrStatementString :\r
2258 <<\r
2259 CIfrString SObj;\r
2260 UINT32 VarArraySize;\r
2261 UINT8 StringMinSize;\r
2262 UINT8 StringMaxSize;\r
2263 >>\r
2264 L:String << SObj.SetLineNo(L->getLine()); >>\r
2265 vfrQuestionHeader[SObj] ","\r
2266 { F:FLAGS "=" vfrStringFlagsField[SObj, F->getLine()] "," }\r
2267 {\r
2268 Key "=" KN:Number "," << AssignQuestionKey (SObj, KN); >>\r
2269 }\r
2270 MinSize "=" MIN:Number "," << \r
2271 VarArraySize = _GET_CURRQEST_ARRAY_SIZE();\r
2272 StringMinSize = _STOU8(MIN->getText());\r
2273 if (_STOU64(MIN->getText()) > StringMinSize) {\r
2274 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "String MinSize takes only one byte, which can't be larger than 0xFF.");\r
2275 } else if (VarArraySize != 0 && StringMinSize > VarArraySize) {\r
2276 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "String MinSize can't be larger than the max number of elements in string array.");\r
2277 }\r
2278 SObj.SetMinSize (StringMinSize);\r
2279 >>\r
2280 MaxSize "=" MAX:Number "," << \r
2281 StringMaxSize = _STOU8(MAX->getText());\r
2282 if (_STOU64(MAX->getText()) > StringMaxSize) {\r
2283 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize takes only one byte, which can't be larger than 0xFF.");\r
2284 } else if (VarArraySize != 0 && StringMaxSize > VarArraySize) {\r
2285 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize can't be larger than the max number of elements in string array.");\r
2286 } else if (StringMaxSize < StringMinSize) {\r
2287 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize can't be less than String MinSize.");\r
2288 }\r
2289 SObj.SetMaxSize (StringMaxSize);\r
2290 >>\r
2291 vfrStatementQuestionOptionList\r
2292 E:EndString << CRT_END_OP (E); >>\r
2293 ";"\r
2294 ;\r
2295\r
2296vfrStringFlagsField [CIfrString & SObj, UINT32 LineNum] :\r
2297 <<\r
2298 UINT8 LFlags = 0;\r
2299 UINT8 HFlags = 0;\r
2300 >>\r
2301 stringFlagsField[HFlags, LFlags] ( "\|" stringFlagsField[HFlags, LFlags] )*\r
2302 << _PCATCH(SObj.SetFlags (HFlags, LFlags), LineNum); >>\r
2303 ;\r
2304\r
2305stringFlagsField [UINT8 & HFlags, UINT8 & LFlags] :\r
2306 N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>\r
2307 | "MULTI_LINE" << $LFlags = 0x01; >>\r
2308 | questionheaderFlagsField[HFlags]\r
2309 ;\r
2310\r
2311vfrStatementPassword :\r
2312 <<\r
2313 CIfrPassword PObj;\r
2314 UINT32 VarArraySize;\r
2315 UINT16 PasswordMinSize;\r
2316 UINT16 PasswordMaxSize;\r
2317 >>\r
2318 L:Password << PObj.SetLineNo(L->getLine()); >>\r
2319 vfrQuestionHeader[PObj] ","\r
2320 { F:FLAGS "=" vfrPasswordFlagsField[PObj, F->getLine()] "," }\r
2321 {\r
2322 Key "=" KN:Number "," << AssignQuestionKey (PObj, KN); >>\r
2323 }\r
2324 MinSize "=" MIN:Number "," << \r
2325 VarArraySize = _GET_CURRQEST_ARRAY_SIZE();\r
2326 PasswordMinSize = _STOU16(MIN->getText());\r
2327 if (_STOU64(MIN->getText()) > PasswordMinSize) {\r
2328 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "Password MinSize takes only two byte, which can't be larger than 0xFFFF.");\r
2329 } else if (VarArraySize != 0 && PasswordMinSize > VarArraySize) {\r
2330 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "Password MinSize can't be larger than the max number of elements in password array.");\r
2331 }\r
2332 PObj.SetMinSize (PasswordMinSize);\r
2333 >>\r
2334 MaxSize "=" MAX:Number "," << \r
2335 PasswordMaxSize = _STOU16(MAX->getText());\r
2336 if (_STOU64(MAX->getText()) > PasswordMaxSize) {\r
2337 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize takes only two byte, which can't be larger than 0xFFFF.");\r
2338 } else if (VarArraySize != 0 && PasswordMaxSize > VarArraySize) {\r
2339 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize can't be larger than the max number of elements in password array.");\r
2340 } else if (PasswordMaxSize < PasswordMinSize) {\r
2341 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize can't be less than Password MinSize.");\r
2342 }\r
2343 PObj.SetMaxSize (PasswordMaxSize);\r
2344 >>\r
2345 { Encoding "=" Number "," }\r
2346 vfrStatementQuestionOptionList\r
2347 E:EndPassword << CRT_END_OP (E); >>\r
2348 ";"\r
2349 ;\r
2350\r
2351vfrPasswordFlagsField [CIfrPassword & PObj, UINT32 LineNum] :\r
2352 << UINT8 HFlags = 0; >>\r
2353 passwordFlagsField[HFlags] ( "\|" passwordFlagsField[HFlags] )*\r
2354 << _PCATCH(PObj.SetFlags(HFlags), LineNum); >>\r
2355 ;\r
2356\r
2357passwordFlagsField [UINT8 & HFlags] :\r
2358 N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>\r
2359 | questionheaderFlagsField[HFlags]\r
2360 ;\r
2361\r
2362vfrStatementOrderedList :\r
2363 <<\r
2364 CIfrOrderedList OLObj;\r
2365 UINT32 VarArraySize;\r
2366 >>\r
2367 L:OrderedList << OLObj.SetLineNo(L->getLine()); >>\r
2368 vfrQuestionHeader[OLObj] ","\r
2369 << \r
2370 VarArraySize = _GET_CURRQEST_ARRAY_SIZE();\r
2371 OLObj.SetMaxContainers ((UINT8) (VarArraySize > 0xFF ? 0xFF : VarArraySize));\r
2372 >>\r
2373 {\r
2374 MaxContainers "=" M:Number "," << \r
2375 if (_STOU64(M->getText()) > _STOU8(M->getText())) {\r
2376 _PCATCH (VFR_RETURN_INVALID_PARAMETER, M->getLine(), "OrderedList MaxContainers takes only one byte, which can't be larger than 0xFF.");\r
2377 } else if (VarArraySize != 0 && _STOU8(M->getText()) > VarArraySize) {\r
2378 _PCATCH (VFR_RETURN_INVALID_PARAMETER, M->getLine(), "OrderedList MaxContainers can't be larger than the max number of elements in array.");\r
2379 }\r
2380 OLObj.SetMaxContainers (_STOU8(M->getText()));\r
2381 >>\r
2382 }\r
2383 { F:FLAGS "=" vfrOrderedListFlags[OLObj, F->getLine()] }\r
2384 vfrStatementQuestionOptionList\r
2385 E:EndList << CRT_END_OP (E); >>\r
2386 ";"\r
2387 ;\r
2388\r
2389vfrOrderedListFlags [CIfrOrderedList & OLObj, UINT32 LineNum] :\r
2390 <<\r
2391 UINT8 HFlags = 0;\r
2392 UINT8 LFlags = 0;\r
2393 >>\r
2394 orderedlistFlagsField[HFlags, LFlags] ( "\|" orderedlistFlagsField[HFlags, LFlags] )*\r
2395 << _PCATCH(OLObj.SetFlags (HFlags, LFlags), LineNum); >>\r
2396 ;\r
2397\r
2398orderedlistFlagsField [UINT8 & HFlags, UINT8 & LFlags] :\r
2399 N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>\r
2400 | "UNIQUE" << $LFlags |= 0x01; >>\r
2401 | "NOEMPTY" << $LFlags |= 0x02; >>\r
2402 | questionheaderFlagsField[HFlags]\r
2403 ;\r
2404\r
2405vfrStatementTime :\r
2406 <<\r
2407 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;\r
2408 CHAR8 *VarIdStr[3] = {NULL, };\r
2409 CIfrTime TObj;\r
2410 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;\r
2411 >>\r
2412 L:Time << TObj.SetLineNo(L->getLine()); >>\r
2413 (\r
2414 (\r
2415 vfrQuestionHeader[TObj, QUESTION_TIME] ","\r
2416 { F:FLAGS "=" vfrTimeFlags[TObj, F->getLine()] "," }\r
2417 vfrStatementQuestionOptionList\r
2418 )\r
2419 |\r
2420 (\r
2421 Hour VarId "=" T1:StringIdentifier "." T1H:StringIdentifier ","\r
2422 << _STRCAT(&VarIdStr[0], T1->getText()); _STRCAT(&VarIdStr[0], "."); _STRCAT(&VarIdStr[0], T1H->getText()); >>\r
2423 Prompt "=" "STRING_TOKEN" "\(" HP:Number "\)" ","\r
2424 Help "=" "STRING_TOKEN" "\(" HH:Number "\)" ","\r
2425 minMaxTimeStepDefault[Val.time, 0]\r
2426\r
2427 Minute VarId "=" T2:StringIdentifier "." T2M:StringIdentifier ","\r
2428 << _STRCAT(&VarIdStr[1], T2->getText()); _STRCAT(&VarIdStr[1], "."); _STRCAT(&VarIdStr[1], T2M->getText()); >>\r
2429 Prompt "=" "STRING_TOKEN" "\(" MP:Number "\)" ","\r
2430 Help "=" "STRING_TOKEN" "\(" MH:Number "\)" ","\r
2431 minMaxTimeStepDefault[Val.time, 1]\r
2432\r
2433 Second VarId "=" T3:StringIdentifier "." T3S:StringIdentifier ","\r
2434 << _STRCAT(&VarIdStr[2], T3->getText()); _STRCAT(&VarIdStr[2], "."); _STRCAT(&VarIdStr[2], T3S->getText()); >>\r
2435 Prompt "=" "STRING_TOKEN" "\(" SP:Number "\)" ","\r
2436 Help "=" "STRING_TOKEN" "\(" SH:Number "\)" ","\r
2437 minMaxTimeStepDefault[Val.time, 2]\r
2438 <<\r
2439 mCVfrQuestionDB.RegisterOldTimeQuestion (VarIdStr[0], VarIdStr[1], VarIdStr[2], QId);\r
2440 TObj.SetQuestionId (QId);\r
2441 TObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, QF_TIME_STORAGE_TIME);\r
2442 TObj.SetPrompt (_STOSID(HP->getText()));\r
2443 TObj.SetHelp (_STOSID(HH->getText()));\r
2444 if (VarIdStr[0] != NULL) { delete VarIdStr[0]; } if (VarIdStr[1] != NULL) { delete VarIdStr[1]; } if (VarIdStr[2] != NULL) { delete VarIdStr[2]; }\r
2445 >>\r
2446 << {CIfrDefault DefaultObj(EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_TIME, Val); DefaultObj.SetLineNo(L->getLine());} >>\r
2447 )\r
2448 ( vfrStatementInconsistentIf )*\r
2449 )\r
2450 E:EndTime << CRT_END_OP (E); >>\r
2451 ";"\r
2452 ;\r
2453\r
2454minMaxTimeStepDefault[EFI_HII_TIME & T, UINT8 KeyValue] :\r
2455 Minimum "=" Number ","\r
2456 Maximum "=" Number ","\r
2457 { "step" "=" Number "," }\r
2458 {\r
2459 "default" "=" N:Number "," <<\r
2460 switch (KeyValue) {\r
2461 case 0: \r
2462 T.Hour = _STOU8(N->getText()); \r
2463 if (T.Hour > 23) {\r
2464 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Hour default value must be between 0 and 23.");\r
2465 }\r
2466 break;\r
2467 case 1: \r
2468 T.Minute = _STOU8(N->getText()); \r
2469 if (T.Minute > 59) {\r
2470 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Minute default value must be between 0 and 59.");\r
2471 }\r
2472 break;\r
2473 case 2: \r
2474 T.Second = _STOU8(N->getText());\r
2475 if (T.Second > 59) {\r
2476 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Second default value must be between 0 and 59.");\r
2477 }\r
2478 break;\r
2479 }\r
2480 >>\r
2481 }\r
2482 ;\r
2483\r
2484vfrTimeFlags [CIfrTime & TObj, UINT32 LineNum] :\r
2485 << UINT8 LFlags = 0; >>\r
2486 timeFlagsField[LFlags] ( "\|" timeFlagsField[LFlags] )*\r
2487 << _PCATCH(TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, LFlags), LineNum); >>\r
2488 ;\r
2489\r
2490timeFlagsField [UINT8 & Flags] :\r
2491 N:Number << $Flags |= _STOU8(N->getText()); >>\r
2492 | "HOUR_SUPPRESS" << $Flags |= 0x01; >>\r
2493 | "MINUTE_SUPPRESS" << $Flags |= 0x02; >>\r
2494 | "SECOND_SUPPRESS" << $Flags |= 0x04; >>\r
2495 | "STORAGE_NORMAL" << $Flags |= 0x00; >>\r
2496 | "STORAGE_TIME" << $Flags |= 0x10; >>\r
2497 | "STORAGE_WAKEUP" << $Flags |= 0x20; >>\r
2498 ;\r
2499\r
2500vfrStatementQuestionTag :\r
2501 vfrStatementStatTag "," |\r
2502 vfrStatementInconsistentIf |\r
2503 vfrStatementNoSubmitIf |\r
2504 vfrStatementDisableIfQuest |\r
2505 vfrStatementRefresh |\r
2506 vfrStatementVarstoreDevice |\r
2507 vfrStatementExtension |\r
2508 vfrStatementRefreshEvent\r
2509 ;\r
2510\r
2511vfrStatementQuestionTagList :\r
2512 ( vfrStatementQuestionTag )*\r
2513 ;\r
2514\r
2515vfrStatementQuestionOptionTag :\r
2516 vfrStatementSuppressIfQuest |\r
2517 vfrStatementGrayOutIfQuest |\r
2518 vfrStatementValue |\r
2519 vfrStatementDefault |\r
2520 vfrStatementRead |\r
2521 vfrStatementWrite |\r
2522 vfrStatementOptions\r
2523 ;\r
2524\r
2525vfrStatementQuestionOptionList :\r
2526 (\r
2527 vfrStatementQuestionTag |\r
2528 vfrStatementQuestionOptionTag\r
2529 )*\r
2530 ;\r
2531\r
2532vfrStatementStatList :\r
2533 vfrStatementStat |\r
2534 vfrStatementQuestions |\r
2535 vfrStatementConditionalNew |\r
2536 vfrStatementLabel |\r
2537 vfrStatementExtension |\r
2538 // Just for framework vfr compatibility\r
2539 vfrStatementInvalid\r
2540 ;\r
2541\r
2542vfrStatementStatListOld :\r
2543 vfrStatementStat |\r
2544 vfrStatementQuestions |\r
2545 vfrStatementLabel |\r
2546 // Just for framework vfr compatibility\r
2547 vfrStatementInvalid\r
2548 ;\r
2549\r
2550vfrStatementDisableIfStat :\r
2551 << \r
2552 CIfrDisableIf DIObj; \r
2553 >>\r
2554 L:DisableIf << DIObj.SetLineNo(L->getLine()); >>\r
2555 vfrStatementExpression[0] ";" \r
2556 ( vfrStatementStatList )*\r
2557 E:EndIf << CRT_END_OP (E); >>\r
2558 ";"\r
2559 ;\r
2560\r
2561vfrStatementInconsistentIfStat :\r
2562 << CIfrInconsistentIf IIObj; >>\r
2563 L:InconsistentIf <<\r
2564 if (!mCompatibleMode) {\r
2565 _PCATCH (VFR_RETURN_UNSUPPORTED, L);\r
2566 }\r
2567 IIObj.SetLineNo(L->getLine());\r
2568 >>\r
2569 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText())); >>\r
2570 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2571 vfrStatementExpression[0]\r
2572 E:EndIf << CRT_END_OP (E); >>\r
2573 ";"\r
2574 ;\r
2575\r
2576//\r
2577// Compatible for framework vfr file\r
2578//\r
2579vfrStatementgrayoutIfSuppressIf:\r
2580 << CIfrSuppressIf SIObj; >>\r
2581 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >>\r
2582 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2583 vfrStatementExpression[0]\r
2584 ";"\r
2585 ;\r
2586\r
2587vfrStatementsuppressIfGrayOutIf:\r
2588 << CIfrGrayOutIf GOIObj; >>\r
2589 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >>\r
2590 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2591 vfrStatementExpression[0]\r
2592 ";"\r
2593 ;\r
2594\r
2595vfrStatementSuppressIfStatNew :\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 ( vfrStatementStatList )*\r
2602 E: EndIf ";" << CRT_END_OP (E); >>\r
2603 ;\r
2604\r
2605vfrStatementGrayOutIfStatNew :\r
2606 << CIfrGrayOutIf GOIObj;>>\r
2607 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >>\r
2608 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2609 vfrStatementExpression[0]\r
2610 ";"\r
2611 ( vfrStatementStatList )*\r
2612 E: EndIf ";" << CRT_END_OP (E); >>\r
2613 ;\r
2614\r
2615vfrStatementSuppressIfStatOld :\r
2616 <<\r
2617 CIfrSuppressIf SIObj;\r
2618 BOOLEAN GrayOutExist = FALSE;\r
2619 >>\r
2620 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >>\r
2621 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2622 vfrStatementExpression[0]\r
2623 ";"\r
2624 {\r
2625 vfrStatementsuppressIfGrayOutIf\r
2626 << GrayOutExist = TRUE; >>\r
2627 }\r
2628 ( vfrStatementStatListOld )*\r
2629 E: EndIf ";" << if (GrayOutExist) CRT_END_OP (E); CRT_END_OP (E);>>\r
2630 ;\r
2631\r
2632vfrStatementGrayOutIfStatOld :\r
2633 <<\r
2634 CIfrGrayOutIf GOIObj;\r
2635 BOOLEAN SuppressExist = FALSE;\r
2636 >>\r
2637 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >>\r
2638 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2639 vfrStatementExpression[0]\r
2640 ";"\r
2641 {\r
2642 vfrStatementgrayoutIfSuppressIf\r
2643 << SuppressExist = TRUE; >>\r
2644 }\r
2645 ( vfrStatementStatListOld )*\r
2646 E: EndIf ";" << if (SuppressExist) CRT_END_OP (E); CRT_END_OP (E); >>\r
2647 ;\r
2648\r
2649vfrImageTag :\r
2650 << CIfrImage IObj; >>\r
2651 L:Image "=" "IMAGE_TOKEN" "\(" S1:Number "\)" << IObj.SetImageId (_STOSID(S1->getText())); IObj.SetLineNo(L->getLine()); >>\r
2652 ;\r
2653\r
2654vfrLockedTag :\r
2655 << CIfrLocked LObj; >>\r
2656 L:Locked << LObj.SetLineNo(L->getLine()); >>\r
2657 ;\r
2658\r
2659vfrModalTag :\r
2660 << CIfrModal MObj; >>\r
2661 L:Modal << MObj.SetLineNo(L->getLine()); >>\r
2662 ;\r
2663\r
2664vfrStatementStatTag :\r
2665 vfrImageTag |\r
2666 vfrLockedTag\r
2667 ;\r
2668\r
2669vfrStatementStatTagList :\r
2670 vfrStatementStatTag ( "," vfrStatementStatTag )*\r
2671 ;\r
2672\r
2673vfrStatementImage :\r
2674 vfrImageTag\r
2675 ";"\r
2676 ;\r
2677\r
2678vfrStatementModal :\r
2679 vfrModalTag\r
2680 ";"\r
2681 ;\r
2682\r
2683vfrStatementLocked :\r
2684 vfrLockedTag\r
2685 ";"\r
2686 ;\r
2687\r
2688vfrStatementInconsistentIf :\r
2689 << CIfrInconsistentIf IIObj; >>\r
2690 L:InconsistentIf << IIObj.SetLineNo(L->getLine()); >>\r
2691 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText())); >>\r
2692 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2693 vfrStatementExpression[0]\r
2694 E:EndIf << CRT_END_OP (E); >>\r
2695 ;\r
2696\r
2697vfrStatementNoSubmitIf :\r
2698 << CIfrNoSubmitIf NSIObj; >>\r
2699 L:NoSubmitIf << NSIObj.SetLineNo(L->getLine()); >>\r
2700 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << NSIObj.SetError (_STOSID(S->getText())); >>\r
2701 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2702 vfrStatementExpression[0]\r
2703 E:EndIf << CRT_END_OP (E); >>\r
2704 ;\r
2705\r
2706vfrStatementDisableIfQuest :\r
2707 << \r
2708 CIfrDisableIf DIObj; \r
2709 >>\r
2710 L:DisableIf << DIObj.SetLineNo(L->getLine()); >>\r
2711 vfrStatementExpression[0] ";"\r
2712 vfrStatementQuestionOptionList\r
2713 E:EndIf << CRT_END_OP (E); >>\r
2714 ;\r
2715\r
2716vfrStatementRefresh :\r
2717 << CIfrRefresh RObj; >>\r
2718 L:Refresh << RObj.SetLineNo(L->getLine()); >>\r
2719 Interval "=" I:Number << RObj.SetRefreshInterval (_STOU8(I->getText())); >>\r
2720 ;\r
2721\r
2722vfrStatementRefreshEvent :\r
2723 <<\r
2724 CIfrRefreshId RiObj;\r
2725 EFI_GUID Guid;\r
2726 >>\r
2727 L:RefreshGuid << RiObj.SetLineNo(L->getLine()); >>\r
2728 "=" guidDefinition[Guid] "," << RiObj.SetRefreshEventGroutId (&Guid); >>\r
2729 ;\r
2730\r
2731vfrStatementVarstoreDevice :\r
2732 << CIfrVarStoreDevice VDObj; >>\r
2733 L:VarstoreDevice << VDObj.SetLineNo(L->getLine()); >>\r
2734 "=" "STRING_TOKEN" "\(" S:Number "\)" "," << VDObj.SetDevicePath (_STOSID(S->getText())); >>\r
2735 ;\r
2736\r
2737vfrStatementSuppressIfQuest :\r
2738 << CIfrSuppressIf SIObj; >>\r
2739 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >>\r
2740 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2741 vfrStatementExpression[0] ";"\r
2742 vfrStatementQuestionOptionList\r
2743 E:EndIf << CRT_END_OP (E); >>\r
2744 ;\r
2745\r
2746vfrStatementGrayOutIfQuest :\r
2747 << CIfrGrayOutIf GOIObj; >>\r
2748 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >>\r
2749 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2750 vfrStatementExpression[0] ";"\r
2751 vfrStatementQuestionOptionList\r
2752 E:EndIf << CRT_END_OP (E); >>\r
2753 ;\r
2754\r
2755vfrStatementOptions :\r
2756 vfrStatementOneOfOption\r
2757 ;\r
2758\r
2759vfrStatementOneOfOption :\r
2760 <<\r
2761 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;\r
2762 CIfrOneOfOption OOOObj;\r
2763 CHAR8 *VarStoreName = NULL;\r
2764 >>\r
2765 L:Option << OOOObj.SetLineNo(L->getLine()); >>\r
2766 Text "=" "STRING_TOKEN" "\(" S:Number "\)" "," << OOOObj.SetOption (_STOSID(S->getText())); >>\r
2767 Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE()] >[Val] "," \r
2768 << \r
2769 if (gCurrentMinMaxData != NULL) {\r
2770 //set min/max value for oneof opcode\r
2771 UINT64 Step = gCurrentMinMaxData->GetStepData(_GET_CURRQEST_DATATYPE());\r
2772 switch (_GET_CURRQEST_DATATYPE()) {\r
2773 case EFI_IFR_TYPE_NUM_SIZE_64:\r
2774 gCurrentMinMaxData->SetMinMaxStepData(Val.u64, Val.u64, Step);\r
2775 break;\r
2776 case EFI_IFR_TYPE_NUM_SIZE_32:\r
2777 gCurrentMinMaxData->SetMinMaxStepData(Val.u32, Val.u32, (UINT32) Step);\r
2778 break;\r
2779 case EFI_IFR_TYPE_NUM_SIZE_16:\r
2780 gCurrentMinMaxData->SetMinMaxStepData(Val.u16, Val.u16, (UINT16) Step);\r
2781 break;\r
2782 case EFI_IFR_TYPE_NUM_SIZE_8:\r
2783 gCurrentMinMaxData->SetMinMaxStepData(Val.u8, Val.u8, (UINT8) Step);\r
2784 break;\r
2785 default:\r
2786 break;\r
2787 }\r
2788 }\r
2789 OOOObj.SetType (_GET_CURRQEST_DATATYPE()); \r
2790 OOOObj.SetValue (Val); \r
2791 >>\r
2792 F:FLAGS "=" vfrOneOfOptionFlags[OOOObj, F->getLine()]\r
2793 <<\r
2794 _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), L->getLine());\r
2795 if (OOOObj.GetFlags () & 0x10) {\r
2796 _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd (\r
2797 EFI_HII_DEFAULT_CLASS_STANDARD,\r
2798 _GET_CURRQEST_VARTINFO(),\r
2799 VarStoreName,\r
2800 _GET_CURRQEST_DATATYPE (),\r
2801 Val\r
2802 ), L->getLine());\r
2803 }\r
2804 if (OOOObj.GetFlags () & 0x20) {\r
2805 _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd (\r
2806 EFI_HII_DEFAULT_CLASS_MANUFACTURING,\r
2807 _GET_CURRQEST_VARTINFO(),\r
2808 VarStoreName,\r
2809 _GET_CURRQEST_DATATYPE (),\r
2810 Val\r
2811 ), L->getLine());\r
2812 }\r
2813 >>\r
2814 {\r
2815 "," Key "=" KN:Number <<\r
2816 if (!mCompatibleMode) {\r
2817 _PCATCH (VFR_RETURN_UNSUPPORTED, KN);\r
2818 }\r
2819 //\r
2820 // Guid Option Key\r
2821 //\r
2822 CIfrOptionKey IfrOptionKey (\r
2823 gCurrentQuestion->QUESTION_ID(),\r
2824 Val,\r
2825 _STOQID(KN->getText())\r
2826 );\r
2827 SET_LINE_INFO (IfrOptionKey, KN);\r
2828 >>\r
2829 }\r
2830 (\r
2831 T:"," vfrImageTag << OOOObj.SetScope (1); CRT_END_OP (T); >>\r
2832 )*\r
2833 ";"\r
2834 ;\r
2835\r
2836vfrOneOfOptionFlags [CIfrOneOfOption & OOOObj, UINT32 LineNum] :\r
2837 <<\r
2838 UINT8 LFlags = _GET_CURRQEST_DATATYPE();\r
2839 UINT8 HFlags = 0;\r
2840 >>\r
2841 oneofoptionFlagsField[HFlags, LFlags] ( "\|" oneofoptionFlagsField[HFlags, LFlags] )*\r
2842 << _PCATCH(gCurrentQuestion->SetFlags(HFlags), LineNum); >>\r
2843 << _PCATCH(OOOObj.SetFlags(LFlags), LineNum); >>\r
2844 ;\r
2845\r
2846oneofoptionFlagsField [UINT8 & HFlags, UINT8 & LFlags] :\r
2847 N:Number << $LFlags |= _STOU8(N->getText()); >>\r
2848 | "OPTION_DEFAULT" << $LFlags |= 0x10; >>\r
2849 | "OPTION_DEFAULT_MFG" << $LFlags |= 0x20; >>\r
2850 | InteractiveFlag << $HFlags |= 0x04; >>\r
2851 | NVAccessFlag << $HFlags |= 0x08; >>\r
2852 | ResetRequiredFlag << $HFlags |= 0x10; >>\r
2853 | LateCheckFlag << $HFlags |= 0x20; >>\r
2854 | ManufacturingFlag << $LFlags |= 0x20; >>\r
2855 | DefaultFlag << $LFlags |= 0x10; >>\r
2856 ;\r
2857\r
2858vfrStatementLabel :\r
2859 L:Label\r
2860 N:Number <<\r
2861 if (mCompatibleMode) {\r
2862 //\r
2863 // Add end Label for Framework Vfr\r
2864 //\r
2865 CIfrLabel LObj1;\r
2866 LObj1.SetLineNo(L->getLine());\r
2867 LObj1.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff\r
2868 }\r
2869\r
2870 {\r
2871 CIfrLabel LObj2;\r
2872 LObj2.SetLineNo(L->getLine());\r
2873 LObj2.SetNumber (_STOU16(N->getText()));\r
2874 }\r
2875 >>\r
2876 ";"\r
2877 ;\r
2878\r
2879vfrStatementBanner :\r
2880 << CIfrBanner BObj; >>\r
2881 B:Banner { "," } << BObj.SetLineNo(B->getLine()); >>\r
2882 Title "=" "STRING_TOKEN" "\(" S:Number "\)" "," << BObj.SetTitle (_STOSID(S->getText())); >>\r
2883 (\r
2884 (\r
2885 Line L:Number "," << BObj.SetLine (_STOU16(L->getText())); >>\r
2886 Align\r
2887 (\r
2888 Left << BObj.SetAlign (0); >>\r
2889 | Center << BObj.SetAlign (1); >>\r
2890 | Right << BObj.SetAlign (2); >>\r
2891 ) ";"\r
2892 )\r
2893 |\r
2894 (\r
2895 Timeout "=" T:Number ";" << {CIfrTimeout TObj(_STOU16(T->getText()));} >>\r
2896 )\r
2897 )\r
2898 ;\r
2899\r
2900//******************************************************************************\r
2901//\r
2902// keep some syntax for compatibility but not generate any IFR object\r
2903//\r
2904vfrStatementInvalidHidden :\r
2905 L:Hidden <<\r
2906 if (!mCompatibleMode) {\r
2907 _PCATCH (VFR_RETURN_UNSUPPORTED, L);\r
2908 }\r
2909 >>\r
2910 Value "=" Number ","\r
2911 Key "=" Number ";"\r
2912 ;\r
2913\r
2914vfrStatementInvalidInconsistentIf :\r
2915 InconsistentIf\r
2916 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" ","\r
2917 { FLAGS "=" flagsField ( "\|" flagsField )* "," }\r
2918 vfrStatementExpression[0]\r
2919 EndIf\r
2920 ";"\r
2921 ;\r
2922\r
2923vfrStatementInvalidInventory :\r
2924 L:Inventory <<\r
2925 if (!mCompatibleMode) {\r
2926 _PCATCH (VFR_RETURN_UNSUPPORTED, L);\r
2927 }\r
2928 >>\r
2929 Help "=" "STRING_TOKEN" "\(" Number "\)" ","\r
2930 Text "=" "STRING_TOKEN" "\(" Number "\)" ","\r
2931 {\r
2932 Text "=" "STRING_TOKEN" "\(" Number "\)"\r
2933 }\r
2934 ";"\r
2935 ;\r
2936\r
2937vfrStatementInvalidSaveRestoreDefaults :\r
2938 (\r
2939 L:Save <<\r
2940 if (!mCompatibleMode) {\r
2941 _PCATCH (VFR_RETURN_UNSUPPORTED, L);\r
2942 }\r
2943 >>\r
2944 |\r
2945 K:Restore <<\r
2946 if (!mCompatibleMode) {\r
2947 _PCATCH (VFR_RETURN_UNSUPPORTED, K);\r
2948 }\r
2949 >>\r
2950 )\r
2951 Defaults ","\r
2952 FormId "=" Number ","\r
2953 Prompt "=" "STRING_TOKEN" "\(" Number "\)" ","\r
2954 Help "=" "STRING_TOKEN" "\(" Number "\)"\r
2955 { "," FLAGS "=" flagsField ( "\|" flagsField )* }\r
2956 { "," Key "=" Number }\r
2957 ";"\r
2958 ;\r
2959\r
2960//******************************************************************************\r
2961//\r
2962// The syntax of expression\r
2963//\r
2964#token Dup("dup") "dup"\r
2965#token VarEqVal("vareqval") "vareqval"\r
2966#token Var("var") "var"\r
2967#token IdEqVal("ideqval") "ideqval"\r
2968#token IdEqId("ideqid") "ideqid"\r
2969#token IdEqValList("ideqvallist") "ideqvallist"\r
2970#token QuestionRef("questionref") "questionref"\r
2971#token RuleRef("ruleref") "ruleref"\r
2972#token StringRef("stringref") "stringref"\r
2973#token PushThis("pushthis") "pushthis"\r
2974#token Security("security") "security"\r
2975#token Get("get") "get"\r
2976#token True("TRUE") "TRUE"\r
2977#token False("FALSE") "FALSE"\r
2978#token One("ONE") "ONE"\r
2979#token Ones("ONES") "ONES"\r
2980#token Zero("ZERO") "ZERO"\r
2981#token Undefined("UNDEFINED") "UNDEFINED"\r
2982#token Version("VERSION") "VERSION"\r
2983#token Length("length") "length"\r
2984#token AND("AND") "AND"\r
2985#token OR("OR") "OR"\r
2986#token NOT("NOT") "NOT"\r
2987#token Set("set") "set"\r
2988#token BitWiseNot("~") "\~"\r
2989#token BoolVal("boolval") "boolval"\r
2990#token StringVal("stringval") "stringval"\r
2991#token UnIntVal("unintval") "unintval"\r
2992#token ToUpper("toupper") "toupper"\r
2993#token ToLower("tolower") "tolower"\r
2994#token Match("match") "match"\r
2995#token Catenate("catenate") "catenate"\r
2996#token QuestionRefVal("questionrefval") "questionrefval"\r
2997#token StringRefVal("stringrefval") "stringrefval"\r
2998#token Map("map") "map"\r
2999#token RefreshGuid("refreshguid") "refreshguid"\r
3000\r
3001//\r
3002// Root expression extension function called by other function.\r
3003//\r
3004vfrStatementExpression [UINT32 RootLevel, UINT32 ExpOpCount = 0] :\r
3005 << 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
3006 andTerm[$RootLevel, $ExpOpCount]\r
3007 (\r
3008 L:OR andTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrOr OObj(L->getLine()); >>\r
3009 )*\r
3010 <<\r
3011 //\r
3012 // Extend OpCode Scope only for the root expression.\r
3013 //\r
3014 if ($ExpOpCount > 1 && $RootLevel == 0) {\r
3015 if (_SET_SAVED_OPHDR_SCOPE()) {\r
3016 CIfrEnd EObj;\r
3017 if (mCIfrOpHdrLineNo[mCIfrOpHdrIndex] != 0) {\r
3018 EObj.SetLineNo (mCIfrOpHdrLineNo[mCIfrOpHdrIndex]);\r
3019 }\r
3020 }\r
3021 }\r
3022 \r
3023 if ($RootLevel == 0) {\r
3024 mCIfrOpHdrIndex --;\r
3025 }\r
3026 >>\r
3027 ;\r
3028\r
3029//\r
3030// Add new sub function for the sub expression extension to remember the ExpOpCount\r
3031// This funciton is only called by sub expression.\r
3032//\r
3033vfrStatementExpressionSub [UINT32 RootLevel, UINT32 & ExpOpCount] :\r
3034 andTerm[$RootLevel, $ExpOpCount]\r
3035 (\r
3036 L:OR andTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrOr OObj(L->getLine()); >>\r
3037 )*\r
3038 ;\r
3039\r
3040andTerm[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3041 bitwiseorTerm[$RootLevel, $ExpOpCount]\r
3042 (\r
3043 L:AND bitwiseorTerm [$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrAnd AObj(L->getLine()); >>\r
3044 )*\r
3045 ;\r
3046\r
3047bitwiseorTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3048 bitwiseandTerm[$RootLevel, $ExpOpCount]\r
3049 (\r
3050 L:"\|" bitwiseandTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrBitWiseOr BWOObj(L->getLine()); >>\r
3051 )*\r
3052 ;\r
3053\r
3054bitwiseandTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3055 equalTerm[$RootLevel, $ExpOpCount]\r
3056 (\r
3057 L:"&" equalTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrBitWiseAnd BWAObj(L->getLine()); >>\r
3058 )*\r
3059 ;\r
3060\r
3061equalTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3062 compareTerm[$RootLevel, $ExpOpCount]\r
3063 (\r
3064 (\r
3065 L1:"==" compareTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrEqual EObj(L1->getLine()); >>\r
3066 )\r
3067 |\r
3068 (\r
3069 L2:"!=" compareTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrNotEqual NEObj(L2->getLine()); >>\r
3070 )\r
3071 )*\r
3072 ;\r
3073\r
3074compareTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3075 shiftTerm[$RootLevel, $ExpOpCount]\r
3076 (\r
3077 (\r
3078 L1:"<" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrLessThan LTObj(L1->getLine()); >>\r
3079 )\r
3080 |\r
3081 (\r
3082 L2:"<=" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrLessEqual LEObj(L2->getLine()); >>\r
3083 )\r
3084 |\r
3085 (\r
3086 L3:">" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrGreaterThan GTObj(L3->getLine()); >>\r
3087 )\r
3088 |\r
3089 (\r
3090 L4:">=" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrGreaterEqual GEObj(L4->getLine()); >>\r
3091 )\r
3092 )*\r
3093 ;\r
3094\r
3095shiftTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3096 addMinusTerm[$RootLevel, $ExpOpCount]\r
3097 (\r
3098 (\r
3099 L1:"\<<" addMinusTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrShiftLeft SLObj(L1->getLine()); >>\r
3100 )\r
3101 |\r
3102 (\r
3103 L2:"\>>" addMinusTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrShiftRight SRObj(L2->getLine()); >>\r
3104 )\r
3105 )*\r
3106 ;\r
3107\r
3108addMinusTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3109 multdivmodTerm[$RootLevel, $ExpOpCount]\r
3110 (\r
3111 (\r
3112 L1:"\+" multdivmodTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrAdd AObj(L1->getLine()); >>\r
3113 )\r
3114 |\r
3115 (\r
3116 L2:"\-" multdivmodTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrSubtract SObj(L2->getLine()); >>\r
3117 )\r
3118 )*\r
3119 ;\r
3120\r
3121multdivmodTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3122 castTerm[$RootLevel, $ExpOpCount]\r
3123 (\r
3124 (\r
3125 L1:"\*" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrMultiply MObj(L1->getLine()); >>\r
3126 )\r
3127 |\r
3128 (\r
3129 L2:"/" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrDivide DObj(L2->getLine()); >>\r
3130 )\r
3131 |\r
3132 (\r
3133 L3:"%" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrModulo MObj(L3->getLine()); >>\r
3134 )\r
3135 )*\r
3136 ;\r
3137\r
3138castTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3139 << UINT8 CastType = 0xFF; >>\r
3140 (\r
3141 L:"\("\r
3142 (\r
3143 Boolean << CastType = 0; >>\r
3144 | Uint64 << CastType = 1; >>\r
3145 | Uint32 << CastType = 1; >>\r
3146 | Uint16 << CastType = 1; >>\r
3147 | Uint8 << CastType = 1; >>\r
3148 )\r
3149 "\)"\r
3150 )*\r
3151 atomTerm[$RootLevel, $ExpOpCount]\r
3152 <<\r
3153 switch (CastType) {\r
3154 case 0: { CIfrToBoolean TBObj(L->getLine()); $ExpOpCount++; } break;\r
3155 case 1: { CIfrToUint TUObj(L->getLine()); $ExpOpCount++; } break;\r
3156 }\r
3157 >>\r
3158 ;\r
3159\r
3160atomTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3161 vfrExpressionCatenate[$RootLevel, $ExpOpCount]\r
3162 | vfrExpressionMatch[$RootLevel, $ExpOpCount]\r
3163 | vfrExpressionParen[$RootLevel, $ExpOpCount]\r
3164 | vfrExpressionBuildInFunction[$RootLevel, $ExpOpCount]\r
3165 | vfrExpressionConstant[$RootLevel, $ExpOpCount]\r
3166 | vfrExpressionUnaryOp[$RootLevel, $ExpOpCount]\r
3167 | vfrExpressionTernaryOp[$RootLevel, $ExpOpCount]\r
3168 | vfrExpressionMap[$RootLevel, $ExpOpCount]\r
3169 | (\r
3170 L:NOT\r
3171 atomTerm[$RootLevel, $ExpOpCount] << { CIfrNot NObj(L->getLine()); $ExpOpCount++; } >>\r
3172 )\r
3173 ;\r
3174\r
3175vfrExpressionCatenate [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3176 L:Catenate\r
3177 "\("\r
3178 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3179 ","\r
3180 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3181 "\)" << { CIfrCatenate CObj(L->getLine()); $ExpOpCount++; } >>\r
3182 ;\r
3183\r
3184vfrExpressionMatch [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3185 L:Match\r
3186 "\("\r
3187 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3188 ","\r
3189 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3190 "\)" << { CIfrMatch MObj(L->getLine()); $ExpOpCount++; } >>\r
3191 ;\r
3192\r
3193vfrExpressionParen [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3194 "\("\r
3195 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3196 "\)"\r
3197 ;\r
3198\r
3199vfrExpressionBuildInFunction [UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3200 dupExp[$RootLevel, $ExpOpCount]\r
3201 | vareqvalExp[$RootLevel, $ExpOpCount] //Compatible for Framework vareqval\r
3202 | ideqvalExp[$RootLevel, $ExpOpCount]\r
3203 | ideqidExp[$RootLevel, $ExpOpCount]\r
3204 | ideqvallistExp[$RootLevel, $ExpOpCount]\r
3205 | questionref13Exp[$RootLevel, $ExpOpCount]\r
3206 | rulerefExp[$RootLevel, $ExpOpCount]\r
3207 | stringref1Exp[$RootLevel, $ExpOpCount]\r
3208 | pushthisExp[$RootLevel, $ExpOpCount]\r
3209 | securityExp[$RootLevel, $ExpOpCount]\r
3210 | getExp[$RootLevel, $ExpOpCount]\r
3211 ;\r
3212\r
3213dupExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3214 L:Dup << { CIfrDup DObj(L->getLine()); _SAVE_OPHDR_COND(DObj, ($ExpOpCount == 0), L->getLine()); $ExpOpCount++; } >>\r
3215 ;\r
3216\r
3217vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3218 <<\r
3219 EFI_QUESTION_ID QId;\r
3220 UINT32 Mask;\r
3221 UINT16 ConstVal;\r
3222 CHAR8 *VarIdStr;\r
3223 UINT32 LineNo;\r
3224 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;\r
3225 EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS;\r
3226 >>\r
3227 L:VarEqVal <<\r
3228 if (!mCompatibleMode) {\r
3229 _PCATCH (VFR_RETURN_UNSUPPORTED, L);\r
3230 }\r
3231 >>\r
3232 VK:Var\r
3233 OpenParen\r
3234 VN:Number <<\r
3235 VarIdStr = NULL; _STRCAT(&VarIdStr, VK->getText()); _STRCAT(&VarIdStr, VN->getText());\r
3236 VfrReturnCode = mCVfrDataStorage.GetVarStoreType (VarIdStr, VarStoreType);\r
3237 if (VfrReturnCode == VFR_RETURN_UNDEFINED) {\r
3238 _PCATCH (mCVfrDataStorage.DeclareEfiVarStore (\r
3239 VarIdStr,\r
3240 &mFormsetGuid,\r
3241 _STOSID(VN->getText()),\r
3242 0x2, //default type is UINT16\r
3243 FALSE\r
3244 ), VN);\r
3245 } else {\r
3246 _PCATCH (VfrReturnCode, VN);\r
3247 }\r
3248 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask);\r
3249 LineNo = GET_LINENO(VN);\r
3250 >>\r
3251 CloseParen\r
3252 (\r
3253 (\r
3254 "=="\r
3255 V1:Number << ConstVal = _STOU16(V1->getText()); >>\r
3256 <<\r
3257 if (Mask == 0) {\r
3258 CIfrEqIdVal EIVObj (L->getLine());\r
3259 _SAVE_OPHDR_COND (EIVObj, ($ExpOpCount == 0), L->getLine());\r
3260 EIVObj.SetQuestionId (QId, VarIdStr, LineNo);\r
3261 EIVObj.SetValue (ConstVal);\r
3262 $ExpOpCount++;\r
3263 } else {\r
3264 IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, EQUAL);\r
3265 }\r
3266 >>\r
3267 )\r
3268 |\r
3269 (\r
3270 "<="\r
3271 V2:Number << ConstVal = _STOU16(V2->getText()); >>\r
3272 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_EQUAL); >>\r
3273 )\r
3274 |\r
3275 (\r
3276 "<"\r
3277 V3:Number << ConstVal = _STOU16(V3->getText()); >>\r
3278 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_THAN); >>\r
3279 )\r
3280 |\r
3281 (\r
3282 ">="\r
3283 V4:Number << ConstVal = _STOU16(V4->getText()); >>\r
3284 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_EQUAL); >>\r
3285 )\r
3286 |\r
3287 (\r
3288 ">"\r
3289 V5:Number << ConstVal = _STOU16(V5->getText()); >>\r
3290 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_THAN); >>\r
3291 )\r
3292 )\r
3293 ;\r
3294\r
3295ideqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3296 <<\r
3297 EFI_QUESTION_ID QId;\r
3298 UINT32 Mask;\r
3299 UINT16 ConstVal;\r
3300 CHAR8 *VarIdStr;\r
3301 UINT32 LineNo;\r
3302 >>\r
3303 L:IdEqVal\r
3304 vfrQuestionDataFieldName[QId, Mask, VarIdStr, LineNo]\r
3305 (\r
3306 (\r
3307 "=="\r
3308 V1:Number << ConstVal = _STOU16(V1->getText()); >>\r
3309 <<\r
3310 if (Mask == 0) {\r
3311 CIfrEqIdVal EIVObj (L->getLine());\r
3312 _SAVE_OPHDR_COND (EIVObj, ($ExpOpCount == 0), L->getLine());\r
3313 EIVObj.SetQuestionId (QId, VarIdStr, LineNo);\r
3314 EIVObj.SetValue (ConstVal);\r
3315 $ExpOpCount++;\r
3316 } else {\r
3317 IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, EQUAL);\r
3318 }\r
3319 >>\r
3320 )\r
3321 |\r
3322 (\r
3323 "<="\r
3324 V2:Number << ConstVal = _STOU16(V2->getText()); >>\r
3325 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_EQUAL); >>\r
3326 )\r
3327 |\r
3328 (\r
3329 "<"\r
3330 V3:Number << ConstVal = _STOU16(V3->getText()); >>\r
3331 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_THAN); >>\r
3332 )\r
3333 |\r
3334 (\r
3335 ">="\r
3336 V4:Number << ConstVal = _STOU16(V4->getText()); >>\r
3337 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_EQUAL); >>\r
3338 )\r
3339 |\r
3340 (\r
3341 ">"\r
3342 V5:Number << ConstVal = _STOU16(V5->getText()); >>\r
3343 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_THAN); >>\r
3344 )\r
3345 )\r
3346 ;\r
3347\r
3348ideqidExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3349 <<\r
3350 EFI_QUESTION_ID QId[2];\r
3351 UINT32 Mask[2];\r
3352 CHAR8 *VarIdStr[2];\r
3353 UINT32 LineNo[2];\r
3354 >>\r
3355 L:IdEqId\r
3356 vfrQuestionDataFieldName[QId[0], Mask[0], VarIdStr[0], LineNo[0]]\r
3357 (\r
3358 (\r
3359 "=="\r
3360 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]\r
3361 <<\r
3362 if (Mask[0] & Mask[1]) {\r
3363 IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], EQUAL);\r
3364 } else {\r
3365 CIfrEqIdId EIIObj(L->getLine());\r
3366 _SAVE_OPHDR_COND (EIIObj, ($ExpOpCount == 0), L->getLine());\r
3367 EIIObj.SetQuestionId1 (QId[0], VarIdStr[0], LineNo[0]);\r
3368 EIIObj.SetQuestionId2 (QId[1], VarIdStr[1], LineNo[1]);\r
3369 $ExpOpCount++;\r
3370 }\r
3371 >>\r
3372 )\r
3373 |\r
3374 (\r
3375 "<="\r
3376 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]\r
3377 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], LESS_EQUAL); >>\r
3378 )\r
3379 |\r
3380 (\r
3381 "<"\r
3382 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]\r
3383 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], LESS_THAN); >>\r
3384 )\r
3385 |\r
3386 (\r
3387 ">="\r
3388 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]\r
3389 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], GREATER_EQUAL); >>\r
3390 )\r
3391 |\r
3392 (\r
3393 ">"\r
3394 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]]\r
3395 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], GREATER_THAN); >>\r
3396 )\r
3397 )\r
3398 ;\r
3399\r
3400ideqvallistExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3401 <<\r
3402 UINT16 ListLen = 0;\r
3403 EFI_QUESTION_ID QId;\r
3404 UINT32 Mask;\r
3405 UINT16 ValueList[EFI_IFR_MAX_LENGTH] = {0,};\r
3406 CHAR8 *VarIdStr;\r
3407 UINT32 LineNo;\r
3408 >>\r
3409 L:IdEqValList\r
3410 vfrQuestionDataFieldName[QId, Mask, VarIdStr, LineNo]\r
3411 "=="\r
3412 (\r
3413 V:Number << ValueList[ListLen] = _STOU16(V->getText()); ListLen++; >>\r
3414 )+\r
3415 <<\r
3416 if (Mask != 0) {\r
3417 IdEqListDoSpecial ($ExpOpCount, LineNo, QId, VarIdStr, Mask, ListLen, ValueList);\r
3418 } else {\r
3419 UINT16 Index;\r
3420 CIfrEqIdList EILObj(L->getLine());\r
3421 if (QId != EFI_QUESTION_ID_INVALID) {\r
3422 EILObj.SetQuestionId (QId, VarIdStr, LineNo);\r
3423 }\r
3424 EILObj.SetListLength (ListLen);\r
3425 for (Index = 0; Index < ListLen; Index++) {\r
3426 EILObj.SetValueList (Index, ValueList[Index]);\r
3427 }\r
3428 \r
3429 EILObj.UpdateIfrBuffer();\r
3430 _SAVE_OPHDR_COND (EILObj, ($ExpOpCount == 0), L->getLine()); \r
3431 \r
3432 if (QId == EFI_QUESTION_ID_INVALID) {\r
3433 EILObj.SetQuestionId (QId, VarIdStr, LineNo);\r
3434 }\r
3435 $ExpOpCount++;\r
3436 }\r
3437 >>\r
3438 ;\r
3439\r
3440questionref13Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3441 <<\r
3442 UINT8 Type = 0x1;\r
3443 EFI_STRING_ID DevPath = EFI_STRING_ID_INVALID;\r
3444 EFI_GUID Guid = {0,};\r
3445 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;\r
3446 UINT32 BitMask;\r
3447 CHAR8 *QName = NULL;\r
3448 UINT32 LineNo = 0;\r
3449 >>\r
3450 L:QuestionRef\r
3451 (\r
3452 (\r
3453 << Type = 0x3; >>\r
3454 {\r
3455 Path "=" "STRING_TOKEN" "\(" S:Number "\)" << Type = 0x4; DevPath = _STOSID(S->getText()); >>\r
3456 }\r
3457 {\r
3458 Uuid "=" guidDefinition[Guid] << Type = 0x5; >>\r
3459 }\r
3460 )\r
3461 |\r
3462 (\r
3463 "\("\r
3464 (\r
3465 QN:StringIdentifier <<\r
3466 QName = QN->getText();\r
3467 LineNo = QN->getLine();\r
3468 mCVfrQuestionDB.GetQuestionId (QN->getText(), NULL, QId, BitMask);\r
3469 >>\r
3470 | ID:Number << QId = _STOQID(ID->getText()); >>\r
3471 )\r
3472 "\)"\r
3473 )\r
3474 )\r
3475 <<\r
3476 switch (Type) {\r
3477 case 0x1: {CIfrQuestionRef1 QR1Obj(L->getLine()); _SAVE_OPHDR_COND (QR1Obj, ($ExpOpCount == 0), L->getLine()); QR1Obj.SetQuestionId (QId, QName, LineNo); break;}\r
3478 case 0x3: {CIfrQuestionRef3 QR3Obj(L->getLine()); _SAVE_OPHDR_COND (QR3Obj, ($ExpOpCount == 0), L->getLine()); break;}\r
3479 case 0x4: {CIfrQuestionRef3_2 QR3_2Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_2Obj, ($ExpOpCount == 0), L->getLine()); QR3_2Obj.SetDevicePath (DevPath); break;}\r
3480 case 0x5: {CIfrQuestionRef3_3 QR3_3Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_3Obj, ($ExpOpCount == 0), L->getLine()); QR3_3Obj.SetDevicePath (DevPath); QR3_3Obj.SetGuid (&Guid); break;}\r
3481 }\r
3482 $ExpOpCount++;\r
3483 >>\r
3484 ;\r
3485\r
3486rulerefExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3487 L:RuleRef\r
3488 "\(" RN:StringIdentifier "\)" << { CIfrRuleRef RRObj(L->getLine()); _SAVE_OPHDR_COND (RRObj, ($ExpOpCount == 0), L->getLine()); RRObj.SetRuleId (mCVfrRulesDB.GetRuleId (RN->getText())); } $ExpOpCount++; >>\r
3489 ;\r
3490\r
3491//******************************************************\r
3492// PARSE:\r
3493// stringref (STR_FORM_SET_TITLE)\r
3494//\r
3495stringref1Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3496 <<\r
3497 EFI_STRING_ID RefStringId = EFI_STRING_ID_INVALID;\r
3498 >>\r
3499 L:StringRef\r
3500 "\("\r
3501 ( \r
3502 "STRING_TOKEN"\r
3503 "\(" \r
3504 S:Number << RefStringId = _STOSID(S->getText()); >>\r
3505 "\)"\r
3506 | I:Number << RefStringId = _STOSID(I->getText()); >>\r
3507 )\r
3508 "\)" << { CIfrStringRef1 SR1Obj(L->getLine()); _SAVE_OPHDR_COND (SR1Obj, ($ExpOpCount == 0), L->getLine()); SR1Obj.SetStringId (RefStringId); $ExpOpCount++; } >>\r
3509 ;\r
3510\r
3511pushthisExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3512 L:PushThis << { CIfrThis TObj(L->getLine()); _SAVE_OPHDR_COND (TObj, ($ExpOpCount == 0), L->getLine()); $ExpOpCount++; } >>\r
3513 ;\r
3514\r
3515securityExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3516 <<\r
3517 EFI_GUID Guid;\r
3518 >>\r
3519 L:Security\r
3520 "\(" guidDefinition[Guid] "\)" << { CIfrSecurity SObj(L->getLine()); _SAVE_OPHDR_COND (SObj, ($ExpOpCount == 0), L->getLine()); SObj.SetPermissions (&Guid); } $ExpOpCount++; >>\r
3521 ;\r
3522\r
3523numericVarStoreType [UINT8 & VarType] :\r
3524 "NUMERIC_SIZE_1" << $VarType = EFI_IFR_NUMERIC_SIZE_1; >>\r
3525 | "NUMERIC_SIZE_2" << $VarType = EFI_IFR_NUMERIC_SIZE_2; >>\r
3526 | "NUMERIC_SIZE_4" << $VarType = EFI_IFR_NUMERIC_SIZE_4; >>\r
3527 | "NUMERIC_SIZE_8" << $VarType = EFI_IFR_NUMERIC_SIZE_8; >>\r
3528 ;\r
3529\r
3530getExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3531 <<\r
3532 EFI_VARSTORE_INFO Info;\r
3533 CHAR8 *VarIdStr = NULL;\r
3534 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;\r
3535 UINT32 Mask = 0;\r
3536 EFI_QUESION_TYPE QType = QUESTION_NORMAL;\r
3537 UINT8 VarType = EFI_IFR_TYPE_UNDEFINED;\r
3538 UINT32 VarSize = 0;\r
3539 Info.mVarStoreId = 0;\r
3540 >>\r
3541 L:Get\r
3542 "\(" \r
3543 vfrStorageVarId[Info, VarIdStr, FALSE]\r
3544 {"\|" FLAGS "=" numericVarStoreType [VarType] }\r
3545 "\)" << \r
3546 {\r
3547 if (Info.mVarStoreId == 0) {\r
3548 // support Date/Time question\r
3549 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask, &QType);\r
3550 if (QId == EFI_QUESTION_ID_INVALID || Mask == 0 || QType == QUESTION_NORMAL) {\r
3551 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");\r
3552 }\r
3553 if (QType == QUESTION_DATE) {\r
3554 Info.mVarType = EFI_IFR_TYPE_DATE;\r
3555 } else if (QType == QUESTION_TIME) {\r
3556 Info.mVarType = EFI_IFR_TYPE_TIME;\r
3557 }\r
3558 switch (Mask) {\r
3559 case DATE_YEAR_BITMASK:\r
3560 Info.mInfo.mVarOffset = 0;\r
3561 break;\r
3562 case DATE_DAY_BITMASK:\r
3563 Info.mInfo.mVarOffset = 3;\r
3564 break;\r
3565 case TIME_HOUR_BITMASK:\r
3566 Info.mInfo.mVarOffset = 0;\r
3567 break;\r
3568 case TIME_MINUTE_BITMASK:\r
3569 Info.mInfo.mVarOffset = 1;\r
3570 break;\r
3571 case TIME_SECOND_BITMASK:\r
3572 Info.mInfo.mVarOffset = 2;\r
3573 break;\r
3574 default:\r
3575 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");\r
3576 break;\r
3577 }\r
3578 } else {\r
3579 if ((mCVfrDataStorage.GetVarStoreType(Info.mVarStoreId) == EFI_VFR_VARSTORE_NAME) && (VarType == EFI_IFR_TYPE_UNDEFINED)) {\r
3580 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support name string");\r
3581 }\r
3582 if (VarType != EFI_IFR_TYPE_UNDEFINED) {\r
3583 Info.mVarType = VarType;\r
3584 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");\r
3585 Info.mVarTotalSize = VarSize;\r
3586 }\r
3587 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");\r
3588 if (VarSize != Info.mVarTotalSize) {\r
3589 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support data array");\r
3590 }\r
3591 }\r
3592 CIfrGet GObj(L->getLine()); \r
3593 _SAVE_OPHDR_COND (GObj, ($ExpOpCount == 0), L->getLine()); \r
3594 GObj.SetVarInfo (&Info); \r
3595 delete VarIdStr; \r
3596 $ExpOpCount++;\r
3597 }\r
3598 >>\r
3599 ;\r
3600\r
3601vfrExpressionConstant[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3602 L1:True << CIfrTrue TObj(L1->getLine()); _SAVE_OPHDR_COND (TObj, ($ExpOpCount == 0), L1->getLine()); $ExpOpCount++; >>\r
3603 | L2:False << CIfrFalse FObj(L2->getLine()); _SAVE_OPHDR_COND (FObj, ($ExpOpCount == 0), L2->getLine()); $ExpOpCount++; >>\r
3604 | L3:One << CIfrOne OObj(L3->getLine()); _SAVE_OPHDR_COND (OObj, ($ExpOpCount == 0), L3->getLine()); $ExpOpCount++; >>\r
3605 | L4:Ones << CIfrOnes OObj(L4->getLine()); _SAVE_OPHDR_COND (OObj, ($ExpOpCount == 0), L4->getLine()); $ExpOpCount++; >>\r
3606 | L5:Zero << CIfrZero ZObj(L5->getLine()); _SAVE_OPHDR_COND (ZObj, ($ExpOpCount == 0), L5->getLine()); $ExpOpCount++; >>\r
3607 | L6:Undefined << CIfrUndefined UObj(L6->getLine()); _SAVE_OPHDR_COND (UObj, ($ExpOpCount == 0), L6->getLine()); $ExpOpCount++; >>\r
3608 | L7:Version << CIfrVersion VObj(L7->getLine()); _SAVE_OPHDR_COND (VObj, ($ExpOpCount == 0), L7->getLine()); $ExpOpCount++; >>\r
3609 | V:Number << CIfrUint64 U64Obj(V->getLine()); U64Obj.SetValue (_STOU64(V->getText())); _SAVE_OPHDR_COND (U64Obj, ($ExpOpCount == 0), V->getLine()); $ExpOpCount++; >>\r
3610 ;\r
3611\r
3612vfrExpressionUnaryOp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3613 lengthExp[$RootLevel, $ExpOpCount]\r
3614 | bitwisenotExp[$RootLevel, $ExpOpCount]\r
3615 | question2refExp[$RootLevel, $ExpOpCount]\r
3616 | stringref2Exp[$RootLevel, $ExpOpCount]\r
3617 | toboolExp[$RootLevel, $ExpOpCount]\r
3618 | unintExp[$RootLevel, $ExpOpCount]\r
3619 | toupperExp[$RootLevel, $ExpOpCount]\r
3620 | tolwerExp[$RootLevel, $ExpOpCount]\r
3621 | setExp[$RootLevel, $ExpOpCount]\r
3622 ;\r
3623\r
3624lengthExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3625 L:Length\r
3626 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3627 << { CIfrLength LObj(L->getLine()); $ExpOpCount++; } >>\r
3628 ;\r
3629\r
3630bitwisenotExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3631 L:BitWiseNot\r
3632 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3633 << { CIfrBitWiseNot BWNObj(L->getLine()); $ExpOpCount++; } >>\r
3634 ;\r
3635\r
3636question2refExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3637 L:QuestionRefVal\r
3638 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3639 << { CIfrQuestionRef2 QR2Obj(L->getLine()); $ExpOpCount++; } >>\r
3640 ;\r
3641\r
3642stringref2Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3643 L:StringRefVal\r
3644 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3645 << { CIfrStringRef2 SR2Obj(L->getLine()); $ExpOpCount++; } >>\r
3646 ;\r
3647\r
3648toboolExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3649 L:BoolVal\r
3650 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3651 << { CIfrToBoolean TBObj(L->getLine()); $ExpOpCount++; } >>\r
3652 ;\r
3653\r
3654tostringExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3655 << UINT8 Fmt = 0; >>\r
3656 L:StringVal\r
3657 {\r
3658 Format "=" F:Number "," << Fmt = _STOU8(F->getText()); >>\r
3659 }\r
3660 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3661 << { CIfrToString TSObj(L->getLine()); TSObj.SetFormat (Fmt); $ExpOpCount++; } >>\r
3662 ;\r
3663\r
3664unintExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3665 L:UnIntVal\r
3666 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3667 << { CIfrToUint TUObj(L->getLine()); $ExpOpCount++; } >>\r
3668 ;\r
3669\r
3670toupperExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3671 L:ToUpper\r
3672 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3673 << { CIfrToUpper TUObj(L->getLine()); $ExpOpCount++; } >>\r
3674 ;\r
3675\r
3676tolwerExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3677 L:ToLower\r
3678 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"\r
3679 << { CIfrToLower TLObj(L->getLine()); $ExpOpCount++; } >>\r
3680 ;\r
3681\r
3682setExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3683 <<\r
3684 EFI_VARSTORE_INFO Info;\r
3685 CHAR8 *VarIdStr = NULL;\r
3686 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;\r
3687 UINT32 Mask = 0;\r
3688 EFI_QUESION_TYPE QType = QUESTION_NORMAL;\r
3689 UINT8 VarType = EFI_IFR_TYPE_UNDEFINED;\r
3690 UINT32 VarSize = 0;\r
3691 Info.mVarStoreId = 0;\r
3692 >>\r
3693 L:Set\r
3694 "\("\r
3695 vfrStorageVarId[Info, VarIdStr, FALSE]\r
3696 {"\|" FLAG "=" numericVarStoreType [VarType] }\r
3697 "," vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] \r
3698 "\)"\r
3699 << \r
3700 {\r
3701 if (Info.mVarStoreId == 0) {\r
3702 // support Date/Time question\r
3703 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask, &QType);\r
3704 if (QId == EFI_QUESTION_ID_INVALID || Mask == 0 || QType == QUESTION_NORMAL) {\r
3705 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");\r
3706 }\r
3707 if (QType == QUESTION_DATE) {\r
3708 Info.mVarType = EFI_IFR_TYPE_DATE;\r
3709 } else if (QType == QUESTION_TIME) {\r
3710 Info.mVarType = EFI_IFR_TYPE_TIME;\r
3711 }\r
3712 switch (Mask) {\r
3713 case DATE_YEAR_BITMASK:\r
3714 Info.mInfo.mVarOffset = 0;\r
3715 break;\r
3716 case DATE_DAY_BITMASK:\r
3717 Info.mInfo.mVarOffset = 3;\r
3718 break;\r
3719 case TIME_HOUR_BITMASK:\r
3720 Info.mInfo.mVarOffset = 0;\r
3721 break;\r
3722 case TIME_MINUTE_BITMASK:\r
3723 Info.mInfo.mVarOffset = 1;\r
3724 break;\r
3725 case TIME_SECOND_BITMASK:\r
3726 Info.mInfo.mVarOffset = 2;\r
3727 break;\r
3728 default:\r
3729 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");\r
3730 break;\r
3731 }\r
3732 } else {\r
3733 if ((mCVfrDataStorage.GetVarStoreType(Info.mVarStoreId) == EFI_VFR_VARSTORE_NAME) && (VarType == EFI_IFR_TYPE_UNDEFINED)) {\r
3734 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support name string");\r
3735 }\r
3736 if (VarType != EFI_IFR_TYPE_UNDEFINED) {\r
3737 Info.mVarType = VarType;\r
3738 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");\r
3739 Info.mVarTotalSize = VarSize;\r
3740 }\r
3741 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");\r
3742 if (VarSize != Info.mVarTotalSize) {\r
3743 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support data array");\r
3744 }\r
3745 }\r
3746 CIfrSet TSObj(L->getLine()); \r
3747 TSObj.SetVarInfo (&Info); \r
3748 delete VarIdStr; \r
3749 $ExpOpCount++;\r
3750 }\r
3751 >>\r
3752 ;\r
3753\r
3754vfrExpressionTernaryOp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3755 conditionalExp[$RootLevel, $ExpOpCount]\r
3756 | findExp[$RootLevel, $ExpOpCount]\r
3757 | midExp[$RootLevel, $ExpOpCount]\r
3758 | tokenExp[$RootLevel, $ExpOpCount]\r
3759 | spanExp[$RootLevel, $ExpOpCount]\r
3760 ;\r
3761\r
3762#token Cond("cond") "cond"\r
3763#token Find("find") "find"\r
3764#token Mid("mid") "mid"\r
3765#token Tok("token") "token"\r
3766#token Span("span") "span"\r
3767\r
3768conditionalExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3769 L:Cond "\("\r
3770 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3771 "?"\r
3772 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3773 ":"\r
3774 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3775 "\)" << { CIfrConditional CObj(L->getLine()); $ExpOpCount++; } >>\r
3776 ;\r
3777\r
3778findExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3779 << UINT8 Format; >>\r
3780 L:Find "\("\r
3781 findFormat[Format] ( "\|" findFormat[Format] )*\r
3782 ","\r
3783 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3784 ","\r
3785 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3786 ","\r
3787 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3788 "\)" << { CIfrFind FObj(L->getLine()); FObj.SetFormat (Format); $ExpOpCount++; } >>\r
3789 ;\r
3790\r
3791findFormat [UINT8 & Format] :\r
3792 "SENSITIVE" << $Format = 0x00; >>\r
3793 | "INSENSITIVE" << $Format = 0x01; >>\r
3794 ;\r
3795\r
3796midExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3797 L:Mid "\("\r
3798 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3799 ","\r
3800 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3801 ","\r
3802 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3803 "\)" << { CIfrMid MObj(L->getLine()); $ExpOpCount++; } >>\r
3804 ;\r
3805\r
3806tokenExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3807 L:Tok "\("\r
3808 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3809 ","\r
3810 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3811 ","\r
3812 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3813 "\)" << { CIfrToken TObj(L->getLine()); $ExpOpCount++; } >>\r
3814 ;\r
3815\r
3816spanExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :\r
3817 << UINT8 Flags = 0; >>\r
3818 S:Span "\("\r
3819 FLAGS "=" spanFlags[Flags] ( "\|" spanFlags[Flags] )*\r
3820 ","\r
3821 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3822 ","\r
3823 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3824 ","\r
3825 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]\r
3826 "\)" << { CIfrSpan SObj(S->getLine()); SObj.SetFlags(Flags); $ExpOpCount++; } >>\r
3827 ;\r
3828\r
3829vfrExpressionMap [UINT32 & RootLevel, UINT32 & ExpOpCount]:\r
3830 L:Map \r
3831 "\(" \r
3832 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] \r
3833 ":" << { CIfrMap MObj(L->getLine()); } >>\r
3834 (\r
3835 vfrStatementExpression[0]\r
3836 ","\r
3837 vfrStatementExpression[0]\r
3838 ";"\r
3839 ) *\r
3840 E:"\)" << { CIfrEnd EObj; EObj.SetLineNo(E->getLine()); $ExpOpCount++; } >>\r
3841 ;\r
3842\r
3843spanFlags [UINT8 & Flags] :\r
3844 N:Number << $Flags |= _STOU8(N->getText()); >>\r
3845 | "LAST_NON_MATCH" << $Flags |= 0x00; >>\r
3846 | "FIRST_NON_MATCH" << $Flags |= 0x01; >>\r
3847 ;\r
3848\r
3849#token StringIdentifier("string identifier") "[A-Za-z_][A-Za-z_0-9]*"\r
3850#token Number("numeric value") "(0x[0-9A-Fa-f]+) | [0-9]+"\r
3851\r
3852//******************************************************************************\r
3853//\r
3854// Parser class definition.\r
3855//\r
3856class EfiVfrParser {\r
3857<<\r
3858private:\r
3859 UINT8 mParserStatus;\r
3860 BOOLEAN mConstantOnlyInExpression;\r
3861\r
3862 CVfrDefaultStore mCVfrDefaultStore;\r
3863 CVfrDataStorage mCVfrDataStorage;\r
3864 CVfrQuestionDB mCVfrQuestionDB;\r
3865 CVfrRulesDB mCVfrRulesDB;\r
3866\r
3867 CIfrOpHeader * mCIfrOpHdr[MAX_IFR_EXPRESSION_DEPTH];\r
3868 UINT32 mCIfrOpHdrLineNo[MAX_IFR_EXPRESSION_DEPTH];\r
3869 UINT8 mCIfrOpHdrIndex;\r
3870 VOID _SAVE_OPHDR_COND (IN CIfrOpHeader &, IN BOOLEAN, UINT32 LineNo = 0);\r
3871 VOID _CLEAR_SAVED_OPHDR (VOID);\r
3872 BOOLEAN _SET_SAVED_OPHDR_SCOPE (VOID);\r
3873\r
3874\r
3875 EFI_VARSTORE_INFO mCurrQestVarInfo;\r
3876 EFI_GUID *mOverrideClassGuid;\r
3877\r
3878//\r
3879// For framework vfr compatibility\r
3880//\r
3881 BOOLEAN mCompatibleMode;\r
3882 EFI_GUID mFormsetGuid;\r
3883\r
3884 VOID _CRT_OP (IN BOOLEAN);\r
3885\r
3886 VOID _SAVE_CURRQEST_VARINFO (IN EFI_VARSTORE_INFO &);\r
3887 EFI_VARSTORE_INFO & _GET_CURRQEST_VARTINFO (VOID);\r
3888\r
3889 UINT8 _GET_CURRQEST_DATATYPE ();\r
3890 UINT32 _GET_CURRQEST_VARSIZE ();\r
3891 UINT32 _GET_CURRQEST_ARRAY_SIZE();\r
3892\r
3893public:\r
3894 VOID _PCATCH (IN INTN, IN INTN, IN ANTLRTokenPtr, IN CONST CHAR8 *);\r
3895 VOID _PCATCH (IN EFI_VFR_RETURN_CODE);\r
3896 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN ANTLRTokenPtr);\r
3897 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32);\r
3898 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32, IN CONST CHAR8 *);\r
3899\r
3900 VOID syn (ANTLRAbstractToken *, ANTLRChar *, SetWordType *, ANTLRTokenType, INT32);\r
3901\r
3902 CHAR8* TrimHex (IN CHAR8 *, OUT BOOLEAN *);\r
3903 CHAR8* _U32TOS (IN UINT32);\r
3904 UINT8 _STOU8 (IN CHAR8 *);\r
3905 UINT16 _STOU16 (IN CHAR8 *);\r
3906 UINT32 _STOU32 (IN CHAR8 *);\r
3907 UINT64 _STOU64 (IN CHAR8 *);\r
3908 EFI_HII_DATE _STOD (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *);\r
3909 EFI_HII_TIME _STOT (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *);\r
3910 EFI_HII_REF _STOR (IN CHAR8 *, IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *);\r
3911\r
3912 EFI_STRING_ID _STOSID (IN CHAR8 *);\r
3913 EFI_FORM_ID _STOFID (IN CHAR8 *);\r
3914 EFI_QUESTION_ID _STOQID (IN CHAR8 *);\r
3915\r
3916 VOID _STRCAT (IN OUT CHAR8 **, IN CONST CHAR8 *);\r
3917\r
3918 VOID _DeclareDefaultLinearVarStore (IN UINT32);\r
3919 VOID _DeclareStandardDefaultStorage (IN UINT32);\r
3920 VOID _DeclareDefaultFrameworkVarStore (IN UINT32);\r
3921\r
3922 VOID AssignQuestionKey (IN CIfrQuestionHeader &, IN ANTLRTokenPtr);\r
3923\r
3924 VOID ConvertIdExpr (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32);\r
3925 VOID IdEqValDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN UINT16, IN EFI_COMPARE_TYPE);\r
3926 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
3927 VOID IdEqListDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN UINT16, IN UINT16 *);\r
3928 VOID SetOverrideClassGuid (IN EFI_GUID *);\r
3929//\r
3930// For framework vfr compatibility\r
3931//\r
3932 VOID SetCompatibleMode (IN BOOLEAN);\r
3933>>\r
3934}\r
3935\r
3936<<\r
3937VOID\r
3938EfiVfrParser::_SAVE_OPHDR_COND (\r
3939 IN CIfrOpHeader &OpHdr,\r
3940 IN BOOLEAN Cond,\r
3941 IN UINT32 LineNo\r
3942 )\r
3943{\r
3944 if (Cond == TRUE) {\r
3945 if (mCIfrOpHdr[mCIfrOpHdrIndex] != NULL) {\r
3946 return ;\r
3947 }\r
3948 mCIfrOpHdr[mCIfrOpHdrIndex] = new CIfrOpHeader(OpHdr);\r
3949 mCIfrOpHdrLineNo[mCIfrOpHdrIndex] = LineNo;\r
3950 }\r
3951}\r
3952\r
3953VOID\r
3954EfiVfrParser::_CLEAR_SAVED_OPHDR (\r
3955 VOID\r
3956 )\r
3957{\r
3958 mCIfrOpHdr[mCIfrOpHdrIndex] = NULL;\r
3959 mCIfrOpHdrLineNo[mCIfrOpHdrIndex] = 0;\r
3960}\r
3961\r
3962BOOLEAN\r
3963EfiVfrParser::_SET_SAVED_OPHDR_SCOPE (\r
3964 VOID\r
3965 )\r
3966{\r
3967 if (mCIfrOpHdr[mCIfrOpHdrIndex] != NULL) {\r
3968 mCIfrOpHdr[mCIfrOpHdrIndex]->SetScope (1);\r
3969 return TRUE;\r
3970 }\r
3971\r
3972 //\r
3973 // IfrOpHdr is not set, FALSE is return.\r
3974 //\r
3975 return FALSE;\r
3976}\r
3977\r
3978VOID\r
3979EfiVfrParser::_CRT_OP (\r
3980 IN BOOLEAN Crt\r
3981 )\r
3982{\r
3983 gCreateOp = Crt;\r
3984}\r
3985\r
3986VOID\r
3987EfiVfrParser::_SAVE_CURRQEST_VARINFO (\r
3988 IN EFI_VARSTORE_INFO &Info\r
3989 )\r
3990{\r
3991 mCurrQestVarInfo = Info;\r
3992}\r
3993\r
3994EFI_VARSTORE_INFO &\r
3995EfiVfrParser::_GET_CURRQEST_VARTINFO (\r
3996 VOID\r
3997 )\r
3998{\r
3999 return mCurrQestVarInfo;\r
4000}\r
4001\r
4002UINT32\r
4003EfiVfrParser::_GET_CURRQEST_ARRAY_SIZE (\r
4004 VOID\r
4005 )\r
4006{\r
4007 UINT8 Size = 1;\r
4008\r
4009 switch (mCurrQestVarInfo.mVarType) {\r
4010 case EFI_IFR_TYPE_NUM_SIZE_8:\r
4011 Size = 1;\r
4012 break;\r
4013\r
4014 case EFI_IFR_TYPE_NUM_SIZE_16:\r
4015 Size = 2;\r
4016 break;\r
4017\r
4018 case EFI_IFR_TYPE_NUM_SIZE_32:\r
4019 Size = 4;\r
4020 break;\r
4021\r
4022 case EFI_IFR_TYPE_NUM_SIZE_64:\r
4023 Size = 8;\r
4024 break;\r
4025\r
4026 default:\r
4027 break;\r
4028 }\r
4029\r
4030 return (mCurrQestVarInfo.mVarTotalSize / Size);\r
4031}\r
4032\r
4033UINT8\r
4034EfiVfrParser::_GET_CURRQEST_DATATYPE (\r
4035 VOID\r
4036 )\r
4037{\r
4038 return mCurrQestVarInfo.mVarType;\r
4039}\r
4040\r
4041UINT32\r
4042EfiVfrParser::_GET_CURRQEST_VARSIZE (\r
4043 VOID\r
4044 )\r
4045{\r
4046 return mCurrQestVarInfo.mVarTotalSize;\r
4047}\r
4048\r
4049VOID\r
4050EfiVfrParser::_PCATCH (\r
4051 IN INTN ReturnCode,\r
4052 IN INTN ExpectCode,\r
4053 IN ANTLRTokenPtr Tok,\r
4054 IN CONST CHAR8 *ErrorMsg\r
4055 )\r
4056{\r
4057 if (ReturnCode != ExpectCode) {\r
4058 mParserStatus++;\r
4059 gCVfrErrorHandle.PrintMsg (Tok->getLine(), Tok->getText(), "Error", ErrorMsg);\r
4060 }\r
4061}\r
4062\r
4063VOID\r
4064EfiVfrParser::_PCATCH (\r
4065 IN EFI_VFR_RETURN_CODE ReturnCode\r
4066 )\r
4067{\r
4068 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode);\r
4069}\r
4070\r
4071VOID\r
4072EfiVfrParser::_PCATCH (\r
4073 IN EFI_VFR_RETURN_CODE ReturnCode,\r
4074 IN ANTLRTokenPtr Tok\r
4075 )\r
4076{\r
4077 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, Tok->getLine(), Tok->getText());\r
4078}\r
4079\r
4080VOID\r
4081EfiVfrParser::_PCATCH (\r
4082 IN EFI_VFR_RETURN_CODE ReturnCode,\r
4083 IN UINT32 LineNum\r
4084 )\r
4085{\r
4086 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, LineNum);\r
4087}\r
4088\r
4089VOID\r
4090EfiVfrParser::_PCATCH (\r
4091 IN EFI_VFR_RETURN_CODE ReturnCode,\r
4092 IN UINT32 LineNum,\r
4093 IN CONST CHAR8 *ErrorMsg\r
4094 )\r
4095{\r
4096 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, LineNum, (CHAR8 *) ErrorMsg);\r
4097}\r
4098\r
4099VOID\r
4100EfiVfrParser::syn (\r
4101 ANTLRAbstractToken *Tok,\r
4102 ANTLRChar *Egroup,\r
4103 SetWordType *Eset,\r
4104 ANTLRTokenType ETok,\r
4105 INT32 Huh\r
4106 )\r
4107{\r
4108 gCVfrErrorHandle.HandleError (VFR_RETURN_MISMATCHED, Tok->getLine(), Tok->getText());\r
4109\r
4110 mParserStatus += 1;\r
4111}\r
4112\r
4113CHAR8 *\r
4114EfiVfrParser::TrimHex (\r
4115 IN CHAR8 *Str,\r
4116 OUT BOOLEAN *IsHex\r
4117 )\r
4118{\r
4119 *IsHex = FALSE;\r
4120\r
4121 while (*Str && *Str == ' ') {\r
4122 Str++;\r
4123 }\r
4124 while (*Str && *Str == '0') {\r
4125 Str++;\r
4126 }\r
4127 if (*Str && (*Str == 'x' || *Str == 'X')) {\r
4128 Str++;\r
4129 *IsHex = TRUE;\r
4130 }\r
4131\r
4132 return Str;\r
4133}\r
4134\r
4135CHAR8 *\r
4136EfiVfrParser::_U32TOS (\r
4137 IN UINT32 Value\r
4138 )\r
4139{\r
4140 CHAR8 *Str;\r
4141 Str = new CHAR8[20];\r
4142 sprintf (Str, "%d", Value);\r
4143 return Str;\r
4144}\r
4145\r
4146UINT8\r
4147EfiVfrParser::_STOU8 (\r
4148 IN CHAR8*Str\r
4149 )\r
4150{\r
4151 BOOLEAN IsHex;\r
4152 UINT8 Value;\r
4153 CHAR8 c;\r
4154\r
4155 Str = TrimHex (Str, &IsHex);\r
4156 for (Value = 0; (c = *Str) != '\0'; Str++) {\r
4157 //\r
4158 // BUG: does not handle overflow here\r
4159 //\r
4160 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);\r
4161\r
4162 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {\r
4163 Value += (c - 'a' + 10);\r
4164 }\r
4165 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {\r
4166 Value += (c - 'A' + 10);\r
4167 }\r
4168 if (c >= '0' && c <= '9') {\r
4169 Value += (c - '0');\r
4170 }\r
4171 }\r
4172\r
4173 return Value;\r
4174}\r
4175\r
4176UINT16\r
4177EfiVfrParser::_STOU16 (\r
4178 IN CHAR8*Str\r
4179 )\r
4180{\r
4181 BOOLEAN IsHex;\r
4182 UINT16 Value;\r
4183 CHAR8 c;\r
4184\r
4185 Str = TrimHex (Str, &IsHex);\r
4186 for (Value = 0; (c = *Str) != '\0'; Str++) {\r
4187 //\r
4188 // BUG: does not handle overflow here\r
4189 //\r
4190 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);\r
4191\r
4192 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {\r
4193 Value += (c - 'a' + 10);\r
4194 }\r
4195 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {\r
4196 Value += (c - 'A' + 10);\r
4197 }\r
4198 if (c >= '0' && c <= '9') {\r
4199 Value += (c - '0');\r
4200 }\r
4201 }\r
4202\r
4203 return Value;\r
4204}\r
4205\r
4206UINT32\r
4207EfiVfrParser::_STOU32 (\r
4208 IN CHAR8*Str\r
4209 )\r
4210{\r
4211 BOOLEAN IsHex;\r
4212 UINT32 Value;\r
4213 CHAR8 c;\r
4214\r
4215 Str = TrimHex (Str, &IsHex);\r
4216 for (Value = 0; (c = *Str) != '\0'; Str++) {\r
4217 //\r
4218 // BUG: does not handle overflow here\r
4219 //\r
4220 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);\r
4221\r
4222 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {\r
4223 Value += (c - 'a' + 10);\r
4224 }\r
4225 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {\r
4226 Value += (c - 'A' + 10);\r
4227 }\r
4228 if (c >= '0' && c <= '9') {\r
4229 Value += (c - '0');\r
4230 }\r
4231 }\r
4232\r
4233 return Value;\r
4234}\r
4235\r
4236UINT64\r
4237EfiVfrParser::_STOU64 (\r
4238 IN CHAR8*Str\r
4239 )\r
4240{\r
4241 BOOLEAN IsHex;\r
4242 UINT64 Value;\r
4243 CHAR8 c;\r
4244\r
4245 Str = TrimHex (Str, &IsHex);\r
4246 for (Value = 0; (c = *Str) != '\0'; Str++) {\r
4247 //\r
4248 // BUG: does not handle overflow here\r
4249 //\r
4250 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);\r
4251\r
4252 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {\r
4253 Value += (c - 'a' + 10);\r
4254 }\r
4255 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {\r
4256 Value += (c - 'A' + 10);\r
4257 }\r
4258 if (c >= '0' && c <= '9') {\r
4259 Value += (c - '0');\r
4260 }\r
4261 }\r
4262\r
4263 return Value;\r
4264}\r
4265\r
4266EFI_HII_DATE\r
4267EfiVfrParser::_STOD (\r
4268 IN CHAR8 *Year,\r
4269 IN CHAR8 *Month,\r
4270 IN CHAR8 *Day\r
4271 )\r
4272{\r
4273 EFI_HII_DATE Date;\r
4274\r
4275 Date.Year = _STOU16 (Year);\r
4276 Date.Month = _STOU8 (Month);\r
4277 Date.Day = _STOU8 (Day);\r
4278\r
4279 return Date;\r
4280}\r
4281\r
4282EFI_HII_TIME\r
4283EfiVfrParser::_STOT (\r
4284 IN CHAR8 *Hour,\r
4285 IN CHAR8 *Minute,\r
4286 IN CHAR8 *Second\r
4287 )\r
4288{\r
4289 EFI_HII_TIME Time;\r
4290\r
4291 Time.Hour = _STOU8 (Hour);\r
4292 Time.Minute = _STOU8 (Minute);\r
4293 Time.Second = _STOU8 (Second);\r
4294\r
4295 return Time;\r
4296}\r
4297\r
4298EFI_STRING_ID\r
4299EfiVfrParser::_STOSID (\r
4300 IN CHAR8 *Str\r
4301 )\r
4302{\r
4303 return (EFI_STRING_ID)_STOU16(Str);\r
4304}\r
4305\r
4306EFI_FORM_ID\r
4307EfiVfrParser::_STOFID (\r
4308 IN CHAR8 *Str\r
4309 )\r
4310{\r
4311 return (EFI_FORM_ID)_STOU16(Str);\r
4312}\r
4313\r
4314EFI_QUESTION_ID\r
4315EfiVfrParser::_STOQID (\r
4316 IN CHAR8 *Str\r
4317 )\r
4318{\r
4319 return (EFI_QUESTION_ID)_STOU16(Str);\r
4320}\r
4321\r
4322VOID\r
4323EfiVfrParser::_STRCAT (\r
4324 IN OUT CHAR8 **Dest,\r
4325 IN CONST CHAR8 *Src\r
4326 )\r
4327{\r
4328 CHAR8 *NewStr;\r
4329 UINT32 Len;\r
4330\r
4331 if ((Dest == NULL) || (Src == NULL)) {\r
4332 return;\r
4333 }\r
4334\r
4335 Len = (*Dest == NULL) ? 0 : strlen (*Dest);\r
4336 Len += strlen (Src);\r
4337 if ((NewStr = new CHAR8[Len + 1]) == NULL) {\r
4338 return;\r
4339 }\r
4340 NewStr[0] = '\0';\r
4341 if (*Dest != NULL) {\r
4342 strcpy (NewStr, *Dest);\r
4343 delete *Dest;\r
4344 }\r
4345 strcat (NewStr, Src);\r
4346\r
4347 *Dest = NewStr;\r
4348}\r
4349\r
4350EFI_HII_REF\r
4351EfiVfrParser::_STOR (\r
4352 IN CHAR8 *QuestionId,\r
4353 IN CHAR8 *FormId,\r
4354 IN EFI_GUID *FormSetGuid,\r
4355 IN CHAR8 *DevicePath\r
4356 )\r
4357{\r
4358 EFI_HII_REF Ref;\r
4359 UINT32 Index;\r
4360\r
4361 memcpy (&Ref.FormSetGuid, FormSetGuid, sizeof (EFI_GUID));\r
4362 Ref.QuestionId = _STOQID (QuestionId);\r
4363 Ref.FormId = _STOFID (FormId);\r
4364 Ref.DevicePath = _STOSID (DevicePath);\r
4365\r
4366 return Ref;\r
4367}\r
4368\r
4369//\r
4370// framework vfr to default declare varstore for each structure\r
4371//\r
4372VOID\r
4373EfiVfrParser::_DeclareDefaultFrameworkVarStore (\r
4374 IN UINT32 LineNo\r
4375 )\r
4376{\r
4377 SVfrVarStorageNode *pNode;\r
4378 UINT32 TypeSize;\r
4379 BOOLEAN FirstNode;\r
4380 CONST CHAR8 VarName[] = "Setup";\r
4381\r
4382 FirstNode = TRUE;\r
4383 pNode = mCVfrDataStorage.GetBufferVarStoreList();\r
4384 if (pNode == NULL && gCVfrVarDataTypeDB.mFirstNewDataTypeName != NULL) {\r
4385 //\r
4386 // Create the default Buffer Var Store when no VarStore is defined.\r
4387 // its name should be "Setup"\r
4388 //\r
4389 gCVfrVarDataTypeDB.GetDataTypeSize (gCVfrVarDataTypeDB.mFirstNewDataTypeName, &TypeSize);\r
4390 CIfrVarStore VSObj;\r
4391 VSObj.SetLineNo (LineNo);\r
4392 VSObj.SetVarStoreId (0x1); //the first and only one Buffer Var Store\r
4393 VSObj.SetSize ((UINT16) TypeSize);\r
4394 //VSObj.SetName (gCVfrVarDataTypeDB.mFirstNewDataTypeName);\r
4395 VSObj.SetName ((CHAR8 *) VarName);\r
4396 VSObj.SetGuid (&mFormsetGuid);\r
4397#ifdef VFREXP_DEBUG\r
4398 printf ("Create the default VarStoreName is %s\n", gCVfrVarDataTypeDB.mFirstNewDataTypeName);\r
4399#endif\r
4400 } else {\r
4401 for (; pNode != NULL; pNode = pNode->mNext) {\r
4402 //\r
4403 // create the default varstore opcode for not declared varstore\r
4404 // the first varstore name should be "Setup"\r
4405 //\r
4406 if (!pNode->mAssignedFlag) {\r
4407 CIfrVarStore VSObj;\r
4408 VSObj.SetLineNo (LineNo);\r
4409 VSObj.SetVarStoreId (pNode->mVarStoreId);\r
4410 VSObj.SetSize ((UINT16) pNode->mStorageInfo.mDataType->mTotalSize);\r
4411 if (FirstNode) {\r
4412 VSObj.SetName ((CHAR8 *) VarName);\r
4413 FirstNode = FALSE;\r
4414 } else {\r
4415 VSObj.SetName (pNode->mVarStoreName);\r
4416 }\r
4417 VSObj.SetGuid (&pNode->mGuid);\r
4418#ifdef VFREXP_DEBUG\r
4419 printf ("undefined VarStoreName is %s and Id is 0x%x\n", pNode->mVarStoreName, pNode->mVarStoreId);\r
4420#endif\r
4421 }\r
4422 }\r
4423 }\r
4424\r
4425 pNode = mCVfrDataStorage.GetEfiVarStoreList();\r
4426 for (; pNode != NULL; pNode = pNode->mNext) {\r
4427 //\r
4428 // create the default efi varstore opcode for not exist varstore\r
4429 //\r
4430 if (!pNode->mAssignedFlag) {\r
4431 CIfrVarStoreEfi VSEObj;\r
4432 VSEObj.SetLineNo (LineNo);\r
4433 VSEObj.SetAttributes (0x00000002); //hardcode EFI_VARIABLE_BOOTSERVICE_ACCESS attribute\r
4434 VSEObj.SetGuid (&pNode->mGuid);\r
4435 VSEObj.SetVarStoreId (pNode->mVarStoreId);\r
4436 // Generate old efi varstore storage structure for compatiable with old "VarEqVal" opcode,\r
4437 // which is 3 bytes less than new structure define in UEFI Spec 2.3.1.\r
4438 VSEObj.SetBinaryLength (sizeof (EFI_IFR_VARSTORE_EFI) - 3);\r
4439#ifdef VFREXP_DEBUG\r
4440 printf ("undefined Efi VarStoreName is %s and Id is 0x%x\n", pNode->mVarStoreName, pNode->mVarStoreId);\r
4441#endif\r
4442 }\r
4443 }\r
4444\r
4445}\r
4446\r
4447VOID\r
4448EfiVfrParser::_DeclareDefaultLinearVarStore (\r
4449 IN UINT32 LineNo\r
4450 )\r
4451{\r
4452 UINT32 Index;\r
4453 CHAR8 **TypeNameList;\r
4454 UINT32 ListSize;\r
4455 CONST CHAR8 DateName[] = "Date";\r
4456 CONST CHAR8 TimeName[] = "Time";\r
4457 CONST CHAR8 DateType[] = "EFI_HII_DATE";\r
4458 CONST CHAR8 TimeType[] = "EFI_HII_TIME";\r
4459\r
4460 gCVfrVarDataTypeDB.GetUserDefinedTypeNameList (&TypeNameList, &ListSize);\r
4461\r
4462 for (Index = 0; Index < ListSize; Index++) {\r
4463 UINT32 Size;\r
4464 EFI_VARSTORE_ID VarStoreId;\r
4465 CIfrVarStore VSObj;\r
4466\r
4467 VSObj.SetLineNo (LineNo);\r
4468 mCVfrDataStorage.DeclareBufferVarStore (\r
4469 TypeNameList[Index],\r
4470 &mFormsetGuid,\r
4471 &gCVfrVarDataTypeDB,\r
4472 TypeNameList[Index],\r
4473 EFI_VARSTORE_ID_INVALID\r
4474 );\r
4475 mCVfrDataStorage.GetVarStoreId(TypeNameList[Index], &VarStoreId);\r
4476 VSObj.SetVarStoreId (VarStoreId);\r
4477 gCVfrVarDataTypeDB.GetDataTypeSize(TypeNameList[Index], &Size);\r
4478 VSObj.SetSize ((UINT16) Size);\r
4479 VSObj.SetName (TypeNameList[Index]);\r
4480 VSObj.SetGuid (&mFormsetGuid);\r
4481 }\r
4482\r
4483//\r
4484// not required to declare Date and Time VarStore,\r
4485// because code to support old format Data and Time\r
4486//\r
4487 if (gCVfrVarDataTypeDB.IsTypeNameDefined ((CHAR8 *) DateName) == FALSE) {\r
4488 UINT32 Size;\r
4489 EFI_VARSTORE_ID VarStoreId;\r
4490 CIfrVarStore VSObj;\r
4491\r
4492 VSObj.SetLineNo (LineNo);\r
4493 mCVfrDataStorage.DeclareBufferVarStore (\r
4494 (CHAR8 *) DateName,\r
4495 &mFormsetGuid,\r
4496 &gCVfrVarDataTypeDB,\r
4497 (CHAR8 *) DateType,\r
4498 EFI_VARSTORE_ID_INVALID\r
4499 );\r
4500 mCVfrDataStorage.GetVarStoreId((CHAR8 *) DateName, &VarStoreId);\r
4501 VSObj.SetVarStoreId (VarStoreId);\r
4502 gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) DateType, &Size);\r
4503 VSObj.SetSize ((UINT16) Size);\r
4504 VSObj.SetName ((CHAR8 *) DateName);\r
4505 VSObj.SetGuid (&mFormsetGuid);\r
4506 }\r
4507\r
4508 if (gCVfrVarDataTypeDB.IsTypeNameDefined ((CHAR8 *) TimeName) == FALSE) {\r
4509 UINT32 Size;\r
4510 EFI_VARSTORE_ID VarStoreId;\r
4511 CIfrVarStore VSObj;\r
4512\r
4513 VSObj.SetLineNo (LineNo);\r
4514 mCVfrDataStorage.DeclareBufferVarStore (\r
4515 (CHAR8 *) TimeName,\r
4516 &mFormsetGuid,\r
4517 &gCVfrVarDataTypeDB,\r
4518 (CHAR8 *) TimeType,\r
4519 EFI_VARSTORE_ID_INVALID\r
4520 );\r
4521 mCVfrDataStorage.GetVarStoreId((CHAR8 *) TimeName, &VarStoreId);\r
4522 VSObj.SetVarStoreId (VarStoreId);\r
4523 gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) TimeType, &Size);\r
4524 VSObj.SetSize ((UINT16) Size);\r
4525 VSObj.SetName ((CHAR8 *) TimeName);\r
4526 VSObj.SetGuid (&mFormsetGuid);\r
4527 }\r
4528}\r
4529\r
4530VOID\r
4531EfiVfrParser::_DeclareStandardDefaultStorage (\r
4532 IN UINT32 LineNo\r
4533 )\r
4534{\r
4535 //\r
4536 // Default Store is declared.\r
4537 //\r
4538 CIfrDefaultStore DSObj;\r
4539\r
4540 mCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), (CHAR8 *) "Standard Defaults", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_STANDARD);\r
4541 DSObj.SetLineNo (LineNo);\r
4542 DSObj.SetDefaultName (EFI_STRING_ID_INVALID);\r
4543 DSObj.SetDefaultId (EFI_HII_DEFAULT_CLASS_STANDARD);\r
4544\r
4545 //\r
4546 // Default MANUFACTURING Store is declared.\r
4547 //\r
4548 CIfrDefaultStore DSObjMF;\r
4549\r
4550 mCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr(), (CHAR8 *) "Standard ManuFacturing", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING);\r
4551 DSObjMF.SetLineNo (LineNo);\r
4552 DSObjMF.SetDefaultName (EFI_STRING_ID_INVALID);\r
4553 DSObjMF.SetDefaultId (EFI_HII_DEFAULT_CLASS_MANUFACTURING);\r
4554}\r
4555\r
4556VOID\r
4557EfiVfrParser::AssignQuestionKey (\r
4558 IN CIfrQuestionHeader &QHObj,\r
4559 IN ANTLRTokenPtr KeyTok\r
4560 )\r
4561{\r
4562 UINT16 KeyValue;\r
4563\r
4564 if (KeyTok == NULL) {\r
4565 return;\r
4566 }\r
4567\r
4568 KeyValue = _STOU16 (KeyTok->getText());\r
4569\r
4570 if (QHObj.FLAGS () & EFI_IFR_FLAG_CALLBACK) {\r
4571 /*\r
4572 * if the question is not CALLBACK ignore the key.\r
4573 */\r
4574 _PCATCH(mCVfrQuestionDB.UpdateQuestionId (QHObj.QUESTION_ID(), KeyValue), KeyTok);\r
4575 QHObj.SetQuestionId (KeyValue);\r
4576 }\r
4577}\r
4578\r
4579VOID\r
4580EfiVfrParser::ConvertIdExpr (\r
4581 IN UINT32 &ExpOpCount,\r
4582 IN UINT32 LineNo,\r
4583 IN EFI_QUESTION_ID QId,\r
4584 IN CHAR8 *VarIdStr,\r
4585 IN UINT32 BitMask\r
4586 )\r
4587{\r
4588 CIfrQuestionRef1 QR1Obj(LineNo);\r
4589 QR1Obj.SetQuestionId (QId, VarIdStr, LineNo);\r
4590 _SAVE_OPHDR_COND (QR1Obj, (ExpOpCount == 0));\r
4591\r
4592 if (BitMask != 0) {\r
4593 CIfrUint32 U32Obj(LineNo);\r
4594 U32Obj.SetValue (BitMask);\r
4595\r
4596 CIfrBitWiseAnd BWAObj(LineNo);\r
4597\r
4598 CIfrUint8 U8Obj(LineNo);\r
4599 switch (BitMask) {\r
4600 case DATE_YEAR_BITMASK : U8Obj.SetValue (0); break;\r
4601 case TIME_SECOND_BITMASK : U8Obj.SetValue (0x10); break;\r
4602 case DATE_DAY_BITMASK : U8Obj.SetValue (0x18); break;\r
4603 case TIME_HOUR_BITMASK : U8Obj.SetValue (0); break;\r
4604 case TIME_MINUTE_BITMASK : U8Obj.SetValue (0x8); break;\r
4605 }\r
4606\r
4607 CIfrShiftRight SRObj(LineNo);\r
4608 }\r
4609\r
4610 ExpOpCount += 4;\r
4611}\r
4612\r
4613VOID\r
4614EfiVfrParser::IdEqValDoSpecial (\r
4615 IN UINT32 &ExpOpCount,\r
4616 IN UINT32 LineNo,\r
4617 IN EFI_QUESTION_ID QId,\r
4618 IN CHAR8 *VarIdStr,\r
4619 IN UINT32 BitMask,\r
4620 IN UINT16 ConstVal,\r
4621 IN EFI_COMPARE_TYPE CompareType\r
4622 )\r
4623{\r
4624 ConvertIdExpr (ExpOpCount, LineNo, QId, VarIdStr, BitMask);\r
4625\r
4626 if (ConstVal > 0xFF) {\r
4627 CIfrUint16 U16Obj(LineNo);\r
4628 U16Obj.SetValue (ConstVal);\r
4629 } else {\r
4630 CIfrUint8 U8Obj(LineNo);\r
4631 U8Obj.SetValue ((UINT8)ConstVal);\r
4632 }\r
4633\r
4634 switch (CompareType) {\r
4635 case EQUAL :\r
4636 {\r
4637 CIfrEqual EObj(LineNo);\r
4638 break;\r
4639 }\r
4640 case LESS_EQUAL :\r
4641 {\r
4642 CIfrLessEqual LEObj(LineNo);\r
4643 break;\r
4644 }\r
4645 case LESS_THAN :\r
4646 {\r
4647 CIfrLessThan LTObj(LineNo);\r
4648 break;\r
4649 }\r
4650 case GREATER_EQUAL :\r
4651 {\r
4652 CIfrGreaterEqual GEObj(LineNo);\r
4653 break;\r
4654 }\r
4655 case GREATER_THAN :\r
4656 {\r
4657 CIfrGreaterThan GTObj(LineNo);\r
4658 break;\r
4659 }\r
4660 }\r
4661\r
4662 ExpOpCount += 2;\r
4663}\r
4664\r
4665VOID\r
4666EfiVfrParser::IdEqIdDoSpecial (\r
4667 IN UINT32 &ExpOpCount,\r
4668 IN UINT32 LineNo,\r
4669 IN EFI_QUESTION_ID QId1,\r
4670 IN CHAR8 *VarId1Str,\r
4671 IN UINT32 BitMask1,\r
4672 IN EFI_QUESTION_ID QId2,\r
4673 IN CHAR8 *VarId2Str,\r
4674 IN UINT32 BitMask2,\r
4675 IN EFI_COMPARE_TYPE CompareType\r
4676 )\r
4677{\r
4678 ConvertIdExpr (ExpOpCount, LineNo, QId1, VarId1Str, BitMask1);\r
4679 ConvertIdExpr (ExpOpCount, LineNo, QId2, VarId2Str, BitMask2);\r
4680\r
4681 switch (CompareType) {\r
4682 case EQUAL :\r
4683 {\r
4684 CIfrEqual EObj(LineNo);\r
4685 break;\r
4686 }\r
4687 case LESS_EQUAL :\r
4688 {\r
4689 CIfrLessEqual LEObj(LineNo);\r
4690 break;\r
4691 }\r
4692 case LESS_THAN :\r
4693 {\r
4694 CIfrLessThan LTObj(LineNo);\r
4695 break;\r
4696 }\r
4697 case GREATER_EQUAL :\r
4698 {\r
4699 CIfrGreaterEqual GEObj(LineNo);\r
4700 break;\r
4701 }\r
4702 case GREATER_THAN :\r
4703 {\r
4704 CIfrGreaterThan GTObj(LineNo);\r
4705 break;\r
4706 }\r
4707 }\r
4708\r
4709 ExpOpCount++;\r
4710}\r
4711\r
4712VOID\r
4713EfiVfrParser::IdEqListDoSpecial (\r
4714 IN UINT32 &ExpOpCount,\r
4715 IN UINT32 LineNo,\r
4716 IN EFI_QUESTION_ID QId,\r
4717 IN CHAR8 *VarIdStr,\r
4718 IN UINT32 BitMask,\r
4719 IN UINT16 ListLen,\r
4720 IN UINT16 *ValueList\r
4721 )\r
4722{\r
4723 UINT16 Index;\r
4724\r
4725 if (ListLen == 0) {\r
4726 return;\r
4727 }\r
4728\r
4729 IdEqValDoSpecial (ExpOpCount, LineNo, QId, VarIdStr, BitMask, ValueList[0], EQUAL);\r
4730 for (Index = 1; Index < ListLen; Index++) {\r
4731 IdEqValDoSpecial (ExpOpCount, LineNo, QId, VarIdStr, BitMask, ValueList[Index], EQUAL);\r
4732 CIfrOr OObj (LineNo);\r
4733 ExpOpCount++;\r
4734 }\r
4735}\r
4736\r
4737VOID \r
4738EfiVfrParser::SetOverrideClassGuid (IN EFI_GUID *OverrideClassGuid)\r
4739{\r
4740 mOverrideClassGuid = OverrideClassGuid;\r
4741}\r
4742\r
4743//\r
4744// For framework vfr compatibility\r
4745//\r
4746VOID\r
4747EfiVfrParser::SetCompatibleMode (IN BOOLEAN Mode)\r
4748{\r
4749 mCompatibleMode = Mode;\r
4750 mCVfrQuestionDB.SetCompatibleMode (Mode);\r
4751}\r
4752>>\r
EFI Development Kit II mirror for PVE