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