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