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