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