]> git.proxmox.com Git - mirror_edk2.git/blame - BaseTools/Source/C/VfrCompile/VfrFormPkg.h
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
BaseTools: silence parentheses-equality warning
[mirror_edk2.git] / BaseTools / Source / C / VfrCompile / VfrFormPkg.h
CommitLineData
30fdf114
LG		 1/** @file\r
2 \r
3 The definition of CFormPkg's member function\r
4\r
42c808d4 5Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>\r
40d841f6 6This program and the accompanying materials \r
30fdf114
LG		 7are licensed and made available under the terms and conditions of the BSD License \r
8which accompanies this distribution. The full text of the license may be found at \r
9http://opensource.org/licenses/bsd-license.php \r
10 \r
11THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
12WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
13\r
14**/\r
15\r
16#ifndef _EFIIFRCLASS_H_\r
17#define _EFIIFRCLASS_H_\r
18\r
19#include "string.h"\r
20#include "EfiVfr.h"\r
21#include "VfrError.h"\r
22#include "VfrUtilityLib.h"\r
23\r
24#define NO_QST_REFED "no question refered"\r
25\r
26struct PACKAGE_DATA {\r
27 CHAR8 *Buffer;\r
28 UINT32 Size;\r
29};\r
30\r
31/*\r
32 * The functions below are used for flags setting\r
33 */\r
34static inline BOOLEAN _FLAGS_ZERO (\r
35 IN UINT8 &Flags\r
36 )\r
37{\r
38 return Flags == 0;\r
39}\r
40\r
41static inline VOID _FLAG_CLEAR (\r
42 IN UINT8 &Flags,\r
43 IN UINT8 Mask\r
44 )\r
45{\r
46 Flags &= (~Mask);\r
47}\r
48\r
49static inline UINT8 _FLAG_TEST_AND_CLEAR (\r
50 IN UINT8 &Flags,\r
51 IN UINT8 Mask\r
52 )\r
53{\r
54 UINT8 Ret = Flags & Mask;\r
55 Flags &= (~Mask);\r
56 return Ret;\r
57}\r
58\r
59static inline UINT8 _IS_EQUAL (\r
60 IN UINT8 &Flags,\r
61 IN UINT8 Value\r
62 )\r
63{\r
64 return Flags == Value;\r
65}\r
66\r
67/*\r
68 * The definition of CIfrBin\r
69 */\r
70typedef enum {\r
71 PENDING,\r
72 ASSIGNED\r
73} ASSIGN_FLAG;\r
74\r
75struct SPendingAssign {\r
76 CHAR8 *mKey; // key ! unique\r
77 VOID *mAddr;\r
78 UINT32 mLen;\r
79 ASSIGN_FLAG mFlag;\r
80 UINT32 mLineNo;\r
81 CHAR8 *mMsg;\r
82 struct SPendingAssign *mNext;\r
83\r
52302d4d 84 SPendingAssign (IN CHAR8 *, IN VOID *, IN UINT32, IN UINT32, IN CONST CHAR8 *);\r
30fdf114
LG		 85 ~SPendingAssign ();\r
86\r
87 VOID SetAddrAndLen (IN VOID *, IN UINT32);\r
88 VOID AssignValue (IN VOID *, IN UINT32);\r
89 CHAR8 * GetKey (VOID);\r
77dee0b1
HW		 90\r
91private:\r
92 SPendingAssign (IN CONST SPendingAssign&); // Prevent copy-construction\r
93 SPendingAssign& operator= (IN CONST SPendingAssign&); // Prevent assignment\r
30fdf114
LG		 94};\r
95\r
96struct SBufferNode {\r
97 CHAR8 *mBufferStart;\r
98 CHAR8 *mBufferEnd;\r
99 CHAR8 *mBufferFree;\r
100 struct SBufferNode *mNext;\r
101};\r
102\r
4234283c
LG		 103typedef struct {\r
104 BOOLEAN CompatibleMode;\r
105 EFI_GUID *OverrideClassGuid;\r
106} INPUT_INFO_TO_SYNTAX;\r
107\r
30fdf114
LG		 108class CFormPkg {\r
109private:\r
110 UINT32 mBufferSize;\r
111 SBufferNode *mBufferNodeQueueHead;\r
112 SBufferNode *mBufferNodeQueueTail;\r
113 SBufferNode *mCurrBufferNode;\r
114\r
115 SBufferNode *mReadBufferNode;\r
116 UINT32 mReadBufferOffset;\r
117\r
118 UINT32 mPkgLength;\r
119\r
52302d4d
LG		 120 VOID _WRITE_PKG_LINE (IN FILE *, IN UINT32 , IN CONST CHAR8 *, IN CHAR8 *, IN UINT32);\r
121 VOID _WRITE_PKG_END (IN FILE *, IN UINT32 , IN CONST CHAR8 *, IN CHAR8 *, IN UINT32);\r
4afd3d04
LG		 122 SBufferNode * GetBinBufferNodeForAddr (IN CHAR8 *);\r
123 SBufferNode * CreateNewNode ();\r
124 SBufferNode * GetNodeBefore (IN SBufferNode *);\r
125 EFI_VFR_RETURN_CODE InsertNodeBefore (IN SBufferNode *, IN SBufferNode *);\r
30fdf114
LG		 126\r
127private:\r
128 SPendingAssign *PendingAssignList;\r
129\r
130public:\r
ed395cfe 131 CFormPkg (IN UINT32 BufferSize = 4096);\r
30fdf114
LG		 132 ~CFormPkg ();\r
133\r
134 CHAR8 * IfrBinBufferGet (IN UINT32);\r
135 inline UINT32 GetPkgLength (VOID);\r
136\r
137 VOID Open ();\r
138 UINT32 Read (IN CHAR8 *, IN UINT32);\r
139 VOID Close ();\r
140\r
141 EFI_VFR_RETURN_CODE BuildPkgHdr (OUT EFI_HII_PACKAGE_HEADER **);\r
142 EFI_VFR_RETURN_CODE BuildPkg (IN FILE *, IN PACKAGE_DATA *PkgData = NULL);\r
143 EFI_VFR_RETURN_CODE BuildPkg (OUT PACKAGE_DATA &);\r
144 EFI_VFR_RETURN_CODE GenCFile (IN CHAR8 *, IN FILE *, IN PACKAGE_DATA *PkgData = NULL);\r
145\r
77dee0b1
HW		 146private:\r
147 CFormPkg (IN CONST CFormPkg&); // Prevent copy-construction\r
148 CFormPkg& operator= (IN CONST CFormPkg&); // Prevent assignment\r
149\r
30fdf114 150public:\r
52302d4d 151 EFI_VFR_RETURN_CODE AssignPending (IN CHAR8 *, IN VOID *, IN UINT32, IN UINT32, IN CONST CHAR8 *Msg = NULL);\r
30fdf114
LG		 152 VOID DoPendingAssign (IN CHAR8 *, IN VOID *, IN UINT32);\r
153 bool HavePendingUnassigned (VOID);\r
154 VOID PendingAssignPrintAll (VOID);\r
155 EFI_VFR_RETURN_CODE DeclarePendingQuestion (\r
156 IN CVfrVarDataTypeDB &lCVfrVarDataTypeDB,\r
157 IN CVfrDataStorage &lCVfrDataStorage,\r
158 IN CVfrQuestionDB &lCVfrQuestionDB,\r
159 IN EFI_GUID *LocalFormSetGuid,\r
4afd3d04
LG		 160 IN UINT32 LineNo,\r
161 OUT CHAR8 **InsertOpcodeAddr\r
162 );\r
163 EFI_VFR_RETURN_CODE AdjustDynamicInsertOpcode (\r
164 IN CHAR8 *LastFormEndAddr,\r
74bbe31b
DB		 165 IN CHAR8 *InsertOpcodeAddr,\r
166 IN BOOLEAN CreateOpcodeAfterParsingVfr\r
4afd3d04
LG		 167 );\r
168 CHAR8 * GetBufAddrBaseOnOffset (\r
169 IN UINT32 Offset\r
30fdf114
LG		 170 );\r
171};\r
172\r
4234283c
LG		 173extern CFormPkg gCFormPkg;\r
174extern CVfrStringDB gCVfrStringDB;\r
4afd3d04
LG		 175extern UINT32 gAdjustOpcodeOffset;\r
176extern BOOLEAN gNeedAdjustOpcode;\r
30fdf114
LG		 177\r
178struct SIfrRecord {\r
179 UINT32 mLineNo;\r
180 CHAR8 *mIfrBinBuf;\r
181 UINT8 mBinBufLen;\r
182 UINT32 mOffset;\r
183 SIfrRecord *mNext;\r
184\r
185 SIfrRecord (VOID);\r
186 ~SIfrRecord (VOID);\r
187};\r
188\r
74bbe31b 189\r
30fdf114
LG		 190#define EFI_IFR_RECORDINFO_IDX_INVALUD 0xFFFFFF\r
191#define EFI_IFR_RECORDINFO_IDX_START 0x0\r
74bbe31b
DB		 192#define EFI_HII_MAX_SUPPORT_DEFAULT_TYPE 0x08\r
193\r
194struct QuestionDefaultRecord {\r
195 BOOLEAN mIsDefaultIdExist[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE]; // Record the default id in mAllDefaultIdArray[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE]\r
196 // whether exists in current question.\r
197\r
198 SIfrRecord *mDefaultValueRecord; // Point to the default value record in RecordList which has smallest default Id.\r
199 // (for checkbox it may be NULL, because the dedault value is always true when the flag is set.)\r
200\r
201 BOOLEAN mIsDefaultOpcode; // whether the default value with smallest default id is given by default opcode.\r
202 // (for oneof and checkbox default info may be given by flag.)\r
203\r
204 UINT16 mDefaultNumber; // The default number of this question.\r
205};\r
30fdf114
LG		 206\r
207class CIfrRecordInfoDB {\r
208private:\r
209 bool mSwitch;\r
210 UINT32 mRecordCount;\r
211 SIfrRecord *mIfrRecordListHead;\r
212 SIfrRecord *mIfrRecordListTail;\r
74bbe31b
DB		 213 UINT8 mAllDefaultTypeCount;\r
214 UINT16 mAllDefaultIdArray[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE];\r
30fdf114
LG		 215\r
216 SIfrRecord * GetRecordInfoFromIdx (IN UINT32);\r
217 BOOLEAN CheckQuestionOpCode (IN UINT8);\r
218 BOOLEAN CheckIdOpCode (IN UINT8);\r
219 EFI_QUESTION_ID GetOpcodeQuestionId (IN EFI_IFR_OP_HEADER *);\r
220public:\r
221 CIfrRecordInfoDB (VOID);\r
222 ~CIfrRecordInfoDB (VOID);\r
223\r
224 inline VOID TurnOn (VOID) {\r
225 mSwitch = TRUE;\r
226 }\r
227\r
228 inline VOID TurnOff (VOID) {\r
229 mSwitch = FALSE;\r
230 }\r
231\r
4afd3d04
LG		 232 SIfrRecord * GetRecordInfoFromOffset (IN UINT32);\r
233 VOID IfrAdjustOffsetForRecord (VOID);\r
74bbe31b 234 BOOLEAN IfrAdjustDynamicOpcodeInRecords (IN BOOLEAN);\r
4afd3d04 235\r
30fdf114
LG		 236 UINT32 IfrRecordRegister (IN UINT32, IN CHAR8 *, IN UINT8, IN UINT32);\r
237 VOID IfrRecordInfoUpdate (IN UINT32, IN UINT32, IN CHAR8*, IN UINT8, IN UINT32);\r
238 VOID IfrRecordOutput (IN FILE *, IN UINT32 LineNo);\r
239 VOID IfrRecordOutput (OUT PACKAGE_DATA &);\r
74bbe31b
DB		 240 EFI_VFR_RETURN_CODE IfrRecordAdjust (VOID);\r
241 VOID IfrUpdateRecordInfoForDynamicOpcode (IN BOOLEAN);\r
242 VOID IfrCheckAddDefaultRecord (IN BOOLEAN, IN BOOLEAN);\r
243 VOID IfrGetDefaultStoreInfo ();\r
244 VOID IfrCreateDefaultRecord (IN UINT8 Size,IN UINT16 DefaultId,IN UINT8 Type,IN UINT32 LineNo,IN EFI_IFR_TYPE_VALUE Value);\r
245 VOID IfrCreateDefaultForQuestion (IN SIfrRecord *, IN QuestionDefaultRecord *);\r
246 VOID IfrParseDefaulInfoInQuestion (IN SIfrRecord *, OUT QuestionDefaultRecord *);\r
247 VOID IfrAddDefaultToBufferConfig (IN UINT16, IN SIfrRecord *,IN EFI_IFR_TYPE_VALUE);\r
77dee0b1
HW		 248\r
249private:\r
250 CIfrRecordInfoDB (IN CONST CIfrRecordInfoDB&); // Prevent copy-construction\r
251 CIfrRecordInfoDB& operator= (IN CONST CIfrRecordInfoDB&); // Prevent assignment\r
30fdf114
LG		 252};\r
253\r
254extern CIfrRecordInfoDB gCIfrRecordInfoDB;\r
255\r
256/*\r
257 * The definition of CIfrObj\r
258 */\r
52302d4d 259extern BOOLEAN gCreateOp;\r
30fdf114
LG		 260\r
261class CIfrObj {\r
262private:\r
52302d4d 263 BOOLEAN mDelayEmit;\r
30fdf114
LG		 264\r
265 CHAR8 *mObjBinBuf;\r
266 UINT8 mObjBinLen;\r
267 UINT32 mLineNo;\r
268 UINT32 mRecordIdx;\r
269 UINT32 mPkgOffset;\r
270\r
271public:\r
272 CIfrObj (IN UINT8 OpCode, OUT CHAR8 **IfrObj = NULL, IN UINT8 ObjBinLen = 0, IN BOOLEAN DelayEmit = FALSE);\r
273 virtual ~CIfrObj(VOID);\r
274\r
275 VOID _EMIT_PENDING_OBJ (VOID);\r
276 \r
277 inline VOID SetLineNo (IN UINT32 LineNo) {\r
278 mLineNo = LineNo;\r
279 }\r
280\r
281 inline CHAR8 * GetObjBinAddr (VOID) {\r
282 return mObjBinBuf;\r
283 }\r
284\r
4afd3d04
LG		 285 inline UINT32 GetObjBinOffset (VOID) {\r
286 return mPkgOffset;\r
287 }\r
288\r
30fdf114
LG		 289 inline UINT8 GetObjBinLen (VOID) {\r
290 return mObjBinLen;\r
291 }\r
292\r
293 inline bool ExpendObjBin (IN UINT8 Size) {\r
294 if ((mDelayEmit == TRUE) && ((mObjBinLen + Size) > mObjBinLen)) {\r
52302d4d 295 mObjBinLen = mObjBinLen + Size;\r
30fdf114
LG		 296 return TRUE;\r
297 } else {\r
298 return FALSE;\r
299 }\r
300 }\r
4234283c
LG		 301\r
302 inline bool ShrinkObjBin (IN UINT8 Size) {\r
303 if ((mDelayEmit == TRUE) && (mObjBinLen > Size)) {\r
304 mObjBinLen -= Size;\r
305 return TRUE;\r
306 } else {\r
307 return FALSE;\r
308 }\r
309 }\r
30fdf114
LG		 310};\r
311\r
312/*\r
313 * The definition of CIfrOpHeader\r
314 */\r
315class CIfrOpHeader {\r
316private:\r
317 EFI_IFR_OP_HEADER *mHeader;\r
318\r
319public:\r
320 CIfrOpHeader (IN UINT8 OpCode, IN VOID *StartAddr, IN UINT8 Length = 0);\r
321 CIfrOpHeader (IN CIfrOpHeader &);\r
0d46defe 322 CIfrOpHeader& operator=(IN CONST CIfrOpHeader &);\r
30fdf114
LG		 323\r
324 VOID IncLength (UINT8 Size) {\r
325 if ((mHeader->Length + Size) > mHeader->Length) {\r
52302d4d 326 mHeader->Length = mHeader->Length + Size;\r
30fdf114
LG		 327 }\r
328 }\r
329\r
330 VOID DecLength (UINT8 Size) {\r
331 if (mHeader->Length >= Size) {\r
4234283c 332 mHeader->Length -= Size;\r
30fdf114
LG		 333 }\r
334 }\r
335\r
336 UINT8 GetLength () {\r
337 return mHeader->Length;\r
338 }\r
339\r
340 UINT8 GetScope () {\r
341 return mHeader->Scope;\r
342 }\r
343\r
344 VOID SetScope (IN UINT8 Scope) {\r
345 mHeader->Scope = Scope;\r
346 }\r
347\r
348 VOID UpdateHeader (IN EFI_IFR_OP_HEADER *Header) {\r
349 mHeader = Header;\r
350 }\r
1afac950
ED		 351\r
352 UINT8 GetOpCode () {\r
353 return mHeader->OpCode;\r
354 }\r
30fdf114
LG		 355};\r
356\r
357extern UINT8 gScopeCount;\r
358\r
359/*\r
360 * The definition of CIfrStatementHeader\r
361 */\r
362class CIfrStatementHeader {\r
363private:\r
364 EFI_IFR_STATEMENT_HEADER *mHeader;\r
365\r
366public:\r
367 CIfrStatementHeader (\r
368 IN EFI_IFR_STATEMENT_HEADER *StartAddr\r
369 ) : mHeader ((EFI_IFR_STATEMENT_HEADER *)StartAddr) {\r
370 mHeader = StartAddr;\r
371 mHeader->Help = EFI_STRING_ID_INVALID;\r
372 mHeader->Prompt = EFI_STRING_ID_INVALID;\r
373 }\r
374\r
375 EFI_IFR_STATEMENT_HEADER *GetStatementHeader () {\r
376 return mHeader;\r
377 }\r
378\r
379 VOID SetPrompt (IN EFI_STRING_ID Prompt) {\r
380 mHeader->Prompt = Prompt;\r
381 }\r
382\r
383 VOID SetHelp (IN EFI_STRING_ID Help) {\r
384 mHeader->Help = Help;\r
385 }\r
386};\r
387\r
388/*\r
389 * The definition of CIfrQuestionHeader\r
390 */\r
391#define EFI_IFR_QUESTION_FLAG_DEFAULT 0\r
392\r
393class CIfrQuestionHeader : public CIfrStatementHeader {\r
394private:\r
395 EFI_IFR_QUESTION_HEADER *mHeader;\r
396\r
397 EFI_IFR_STATEMENT_HEADER * QH2SH (EFI_IFR_QUESTION_HEADER *Qheader) {\r
398 return &(Qheader)->Header;\r
399 }\r
400\r
401public:\r
402 EFI_QUESTION_ID QUESTION_ID (VOID) {\r
403 return mHeader->QuestionId;\r
404 }\r
405\r
406 EFI_VARSTORE_ID VARSTORE_ID (VOID) {\r
407 return mHeader->VarStoreId;\r
408 }\r
409\r
410 VOID VARSTORE_INFO (OUT EFI_VARSTORE_INFO *Info) {\r
411 if (Info != NULL) {\r
412 Info->mVarStoreId = mHeader->VarStoreId;\r
f51461c8 413 memmove (&Info->mVarStoreId, &mHeader->VarStoreInfo, sizeof (Info->mVarStoreId));\r
30fdf114
LG		 414 }\r
415 }\r
416\r
417 UINT8 FLAGS (VOID) {\r
418 return mHeader->Flags;\r
419 }\r
420\r
421public:\r
422 CIfrQuestionHeader (\r
423 IN EFI_IFR_QUESTION_HEADER *StartAddr, \r
424 IN UINT8 Flags = EFI_IFR_QUESTION_FLAG_DEFAULT\r
425 ) : CIfrStatementHeader (QH2SH(StartAddr)) {\r
426 mHeader = StartAddr;\r
427 mHeader->QuestionId = EFI_QUESTION_ID_INVALID;\r
428 mHeader->VarStoreId = EFI_VARSTORE_ID_INVALID;\r
429 mHeader->VarStoreInfo.VarName = EFI_STRING_ID_INVALID;\r
430 mHeader->VarStoreInfo.VarOffset = EFI_VAROFFSET_INVALID;\r
431 mHeader->Flags = Flags;\r
432 }\r
433\r
434 VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {\r
435 mHeader->QuestionId = QuestionId;\r
436 }\r
437\r
438 VOID SetVarStoreInfo (IN EFI_VARSTORE_INFO *Info) {\r
439 mHeader->VarStoreId = Info->mVarStoreId;\r
fd171542 440 mHeader->VarStoreInfo.VarName = Info->mInfo.mVarName;\r
30fdf114
LG		 441 mHeader->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset;\r
442 }\r
443\r
444 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 Flags) {\r
445 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_READ_ONLY)) {\r
446 mHeader->Flags |= EFI_IFR_FLAG_READ_ONLY;\r
447 }\r
448\r
449 _FLAG_CLEAR (Flags, 0x02);\r
450\r
451 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_CALLBACK)) {\r
452 mHeader->Flags |= EFI_IFR_FLAG_CALLBACK;\r
453 }\r
454 \r
455 //\r
456 // ignore NVAccessFlag\r
457 //\r
458 _FLAG_CLEAR (Flags, 0x08);\r
459\r
460 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_RESET_REQUIRED)) {\r
461 mHeader->Flags |= EFI_IFR_FLAG_RESET_REQUIRED;\r
462 }\r
366430c7
ED		 463\r
464 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_RECONNECT_REQUIRED)) {\r
465 mHeader->Flags |= EFI_IFR_FLAG_RECONNECT_REQUIRED;\r
466 }\r
467\r
30fdf114
LG		 468 //\r
469 // Set LateCheck Flag to compatible for framework flag\r
470 // but it uses 0x20 as its flag, if in the future UEFI may take this flag\r
471 //\r
472 if (_FLAG_TEST_AND_CLEAR (Flags, 0x20)) {\r
473 mHeader->Flags |= 0x20;\r
474 }\r
475\r
476 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_OPTIONS_ONLY)) {\r
477 mHeader->Flags |= EFI_IFR_FLAG_OPTIONS_ONLY;\r
478 }\r
479\r
480 return _FLAGS_ZERO (Flags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
481 }\r
4afd3d04
LG		 482\r
483 VOID UpdateCIfrQuestionHeader (IN EFI_IFR_QUESTION_HEADER *Header) {\r
484 mHeader = Header;\r
485 }\r
30fdf114
LG		 486};\r
487\r
30fdf114
LG		 488/*\r
489 * The definition of CIfrMinMaxStepData\r
490 */\r
491class CIfrMinMaxStepData {\r
492private:\r
493 MINMAXSTEP_DATA *mMinMaxStepData;\r
a709adfa
LG		 494 BOOLEAN ValueIsSet;\r
495 BOOLEAN IsNumeric;\r
30fdf114
LG		 496\r
497public:\r
a709adfa 498 CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr, BOOLEAN NumericOpcode=FALSE) : mMinMaxStepData (DataAddr) {\r
30fdf114
LG		 499 mMinMaxStepData->u64.MinValue = 0;\r
500 mMinMaxStepData->u64.MaxValue = 0;\r
501 mMinMaxStepData->u64.Step = 0;\r
a709adfa
LG		 502 ValueIsSet = FALSE;\r
503 IsNumeric = NumericOpcode;\r
30fdf114
LG		 504 }\r
505\r
506 VOID SetMinMaxStepData (IN UINT64 MinValue, IN UINT64 MaxValue, IN UINT64 Step) {\r
a709adfa
LG		 507 if (!ValueIsSet) {\r
508 mMinMaxStepData->u64.MinValue = MinValue;\r
509 mMinMaxStepData->u64.MaxValue = MaxValue;\r
510 ValueIsSet = TRUE;\r
511 } else {\r
512 if (MinValue < mMinMaxStepData->u64.MinValue) {\r
513 mMinMaxStepData->u64.MinValue = MinValue;\r
514 }\r
515 if (MaxValue > mMinMaxStepData->u64.MaxValue) {\r
516 mMinMaxStepData->u64.MaxValue = MaxValue;\r
517 }\r
518 }\r
519 mMinMaxStepData->u64.Step = Step;\r
30fdf114
LG		 520 }\r
521\r
522 VOID SetMinMaxStepData (IN UINT32 MinValue, IN UINT32 MaxValue, IN UINT32 Step) {\r
a709adfa
LG		 523 if (!ValueIsSet) {\r
524 mMinMaxStepData->u32.MinValue = MinValue;\r
525 mMinMaxStepData->u32.MaxValue = MaxValue;\r
526 ValueIsSet = TRUE;\r
527 } else {\r
528 if (MinValue < mMinMaxStepData->u32.MinValue) {\r
529 mMinMaxStepData->u32.MinValue = MinValue;\r
530 }\r
531 if (MaxValue > mMinMaxStepData->u32.MaxValue) {\r
532 mMinMaxStepData->u32.MaxValue = MaxValue;\r
533 }\r
534 }\r
535 mMinMaxStepData->u32.Step = Step;\r
30fdf114
LG		 536 }\r
537\r
538 VOID SetMinMaxStepData (IN UINT16 MinValue, IN UINT16 MaxValue, IN UINT16 Step) {\r
a709adfa
LG		 539 if (!ValueIsSet) {\r
540 mMinMaxStepData->u16.MinValue = MinValue;\r
541 mMinMaxStepData->u16.MaxValue = MaxValue;\r
542 ValueIsSet = TRUE;\r
543 } else {\r
544 if (MinValue < mMinMaxStepData->u16.MinValue) {\r
545 mMinMaxStepData->u16.MinValue = MinValue;\r
546 }\r
547 if (MaxValue > mMinMaxStepData->u16.MaxValue) {\r
548 mMinMaxStepData->u16.MaxValue = MaxValue;\r
549 }\r
550 }\r
551 mMinMaxStepData->u16.Step = Step;\r
30fdf114
LG		 552 }\r
553\r
554 VOID SetMinMaxStepData (IN UINT8 MinValue, IN UINT8 MaxValue, IN UINT8 Step) {\r
a709adfa
LG		 555 if (!ValueIsSet) {\r
556 mMinMaxStepData->u8.MinValue = MinValue;\r
557 mMinMaxStepData->u8.MaxValue = MaxValue;\r
558 ValueIsSet = TRUE;\r
559 } else {\r
560 if (MinValue < mMinMaxStepData->u8.MinValue) {\r
561 mMinMaxStepData->u8.MinValue = MinValue;\r
562 }\r
563 if (MaxValue > mMinMaxStepData->u8.MaxValue) {\r
564 mMinMaxStepData->u8.MaxValue = MaxValue;\r
565 }\r
566 }\r
567 mMinMaxStepData->u8.Step = Step;\r
568 }\r
569\r
42c808d4 570 UINT64 GetMinData (UINT8 VarType, BOOLEAN IsBitVar) {\r
a709adfa 571 UINT64 MinValue = 0;\r
42c808d4
DB		 572 if (IsBitVar) {\r
573 MinValue = mMinMaxStepData->u32.MinValue;\r
574 return MinValue;\r
575 }\r
a709adfa
LG		 576 switch (VarType) {\r
577 case EFI_IFR_TYPE_NUM_SIZE_64:\r
578 MinValue = mMinMaxStepData->u64.MinValue;\r
579 break;\r
580 case EFI_IFR_TYPE_NUM_SIZE_32:\r
581 MinValue = (UINT64) mMinMaxStepData->u32.MinValue;\r
582 break;\r
583 case EFI_IFR_TYPE_NUM_SIZE_16:\r
584 MinValue = (UINT64) mMinMaxStepData->u16.MinValue;\r
585 break;\r
586 case EFI_IFR_TYPE_NUM_SIZE_8:\r
587 MinValue = (UINT64) mMinMaxStepData->u8.MinValue;\r
588 break;\r
589 default:\r
590 break;\r
591 }\r
592 return MinValue;\r
593 }\r
594\r
42c808d4 595 UINT64 GetMaxData (UINT8 VarType, BOOLEAN IsBitVar) {\r
a709adfa 596 UINT64 MaxValue = 0;\r
42c808d4
DB		 597 if (IsBitVar) {\r
598 MaxValue = mMinMaxStepData->u32.MaxValue;\r
599 return MaxValue;\r
600 }\r
a709adfa
LG		 601 switch (VarType) {\r
602 case EFI_IFR_TYPE_NUM_SIZE_64:\r
603 MaxValue = mMinMaxStepData->u64.MaxValue;\r
604 break;\r
605 case EFI_IFR_TYPE_NUM_SIZE_32:\r
606 MaxValue = (UINT64) mMinMaxStepData->u32.MaxValue;\r
607 break;\r
608 case EFI_IFR_TYPE_NUM_SIZE_16:\r
609 MaxValue = (UINT64) mMinMaxStepData->u16.MaxValue;\r
610 break;\r
611 case EFI_IFR_TYPE_NUM_SIZE_8:\r
612 MaxValue = (UINT64) mMinMaxStepData->u8.MaxValue;\r
613 break;\r
614 default:\r
615 break;\r
616 }\r
617 return MaxValue;\r
618 }\r
619\r
42c808d4 620 UINT64 GetStepData (UINT8 VarType, BOOLEAN IsBitVar) {\r
a709adfa 621 UINT64 MaxValue = 0;\r
42c808d4
DB		 622 if (IsBitVar) {\r
623 MaxValue = mMinMaxStepData->u32.Step;\r
624 return MaxValue;\r
625 }\r
a709adfa
LG		 626 switch (VarType) {\r
627 case EFI_IFR_TYPE_NUM_SIZE_64:\r
628 MaxValue = mMinMaxStepData->u64.Step;\r
629 break;\r
630 case EFI_IFR_TYPE_NUM_SIZE_32:\r
631 MaxValue = (UINT64) mMinMaxStepData->u32.Step;\r
632 break;\r
633 case EFI_IFR_TYPE_NUM_SIZE_16:\r
634 MaxValue = (UINT64) mMinMaxStepData->u16.Step;\r
635 break;\r
636 case EFI_IFR_TYPE_NUM_SIZE_8:\r
637 MaxValue = (UINT64) mMinMaxStepData->u8.Step;\r
638 break;\r
639 default:\r
640 break;\r
641 }\r
642 return MaxValue;\r
30fdf114
LG		 643 }\r
644\r
a709adfa
LG		 645 BOOLEAN IsNumericOpcode () {\r
646 return IsNumeric;\r
647 }\r
4afd3d04
LG		 648\r
649 VOID UpdateCIfrMinMaxStepData (IN MINMAXSTEP_DATA *MinMaxStepData) {\r
650 mMinMaxStepData = MinMaxStepData;\r
651 }\r
30fdf114
LG		 652};\r
653\r
a709adfa
LG		 654static CIfrQuestionHeader *gCurrentQuestion = NULL;\r
655static CIfrMinMaxStepData *gCurrentMinMaxData = NULL;\r
ddaf640f 656static BOOLEAN gIsOrderedList = FALSE;\r
2bf63b20 657static BOOLEAN gIsStringOp = FALSE;\r
a709adfa 658\r
30fdf114
LG		 659/*\r
660 * The definition of all of the UEFI IFR Objects\r
661 */\r
662class CIfrFormSet : public CIfrObj, public CIfrOpHeader {\r
663private:\r
664 EFI_IFR_FORM_SET *mFormSet;\r
52302d4d 665 EFI_GUID *mClassGuid;\r
30fdf114
LG		 666\r
667public:\r
668 CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mFormSet, Size),\r
669 CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header, Size) {\r
670 mFormSet->Help = EFI_STRING_ID_INVALID;\r
671 mFormSet->FormSetTitle = EFI_STRING_ID_INVALID;\r
672 mFormSet->Flags = 0;\r
673 memset (&mFormSet->Guid, 0, sizeof (EFI_GUID));\r
52302d4d 674 mClassGuid = (EFI_GUID *) (mFormSet + 1);\r
30fdf114
LG		 675 }\r
676\r
677 VOID SetGuid (IN EFI_GUID *Guid) {\r
f51461c8 678 memmove (&mFormSet->Guid, Guid, sizeof (EFI_GUID));\r
30fdf114
LG		 679 }\r
680\r
681 VOID SetFormSetTitle (IN EFI_STRING_ID FormSetTitle) {\r
682 mFormSet->FormSetTitle = FormSetTitle;\r
683 }\r
684\r
685 VOID SetHelp (IN EFI_STRING_ID Help) {\r
686 mFormSet->Help = Help;\r
687 }\r
688\r
689 VOID SetClassGuid (IN EFI_GUID *Guid) {\r
f51461c8 690 memmove (&(mClassGuid[mFormSet->Flags++]), Guid, sizeof (EFI_GUID));\r
30fdf114
LG		 691 }\r
692\r
693 UINT8 GetFlags() {\r
694 return mFormSet->Flags;\r
695 }\r
696};\r
697\r
698class CIfrEnd : public CIfrObj, public CIfrOpHeader {\r
699private:\r
700 EFI_IFR_END *mEnd;\r
701\r
702public:\r
703 CIfrEnd () : CIfrObj (EFI_IFR_END_OP, (CHAR8 **)&mEnd),\r
704 CIfrOpHeader (EFI_IFR_END_OP, &mEnd->Header) {}\r
705};\r
706\r
707class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader {\r
708private:\r
709 EFI_IFR_DEFAULTSTORE *mDefaultStore;\r
710\r
711public:\r
712 CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP, (CHAR8 **)&mDefaultStore),\r
713 CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &mDefaultStore->Header) {\r
714 mDefaultStore->DefaultId = EFI_VARSTORE_ID_INVALID;\r
715 mDefaultStore->DefaultName = EFI_STRING_ID_INVALID;\r
716 }\r
717\r
718 VOID SetDefaultName (IN EFI_STRING_ID DefaultName) {\r
719 mDefaultStore->DefaultName = DefaultName;\r
720 }\r
721\r
722 VOID SetDefaultId (IN UINT16 DefaultId) {\r
723 mDefaultStore->DefaultId = DefaultId;\r
724 }\r
725};\r
726\r
727#define EFI_FORM_ID_MAX 0xFFFF\r
728#define EFI_FREE_FORM_ID_BITMAP_SIZE ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)\r
729\r
52302d4d
LG		 730class CIfrFormId {\r
731public:\r
30fdf114
LG		 732 STATIC UINT32 FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE];\r
733\r
734 STATIC BOOLEAN ChekFormIdFree (IN EFI_FORM_ID FormId) {\r
735 UINT32 Index = (FormId / EFI_BITS_PER_UINT32);\r
736 UINT32 Offset = (FormId % EFI_BITS_PER_UINT32);\r
737\r
738 return (FormIdBitMap[Index] & (0x80000000 >> Offset)) == 0;\r
739 }\r
740\r
741 STATIC VOID MarkFormIdUsed (IN EFI_FORM_ID FormId) {\r
742 UINT32 Index = (FormId / EFI_BITS_PER_UINT32);\r
743 UINT32 Offset = (FormId % EFI_BITS_PER_UINT32);\r
744\r
745 FormIdBitMap[Index] |= (0x80000000 >> Offset);\r
746 }\r
52302d4d
LG		 747};\r
748\r
749class CIfrForm : public CIfrObj, public CIfrOpHeader {\r
750private:\r
751 EFI_IFR_FORM *mForm;\r
30fdf114
LG		 752\r
753public:\r
754 CIfrForm () : CIfrObj (EFI_IFR_FORM_OP, (CHAR8 **)&mForm), \r
755 CIfrOpHeader (EFI_IFR_FORM_OP, &mForm->Header) {\r
756 mForm->FormId = 0;\r
757 mForm->FormTitle = EFI_STRING_ID_INVALID;\r
758 }\r
759\r
760 EFI_VFR_RETURN_CODE SetFormId (IN EFI_FORM_ID FormId) {\r
fd171542 761 if (FormId == 0) {\r
762 //\r
763 // FormId can't be 0.\r
764 //\r
765 return VFR_RETURN_INVALID_PARAMETER;\r
766 }\r
52302d4d 767 if (CIfrFormId::ChekFormIdFree (FormId) == FALSE) {\r
30fdf114
LG		 768 return VFR_RETURN_FORMID_REDEFINED;\r
769 }\r
770 mForm->FormId = FormId;\r
52302d4d 771 CIfrFormId::MarkFormIdUsed (FormId);\r
30fdf114
LG		 772 return VFR_RETURN_SUCCESS;\r
773 }\r
774\r
775 VOID SetFormTitle (IN EFI_STRING_ID FormTitle) {\r
776 mForm->FormTitle = FormTitle;\r
777 }\r
778};\r
779\r
52302d4d
LG		 780class CIfrFormMap : public CIfrObj, public CIfrOpHeader {\r
781private:\r
782 EFI_IFR_FORM_MAP *mFormMap;\r
783 EFI_IFR_FORM_MAP_METHOD *mMethodMap;\r
784\r
785public:\r
786 CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP, (CHAR8 **)&mFormMap, sizeof (EFI_IFR_FORM_MAP), TRUE), \r
787 CIfrOpHeader (EFI_IFR_FORM_MAP_OP, &mFormMap->Header) {\r
788 mFormMap->FormId = 0;\r
789 mMethodMap = (EFI_IFR_FORM_MAP_METHOD *) (mFormMap + 1);\r
790 }\r
791\r
792 EFI_VFR_RETURN_CODE SetFormId (IN EFI_FORM_ID FormId) {\r
793 if (FormId == 0) {\r
794 //\r
795 // FormId can't be 0.\r
796 //\r
797 return VFR_RETURN_INVALID_PARAMETER;\r
798 }\r
799 if (CIfrFormId::ChekFormIdFree (FormId) == FALSE) {\r
800 return VFR_RETURN_FORMID_REDEFINED;\r
801 }\r
802 mFormMap->FormId = FormId;\r
803 CIfrFormId::MarkFormIdUsed (FormId);\r
804 return VFR_RETURN_SUCCESS;\r
805 }\r
806\r
807 VOID SetFormMapMethod (IN EFI_STRING_ID MethodTitle, IN EFI_GUID *MethodGuid) {\r
808 if (ExpendObjBin (sizeof (EFI_IFR_FORM_MAP_METHOD))) {\r
809 IncLength (sizeof (EFI_IFR_FORM_MAP_METHOD));\r
810\r
811 mMethodMap->MethodTitle = MethodTitle;\r
f51461c8 812 memmove (&(mMethodMap->MethodIdentifier), MethodGuid, sizeof (EFI_GUID));\r
52302d4d
LG		 813 mMethodMap ++;\r
814 }\r
815 }\r
816};\r
817\r
30fdf114
LG		 818class CIfrVarStore : public CIfrObj, public CIfrOpHeader {\r
819private:\r
820 EFI_IFR_VARSTORE *mVarStore;\r
821\r
822public:\r
823 CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)&mVarStore, sizeof (EFI_IFR_VARSTORE), TRUE), \r
824 CIfrOpHeader (EFI_IFR_VARSTORE_OP, &mVarStore->Header) {\r
825 mVarStore->VarStoreId = EFI_VARSTORE_ID_INVALID;\r
826 mVarStore->Size = 0;\r
827 memset (&mVarStore->Guid, 0, sizeof (EFI_GUID));\r
828 mVarStore->Name[0] = '\0';\r
829 }\r
830\r
831 VOID SetGuid (IN EFI_GUID *Guid) {\r
f51461c8 832 memmove (&mVarStore->Guid, Guid, sizeof (EFI_GUID));\r
30fdf114
LG		 833 }\r
834\r
835 VOID SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId) {\r
836 mVarStore->VarStoreId = VarStoreId;\r
837 }\r
838\r
839 VOID SetSize (IN UINT16 Size) {\r
840 mVarStore->Size = Size;\r
841 }\r
842\r
843 VOID SetName (IN CHAR8 *Name) {\r
844 UINT8 Len;\r
845\r
846 if (Name != NULL) {\r
52302d4d 847 Len = (UINT8) strlen (Name);\r
30fdf114
LG		 848 if (Len != 0) {\r
849 if (ExpendObjBin (Len) == TRUE) {\r
850 IncLength (Len);\r
851 strcpy ((CHAR8 *)(mVarStore->Name), Name);\r
852 }\r
853 }\r
854 }\r
855 }\r
856};\r
857\r
858class CIfrVarStoreEfi : public CIfrObj, public CIfrOpHeader {\r
859private:\r
860 EFI_IFR_VARSTORE_EFI *mVarStoreEfi;\r
861\r
862public:\r
4234283c 863 CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)&mVarStoreEfi, sizeof (EFI_IFR_VARSTORE_EFI), TRUE),\r
30fdf114
LG		 864 CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &mVarStoreEfi->Header) {\r
865 mVarStoreEfi->VarStoreId = EFI_VAROFFSET_INVALID;\r
4234283c 866 mVarStoreEfi->Size = 0;\r
30fdf114 867 memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID));\r
4234283c 868 mVarStoreEfi->Name[0] = '\0';\r
30fdf114
LG		 869 }\r
870\r
871 VOID SetGuid (IN EFI_GUID *Guid) {\r
f51461c8 872 memmove (&mVarStoreEfi->Guid, Guid, sizeof (EFI_GUID));\r
30fdf114
LG		 873 }\r
874\r
875 VOID SetVarStoreId (IN UINT16 VarStoreId) {\r
876 mVarStoreEfi->VarStoreId = VarStoreId;\r
877 }\r
878\r
879 VOID SetAttributes (IN UINT32 Attributes) {\r
880 mVarStoreEfi->Attributes = Attributes;\r
881 }\r
4234283c
LG		 882 VOID SetSize (IN UINT16 Size) {\r
883 mVarStoreEfi->Size = Size;\r
884 }\r
885\r
886 VOID SetName (IN CHAR8 *Name) {\r
887 UINT8 Len;\r
888\r
889 if (Name != NULL) {\r
890 Len = (UINT8) strlen (Name);\r
891 if (Len != 0) {\r
892 if (ExpendObjBin (Len) == TRUE) {\r
893 IncLength (Len);\r
894 strcpy ((CHAR8 *)(mVarStoreEfi->Name), Name);\r
895 }\r
896 }\r
897 }\r
898 }\r
899\r
900 VOID SetBinaryLength (IN UINT16 Size) {\r
901 UINT16 Len;\r
902\r
903 Len = sizeof (EFI_IFR_VARSTORE_EFI);\r
904 if (Size > Len) {\r
905 ExpendObjBin(Size - Len);\r
906 IncLength(Size - Len);\r
907 } else {\r
908 ShrinkObjBin(Len - Size);\r
909 DecLength(Len - Size);\r
910 }\r
911 }\r
30fdf114
LG		 912};\r
913\r
914class CIfrVarStoreNameValue : public CIfrObj, public CIfrOpHeader {\r
915private:\r
916 EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue;\r
917\r
918public:\r
919 CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP, (CHAR8 **)&mVarStoreNameValue), \r
920 CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &mVarStoreNameValue->Header) {\r
921 mVarStoreNameValue->VarStoreId = EFI_VAROFFSET_INVALID;\r
922 memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID));\r
923 }\r
924\r
925 VOID SetGuid (IN EFI_GUID *Guid) {\r
f51461c8 926 memmove (&mVarStoreNameValue->Guid, Guid, sizeof (EFI_GUID));\r
30fdf114
LG		 927 }\r
928\r
929 VOID SetVarStoreId (IN UINT16 VarStoreId) {\r
930 mVarStoreNameValue->VarStoreId = VarStoreId;\r
931 }\r
932};\r
933\r
934class CIfrImage : public CIfrObj, public CIfrOpHeader {\r
935private:\r
936 EFI_IFR_IMAGE *mImage;\r
937\r
938public:\r
939 CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP, (CHAR8 **)&mImage),\r
0d2711a6 940 CIfrOpHeader (EFI_IFR_IMAGE_OP, &mImage->Header) {\r
30fdf114
LG		 941 mImage->Id = EFI_IMAGE_ID_INVALID;\r
942 }\r
943\r
944 VOID SetImageId (IN EFI_IMAGE_ID ImageId) {\r
945 mImage->Id = ImageId;\r
946 }\r
947};\r
948\r
4234283c
LG		 949class CIfrModal : public CIfrObj, public CIfrOpHeader {\r
950private:\r
4afd3d04 951 EFI_IFR_MODAL_TAG *mModal;\r
4234283c
LG		 952\r
953public:\r
954 CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP, (CHAR8 **)&mModal),\r
955 CIfrOpHeader (EFI_IFR_MODAL_TAG_OP, &mModal->Header) {\r
956 }\r
957};\r
958\r
959\r
30fdf114
LG		 960class CIfrLocked : public CIfrObj, public CIfrOpHeader {\r
961private:\r
962 EFI_IFR_LOCKED *mLocked;\r
963\r
964public:\r
965 CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP, (CHAR8 **)&mLocked),\r
966 CIfrOpHeader (EFI_IFR_LOCKED_OP, &mLocked->Header) {}\r
967};\r
968\r
969class CIfrRule : public CIfrObj, public CIfrOpHeader {\r
970private:\r
971 EFI_IFR_RULE *mRule;\r
972\r
973public:\r
974 CIfrRule () : CIfrObj (EFI_IFR_RULE_OP, (CHAR8 **)&mRule),\r
975 mRule ((EFI_IFR_RULE *)GetObjBinAddr()),\r
976 CIfrOpHeader (EFI_IFR_RULE_OP, &mRule->Header) {\r
977 mRule->RuleId = EFI_RULE_ID_INVALID;\r
978 }\r
979\r
980 VOID SetRuleId (IN UINT8 RuleId) {\r
981 mRule->RuleId = RuleId;\r
982 }\r
983};\r
984\r
985static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue = {0, };\r
986\r
987class CIfrDefault : public CIfrObj, public CIfrOpHeader {\r
988private:\r
989 EFI_IFR_DEFAULT *mDefault;\r
990\r
991public:\r
992 CIfrDefault (\r
4afd3d04 993 IN UINT8 Size,\r
30fdf114
LG		 994 IN UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,\r
995 IN UINT8 Type = EFI_IFR_TYPE_OTHER,\r
996 IN EFI_IFR_TYPE_VALUE Value = gZeroEfiIfrTypeValue\r
4afd3d04
LG		 997 ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault, Size),\r
998 CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header, Size) {\r
30fdf114 999 mDefault->Type = Type;\r
30fdf114 1000 mDefault->DefaultId = DefaultId;\r
f51461c8 1001 memmove (&(mDefault->Value), &Value, Size - OFFSET_OF (EFI_IFR_DEFAULT, Value));\r
30fdf114
LG		 1002 }\r
1003\r
1004 VOID SetDefaultId (IN UINT16 DefaultId) {\r
1005 mDefault->DefaultId = DefaultId;\r
1006 }\r
1007\r
1008 VOID SetType (IN UINT8 Type) {\r
1009 mDefault->Type = Type;\r
1010 }\r
1011\r
1012 VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {\r
f51461c8 1013 memmove (&mDefault->Value, &Value, mDefault->Header.Length - OFFSET_OF (EFI_IFR_DEFAULT, Value));\r
4afd3d04
LG		 1014 }\r
1015};\r
1016\r
1017class CIfrDefault2 : public CIfrObj, public CIfrOpHeader {\r
1018private:\r
1019 EFI_IFR_DEFAULT_2 *mDefault;\r
1020\r
1021public:\r
1022 CIfrDefault2 (\r
1023 IN UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,\r
1024 IN UINT8 Type = EFI_IFR_TYPE_OTHER\r
1025 ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault, sizeof (EFI_IFR_DEFAULT_2)),\r
1026 CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header, sizeof (EFI_IFR_DEFAULT_2)) {\r
1027 mDefault->Type = Type;\r
1028 mDefault->DefaultId = DefaultId;\r
1029 }\r
1030\r
1031 VOID SetDefaultId (IN UINT16 DefaultId) {\r
1032 mDefault->DefaultId = DefaultId;\r
1033 }\r
1034\r
1035 VOID SetType (IN UINT8 Type) {\r
1036 mDefault->Type = Type;\r
30fdf114
LG		 1037 }\r
1038};\r
1039\r
1040class CIfrValue : public CIfrObj, public CIfrOpHeader{\r
1041private:\r
1042 EFI_IFR_VALUE *mValue;\r
1043\r
1044public:\r
1045 CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP, (CHAR8 **)&mValue),\r
1046 CIfrOpHeader (EFI_IFR_VALUE_OP, &mValue->Header) {}\r
1047\r
1048};\r
1049\r
52302d4d
LG		 1050class CIfrRead : public CIfrObj, public CIfrOpHeader{\r
1051private:\r
1052 EFI_IFR_READ *mRead;\r
1053\r
1054public:\r
1055 CIfrRead () : CIfrObj (EFI_IFR_READ_OP, (CHAR8 **)&mRead),\r
1056 CIfrOpHeader (EFI_IFR_READ_OP, &mRead->Header) {}\r
1057\r
1058};\r
1059\r
1060class CIfrWrite : public CIfrObj, public CIfrOpHeader{\r
1061private:\r
1062 EFI_IFR_WRITE *mWrite;\r
1063\r
1064public:\r
1065 CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP, (CHAR8 **)&mWrite),\r
1066 CIfrOpHeader (EFI_IFR_WRITE_OP, &mWrite->Header) {}\r
1067\r
1068};\r
1069\r
1070class CIfrGet : public CIfrObj, public CIfrOpHeader{\r
1071private:\r
1072 EFI_IFR_GET *mGet;\r
1073\r
1074public:\r
1075 CIfrGet (\r
1076 IN UINT32 LineNo \r
1077 ) : CIfrObj (EFI_IFR_GET_OP, (CHAR8 **)&mGet),\r
1078 CIfrOpHeader (EFI_IFR_GET_OP, &mGet->Header) {\r
1079 SetLineNo (LineNo);\r
1080 }\r
1081\r
1082 VOID SetVarInfo (IN EFI_VARSTORE_INFO *Info) {\r
1083 mGet->VarStoreId = Info->mVarStoreId;\r
1084 mGet->VarStoreInfo.VarName = Info->mInfo.mVarName;\r
1085 mGet->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset;\r
1086 mGet->VarStoreType = Info->mVarType;\r
1087 }\r
1088};\r
1089\r
1090class CIfrSet : public CIfrObj, public CIfrOpHeader{\r
1091private:\r
1092 EFI_IFR_SET *mSet;\r
1093\r
1094public:\r
1095 CIfrSet (\r
1096 IN UINT32 LineNo\r
1097 ) : CIfrObj (EFI_IFR_SET_OP, (CHAR8 **)&mSet),\r
1098 CIfrOpHeader (EFI_IFR_SET_OP, &mSet->Header) {\r
1099 SetLineNo (LineNo);\r
1100 }\r
1101\r
1102 VOID SetVarInfo (IN EFI_VARSTORE_INFO *Info) {\r
1103 mSet->VarStoreId = Info->mVarStoreId;\r
1104 mSet->VarStoreInfo.VarName = Info->mInfo.mVarName;\r
1105 mSet->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset;\r
1106 mSet->VarStoreType = Info->mVarType;\r
1107 }\r
1108};\r
1109\r
30fdf114
LG		 1110class CIfrSubtitle : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {\r
1111private:\r
1112 EFI_IFR_SUBTITLE *mSubtitle;\r
1113\r
1114public:\r
1115 CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP, (CHAR8 **)&mSubtitle),\r
1116 CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &mSubtitle->Header),\r
fd171542 1117 CIfrStatementHeader (&mSubtitle->Statement) {\r
30fdf114
LG		 1118 mSubtitle->Flags = 0;\r
1119 }\r
1120\r
1121 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {\r
1122 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_HORIZONTAL)) {\r
1123 mSubtitle->Flags |= EFI_IFR_FLAGS_HORIZONTAL;\r
1124 }\r
1125\r
1126 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1127 }\r
1128};\r
1129\r
1130class CIfrText : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {\r
1131private:\r
1132 EFI_IFR_TEXT *mText;\r
1133\r
1134public:\r
1135 CIfrText () : CIfrObj (EFI_IFR_TEXT_OP, (CHAR8 **)&mText),\r
1136 CIfrOpHeader (EFI_IFR_TEXT_OP, &mText->Header), \r
1137 CIfrStatementHeader (&mText->Statement) {\r
1138 mText->TextTwo = EFI_STRING_ID_INVALID;\r
1139 }\r
1140\r
1141 VOID SetTextTwo (IN EFI_STRING_ID StringId) {\r
1142 mText->TextTwo = StringId;\r
1143 }\r
1144};\r
1145\r
1146class CIfrRef : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1147private:\r
1148 EFI_IFR_REF *mRef;\r
1149\r
1150public:\r
1151 CIfrRef () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef),\r
1152 CIfrOpHeader (EFI_IFR_REF_OP, &mRef->Header), \r
1153 CIfrQuestionHeader (&mRef->Question) {\r
1154 mRef->FormId = 0;\r
1155 }\r
1156\r
1157 VOID SetFormId (IN EFI_FORM_ID FormId) {\r
1158 mRef->FormId = FormId;\r
1159 }\r
1160};\r
1161\r
1162class CIfrRef2 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1163private:\r
1164 EFI_IFR_REF2 *mRef2;\r
1165\r
1166public:\r
1167 CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef2, sizeof (EFI_IFR_REF2)),\r
1168 CIfrOpHeader (EFI_IFR_REF_OP, &mRef2->Header, sizeof (EFI_IFR_REF2)), \r
1169 CIfrQuestionHeader (&mRef2->Question) {\r
1170 mRef2->FormId = 0;\r
1171 mRef2->QuestionId = EFI_QUESTION_ID_INVALID;\r
1172 }\r
1173\r
1174 VOID SetFormId (IN EFI_FORM_ID FormId) {\r
1175 mRef2->FormId = FormId;\r
1176 }\r
1177\r
0d2711a6 1178 VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {\r
30fdf114 1179 mRef2->QuestionId = QuestionId;\r
30fdf114
LG		 1180 }\r
1181};\r
1182\r
1183class CIfrRef3 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1184private:\r
1185 EFI_IFR_REF3 *mRef3;\r
1186\r
1187public:\r
1188 CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef3, sizeof(EFI_IFR_REF3)),\r
1189 CIfrOpHeader (EFI_IFR_REF_OP, &mRef3->Header, sizeof (EFI_IFR_REF3)), \r
1190 CIfrQuestionHeader (&mRef3->Question) {\r
1191 mRef3->FormId = 0;\r
1192 mRef3->QuestionId = EFI_QUESTION_ID_INVALID;\r
1193 memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID));\r
1194 }\r
1195\r
1196 VOID SetFormId (IN EFI_FORM_ID FormId) {\r
1197 mRef3->FormId = FormId;\r
1198 }\r
1199\r
1200 VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {\r
1201 mRef3->QuestionId = QuestionId;\r
1202 }\r
1203\r
1204 VOID SetFormSetId (IN EFI_GUID FormSetId) {\r
1205 mRef3->FormSetId = FormSetId;\r
1206 }\r
1207};\r
1208\r
1209class CIfrRef4 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1210private:\r
1211 EFI_IFR_REF4 *mRef4;\r
1212\r
1213public:\r
4234283c
LG		 1214 CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef4, sizeof(EFI_IFR_REF4)),\r
1215 CIfrOpHeader (EFI_IFR_REF_OP, &mRef4->Header, sizeof(EFI_IFR_REF4)), \r
30fdf114
LG		 1216 CIfrQuestionHeader (&mRef4->Question) {\r
1217 mRef4->FormId = 0;\r
1218 mRef4->QuestionId = EFI_QUESTION_ID_INVALID;\r
1219 memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID));\r
1220 mRef4->DevicePath = EFI_STRING_ID_INVALID;\r
1221 }\r
1222\r
1223 VOID SetFormId (IN EFI_FORM_ID FormId) {\r
1224 mRef4->FormId = FormId;\r
1225 }\r
1226\r
1227 VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {\r
1228 mRef4->QuestionId = QuestionId;\r
1229 }\r
1230\r
1231 VOID SetFormSetId (IN EFI_GUID FormSetId) {\r
1232 mRef4->FormSetId = FormSetId;\r
1233 }\r
1234\r
1235 VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {\r
1236 mRef4->DevicePath = DevicePath;\r
1237 }\r
1238};\r
1239\r
4234283c
LG		 1240class CIfrRef5 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1241private:\r
1242 EFI_IFR_REF5 *mRef5;\r
1243\r
1244public:\r
1245 CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef5, sizeof (EFI_IFR_REF5)),\r
1246 CIfrOpHeader (EFI_IFR_REF_OP, &mRef5->Header, sizeof (EFI_IFR_REF5)), \r
1247 CIfrQuestionHeader (&mRef5->Question) {\r
1248 }\r
1249};\r
1250\r
30fdf114
LG		 1251class CIfrResetButton : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {\r
1252private:\r
1253 EFI_IFR_RESET_BUTTON *mResetButton;\r
1254\r
1255public:\r
1256 CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP, (CHAR8 **)&mResetButton),\r
1257 CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetButton->Header), \r
fd171542 1258 CIfrStatementHeader (&mResetButton->Statement) {\r
30fdf114
LG		 1259 mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;\r
1260 }\r
1261\r
1262 VOID SetDefaultId (IN UINT16 DefaultId) {\r
1263 mResetButton->DefaultId = DefaultId;\r
1264 }\r
1265};\r
1266\r
1267class CIfrCheckBox : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1268private:\r
1269 EFI_IFR_CHECKBOX *mCheckBox;\r
1270\r
1271public:\r
1272 CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox),\r
1273 CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Header), \r
1274 CIfrQuestionHeader (&mCheckBox->Question) {\r
1275 mCheckBox->Flags = 0;\r
fd171542 1276 gCurrentQuestion = this;\r
30fdf114
LG		 1277 }\r
1278\r
1279 ~CIfrCheckBox () {\r
fd171542 1280 gCurrentQuestion = NULL;\r
30fdf114
LG		 1281 }\r
1282\r
1283 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, UINT8 LFlags) {\r
1284 EFI_VFR_RETURN_CODE Ret;\r
1285\r
1286 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1287 if (Ret != VFR_RETURN_SUCCESS) {\r
1288 return Ret;\r
1289 }\r
1290\r
1291 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT)) {\r
1292 mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT;\r
1293 }\r
1294\r
1295 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT_MFG)) {\r
1296 mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT_MFG;\r
1297 }\r
1298\r
1299 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1300 }\r
1301\r
1302 UINT8 GetFlags (VOID) {\r
1303 return mCheckBox->Flags;\r
1304 }\r
1305};\r
1306\r
1307class CIfrAction : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1308private:\r
1309 EFI_IFR_ACTION *mAction;\r
1310\r
1311public:\r
1312 CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP, (CHAR8 **)&mAction),\r
1313 CIfrOpHeader (EFI_IFR_ACTION_OP, &mAction->Header), \r
1314 CIfrQuestionHeader (&mAction->Question) {\r
1315 mAction->QuestionConfig = EFI_STRING_ID_INVALID;\r
1316 }\r
1317\r
1318 VOID SetQuestionConfig (IN EFI_STRING_ID QuestionConfig) {\r
1319 mAction->QuestionConfig = QuestionConfig;\r
1320 }\r
1321};\r
1322\r
1323class CIfrDate : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1324private:\r
1325 EFI_IFR_DATE *mDate;\r
1326\r
1327public:\r
1328 CIfrDate () : CIfrObj (EFI_IFR_DATE_OP, (CHAR8 **)&mDate),\r
1329 CIfrOpHeader (EFI_IFR_DATE_OP, &mDate->Header),\r
1330 CIfrQuestionHeader (&mDate->Question) {\r
1331 mDate->Flags = 0;\r
1332 }\r
1333\r
1334 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1335 EFI_VFR_RETURN_CODE Ret;\r
1336\r
1337 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1338 if (Ret != VFR_RETURN_SUCCESS) {\r
1339 return Ret;\r
1340 }\r
1341\r
1342 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_YEAR_SUPPRESS)) {\r
1343 mDate->Flags |= EFI_QF_DATE_YEAR_SUPPRESS;\r
1344 }\r
1345\r
1346 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_MONTH_SUPPRESS)) {\r
1347 mDate->Flags |= EFI_QF_DATE_MONTH_SUPPRESS;\r
1348 }\r
1349\r
1350 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_DAY_SUPPRESS)) {\r
1351 mDate->Flags |= EFI_QF_DATE_DAY_SUPPRESS;\r
1352 }\r
1353\r
1354 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_NORMAL)) {\r
1355 mDate->Flags |= QF_DATE_STORAGE_NORMAL;\r
1356 } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_TIME)) {\r
1357 mDate->Flags |= QF_DATE_STORAGE_TIME;\r
1358 } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_WAKEUP)) {\r
1359 mDate->Flags |= QF_DATE_STORAGE_WAKEUP;\r
1360 }\r
1361\r
1362 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1363 }\r
1364};\r
1365\r
1366class CIfrNumeric : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {\r
1367private:\r
1368 EFI_IFR_NUMERIC *mNumeric;\r
1369\r
1370public:\r
4afd3d04 1371 CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric, sizeof (EFI_IFR_NUMERIC), TRUE),\r
30fdf114
LG		 1372 CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),\r
1373 CIfrQuestionHeader (&mNumeric->Question),\r
a709adfa 1374 CIfrMinMaxStepData (&mNumeric->data, TRUE) {\r
30fdf114 1375 mNumeric->Flags = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;\r
a709adfa
LG		 1376 gCurrentQuestion = this;\r
1377 gCurrentMinMaxData = this;\r
30fdf114
LG		 1378 }\r
1379\r
1380 ~CIfrNumeric () {\r
a709adfa
LG		 1381 gCurrentQuestion = NULL;\r
1382 gCurrentMinMaxData = NULL;\r
30fdf114
LG		 1383 }\r
1384\r
4afd3d04
LG		 1385 VOID ShrinkBinSize (IN UINT16 Size) {\r
1386 //\r
1387 // Update the buffer size which is truly be used later.\r
1388 //\r
1389 ShrinkObjBin(Size);\r
1390 DecLength(Size);\r
1391\r
1392 //\r
1393 // Allocate buffer in gCFormPkg.\r
1394 //\r
1395 _EMIT_PENDING_OBJ();\r
1396\r
1397 //\r
1398 // Update the buffer pointer used by other class.\r
1399 //\r
1400 mNumeric = (EFI_IFR_NUMERIC *) GetObjBinAddr();\r
1401 UpdateHeader (&mNumeric->Header);\r
1402 UpdateCIfrQuestionHeader(&mNumeric->Question);\r
1403 UpdateCIfrMinMaxStepData(&mNumeric->data);\r
1404 }\r
1405\r
e4ac870f 1406 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags, BOOLEAN DisplaySettingsSpecified = FALSE) {\r
30fdf114
LG		 1407 EFI_VFR_RETURN_CODE Ret;\r
1408\r
1409 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1410 if (Ret != VFR_RETURN_SUCCESS) {\r
1411 return Ret;\r
1412 }\r
1413\r
e4ac870f 1414 if (DisplaySettingsSpecified == FALSE) {\r
30fdf114 1415 mNumeric->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;\r
e4ac870f
LG		 1416 } else {\r
1417 mNumeric->Flags = LFlags;\r
30fdf114
LG		 1418 }\r
1419 return VFR_RETURN_SUCCESS;\r
1420 }\r
1afac950 1421\r
42c808d4
DB		 1422 EFI_VFR_RETURN_CODE SetFlagsForBitField (IN UINT8 HFlags, IN UINT8 LFlags, BOOLEAN DisplaySettingsSpecified = FALSE) {\r
1423 EFI_VFR_RETURN_CODE Ret;\r
1424\r
1425 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1426 if (Ret != VFR_RETURN_SUCCESS) {\r
1427 return Ret;\r
1428 }\r
1429\r
1430 if (DisplaySettingsSpecified == FALSE) {\r
1431 mNumeric->Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT;\r
1432 } else {\r
1433 mNumeric->Flags = LFlags;\r
1434 }\r
1435 return VFR_RETURN_SUCCESS;\r
1436 }\r
1437\r
1afac950
ED		 1438 UINT8 GetNumericFlags () {\r
1439 return mNumeric->Flags;\r
1440 }\r
30fdf114
LG		 1441};\r
1442\r
1443class CIfrOneOf : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {\r
1444private:\r
1445 EFI_IFR_ONE_OF *mOneOf;\r
1446\r
1447public:\r
4afd3d04 1448 CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)&mOneOf, sizeof (EFI_IFR_ONE_OF), TRUE),\r
30fdf114
LG		 1449 CIfrOpHeader (EFI_IFR_ONE_OF_OP, &mOneOf->Header),\r
1450 CIfrQuestionHeader (&mOneOf->Question),\r
1451 CIfrMinMaxStepData (&mOneOf->data) {\r
1452 mOneOf->Flags = 0;\r
a709adfa
LG		 1453 gCurrentQuestion = this;\r
1454 gCurrentMinMaxData = this;\r
30fdf114
LG		 1455 }\r
1456\r
1457 ~CIfrOneOf () {\r
a709adfa
LG		 1458 gCurrentQuestion = NULL;\r
1459 gCurrentMinMaxData = NULL;\r
30fdf114
LG		 1460 }\r
1461\r
1462 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1463 EFI_VFR_RETURN_CODE Ret;\r
1464\r
1465 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1466 if (Ret != VFR_RETURN_SUCCESS) {\r
1467 return Ret;\r
1468 }\r
1469\r
1470 if (LFlags & EFI_IFR_DISPLAY) {\r
1471 mOneOf->Flags = LFlags;\r
1472 } else {\r
1473 mOneOf->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;\r
1474 }\r
1475 return VFR_RETURN_SUCCESS;\r
1476 }\r
4afd3d04 1477\r
42c808d4
DB		 1478 EFI_VFR_RETURN_CODE SetFlagsForBitField (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1479 EFI_VFR_RETURN_CODE Ret;\r
1480\r
1481 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1482 if (Ret != VFR_RETURN_SUCCESS) {\r
1483 return Ret;\r
1484 }\r
1485\r
1486 if (LFlags & EFI_IFR_DISPLAY) {\r
1487 mOneOf->Flags = LFlags;\r
1488 } else {\r
1489 mOneOf->Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT;\r
1490 }\r
1491 return VFR_RETURN_SUCCESS;\r
1492 }\r
1493\r
4afd3d04
LG		 1494 VOID ShrinkBinSize (IN UINT16 Size) {\r
1495 //\r
1496 // Update the buffer size which is truly be used later.\r
1497 //\r
1498 ShrinkObjBin(Size);\r
1499 DecLength(Size);\r
1500\r
1501 //\r
1502 // Allocate buffer in gCFormPkg.\r
1503 //\r
1504 _EMIT_PENDING_OBJ();\r
1505\r
1506 //\r
1507 // Update the buffer pointer used by other class.\r
1508 //\r
1509 mOneOf = (EFI_IFR_ONE_OF *) GetObjBinAddr();\r
1510 UpdateHeader (&mOneOf->Header);\r
1511 UpdateCIfrQuestionHeader(&mOneOf->Question);\r
1512 UpdateCIfrMinMaxStepData(&mOneOf->data);\r
1513 }\r
30fdf114
LG		 1514};\r
1515\r
1516class CIfrString : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1517private:\r
1518 EFI_IFR_STRING *mString;\r
1519\r
1520public:\r
1521 CIfrString () : CIfrObj (EFI_IFR_STRING_OP, (CHAR8 **)&mString),\r
1522 CIfrOpHeader (EFI_IFR_STRING_OP, &mString->Header),\r
1523 CIfrQuestionHeader (&mString->Question) {\r
1524 mString->Flags = 0;\r
1525 mString->MinSize = 0;\r
1526 mString->MaxSize = 0;\r
1527 gCurrentQuestion = this;\r
1528 }\r
1529\r
1530 ~CIfrString () {\r
1531 gCurrentQuestion = NULL;\r
1532 }\r
1533\r
1534 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1535 EFI_VFR_RETURN_CODE Ret;\r
1536\r
1537 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1538 if (Ret != VFR_RETURN_SUCCESS) {\r
1539 return Ret;\r
1540 }\r
1541\r
1542 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_STRING_MULTI_LINE)) {\r
1543 mString->Flags |= EFI_IFR_STRING_MULTI_LINE;\r
1544 }\r
1545\r
1546 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1547 }\r
1548\r
1549 VOID SetMinSize (IN UINT8 Flags) {\r
1550 mString->MinSize = Flags;\r
1551 }\r
1552\r
1553 VOID SetMaxSize (IN UINT8 MaxSize) {\r
1554 mString->MaxSize = MaxSize;\r
1555 }\r
1556};\r
1557\r
1558class CIfrPassword : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1559private:\r
1560 EFI_IFR_PASSWORD *mPassword;\r
1561\r
1562public:\r
1563 CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP, (CHAR8 **)&mPassword),\r
1564 CIfrOpHeader (EFI_IFR_PASSWORD_OP, &mPassword->Header),\r
1565 CIfrQuestionHeader (&mPassword->Question) {\r
1566 mPassword->MinSize = 0;\r
1567 mPassword->MaxSize = 0;\r
1568 gCurrentQuestion = this;\r
1569 }\r
1570\r
1571 ~CIfrPassword () {\r
1572 gCurrentQuestion = NULL;\r
1573 }\r
1574\r
1575 VOID SetMinSize (IN UINT16 MinSize) {\r
1576 mPassword->MinSize = MinSize;\r
1577 }\r
1578\r
1579 VOID SetMaxSize (IN UINT16 MaxSize) {\r
1580 mPassword->MaxSize = MaxSize;\r
1581 }\r
1582};\r
1583\r
1584class CIfrOrderedList : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1585private:\r
1586 EFI_IFR_ORDERED_LIST *mOrderedList;\r
1587\r
1588public:\r
1589 CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP, (CHAR8 **)&mOrderedList),\r
1590 CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &mOrderedList->Header),\r
1591 CIfrQuestionHeader (&mOrderedList->Question) {\r
1592 mOrderedList->MaxContainers = 0;\r
1593 mOrderedList->Flags = 0;\r
1594 gCurrentQuestion = this;\r
1595 }\r
1596\r
1597 ~CIfrOrderedList () {\r
1598 gCurrentQuestion = NULL;\r
1599 }\r
1600\r
1601 VOID SetMaxContainers (IN UINT8 MaxContainers) {\r
1602 mOrderedList->MaxContainers = MaxContainers;\r
1603 }\r
1604\r
1605 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1606 EFI_VFR_RETURN_CODE Ret;\r
1607\r
1608 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1609 if (Ret != VFR_RETURN_SUCCESS) {\r
1610 return Ret;\r
1611 }\r
1612\r
1613 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_UNIQUE_SET)) {\r
1614 mOrderedList->Flags |= EFI_IFR_UNIQUE_SET;\r
1615 }\r
1616\r
1617 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_NO_EMPTY_SET)) {\r
1618 mOrderedList->Flags |= EFI_IFR_NO_EMPTY_SET;\r
1619 }\r
1620\r
1621 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1622 }\r
1623};\r
1624\r
1625class CIfrTime : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1626private:\r
1627 EFI_IFR_TIME *mTime;\r
1628\r
1629public:\r
1630 CIfrTime () : CIfrObj (EFI_IFR_TIME_OP, (CHAR8 **)&mTime),\r
1631 CIfrOpHeader (EFI_IFR_TIME_OP, &mTime->Header),\r
1632 CIfrQuestionHeader (&mTime->Question) {\r
1633 mTime->Flags = 0;\r
1634 }\r
1635\r
1636 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1637 EFI_VFR_RETURN_CODE Ret;\r
1638\r
1639 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1640 if (Ret != VFR_RETURN_SUCCESS) {\r
1641 return Ret;\r
1642 }\r
1643\r
1644 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_HOUR_SUPPRESS)) {\r
1645 mTime->Flags |= QF_TIME_HOUR_SUPPRESS;\r
1646 }\r
1647\r
1648 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_MINUTE_SUPPRESS)) {\r
1649 mTime->Flags |= QF_TIME_MINUTE_SUPPRESS;\r
1650 }\r
1651\r
1652 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_SECOND_SUPPRESS)) {\r
1653 mTime->Flags |= QF_TIME_SECOND_SUPPRESS;\r
1654 }\r
1655\r
1656 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_NORMAL)) {\r
1657 mTime->Flags |= QF_TIME_STORAGE_NORMAL;\r
1658 } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_TIME)) {\r
1659 mTime->Flags |= QF_TIME_STORAGE_TIME;\r
1660 } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_WAKEUP)) {\r
1661 mTime->Flags |= QF_TIME_STORAGE_WAKEUP;\r
1662 }\r
1663\r
1664 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1665 }\r
1666};\r
1667\r
1668class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {\r
1669private:\r
1670 EFI_IFR_DISABLE_IF *mDisableIf;\r
1671\r
1672public:\r
1673 CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP, (CHAR8 **)&mDisableIf),\r
1674 mDisableIf ((EFI_IFR_DISABLE_IF *) GetObjBinAddr()),\r
1675 CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &mDisableIf->Header) {}\r
1676};\r
1677\r
1678class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader {\r
1679private:\r
1680 EFI_IFR_SUPPRESS_IF *mSuppressIf;\r
1681\r
1682public:\r
1683 CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP, (CHAR8 **)&mSuppressIf),\r
1684 CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &mSuppressIf->Header) {}\r
1685};\r
1686\r
1687class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader {\r
1688private:\r
1689 EFI_IFR_GRAY_OUT_IF *mGrayOutIf;\r
1690\r
1691public:\r
1692 CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP, (CHAR8 **)&mGrayOutIf),\r
1693 CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &mGrayOutIf->Header) {}\r
1694};\r
1695\r
1696class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader {\r
1697private:\r
1698 EFI_IFR_INCONSISTENT_IF *mInconsistentIf;\r
1699\r
1700public:\r
1701 CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP, (CHAR8 **)&mInconsistentIf),\r
1702 CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &mInconsistentIf->Header) {\r
1703 mInconsistentIf->Error = EFI_STRING_ID_INVALID;\r
1704 }\r
1705\r
1706 VOID SetError (IN EFI_STRING_ID Error) {\r
1707 mInconsistentIf->Error = Error;\r
1708 }\r
1709};\r
1710\r
ea0f6464
LG		 1711class CIfrWarningIf : public CIfrObj, public CIfrOpHeader {\r
1712private:\r
1713 EFI_IFR_WARNING_IF *mWarningIf;\r
1714\r
1715public:\r
1716 CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP, (CHAR8 **)&mWarningIf),\r
1717 CIfrOpHeader (EFI_IFR_WARNING_IF_OP, &mWarningIf->Header) {\r
1718 mWarningIf->Warning = EFI_STRING_ID_INVALID;\r
1719 mWarningIf->TimeOut = 0;\r
1720 }\r
1721\r
1722 VOID SetWarning (IN EFI_STRING_ID Warning) {\r
1723 mWarningIf->Warning = Warning;\r
1724 }\r
1725\r
1726 VOID SetTimeOut (IN UINT8 TimeOut) {\r
1727 mWarningIf->TimeOut = TimeOut;\r
1728 }\r
1729};\r
1730\r
30fdf114
LG		 1731class CIfrNoSubmitIf : public CIfrObj, public CIfrOpHeader {\r
1732private:\r
1733 EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf;\r
1734\r
1735public:\r
1736 CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP, (CHAR8 **)&mNoSubmitIf),\r
1737 CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &mNoSubmitIf->Header) {\r
1738 mNoSubmitIf->Error = EFI_STRING_ID_INVALID;\r
1739 }\r
1740\r
1741 VOID SetError (IN EFI_STRING_ID Error) {\r
1742 mNoSubmitIf->Error = Error;\r
1743 }\r
1744};\r
1745\r
1746class CIfrRefresh : public CIfrObj, public CIfrOpHeader {\r
1747private:\r
1748 EFI_IFR_REFRESH *mRefresh;\r
1749\r
1750public:\r
1751 CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP, (CHAR8 **)&mRefresh),\r
1752 CIfrOpHeader (EFI_IFR_REFRESH_OP, &mRefresh->Header) {\r
1753 mRefresh->RefreshInterval = 0;\r
1754 }\r
1755\r
1756 VOID SetRefreshInterval (IN UINT8 RefreshInterval) {\r
1757 mRefresh->RefreshInterval = RefreshInterval;\r
1758 }\r
1759};\r
1760\r
4234283c
LG		 1761class CIfrRefreshId : public CIfrObj, public CIfrOpHeader {\r
1762private:\r
1763 EFI_IFR_REFRESH_ID *mRefreshId;\r
1764\r
1765public:\r
1766 CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP, (CHAR8 **)&mRefreshId),\r
1767 CIfrOpHeader (EFI_IFR_REFRESH_ID_OP, &mRefreshId->Header) {\r
1768 memset (&mRefreshId->RefreshEventGroupId, 0, sizeof (EFI_GUID));\r
1769 }\r
1770\r
1771 VOID SetRefreshEventGroutId (IN EFI_GUID *RefreshEventGroupId) {\r
f51461c8 1772 memmove (&mRefreshId->RefreshEventGroupId, RefreshEventGroupId, sizeof (EFI_GUID));\r
4234283c
LG		 1773 }\r
1774};\r
1775\r
30fdf114
LG		 1776class CIfrVarStoreDevice : public CIfrObj, public CIfrOpHeader {\r
1777private:\r
1778 EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice;\r
1779\r
1780public:\r
1781 CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP, (CHAR8 **)&mVarStoreDevice),\r
1782 CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &mVarStoreDevice->Header) {\r
1783 mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID;\r
1784 }\r
1785\r
1786 VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {\r
1787 mVarStoreDevice->DevicePath = DevicePath;\r
1788 }\r
1789};\r
1790\r
1791class CIfrOneOfOption : public CIfrObj, public CIfrOpHeader {\r
1792private:\r
1793 EFI_IFR_ONE_OF_OPTION *mOneOfOption;\r
1794\r
1795public:\r
4afd3d04
LG		 1796 CIfrOneOfOption (UINT8 Size) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)&mOneOfOption, Size),\r
1797 CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &mOneOfOption->Header, Size) {\r
30fdf114
LG		 1798 mOneOfOption->Flags = 0;\r
1799 mOneOfOption->Option = EFI_STRING_ID_INVALID;\r
1800 mOneOfOption->Type = EFI_IFR_TYPE_OTHER;\r
4afd3d04 1801 memset (&mOneOfOption->Value, 0, Size - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value));\r
30fdf114
LG		 1802 }\r
1803\r
1804 VOID SetOption (IN EFI_STRING_ID Option) {\r
1805 mOneOfOption->Option = Option;\r
1806 }\r
1807\r
1808 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {\r
ddaf640f 1809 mOneOfOption->Flags = 0;\r
30fdf114
LG		 1810 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT)) {\r
1811 mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT;\r
1812 }\r
1813\r
1814 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT_MFG)) {\r
1815 mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT_MFG;\r
1816 }\r
1817\r
1818 if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_8)) {\r
1819 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_8);\r
1820 mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_8;\r
1821 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_16)) {\r
1822 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_16);\r
1823 mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_16;\r
1824 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_32)) {\r
1825 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_32);\r
1826 mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_32;\r
1827 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_64)) {\r
1828 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_64);\r
1829 mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_64;\r
1830 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_BOOLEAN)) {\r
1831 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_BOOLEAN);\r
1832 mOneOfOption->Flags |= EFI_IFR_TYPE_BOOLEAN;\r
1833 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_TIME)) {\r
1834 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_TIME);\r
1835 mOneOfOption->Flags |= EFI_IFR_TYPE_TIME;\r
1836 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_DATE)) {\r
1837 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_DATE);\r
1838 mOneOfOption->Flags |= EFI_IFR_TYPE_DATE;\r
1839 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_STRING)) {\r
1840 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_STRING);\r
1841 mOneOfOption->Flags |= EFI_IFR_TYPE_STRING;\r
1842 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_OTHER)) {\r
1843 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_OTHER);\r
1844 mOneOfOption->Flags |= EFI_IFR_TYPE_OTHER;\r
1845 }\r
1846\r
1847 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1848 }\r
1849\r
1850 VOID SetType (IN UINT8 Type) {\r
1851 mOneOfOption->Type = Type;\r
1852 }\r
1853\r
1854 VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {\r
f51461c8 1855 memmove (&mOneOfOption->Value, &Value, mOneOfOption->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value));\r
30fdf114
LG		 1856 }\r
1857\r
1858 UINT8 GetFlags (VOID) {\r
1859 return mOneOfOption->Flags;\r
1860 }\r
1861};\r
1862\r
1863static EFI_GUID IfrTianoGuid = EFI_IFR_TIANO_GUID;\r
1864static EFI_GUID IfrFrameworkGuid = EFI_IFR_FRAMEWORK_GUID;\r
1865\r
1866class CIfrClass : public CIfrObj, public CIfrOpHeader {\r
1867private:\r
1868 EFI_IFR_GUID_CLASS *mClass;\r
1869\r
1870public:\r
1871 CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mClass, sizeof (EFI_IFR_GUID_CLASS)),\r
1872 CIfrOpHeader (EFI_IFR_GUID_OP, &mClass->Header, sizeof (EFI_IFR_GUID_CLASS)) {\r
1873 mClass->ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS;\r
1874 mClass->Guid = IfrTianoGuid;\r
1875 mClass->Class = EFI_NON_DEVICE_CLASS;\r
1876 }\r
1877\r
1878 VOID SetClass (IN UINT16 Class) {\r
1879 mClass->Class = Class;\r
1880 }\r
1881};\r
1882\r
1883class CIfrSubClass : public CIfrObj, public CIfrOpHeader {\r
1884private:\r
1885 EFI_IFR_GUID_SUBCLASS *mSubClass;\r
1886\r
1887public:\r
1888 CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mSubClass, sizeof (EFI_IFR_GUID_SUBCLASS)),\r
1889 CIfrOpHeader (EFI_IFR_GUID_OP, &mSubClass->Header, sizeof (EFI_IFR_GUID_SUBCLASS)) {\r
1890 mSubClass->ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS;\r
1891 mSubClass->Guid = IfrTianoGuid;\r
1892 mSubClass->SubClass = EFI_SETUP_APPLICATION_SUBCLASS;\r
1893 }\r
1894\r
1895 VOID SetSubClass (IN UINT16 SubClass) {\r
1896 mSubClass->SubClass = SubClass;\r
1897 }\r
1898};\r
1899\r
1900class CIfrLabel : public CIfrObj, public CIfrOpHeader {\r
1901private:\r
1902 EFI_IFR_GUID_LABEL *mLabel;\r
1903\r
1904public:\r
1905 CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mLabel, sizeof (EFI_IFR_GUID_LABEL)),\r
1906 CIfrOpHeader (EFI_IFR_GUID_OP, &mLabel->Header, sizeof (EFI_IFR_GUID_LABEL)) {\r
1907 mLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
1908 mLabel->Guid = IfrTianoGuid;\r
1909 }\r
1910\r
1911 VOID SetNumber (IN UINT16 Number) {\r
1912 mLabel->Number = Number;\r
1913 }\r
1914};\r
1915\r
1916class CIfrBanner : public CIfrObj, public CIfrOpHeader {\r
1917private:\r
1918 EFI_IFR_GUID_BANNER *mBanner;\r
1919\r
1920public:\r
1921 CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mBanner, sizeof (EFI_IFR_GUID_BANNER)),\r
1922 CIfrOpHeader (EFI_IFR_GUID_OP, &mBanner->Header, sizeof (EFI_IFR_GUID_BANNER)) {\r
1923 mBanner->ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;\r
1924 mBanner->Guid = IfrTianoGuid;\r
1925 }\r
1926\r
1927 VOID SetTitle (IN EFI_STRING_ID StringId) {\r
1928 mBanner->Title = StringId;\r
1929 }\r
1930\r
1931 VOID SetLine (IN UINT16 Line) {\r
1932 mBanner->LineNumber = Line;\r
1933 }\r
1934\r
1935 VOID SetAlign (IN UINT8 Align) {\r
1936 mBanner->Alignment = Align;\r
1937 }\r
1938};\r
1939\r
1940class CIfrOptionKey : public CIfrObj, public CIfrOpHeader {\r
1941private:\r
1942 EFI_IFR_GUID_OPTIONKEY *mOptionKey;\r
1943\r
1944public:\r
1945 CIfrOptionKey (\r
1946 IN EFI_QUESTION_ID QuestionId,\r
1947 IN EFI_IFR_TYPE_VALUE &OptionValue,\r
1948 IN EFI_QUESTION_ID KeyValue\r
1949 ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mOptionKey, sizeof (EFI_IFR_GUID_OPTIONKEY)),\r
1950 CIfrOpHeader (EFI_IFR_GUID_OP, &mOptionKey->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)) {\r
1951 mOptionKey->ExtendOpCode = EFI_IFR_EXTEND_OP_OPTIONKEY;\r
1952 mOptionKey->Guid = IfrFrameworkGuid;\r
1953 mOptionKey->QuestionId = QuestionId;\r
1954 mOptionKey->OptionValue = OptionValue;\r
1955 mOptionKey->KeyValue = KeyValue;\r
1956 }\r
1957};\r
1958\r
1959class CIfrVarEqName : public CIfrObj, public CIfrOpHeader {\r
1960private:\r
1961 EFI_IFR_GUID_VAREQNAME *mVarEqName;\r
1962\r
1963public:\r
1964 CIfrVarEqName (\r
1965 IN EFI_QUESTION_ID QuestionId,\r
1966 IN EFI_STRING_ID NameId\r
1967 ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mVarEqName, sizeof (EFI_IFR_GUID_VAREQNAME)),\r
1968 CIfrOpHeader (EFI_IFR_GUID_OP, &mVarEqName->Header, sizeof (EFI_IFR_GUID_VAREQNAME)) {\r
1969 mVarEqName->ExtendOpCode = EFI_IFR_EXTEND_OP_VAREQNAME;\r
1970 mVarEqName->Guid = IfrFrameworkGuid;\r
1971 mVarEqName->QuestionId = QuestionId;\r
1972 mVarEqName->NameId = NameId;\r
1973 }\r
1974};\r
1975\r
1976class CIfrTimeout : public CIfrObj, public CIfrOpHeader {\r
1977private:\r
1978 EFI_IFR_GUID_TIMEOUT *mTimeout;\r
1979\r
1980public:\r
1981 CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mTimeout, sizeof (EFI_IFR_GUID_TIMEOUT)),\r
1982 CIfrOpHeader (EFI_IFR_GUID_OP, &mTimeout->Header, sizeof (EFI_IFR_GUID_TIMEOUT)) {\r
1983 mTimeout->ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT;\r
1984 mTimeout->Guid = IfrTianoGuid;\r
1985 mTimeout->TimeOut = Timeout;\r
1986 }\r
1987\r
1988 VOID SetTimeout (IN UINT16 Timeout) {\r
1989 mTimeout->TimeOut = Timeout;\r
1990 }\r
1991};\r
1992\r
da92f276
LG		 1993class CIfrGuid : public CIfrObj, public CIfrOpHeader {\r
1994private:\r
1995 EFI_IFR_GUID *mGuid;\r
1996\r
1997public:\r
1998 CIfrGuid (UINT8 Size) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mGuid, sizeof (EFI_IFR_GUID)+Size),\r
1999 CIfrOpHeader (EFI_IFR_GUID_OP, &mGuid->Header, sizeof (EFI_IFR_GUID)+Size) {\r
2000 memset (&mGuid->Guid, 0, sizeof (EFI_GUID));\r
2001 }\r
2002\r
2003 VOID SetGuid (IN EFI_GUID *Guid) {\r
f51461c8 2004 memmove (&mGuid->Guid, Guid, sizeof (EFI_GUID));\r
da92f276
LG		 2005 }\r
2006\r
2007 VOID SetData (IN UINT8* DataBuff, IN UINT8 Size) {\r
f51461c8 2008 memmove ((UINT8 *)mGuid + sizeof (EFI_IFR_GUID), DataBuff, Size);\r
da92f276
LG		 2009 }\r
2010};\r
2011\r
30fdf114
LG		 2012class CIfrDup : public CIfrObj, public CIfrOpHeader {\r
2013private:\r
2014 EFI_IFR_DUP *mDup;\r
2015\r
2016public:\r
2017 CIfrDup (\r
2018 IN UINT32 LineNo\r
2019 ) : CIfrObj (EFI_IFR_DUP_OP, (CHAR8 **)&mDup),\r
2020 CIfrOpHeader (EFI_IFR_DUP_OP, &mDup->Header) {\r
2021 SetLineNo (LineNo);\r
2022 }\r
2023};\r
2024\r
2025class CIfrEqIdId : public CIfrObj, public CIfrOpHeader {\r
2026private:\r
2027 EFI_IFR_EQ_ID_ID *mEqIdId;\r
2028\r
2029public:\r
2030 CIfrEqIdId (\r
2031 IN UINT32 LineNo\r
2032 ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP, (CHAR8 **)&mEqIdId),\r
2033 CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &mEqIdId->Header) {\r
2034 SetLineNo (LineNo);\r
2035 mEqIdId->QuestionId1 = EFI_QUESTION_ID_INVALID;\r
2036 mEqIdId->QuestionId2 = EFI_QUESTION_ID_INVALID;\r
2037 }\r
2038\r
2039 VOID SetQuestionId1 (\r
2040 IN EFI_QUESTION_ID QuestionId,\r
2041 IN CHAR8 *VarIdStr,\r
2042 IN UINT32 LineNo\r
2043 ) {\r
2044 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
2045 mEqIdId->QuestionId1 = QuestionId;\r
2046 } else {\r
2047 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId1), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);\r
2048 }\r
2049 }\r
2050\r
2051 VOID SetQuestionId2 (\r
2052 IN EFI_QUESTION_ID QuestionId,\r
2053 IN CHAR8 *VarIdStr,\r
2054 IN UINT32 LineNo\r
2055 ) {\r
2056 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
2057 mEqIdId->QuestionId2 = QuestionId;\r
2058 } else {\r
2059 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId2), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);\r
2060 }\r
2061 }\r
2062};\r
2063\r
2064class CIfrEqIdVal : public CIfrObj, public CIfrOpHeader {\r
2065private:\r
2066 EFI_IFR_EQ_ID_VAL *mEqIdVal;\r
2067\r
2068public:\r
2069 CIfrEqIdVal (\r
2070 IN UINT32 LineNo\r
2071 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP, (CHAR8 **)&mEqIdVal),\r
2072 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &mEqIdVal->Header) {\r
2073 SetLineNo (LineNo);\r
2074 mEqIdVal->QuestionId = EFI_QUESTION_ID_INVALID;\r
2075 }\r
2076\r
2077 VOID SetQuestionId (\r
2078 IN EFI_QUESTION_ID QuestionId,\r
2079 IN CHAR8 *VarIdStr,\r
2080 IN UINT32 LineNo\r
2081 ) {\r
2082 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
2083 mEqIdVal->QuestionId = QuestionId;\r
2084 } else {\r
2085 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVal->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);\r
2086 }\r
2087 }\r
2088\r
2089 VOID SetValue (IN UINT16 Value) {\r
2090 mEqIdVal->Value = Value;\r
2091 }\r
2092};\r
2093\r
2094class CIfrEqIdList : public CIfrObj, public CIfrOpHeader {\r
2095private:\r
b303ea72 2096 EFI_IFR_EQ_ID_VAL_LIST *mEqIdVList;\r
30fdf114
LG		 2097\r
2098public:\r
2099 CIfrEqIdList (\r
2100 IN UINT32 LineNo\r
64b2609f
LG		 2101 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP, (CHAR8 **)&mEqIdVList, sizeof (EFI_IFR_EQ_ID_VAL_LIST), TRUE),\r
2102 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP, &mEqIdVList->Header) {\r
30fdf114
LG		 2103 SetLineNo (LineNo);\r
2104 mEqIdVList->QuestionId = EFI_QUESTION_ID_INVALID;\r
2105 mEqIdVList->ListLength = 0;\r
2106 mEqIdVList->ValueList[0] = 0;\r
2107 }\r
2108 \r
2109 VOID UpdateIfrBuffer ( \r
2110 ) {\r
2111 _EMIT_PENDING_OBJ();\r
b303ea72 2112 mEqIdVList = (EFI_IFR_EQ_ID_VAL_LIST *) GetObjBinAddr();\r
30fdf114
LG		 2113 UpdateHeader (&mEqIdVList->Header);\r
2114 }\r
2115\r
2116 VOID SetQuestionId (\r
2117 IN EFI_QUESTION_ID QuestionId,\r
2118 IN CHAR8 *VarIdStr,\r
2119 IN UINT32 LineNo\r
2120 ) {\r
2121 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
2122 mEqIdVList->QuestionId = QuestionId;\r
2123 } else {\r
2124 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVList->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);\r
2125 }\r
2126 }\r
2127\r
2128 VOID SetListLength (IN UINT16 ListLength) {\r
2129 mEqIdVList->ListLength = ListLength;\r
2130 }\r
2131\r
2132 VOID SetValueList (IN UINT16 Index, IN UINT16 Value) {\r
2133 if (Index == 0) {\r
2134 mEqIdVList->ValueList[0] = Value;\r
2135 return;\r
2136 }\r
2137\r
2138 if (ExpendObjBin (sizeof (UINT16)) ==TRUE) {\r
2139 IncLength (sizeof (UINT16));\r
2140 mEqIdVList->ValueList[Index] = Value;\r
2141 }\r
2142 }\r
2143};\r
2144\r
2145class CIfrQuestionRef1 : public CIfrObj, public CIfrOpHeader {\r
2146private:\r
2147 EFI_IFR_QUESTION_REF1 *mQuestionRef1;\r
2148\r
2149public:\r
2150 CIfrQuestionRef1 (\r
2151 IN UINT32 LineNo\r
2152 ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP, (CHAR8 **)&mQuestionRef1),\r
2153 CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &mQuestionRef1->Header) {\r
2154 SetLineNo (LineNo);\r
2155 mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID;\r
2156 }\r
2157\r
2158 VOID SetQuestionId (\r
2159 IN EFI_QUESTION_ID QuestionId,\r
2160 IN CHAR8 *VarIdStr,\r
2161 IN UINT32 LineNo\r
2162 ) {\r
2163 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
2164 mQuestionRef1->QuestionId = QuestionId;\r
2165 } else {\r
2166 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mQuestionRef1->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);\r
2167 }\r
2168 }\r
2169};\r
2170\r
2171class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader {\r
2172private:\r
2173 EFI_IFR_QUESTION_REF2 *mQuestionRef2;\r
2174\r
2175public:\r
2176 CIfrQuestionRef2 (\r
2177 IN UINT32 LineNo\r
2178 ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP, (CHAR8 **)&mQuestionRef2),\r
2179 CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &mQuestionRef2->Header) {\r
2180 SetLineNo (LineNo);\r
2181 }\r
2182};\r
2183\r
2184class CIfrQuestionRef3 : public CIfrObj, public CIfrOpHeader {\r
2185private:\r
2186 EFI_IFR_QUESTION_REF3 *mQuestionRef3;\r
2187\r
2188public:\r
2189 CIfrQuestionRef3 (\r
2190 IN UINT32 LineNo\r
2191 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3),\r
2192 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3->Header) {\r
2193 SetLineNo (LineNo);\r
2194 }\r
2195};\r
2196\r
2197class CIfrQuestionRef3_2 : public CIfrObj, public CIfrOpHeader {\r
2198private:\r
2199 EFI_IFR_QUESTION_REF3_2 *mQuestionRef3_2;\r
2200\r
2201public:\r
2202 CIfrQuestionRef3_2 (\r
2203 IN UINT32 LineNo\r
2204 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_2, sizeof (EFI_IFR_QUESTION_REF3_2)),\r
2205 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_2->Header, sizeof (EFI_IFR_QUESTION_REF3_2)) {\r
2206 SetLineNo (LineNo);\r
2207 mQuestionRef3_2->DevicePath = EFI_STRING_ID_INVALID;\r
2208 }\r
2209\r
2210 VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {\r
2211 mQuestionRef3_2->DevicePath = DevicePath;\r
2212 }\r
2213};\r
2214\r
2215class CIfrQuestionRef3_3 : public CIfrObj, public CIfrOpHeader {\r
2216private:\r
2217 EFI_IFR_QUESTION_REF3_3 *mQuestionRef3_3;\r
2218\r
2219public:\r
2220 CIfrQuestionRef3_3 (\r
2221 IN UINT32 LineNo\r
2222 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_3, sizeof (EFI_IFR_QUESTION_REF3_3)),\r
2223 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_3->Header, sizeof (EFI_IFR_QUESTION_REF3_3)) {\r
2224 SetLineNo (LineNo);\r
2225 mQuestionRef3_3->DevicePath = EFI_STRING_ID_INVALID;\r
2226 memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID));\r
2227 }\r
2228\r
2229 VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {\r
2230 mQuestionRef3_3->DevicePath = DevicePath;\r
2231 }\r
2232\r
2233 VOID SetGuid (IN EFI_GUID *Guid) {\r
2234 mQuestionRef3_3->Guid = *Guid;\r
2235 }\r
2236};\r
2237\r
2238class CIfrRuleRef : public CIfrObj, public CIfrOpHeader {\r
2239private:\r
2240 EFI_IFR_RULE_REF *mRuleRef;\r
2241\r
2242public:\r
2243 CIfrRuleRef (\r
2244 IN UINT32 LineNo\r
2245 ) : CIfrObj (EFI_IFR_RULE_REF_OP, (CHAR8 **)&mRuleRef),\r
2246 CIfrOpHeader (EFI_IFR_RULE_REF_OP, &mRuleRef->Header) {\r
2247 SetLineNo (LineNo);\r
2248 mRuleRef->RuleId = EFI_RULE_ID_INVALID;\r
2249 }\r
2250\r
2251 VOID SetRuleId (IN UINT8 RuleId) {\r
2252 mRuleRef->RuleId = RuleId;\r
2253 }\r
2254};\r
2255\r
2256class CIfrStringRef1 : public CIfrObj, public CIfrOpHeader {\r
2257private:\r
2258 EFI_IFR_STRING_REF1 *mStringRef1;\r
2259\r
2260public:\r
2261 CIfrStringRef1 (\r
2262 IN UINT32 LineNo\r
2263 ) : CIfrObj (EFI_IFR_STRING_REF1_OP, (CHAR8 **)&mStringRef1),\r
2264 CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &mStringRef1->Header) {\r
2265 SetLineNo (LineNo);\r
2266 mStringRef1->StringId = EFI_STRING_ID_INVALID;\r
2267 }\r
2268\r
2269 VOID SetStringId (IN EFI_STRING_ID StringId) {\r
2270 mStringRef1->StringId = StringId;\r
2271 }\r
2272};\r
2273\r
2274class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader {\r
2275private:\r
2276 EFI_IFR_STRING_REF2 *mStringRef2;\r
2277\r
2278public:\r
2279 CIfrStringRef2 (\r
2280 IN UINT32 LineNo\r
2281 ) : CIfrObj (EFI_IFR_STRING_REF2_OP, (CHAR8 **)&mStringRef2),\r
2282 CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &mStringRef2->Header) {\r
2283 SetLineNo (LineNo);\r
2284 }\r
2285};\r
2286\r
2287class CIfrThis : public CIfrObj, public CIfrOpHeader {\r
2288private:\r
2289 EFI_IFR_THIS *mThis;\r
2290\r
2291public:\r
2292 CIfrThis (\r
2293 IN UINT32 LineNo\r
2294 ) : CIfrObj (EFI_IFR_THIS_OP, (CHAR8 **)&mThis),\r
2295 CIfrOpHeader (EFI_IFR_THIS_OP, &mThis->Header) {\r
2296 SetLineNo (LineNo);\r
2297 }\r
2298};\r
2299\r
a709adfa
LG		 2300class CIfrSecurity : public CIfrObj, public CIfrOpHeader {\r
2301private:\r
2302 EFI_IFR_SECURITY *mSecurity;\r
2303\r
2304public:\r
2305 CIfrSecurity (\r
2306 IN UINT32 LineNo\r
2307 ) : CIfrObj (EFI_IFR_SECURITY_OP, (CHAR8 **)&mSecurity),\r
2308 CIfrOpHeader (EFI_IFR_SECURITY_OP, &mSecurity->Header) {\r
2309 SetLineNo (LineNo);\r
2310 memset (&mSecurity->Permissions, 0, sizeof (EFI_GUID));\r
2311 }\r
2312\r
2313 VOID SetPermissions (IN EFI_GUID *Permissions) {\r
f51461c8 2314 memmove (&mSecurity->Permissions, Permissions, sizeof (EFI_GUID));\r
a709adfa
LG		 2315 }\r
2316};\r
2317\r
30fdf114
LG		 2318class CIfrUint8 : public CIfrObj, public CIfrOpHeader {\r
2319private:\r
2320 EFI_IFR_UINT8 *mUint8;\r
2321\r
2322public:\r
2323 CIfrUint8 (\r
2324 IN UINT32 LineNo\r
2325 ) : CIfrObj (EFI_IFR_UINT8_OP, (CHAR8 **)&mUint8),\r
2326 CIfrOpHeader (EFI_IFR_UINT8_OP, &mUint8->Header) {\r
2327 SetLineNo (LineNo);\r
2328 }\r
2329\r
2330 VOID SetValue (IN UINT8 Value) {\r
2331 mUint8->Value = Value;\r
2332 }\r
2333};\r
2334\r
2335class CIfrUint16 : public CIfrObj, public CIfrOpHeader {\r
2336private:\r
2337 EFI_IFR_UINT16 *mUint16;\r
2338\r
2339public:\r
2340 CIfrUint16 (\r
2341 IN UINT32 LineNo\r
2342 ) : CIfrObj (EFI_IFR_UINT16_OP, (CHAR8 **)&mUint16),\r
2343 CIfrOpHeader (EFI_IFR_UINT16_OP, &mUint16->Header) {\r
2344 SetLineNo (LineNo);\r
2345 }\r
2346\r
2347 VOID SetValue (IN UINT16 Value) {\r
2348 mUint16->Value = Value;\r
2349 }\r
2350};\r
2351\r
2352class CIfrUint32 : public CIfrObj, public CIfrOpHeader {\r
2353private:\r
2354 EFI_IFR_UINT32 *mUint32;\r
2355\r
2356public:\r
2357 CIfrUint32 (\r
2358 IN UINT32 LineNo\r
2359 ) : CIfrObj (EFI_IFR_UINT32_OP, (CHAR8 **)&mUint32),\r
2360 CIfrOpHeader (EFI_IFR_UINT32_OP, &mUint32->Header) {\r
2361 SetLineNo (LineNo);\r
2362 }\r
2363\r
2364 VOID SetValue (IN UINT32 Value) {\r
2365 mUint32->Value = Value;\r
2366 }\r
2367};\r
2368\r
2369class CIfrUint64 : public CIfrObj, public CIfrOpHeader {\r
2370private:\r
2371 EFI_IFR_UINT64 *mUint64;\r
2372\r
2373public:\r
2374 CIfrUint64 (\r
2375 IN UINT32 LineNo\r
2376 ) : CIfrObj (EFI_IFR_UINT64_OP, (CHAR8 **)&mUint64),\r
2377 CIfrOpHeader (EFI_IFR_UINT64_OP, &mUint64->Header) {\r
2378 SetLineNo (LineNo);\r
2379 }\r
2380\r
2381 VOID SetValue (IN UINT64 Value) {\r
2382 mUint64->Value = Value;\r
2383 }\r
2384};\r
2385\r
2386class CIfrTrue : public CIfrObj, public CIfrOpHeader {\r
2387private:\r
2388 EFI_IFR_TRUE *mTrue;\r
2389\r
2390public:\r
2391 CIfrTrue (\r
2392 IN UINT32 LineNo\r
2393 ) : CIfrObj (EFI_IFR_TRUE_OP, (CHAR8 **)&mTrue),\r
2394 CIfrOpHeader (EFI_IFR_TRUE_OP, &mTrue->Header) {\r
2395 SetLineNo (LineNo);\r
2396 }\r
2397};\r
2398\r
2399class CIfrFalse : public CIfrObj, public CIfrOpHeader {\r
2400private:\r
2401 EFI_IFR_FALSE *mFalse;\r
2402\r
2403public:\r
2404 CIfrFalse (\r
2405 IN UINT32 LineNo\r
2406 ) : CIfrObj (EFI_IFR_FALSE_OP, (CHAR8 **)&mFalse),\r
2407 CIfrOpHeader (EFI_IFR_FALSE_OP, &mFalse->Header) {\r
2408 SetLineNo (LineNo);\r
2409 }\r
2410};\r
2411\r
2412class CIfrOne : public CIfrObj, public CIfrOpHeader {\r
2413private:\r
2414 EFI_IFR_ONE *mOne;\r
2415\r
2416public:\r
2417 CIfrOne (\r
2418 IN UINT32 LineNo\r
2419 ) : CIfrObj (EFI_IFR_ONE_OP, (CHAR8 **)&mOne),\r
2420 CIfrOpHeader (EFI_IFR_ONE_OP, &mOne->Header) {\r
2421 SetLineNo (LineNo);\r
2422 }\r
2423};\r
2424\r
2425class CIfrOnes : public CIfrObj, public CIfrOpHeader {\r
2426private:\r
2427 EFI_IFR_ONES *mOnes;\r
2428\r
2429public:\r
2430 CIfrOnes (\r
2431 IN UINT32 LineNo\r
2432 ) : CIfrObj (EFI_IFR_ONES_OP, (CHAR8 **)&mOnes),\r
2433 CIfrOpHeader (EFI_IFR_ONES_OP, &mOnes->Header) {\r
2434 SetLineNo (LineNo);\r
2435 }\r
2436};\r
2437\r
2438class CIfrZero : public CIfrObj, public CIfrOpHeader {\r
2439private:\r
2440 EFI_IFR_ZERO *mZero;\r
2441\r
2442public:\r
2443 CIfrZero (\r
2444 IN UINT32 LineNo\r
2445 ) : CIfrObj (EFI_IFR_ZERO_OP, (CHAR8 **)&mZero),\r
2446 CIfrOpHeader (EFI_IFR_ZERO_OP, &mZero->Header) {\r
2447 SetLineNo (LineNo);\r
2448 }\r
2449};\r
2450\r
2451class CIfrUndefined : public CIfrObj, public CIfrOpHeader {\r
2452private:\r
2453 EFI_IFR_UNDEFINED *mUndefined;\r
2454\r
2455public:\r
2456 CIfrUndefined (\r
2457 IN UINT32 LineNo\r
2458 ) : CIfrObj (EFI_IFR_UNDEFINED_OP, (CHAR8 **)&mUndefined),\r
2459 CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &mUndefined->Header) {\r
2460 SetLineNo (LineNo);\r
2461 }\r
2462};\r
2463\r
2464class CIfrVersion : public CIfrObj, public CIfrOpHeader {\r
2465private:\r
2466 EFI_IFR_VERSION *mVersion;\r
2467\r
2468public:\r
2469 CIfrVersion (\r
2470 IN UINT32 LineNo\r
2471 ) : CIfrObj (EFI_IFR_VERSION_OP, (CHAR8 **)&mVersion),\r
2472 CIfrOpHeader (EFI_IFR_VERSION_OP, &mVersion->Header) {\r
2473 SetLineNo (LineNo);\r
2474 }\r
2475};\r
2476\r
2477class CIfrLength : public CIfrObj, public CIfrOpHeader {\r
2478private:\r
2479 EFI_IFR_LENGTH *mLength;\r
2480\r
2481public:\r
2482 CIfrLength (\r
2483 IN UINT32 LineNo\r
2484 ) : CIfrObj (EFI_IFR_LENGTH_OP, (CHAR8 **)&mLength),\r
2485 CIfrOpHeader (EFI_IFR_LENGTH_OP, &mLength->Header) {\r
2486 SetLineNo (LineNo);\r
2487 }\r
2488};\r
2489\r
2490class CIfrNot : public CIfrObj, public CIfrOpHeader {\r
2491private:\r
2492 EFI_IFR_NOT *mNot;\r
2493\r
2494public:\r
2495 CIfrNot (\r
2496 IN UINT32 LineNo\r
2497 ) : CIfrObj (EFI_IFR_NOT_OP, (CHAR8 **)&mNot),\r
2498 CIfrOpHeader (EFI_IFR_NOT_OP, &mNot->Header) {\r
2499 SetLineNo (LineNo);\r
2500 }\r
2501};\r
2502\r
2503class CIfrBitWiseNot : public CIfrObj, public CIfrOpHeader {\r
2504private:\r
2505 EFI_IFR_BITWISE_NOT *mBitWise;\r
2506\r
2507public:\r
2508 CIfrBitWiseNot (\r
2509 IN UINT32 LineNo\r
2510 ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP, (CHAR8 **)&mBitWise),\r
2511 CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &mBitWise->Header) {\r
2512 SetLineNo (LineNo);\r
2513 }\r
2514};\r
2515\r
2516class CIfrToBoolean : public CIfrObj, public CIfrOpHeader {\r
2517private:\r
2518 EFI_IFR_TO_BOOLEAN *mToBoolean;\r
2519\r
2520public:\r
2521 CIfrToBoolean (\r
2522 IN UINT32 LineNo\r
2523 ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP, (CHAR8 **)&mToBoolean),\r
2524 CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &mToBoolean->Header) {\r
2525 SetLineNo (LineNo);\r
2526 }\r
2527};\r
2528\r
2529class CIfrToString : public CIfrObj, public CIfrOpHeader {\r
2530private:\r
2531 EFI_IFR_TO_STRING *mToString;\r
2532\r
2533public:\r
2534 CIfrToString (\r
2535 IN UINT32 LineNo\r
2536 ) : CIfrObj (EFI_IFR_TO_STRING_OP, (CHAR8 **)&mToString),\r
2537 CIfrOpHeader (EFI_IFR_TO_STRING_OP, &mToString->Header) {\r
2538 SetLineNo (LineNo);\r
2539 }\r
2540\r
2541 VOID SetFormat (IN UINT8 Format) {\r
2542 mToString->Format = Format;\r
2543 }\r
2544};\r
2545\r
2546class CIfrToUint : public CIfrObj, public CIfrOpHeader {\r
2547private:\r
2548 EFI_IFR_TO_UINT *mToUint;\r
2549\r
2550public:\r
2551 CIfrToUint (\r
2552 IN UINT32 LineNo\r
2553 ) : CIfrObj (EFI_IFR_TO_UINT_OP, (CHAR8 **)&mToUint),\r
2554 CIfrOpHeader (EFI_IFR_TO_UINT_OP, &mToUint->Header) {\r
2555 SetLineNo (LineNo);\r
2556 }\r
2557};\r
2558\r
2559class CIfrToUpper : public CIfrObj, public CIfrOpHeader {\r
2560private:\r
2561 EFI_IFR_TO_UPPER *mToUpper;\r
2562\r
2563public:\r
2564 CIfrToUpper (\r
2565 IN UINT32 LineNo\r
2566 ) : CIfrObj (EFI_IFR_TO_UPPER_OP, (CHAR8 **)&mToUpper),\r
2567 CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &mToUpper->Header) {\r
2568 SetLineNo (LineNo);\r
2569 }\r
2570};\r
2571\r
2572class CIfrToLower : public CIfrObj, public CIfrOpHeader {\r
2573private:\r
2574 EFI_IFR_TO_LOWER *mToLower;\r
2575\r
2576public:\r
2577 CIfrToLower (\r
2578 IN UINT32 LineNo\r
2579 ) : CIfrObj (EFI_IFR_TO_LOWER_OP, (CHAR8 **)&mToLower),\r
2580 CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &mToLower->Header) {\r
2581 SetLineNo (LineNo);\r
2582 }\r
2583};\r
2584\r
2585class CIfrAdd : public CIfrObj, public CIfrOpHeader {\r
2586private:\r
2587 EFI_IFR_ADD *mAdd;\r
2588\r
2589public:\r
2590 CIfrAdd (\r
2591 IN UINT32 LineNo\r
2592 ) : CIfrObj (EFI_IFR_ADD_OP, (CHAR8 **)&mAdd),\r
2593 CIfrOpHeader (EFI_IFR_ADD_OP, &mAdd->Header) {\r
2594 SetLineNo (LineNo);\r
2595 }\r
2596};\r
2597\r
2598class CIfrBitWiseAnd : public CIfrObj, public CIfrOpHeader {\r
2599private:\r
2600 EFI_IFR_BITWISE_AND *mBitWiseAnd;\r
2601\r
2602public:\r
2603 CIfrBitWiseAnd (\r
2604 IN UINT32 LineNo\r
2605 ) : CIfrObj (EFI_IFR_BITWISE_AND_OP, (CHAR8 **)&mBitWiseAnd),\r
2606 CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &mBitWiseAnd->Header) {\r
2607 SetLineNo(LineNo);\r
2608 }\r
2609};\r
2610\r
2611class CIfrBitWiseOr : public CIfrObj, public CIfrOpHeader {\r
2612private:\r
2613 EFI_IFR_BITWISE_OR *mBitWiseOr;\r
2614\r
2615public:\r
2616 CIfrBitWiseOr (\r
2617 IN UINT32 LineNo\r
2618 ) : CIfrObj (EFI_IFR_BITWISE_OR_OP, (CHAR8 **)&mBitWiseOr),\r
2619 CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &mBitWiseOr->Header) {\r
2620 SetLineNo (LineNo);\r
2621 }\r
2622};\r
2623\r
2624class CIfrAnd : public CIfrObj, public CIfrOpHeader {\r
2625private:\r
2626 EFI_IFR_AND *mAnd;\r
2627\r
2628public:\r
2629 CIfrAnd (\r
2630 IN UINT32 LineNo\r
2631 ) : CIfrObj (EFI_IFR_AND_OP, (CHAR8 **)&mAnd),\r
2632 CIfrOpHeader (EFI_IFR_AND_OP, &mAnd->Header) {\r
2633 SetLineNo (LineNo);\r
2634 }\r
2635};\r
2636\r
2637class CIfrCatenate : public CIfrObj, public CIfrOpHeader {\r
2638private:\r
2639 EFI_IFR_CATENATE *mCatenate;\r
2640\r
2641public:\r
2642 CIfrCatenate (\r
2643 IN UINT32 LineNo\r
2644 ) : CIfrObj (EFI_IFR_CATENATE_OP, (CHAR8 **)&mCatenate),\r
2645 CIfrOpHeader (EFI_IFR_CATENATE_OP, &mCatenate->Header) {\r
2646 SetLineNo (LineNo);\r
2647 }\r
2648};\r
2649\r
2650class CIfrDivide : public CIfrObj, public CIfrOpHeader {\r
2651private:\r
2652 EFI_IFR_DIVIDE *mDivide;\r
2653\r
2654public:\r
2655 CIfrDivide (\r
2656 IN UINT32 LineNo\r
2657 ) : CIfrObj (EFI_IFR_DIVIDE_OP, (CHAR8 **)&mDivide),\r
2658 CIfrOpHeader (EFI_IFR_DIVIDE_OP, &mDivide->Header) {\r
2659 SetLineNo (LineNo);\r
2660 }\r
2661};\r
2662\r
2663class CIfrEqual : public CIfrObj, public CIfrOpHeader {\r
2664private:\r
2665 EFI_IFR_EQUAL *mEqual;\r
2666\r
2667public:\r
2668 CIfrEqual (\r
2669 IN UINT32 LineNo\r
2670 ) : CIfrObj (EFI_IFR_EQUAL_OP, (CHAR8 **)&mEqual),\r
2671 CIfrOpHeader (EFI_IFR_EQUAL_OP, &mEqual->Header) {\r
2672 SetLineNo (LineNo);\r
2673 }\r
2674};\r
2675\r
2676class CIfrGreaterEqual : public CIfrObj, public CIfrOpHeader {\r
2677private:\r
2678 EFI_IFR_GREATER_EQUAL *mGreaterEqual;\r
2679\r
2680public:\r
2681 CIfrGreaterEqual (\r
2682 IN UINT32 LineNo\r
2683 ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP, (CHAR8 **)&mGreaterEqual),\r
2684 CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &mGreaterEqual->Header) {\r
2685 SetLineNo (LineNo);\r
2686 }\r
2687};\r
2688\r
2689class CIfrGreaterThan : public CIfrObj, public CIfrOpHeader {\r
2690private:\r
2691 EFI_IFR_GREATER_THAN *mGreaterThan;\r
2692\r
2693public:\r
2694 CIfrGreaterThan (\r
2695 IN UINT32 LineNo\r
2696 ) : CIfrObj (EFI_IFR_GREATER_THAN_OP, (CHAR8 **)&mGreaterThan),\r
2697 CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &mGreaterThan->Header) {\r
2698 SetLineNo (LineNo);\r
2699 }\r
2700};\r
2701\r
2702class CIfrLessEqual : public CIfrObj, public CIfrOpHeader {\r
2703private:\r
2704 EFI_IFR_LESS_EQUAL *mLessEqual;\r
2705\r
2706public:\r
2707 CIfrLessEqual (\r
2708 IN UINT32 LineNo\r
2709 ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP, (CHAR8 **)&mLessEqual),\r
2710 CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &mLessEqual->Header) {\r
2711 SetLineNo (LineNo);\r
2712 }\r
2713};\r
2714\r
2715class CIfrLessThan : public CIfrObj, public CIfrOpHeader {\r
2716private:\r
2717 EFI_IFR_LESS_THAN *mLessThan;\r
2718\r
2719public:\r
2720 CIfrLessThan (\r
2721 IN UINT32 LineNo\r
2722 ) : CIfrObj (EFI_IFR_LESS_THAN_OP, (CHAR8 **)&mLessThan),\r
2723 CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &mLessThan->Header) {\r
2724 SetLineNo (LineNo);\r
2725 }\r
2726};\r
2727\r
52302d4d
LG		 2728class CIfrMap : public CIfrObj, public CIfrOpHeader{\r
2729private:\r
2730 EFI_IFR_MAP *mMap;\r
2731\r
2732public:\r
2733 CIfrMap (\r
2734 IN UINT32 LineNo \r
2735 ) : CIfrObj (EFI_IFR_MAP_OP, (CHAR8 **)&mMap),\r
2736 CIfrOpHeader (EFI_IFR_MAP_OP, &mMap->Header) {\r
2737 SetLineNo (LineNo);\r
2738 }\r
2739};\r
2740\r
30fdf114
LG		 2741class CIfrMatch : public CIfrObj, public CIfrOpHeader {\r
2742private:\r
2743 EFI_IFR_MATCH *mMatch;\r
2744\r
2745public:\r
2746 CIfrMatch (\r
2747 IN UINT32 LineNo\r
2748 ) : CIfrObj (EFI_IFR_MATCH_OP, (CHAR8 **)&mMatch),\r
2749 CIfrOpHeader (EFI_IFR_MATCH_OP, &mMatch->Header) {\r
2750 SetLineNo (LineNo);\r
2751 }\r
2752};\r
2753\r
5d377616
ED		 2754class CIfrMatch2 : public CIfrObj, public CIfrOpHeader {\r
2755private:\r
2756 EFI_IFR_MATCH2 *mMatch2;\r
2757\r
2758public:\r
2759 CIfrMatch2 (\r
2760 IN UINT32 LineNo,\r
2761 IN EFI_GUID *Guid\r
2762 ) : CIfrObj (EFI_IFR_MATCH2_OP, (CHAR8 **)&mMatch2),\r
2763 CIfrOpHeader (EFI_IFR_MATCH2_OP, &mMatch2->Header) {\r
2764 SetLineNo (LineNo);\r
2765 memmove (&mMatch2->SyntaxType, Guid, sizeof (EFI_GUID));\r
2766 }\r
2767};\r
2768\r
30fdf114
LG		 2769class CIfrMultiply : public CIfrObj, public CIfrOpHeader {\r
2770private:\r
2771 EFI_IFR_MULTIPLY *mMultiply;\r
2772\r
2773public:\r
2774 CIfrMultiply (\r
2775 IN UINT32 LineNo\r
2776 ) : CIfrObj (EFI_IFR_MULTIPLY_OP, (CHAR8 **)&mMultiply),\r
2777 CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &mMultiply->Header) {\r
2778 SetLineNo (LineNo);\r
2779 }\r
2780};\r
2781\r
2782class CIfrModulo : public CIfrObj, public CIfrOpHeader {\r
2783private:\r
2784 EFI_IFR_MODULO *mModulo;\r
2785\r
2786public:\r
2787 CIfrModulo (\r
2788 IN UINT32 LineNo\r
2789 ) : CIfrObj (EFI_IFR_MODULO_OP, (CHAR8 **)&mModulo),\r
2790 CIfrOpHeader (EFI_IFR_MODULO_OP, &mModulo->Header) {\r
2791 SetLineNo (LineNo);\r
2792 }\r
2793};\r
2794\r
2795class CIfrNotEqual : public CIfrObj, public CIfrOpHeader {\r
2796private:\r
2797 EFI_IFR_NOT_EQUAL *mNotEqual;\r
2798\r
2799public:\r
2800 CIfrNotEqual (\r
2801 IN UINT32 LineNo\r
2802 ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP, (CHAR8 **)&mNotEqual),\r
2803 CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &mNotEqual->Header) {\r
2804 SetLineNo (LineNo);\r
2805 }\r
2806};\r
2807\r
2808class CIfrOr : public CIfrObj, public CIfrOpHeader {\r
2809private:\r
2810 EFI_IFR_OR *mOr;\r
2811\r
2812public:\r
2813 CIfrOr (\r
2814 IN UINT32 LineNo\r
2815 ) : CIfrObj (EFI_IFR_OR_OP, (CHAR8 **)&mOr),\r
2816 CIfrOpHeader (EFI_IFR_OR_OP, &mOr->Header) {\r
2817 SetLineNo (LineNo);\r
2818 }\r
2819};\r
2820\r
2821class CIfrShiftLeft : public CIfrObj, public CIfrOpHeader {\r
2822private:\r
2823 EFI_IFR_SHIFT_LEFT *mShiftLeft;\r
2824\r
2825public:\r
2826 CIfrShiftLeft (\r
2827 IN UINT32 LineNo\r
2828 ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP, (CHAR8 **)&mShiftLeft),\r
2829 CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &mShiftLeft->Header) {\r
2830 SetLineNo (LineNo);\r
2831 }\r
2832};\r
2833\r
2834class CIfrShiftRight : public CIfrObj, public CIfrOpHeader {\r
2835private:\r
2836 EFI_IFR_SHIFT_RIGHT *mShiftRight;\r
2837\r
2838public:\r
2839 CIfrShiftRight (\r
2840 IN UINT32 LineNo\r
2841 ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP, (CHAR8 **)&mShiftRight),\r
2842 CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &mShiftRight->Header) {\r
2843 SetLineNo (LineNo);\r
2844 }\r
2845};\r
2846\r
2847class CIfrSubtract : public CIfrObj, public CIfrOpHeader {\r
2848private:\r
2849 EFI_IFR_SUBTRACT *mSubtract;\r
2850\r
2851public:\r
2852 CIfrSubtract (\r
2853 IN UINT32 LineNo\r
2854 ) : CIfrObj (EFI_IFR_SUBTRACT_OP, (CHAR8 **)&mSubtract),\r
2855 CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &mSubtract->Header) {\r
2856 SetLineNo (LineNo);\r
2857 }\r
2858};\r
2859\r
2860class CIfrConditional : public CIfrObj, public CIfrOpHeader {\r
2861private:\r
2862 EFI_IFR_CONDITIONAL *mConditional;\r
2863\r
2864public:\r
2865 CIfrConditional (\r
2866 IN UINT32 LineNo\r
2867 ) : CIfrObj (EFI_IFR_CONDITIONAL_OP, (CHAR8 **)&mConditional),\r
2868 CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &mConditional->Header) {\r
2869 SetLineNo (LineNo);\r
2870 }\r
2871};\r
2872\r
2873class CIfrFind : public CIfrObj, public CIfrOpHeader {\r
2874private:\r
2875 EFI_IFR_FIND *mFind;\r
2876\r
2877public:\r
2878 CIfrFind (\r
2879 IN UINT32 LineNo\r
2880 ) : CIfrObj (EFI_IFR_FIND_OP, (CHAR8 **)&mFind),\r
2881 CIfrOpHeader (EFI_IFR_FIND_OP, &mFind->Header) {\r
2882 SetLineNo (LineNo);\r
2883 }\r
2884\r
2885 VOID SetFormat (IN UINT8 Format) {\r
2886 mFind->Format = Format;\r
2887 }\r
2888};\r
2889\r
2890class CIfrMid : public CIfrObj, public CIfrOpHeader {\r
2891private:\r
2892 EFI_IFR_MID *mMid;\r
2893\r
2894public:\r
2895 CIfrMid (\r
2896 IN UINT32 LineNo\r
2897 ) : CIfrObj (EFI_IFR_MID_OP, (CHAR8 **)&mMid),\r
2898 CIfrOpHeader (EFI_IFR_MID_OP, &mMid->Header) {\r
2899 SetLineNo (LineNo);\r
2900 }\r
2901};\r
2902\r
2903class CIfrToken : public CIfrObj, public CIfrOpHeader {\r
2904private:\r
2905 EFI_IFR_TOKEN *mToken;\r
2906\r
2907public:\r
2908 CIfrToken (\r
2909 IN UINT32 LineNo\r
2910 ) : CIfrObj (EFI_IFR_TOKEN_OP, (CHAR8 **)&mToken),\r
2911 CIfrOpHeader (EFI_IFR_TOKEN_OP, &mToken->Header) {\r
2912 SetLineNo (LineNo);\r
2913 }\r
2914};\r
2915\r
2916class CIfrSpan : public CIfrObj, public CIfrOpHeader {\r
2917private:\r
2918 EFI_IFR_SPAN *mSpan;\r
2919\r
2920public:\r
2921 CIfrSpan (\r
2922 IN UINT32 LineNo\r
2923 ) : CIfrObj (EFI_IFR_SPAN_OP, (CHAR8 **)&mSpan),\r
2924 CIfrOpHeader (EFI_IFR_SPAN_OP, &mSpan->Header) {\r
2925 SetLineNo (LineNo);\r
2926 mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING;\r
2927 }\r
2928\r
2929 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {\r
2930 if (_IS_EQUAL (LFlags, EFI_IFR_FLAGS_FIRST_MATCHING)) {\r
2931 mSpan->Flags |= EFI_IFR_FLAGS_FIRST_MATCHING;\r
2932 } else if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_FIRST_NON_MATCHING)) {\r
2933 mSpan->Flags |= EFI_IFR_FLAGS_FIRST_NON_MATCHING;\r
2934 }\r
2935\r
2936 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
2937 }\r
2938};\r
2939\r
2940#endif\r
EFI Development Kit II mirror for PVE