]> git.proxmox.com Git - mirror_edk2.git/blame - EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrFormPkg.h
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add the missing BDS license header.
[mirror_edk2.git] / EdkCompatibilityPkg / Sample / Tools / Source / UefiVfrCompile / VfrFormPkg.h
CommitLineData
5b19df7f
LG		 1/*++\r
2\r
3Copyright (c) 2004 - 2010, Intel Corporation\r
4All rights reserved. This program and the accompanying materials\r
5are licensed and made available under the terms and conditions of the BSD License\r
6which accompanies this distribution. The full text of the license may be found at\r
7http://opensource.org/licenses/bsd-license.php\r
8\r
9THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
10WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
11\r
12Module Name:\r
13\r
14VfrFormPkg.h\r
15\r
16Abstract:\r
17\r
18--*/\r
19\r
95d675b5 20#ifndef _EFIIFRCLASS_H_\r
21#define _EFIIFRCLASS_H_\r
22\r
23#include "string.h"\r
24#include "EfiVfr.h"\r
25#include "VfrError.h"\r
26#include "VfrUtilityLib.h"\r
27\r
28/*\r
29 * The functions below are used for flags setting\r
30 */\r
31static inline BOOLEAN _FLAGS_ZERO (\r
32 IN UINT8 &Flags\r
33 )\r
34{\r
35 return Flags == 0;\r
36}\r
37\r
38static inline VOID _FLAG_CLEAR (\r
39 IN UINT8 &Flags,\r
40 IN UINT8 Mask\r
41 )\r
42{\r
43 Flags &= (~Mask);\r
44}\r
45\r
46static inline UINT8 _FLAG_TEST_AND_CLEAR (\r
47 IN UINT8 &Flags,\r
48 IN UINT8 Mask\r
49 )\r
50{\r
51 UINT8 Ret = Flags & Mask;\r
52 Flags &= (~Mask);\r
53 return Ret;\r
54}\r
55\r
56static inline UINT8 _IS_EQUAL (\r
57 IN UINT8 &Flags,\r
58 IN UINT8 Value\r
59 )\r
60{\r
61 return Flags == Value;\r
62}\r
63\r
64/*\r
65 * The definition of CIfrBin\r
66 */\r
67typedef enum {\r
68 PENDING,\r
69 ASSIGNED\r
70} ASSIGN_FLAG;\r
71\r
72struct SPendingAssign {\r
73 INT8 *mKey; // key ! unique\r
74 VOID *mAddr;\r
75 UINT32 mLen;\r
76 ASSIGN_FLAG mFlag;\r
77 UINT32 mLineNo;\r
78 struct SPendingAssign *mNext;\r
79\r
80 SPendingAssign (IN INT8 *, IN VOID *, IN UINT32, IN UINT32);\r
81 ~SPendingAssign ();\r
82\r
83 VOID SetAddrAndLen (IN VOID *, IN UINT32);\r
84 VOID AssignValue (IN VOID *, IN UINT32);\r
85 INT8 * GetKey (VOID);\r
86};\r
87\r
88struct SBufferNode {\r
89 CHAR8 *mBufferStart;\r
90 CHAR8 *mBufferEnd;\r
91 CHAR8 *mBufferFree;\r
92 struct SBufferNode *mNext;\r
93};\r
94\r
95class CFormPkg {\r
96private:\r
97 UINT32 mBufferSize;\r
98 SBufferNode *mBufferNodeQueueHead;\r
99 SBufferNode *mBufferNodeQueueTail;\r
100 SBufferNode *mCurrBufferNode;\r
101\r
102 SBufferNode *mReadBufferNode;\r
103 UINT32 mReadBufferOffset;\r
104\r
105 UINT32 mPkgLength;\r
106\r
107 VOID _WRITE_PKG_LINE (IN FILE *, IN UINT32 , IN INT8 *, IN INT8 *, IN UINT32);\r
108 VOID _WRITE_PKG_END (IN FILE *, IN UINT32 , IN INT8 *, IN INT8 *, IN UINT32);\r
109\r
110private:\r
111 SPendingAssign *PendingAssignList;\r
112\r
113public:\r
114 CFormPkg (IN UINT32 BufferSize);\r
115 ~CFormPkg ();\r
116\r
117 CHAR8 * IfrBinBufferGet (IN UINT32);\r
118 inline UINT32 GetPkgLength (VOID);\r
119\r
120 VOID Open ();\r
121 UINT32 Read (IN CHAR8 *, IN UINT32);\r
122 VOID Close ();\r
123\r
124 EFI_VFR_RETURN_CODE BuildPkgHdr (OUT EFI_HII_PACKAGE_HEADER **);\r
125 EFI_VFR_RETURN_CODE BuildPkg (IN FILE *);\r
126 EFI_VFR_RETURN_CODE GenCFile (IN INT8 *, IN FILE *);\r
127\r
128public:\r
129 EFI_VFR_RETURN_CODE AssignPending (IN INT8 *, IN VOID *, IN UINT32, IN UINT32);\r
130 VOID DoPendingAssign (IN INT8 *, IN VOID *, IN UINT32);\r
131 bool HavePendingUnassigned (VOID);\r
132 VOID PendingAssignPrintAll (VOID);\r
133};\r
134\r
135extern CFormPkg gCFormPkg;\r
136\r
137struct SIfrRecord {\r
138 UINT32 mLineNo;\r
139 CHAR8 *mIfrBinBuf;\r
140 UINT8 mBinBufLen;\r
141 UINT32 mOffset;\r
142 SIfrRecord *mNext;\r
143\r
144 SIfrRecord (VOID);\r
145 ~SIfrRecord (VOID);\r
146};\r
147\r
148#define EFI_IFR_RECORDINFO_IDX_INVALUD 0xFFFFFF\r
149#define EFI_IFR_RECORDINFO_IDX_START 0x0\r
150\r
151class CIfrRecordInfoDB {\r
152private:\r
153 bool mSwitch;\r
154 UINT32 mRecordCount;\r
155 SIfrRecord *mIfrRecordListHead;\r
156 SIfrRecord *mIfrRecordListTail;\r
157\r
158 SIfrRecord * GetRecordInfoFromIdx (IN UINT32);\r
159public:\r
160 CIfrRecordInfoDB (VOID);\r
161 ~CIfrRecordInfoDB (VOID);\r
162\r
163 inline VOID TurnOn (VOID) {\r
164 mSwitch = TRUE;\r
165 }\r
166\r
167 inline VOID TurnOff (VOID) {\r
168 mSwitch = FALSE;\r
169 }\r
170\r
171 UINT32 IfrRecordRegister (IN UINT32, IN CHAR8 *, IN UINT8, IN UINT32);\r
172 VOID IfrRecordInfoUpdate (IN UINT32, IN UINT32, IN CHAR8*, IN UINT8, IN UINT32);\r
173 VOID IfrRecordOutput (IN FILE *, IN UINT32 LineNo);\r
174};\r
175\r
176extern CIfrRecordInfoDB gCIfrRecordInfoDB;\r
177\r
178/*\r
179 * The definition of CIfrObj\r
180 */\r
181extern bool gCreateOp;\r
182\r
183class CIfrObj {\r
184private:\r
185 bool mDelayEmit;\r
186\r
187 CHAR8 *mObjBinBuf;\r
188 UINT8 mObjBinLen;\r
189 UINT32 mLineNo;\r
190 UINT32 mRecordIdx;\r
191 UINT32 mPkgOffset;\r
192\r
193 VOID _EMIT_PENDING_OBJ (VOID);\r
194\r
195public:\r
196 CIfrObj (IN UINT8 OpCode, OUT CHAR8 **IfrObj = NULL, IN UINT8 ObjBinLen = 0, IN BOOLEAN DelayEmit = FALSE);\r
197 virtual ~CIfrObj(VOID);\r
198\r
199 inline VOID SetLineNo (IN UINT32 LineNo) {\r
200 mLineNo = LineNo;\r
201 }\r
202\r
203 inline CHAR8 * GetObjBinAddr (VOID) {\r
204 return mObjBinBuf;\r
205 }\r
206\r
207 inline UINT8 GetObjBinLen (VOID) {\r
208 return mObjBinLen;\r
209 }\r
210\r
211 inline bool ExpendObjBin (IN UINT8 Size) {\r
212 if ((mDelayEmit == TRUE) && ((mObjBinLen + Size) > mObjBinLen)) {\r
213 mObjBinLen += Size;\r
214 return TRUE;\r
215 } else {\r
216 return FALSE;\r
217 }\r
218 }\r
219};\r
220\r
221/*\r
222 * The definition of CIfrOpHeader\r
223 */\r
224class CIfrOpHeader {\r
225private:\r
226 EFI_IFR_OP_HEADER *mHeader;\r
227\r
228public:\r
229 CIfrOpHeader (IN UINT8 OpCode, IN VOID *StartAddr, IN UINT8 Length = 0);\r
230 CIfrOpHeader (IN CIfrOpHeader &);\r
231\r
232 VOID IncLength (UINT8 Size) {\r
233 if ((mHeader->Length + Size) > mHeader->Length) {\r
234 mHeader->Length += Size;\r
235 }\r
236 }\r
237\r
238 VOID DecLength (UINT8 Size) {\r
239 if (mHeader->Length >= Size) {\r
240 mHeader -= Size;\r
241 }\r
242 }\r
243\r
244 UINT8 GetLength () {\r
245 return mHeader->Length;\r
246 }\r
247\r
248 UINT8 GetScope () {\r
249 return mHeader->Scope;\r
250 }\r
251\r
252 VOID SetScope (IN UINT8 Scope) {\r
253 mHeader->Scope = Scope;\r
254 }\r
255};\r
256\r
257extern UINT8 gScopeCount;\r
258\r
259/*\r
260 * The definition of CIfrStatementHeader\r
261 */\r
262class CIfrStatementHeader {\r
263private:\r
264 EFI_IFR_STATEMENT_HEADER *mHeader;\r
265\r
266public:\r
267 CIfrStatementHeader (\r
268 IN EFI_IFR_STATEMENT_HEADER *StartAddr\r
269 ) : mHeader ((EFI_IFR_STATEMENT_HEADER *)StartAddr) {\r
270 mHeader = StartAddr;\r
271 mHeader->Help = EFI_STRING_ID_INVALID;\r
272 mHeader->Prompt = EFI_STRING_ID_INVALID;\r
273 }\r
274\r
275 EFI_IFR_STATEMENT_HEADER *GetStatementHeader () {\r
276 return mHeader;\r
277 }\r
278\r
279 VOID SetPrompt (IN EFI_STRING_ID Prompt) {\r
280 mHeader->Prompt = Prompt;\r
281 }\r
282\r
283 VOID SetHelp (IN EFI_STRING_ID Help) {\r
284 mHeader->Help = Help;\r
285 }\r
286};\r
287\r
288/*\r
289 * The definition of CIfrQuestionHeader\r
290 */\r
291#define EFI_IFR_QUESTION_FLAG_DEFAULT 0\r
292\r
293class CIfrQuestionHeader : public CIfrStatementHeader {\r
294private:\r
295 EFI_IFR_QUESTION_HEADER *mHeader;\r
296\r
297 EFI_IFR_STATEMENT_HEADER * QH2SH (EFI_IFR_QUESTION_HEADER *Qheader) {\r
298 return &(Qheader)->Header;\r
299 }\r
300\r
301public:\r
302 EFI_QUESTION_ID QUESTION_ID (VOID) {\r
303 return mHeader->QuestionId;\r
304 }\r
305\r
306 EFI_VARSTORE_ID VARSTORE_ID (VOID) {\r
307 return mHeader->VarStoreId;\r
308 }\r
309\r
310 VOID VARSTORE_INFO (OUT EFI_VARSTORE_INFO *Info) {\r
311 if (Info != NULL) {\r
312 Info->mVarStoreId = mHeader->VarStoreId;\r
313 memcpy (&Info->mVarStoreId, &mHeader->VarStoreInfo, sizeof (Info->mVarStoreId));\r
314 }\r
315 }\r
316\r
317 UINT8 FLAGS (VOID) {\r
318 return mHeader->Flags;\r
319 }\r
320\r
321public:\r
322 CIfrQuestionHeader (\r
323 IN EFI_IFR_QUESTION_HEADER *StartAddr, \r
324 IN UINT8 Flags = EFI_IFR_QUESTION_FLAG_DEFAULT\r
325 ) : CIfrStatementHeader (QH2SH(StartAddr)) {\r
326 mHeader = StartAddr;\r
327 mHeader->QuestionId = EFI_QUESTION_ID_INVALID;\r
328 mHeader->VarStoreId = EFI_VARSTORE_ID_INVALID;\r
329 mHeader->VarStoreInfo.VarName = EFI_STRING_ID_INVALID;\r
330 mHeader->VarStoreInfo.VarOffset = EFI_VAROFFSET_INVALID;\r
331 mHeader->Flags = Flags;\r
332 }\r
333\r
334 VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {\r
335 mHeader->QuestionId = QuestionId;\r
336 }\r
337\r
338 VOID SetVarStoreInfo (IN EFI_VARSTORE_INFO *Info) {\r
339 mHeader->VarStoreId = Info->mVarStoreId;\r
340 mHeader->VarStoreInfo.VarName = Info->mInfo.mVarName;\r
341 mHeader->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset;\r
342 }\r
343\r
344 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 Flags) {\r
345 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_READ_ONLY)) {\r
346 mHeader->Flags |= EFI_IFR_FLAG_READ_ONLY;\r
347 }\r
348\r
349 _FLAG_CLEAR (Flags, 0x02);\r
350\r
351 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_CALLBACK)) {\r
352 mHeader->Flags |= EFI_IFR_FLAG_CALLBACK;\r
353 }\r
354\r
355 _FLAG_CLEAR (Flags, 0x08);\r
356\r
357 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_RESET_REQUIRED)) {\r
358 mHeader->Flags |= EFI_IFR_FLAG_RESET_REQUIRED;\r
359 }\r
360\r
361 _FLAG_CLEAR (Flags, 0x20);\r
362\r
363 if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_OPTIONS_ONLY)) {\r
364 mHeader->Flags |= EFI_IFR_FLAG_OPTIONS_ONLY;\r
365 }\r
366\r
367 return _FLAGS_ZERO (Flags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
368 }\r
369};\r
370\r
371static CIfrQuestionHeader *gCurrentQuestion = NULL;\r
372\r
373/*\r
374 * The definition of CIfrMinMaxStepData\r
375 */\r
376class CIfrMinMaxStepData {\r
377private:\r
378 MINMAXSTEP_DATA *mMinMaxStepData;\r
379\r
380public:\r
381 CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr) : mMinMaxStepData (DataAddr) {\r
382 mMinMaxStepData->u64.MinValue = 0;\r
383 mMinMaxStepData->u64.MaxValue = 0;\r
384 mMinMaxStepData->u64.Step = 0;\r
385 }\r
386\r
387 VOID SetMinMaxStepData (IN UINT64 MinValue, IN UINT64 MaxValue, IN UINT64 Step) {\r
388 mMinMaxStepData->u64.MinValue = MinValue;\r
389 mMinMaxStepData->u64.MaxValue = MaxValue;\r
390 mMinMaxStepData->u64.Step = Step;\r
391 }\r
392\r
393 VOID SetMinMaxStepData (IN UINT32 MinValue, IN UINT32 MaxValue, IN UINT32 Step) {\r
394 mMinMaxStepData->u32.MinValue = MinValue;\r
395 mMinMaxStepData->u32.MaxValue = MaxValue;\r
396 mMinMaxStepData->u32.Step = Step;\r
397 }\r
398\r
399 VOID SetMinMaxStepData (IN UINT16 MinValue, IN UINT16 MaxValue, IN UINT16 Step) {\r
400 mMinMaxStepData->u16.MinValue = MinValue;\r
401 mMinMaxStepData->u16.MaxValue = MaxValue;\r
402 mMinMaxStepData->u16.Step = Step;\r
403 }\r
404\r
405 VOID SetMinMaxStepData (IN UINT8 MinValue, IN UINT8 MaxValue, IN UINT8 Step) {\r
406 mMinMaxStepData->u8.MinValue = MinValue;\r
407 mMinMaxStepData->u8.MaxValue = MaxValue;\r
408 mMinMaxStepData->u8.Step = Step;\r
409 }\r
410\r
411};\r
412\r
413/*\r
414 * The definition of all of the UEFI IFR Objects\r
415 */\r
416class CIfrFormSet : public CIfrObj, public CIfrOpHeader {\r
417private:\r
418 EFI_IFR_FORM_SET *mFormSet;\r
419\r
420public:\r
421 CIfrFormSet () : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mFormSet),\r
422 CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header) {\r
423 mFormSet->Help = EFI_STRING_ID_INVALID;\r
424 mFormSet->FormSetTitle = EFI_STRING_ID_INVALID;\r
425 memset (&mFormSet->Guid, 0, sizeof (EFI_GUID));\r
426 }\r
427\r
428 VOID SetGuid (IN EFI_GUID *Guid) {\r
429 memcpy (&mFormSet->Guid, Guid, sizeof (EFI_GUID));\r
430 }\r
431\r
432 VOID SetFormSetTitle (IN EFI_STRING_ID FormSetTitle) {\r
433 mFormSet->FormSetTitle = FormSetTitle;\r
434 }\r
435\r
436 VOID SetHelp (IN EFI_STRING_ID Help) {\r
437 mFormSet->Help = Help;\r
438 }\r
439};\r
440\r
441class CIfrEnd : public CIfrObj, public CIfrOpHeader {\r
442private:\r
443 EFI_IFR_END *mEnd;\r
444\r
445public:\r
446 CIfrEnd () : CIfrObj (EFI_IFR_END_OP, (CHAR8 **)&mEnd),\r
447 CIfrOpHeader (EFI_IFR_END_OP, &mEnd->Header) {}\r
448};\r
449\r
450class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader {\r
451private:\r
452 EFI_IFR_DEFAULTSTORE *mDefaultStore;\r
453\r
454public:\r
455 CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP, (CHAR8 **)&mDefaultStore),\r
456 CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &mDefaultStore->Header) {\r
457 mDefaultStore->DefaultId = EFI_VARSTORE_ID_INVALID;\r
458 mDefaultStore->DefaultName = EFI_STRING_ID_INVALID;\r
459 }\r
460\r
461 VOID SetDefaultName (IN EFI_STRING_ID DefaultName) {\r
462 mDefaultStore->DefaultName = DefaultName;\r
463 }\r
464\r
465 VOID SetDefaultId (IN UINT16 DefaultId) {\r
466 mDefaultStore->DefaultId = DefaultId;\r
467 }\r
468};\r
469\r
470#define EFI_FORM_ID_MAX 0xFFFF\r
471#define EFI_FREE_FORM_ID_BITMAP_SIZE ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)\r
472\r
473class CIfrForm : public CIfrObj, public CIfrOpHeader {\r
474private:\r
475 EFI_IFR_FORM *mForm;\r
476\r
477 STATIC UINT32 FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE];\r
478\r
479 STATIC BOOLEAN ChekFormIdFree (IN EFI_FORM_ID FormId) {\r
480 UINT32 Index = (FormId / EFI_BITS_PER_UINT32);\r
481 UINT32 Offset = (FormId % EFI_BITS_PER_UINT32);\r
482\r
483 return (FormIdBitMap[Index] & (0x80000000 >> Offset)) == 0;\r
484 }\r
485\r
486 STATIC VOID MarkFormIdUsed (IN EFI_FORM_ID FormId) {\r
487 UINT32 Index = (FormId / EFI_BITS_PER_UINT32);\r
488 UINT32 Offset = (FormId % EFI_BITS_PER_UINT32);\r
489\r
490 FormIdBitMap[Index] |= (0x80000000 >> Offset);\r
491 }\r
492\r
493public:\r
494 CIfrForm () : CIfrObj (EFI_IFR_FORM_OP, (CHAR8 **)&mForm), \r
495 CIfrOpHeader (EFI_IFR_FORM_OP, &mForm->Header) {\r
496 mForm->FormId = 0;\r
497 mForm->FormTitle = EFI_STRING_ID_INVALID;\r
498 }\r
499\r
500 EFI_VFR_RETURN_CODE SetFormId (IN EFI_FORM_ID FormId) {\r
501 if (CIfrForm::ChekFormIdFree (FormId) == FALSE) {\r
502 return VFR_RETURN_FORMID_REDEFINED;\r
503 }\r
504 mForm->FormId = FormId;\r
505 CIfrForm::MarkFormIdUsed (FormId);\r
506 return VFR_RETURN_SUCCESS;\r
507 }\r
508\r
509 VOID SetFormTitle (IN EFI_STRING_ID FormTitle) {\r
510 mForm->FormTitle = FormTitle;\r
511 }\r
512};\r
513\r
514class CIfrVarStore : public CIfrObj, public CIfrOpHeader {\r
515private:\r
516 EFI_IFR_VARSTORE *mVarStore;\r
517\r
518public:\r
519 CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)&mVarStore, sizeof (EFI_IFR_VARSTORE), TRUE), \r
520 CIfrOpHeader (EFI_IFR_VARSTORE_OP, &mVarStore->Header) {\r
521 mVarStore->VarStoreId = EFI_VARSTORE_ID_INVALID;\r
522 mVarStore->Size = 0;\r
523 memset (&mVarStore->Guid, 0, sizeof (EFI_GUID));\r
524 mVarStore->Name[0] = '\0';\r
525 }\r
526\r
527 VOID SetGuid (IN EFI_GUID *Guid) {\r
528 memcpy (&mVarStore->Guid, Guid, sizeof (EFI_GUID));\r
529 }\r
530\r
531 VOID SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId) {\r
532 mVarStore->VarStoreId = VarStoreId;\r
533 }\r
534\r
535 VOID SetSize (IN UINT16 Size) {\r
536 mVarStore->Size = Size;\r
537 }\r
538\r
539 VOID SetName (IN INT8 *Name) {\r
540 UINT8 Len;\r
541\r
542 if (Name != NULL) {\r
543 Len = strlen (Name);\r
544 if (Len != 0) {\r
545 if (ExpendObjBin (Len) == TRUE) {\r
546 IncLength (Len);\r
547 strcpy ((INT8 *)(mVarStore->Name), Name);\r
548 }\r
549 }\r
550 }\r
551 }\r
552};\r
553\r
554class CIfrVarStoreEfi : public CIfrObj, public CIfrOpHeader {\r
555private:\r
556 EFI_IFR_VARSTORE_EFI *mVarStoreEfi;\r
557\r
558public:\r
559 CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)&mVarStoreEfi), \r
560 CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &mVarStoreEfi->Header) {\r
561 mVarStoreEfi->VarStoreId = EFI_VAROFFSET_INVALID;\r
562 memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID));\r
563 }\r
564\r
565 VOID SetGuid (IN EFI_GUID *Guid) {\r
566 memcpy (&mVarStoreEfi->Guid, Guid, sizeof (EFI_GUID));\r
567 }\r
568\r
569 VOID SetVarStoreId (IN UINT16 VarStoreId) {\r
570 mVarStoreEfi->VarStoreId = VarStoreId;\r
571 }\r
572\r
573 VOID SetAttributes (IN UINT32 Attributes) {\r
574 mVarStoreEfi->Attributes = Attributes;\r
575 }\r
576};\r
577\r
578class CIfrVarStoreNameValue : public CIfrObj, public CIfrOpHeader {\r
579private:\r
580 EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue;\r
581\r
582public:\r
583 CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP, (CHAR8 **)&mVarStoreNameValue), \r
584 CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &mVarStoreNameValue->Header) {\r
585 mVarStoreNameValue->VarStoreId = EFI_VAROFFSET_INVALID;\r
586 memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID));\r
587 }\r
588\r
589 VOID SetGuid (IN EFI_GUID *Guid) {\r
590 memcpy (&mVarStoreNameValue->Guid, Guid, sizeof (EFI_GUID));\r
591 }\r
592\r
593 VOID SetVarStoreId (IN UINT16 VarStoreId) {\r
594 mVarStoreNameValue->VarStoreId = VarStoreId;\r
595 }\r
596};\r
597\r
598class CIfrImage : public CIfrObj, public CIfrOpHeader {\r
599private:\r
600 EFI_IFR_IMAGE *mImage;\r
601\r
602public:\r
603 CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP, (CHAR8 **)&mImage),\r
604 CIfrOpHeader (EFI_IFR_FORM_OP, &mImage->Header) {\r
605 mImage->Id = EFI_IMAGE_ID_INVALID;\r
606 }\r
607\r
608 VOID SetImageId (IN EFI_IMAGE_ID ImageId) {\r
609 mImage->Id = ImageId;\r
610 }\r
611};\r
612\r
613class CIfrLocked : public CIfrObj, public CIfrOpHeader {\r
614private:\r
615 EFI_IFR_LOCKED *mLocked;\r
616\r
617public:\r
618 CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP, (CHAR8 **)&mLocked),\r
619 CIfrOpHeader (EFI_IFR_LOCKED_OP, &mLocked->Header) {}\r
620};\r
621\r
622class CIfrRule : public CIfrObj, public CIfrOpHeader {\r
623private:\r
624 EFI_IFR_RULE *mRule;\r
625\r
626public:\r
627 CIfrRule () : CIfrObj (EFI_IFR_RULE_OP, (CHAR8 **)&mRule),\r
628 mRule ((EFI_IFR_RULE *)GetObjBinAddr()),\r
629 CIfrOpHeader (EFI_IFR_RULE_OP, &mRule->Header) {\r
630 mRule->RuleId = EFI_RULE_ID_INVALID;\r
631 }\r
632\r
633 VOID SetRuleId (IN UINT8 RuleId) {\r
634 mRule->RuleId = RuleId;\r
635 }\r
636};\r
637\r
638static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue = {0, };\r
639\r
640class CIfrDefault : public CIfrObj, public CIfrOpHeader {\r
641private:\r
642 EFI_IFR_DEFAULT *mDefault;\r
643\r
644public:\r
645 CIfrDefault (\r
646 IN UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,\r
647 IN UINT8 Type = EFI_IFR_TYPE_OTHER,\r
648 IN EFI_IFR_TYPE_VALUE Value = gZeroEfiIfrTypeValue\r
649 ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault),\r
650 CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header) {\r
651 mDefault->Type = Type;\r
652 mDefault->Value = Value;\r
653 mDefault->DefaultId = DefaultId;\r
654 }\r
655\r
656 VOID SetDefaultId (IN UINT16 DefaultId) {\r
657 mDefault->DefaultId = DefaultId;\r
658 }\r
659\r
660 VOID SetType (IN UINT8 Type) {\r
661 mDefault->Type = Type;\r
662 }\r
663\r
664 VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {\r
665 mDefault->Value = Value;\r
666 }\r
667};\r
668\r
669class CIfrValue : public CIfrObj, public CIfrOpHeader{\r
670private:\r
671 EFI_IFR_VALUE *mValue;\r
672\r
673public:\r
674 CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP, (CHAR8 **)&mValue),\r
675 CIfrOpHeader (EFI_IFR_VALUE_OP, &mValue->Header) {}\r
676\r
677};\r
678\r
679class CIfrSubtitle : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {\r
680private:\r
681 EFI_IFR_SUBTITLE *mSubtitle;\r
682\r
683public:\r
684 CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP, (CHAR8 **)&mSubtitle),\r
685 CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &mSubtitle->Header),\r
686 CIfrStatementHeader (&mSubtitle->Statement) {\r
687 mSubtitle->Flags = 0;\r
688 }\r
689\r
690 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {\r
691 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_HORIZONTAL)) {\r
692 mSubtitle->Flags |= EFI_IFR_FLAGS_HORIZONTAL;\r
693 }\r
694\r
695 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
696 }\r
697};\r
698\r
699class CIfrText : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {\r
700private:\r
701 EFI_IFR_TEXT *mText;\r
702\r
703public:\r
704 CIfrText () : CIfrObj (EFI_IFR_TEXT_OP, (CHAR8 **)&mText),\r
705 CIfrOpHeader (EFI_IFR_TEXT_OP, &mText->Header), \r
706 CIfrStatementHeader (&mText->Statement) {\r
707 mText->TextTwo = EFI_STRING_ID_INVALID;\r
708 }\r
709\r
710 VOID SetTextTwo (IN EFI_STRING_ID StringId) {\r
711 mText->TextTwo = StringId;\r
712 }\r
713};\r
714\r
715class CIfrRef : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
716private:\r
717 EFI_IFR_REF *mRef;\r
718\r
719public:\r
720 CIfrRef () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef),\r
721 CIfrOpHeader (EFI_IFR_REF_OP, &mRef->Header), \r
722 CIfrQuestionHeader (&mRef->Question) {\r
723 mRef->FormId = 0;\r
724 }\r
725\r
726 VOID SetFormId (IN EFI_FORM_ID FormId) {\r
727 mRef->FormId = FormId;\r
728 }\r
729};\r
730\r
731class CIfrRef2 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
732private:\r
733 EFI_IFR_REF2 *mRef2;\r
734\r
735public:\r
736 CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef2, sizeof (EFI_IFR_REF2)),\r
737 CIfrOpHeader (EFI_IFR_REF_OP, &mRef2->Header, sizeof (EFI_IFR_REF2)), \r
738 CIfrQuestionHeader (&mRef2->Question) {\r
739 mRef2->FormId = 0;\r
740 mRef2->QuestionId = EFI_QUESTION_ID_INVALID;\r
741 }\r
742\r
743 VOID SetFormId (IN EFI_FORM_ID FormId) {\r
744 mRef2->FormId = FormId;\r
745 }\r
746\r
747 EFI_VFR_RETURN_CODE SetQuestionId (IN EFI_QUESTION_ID QuestionId) {\r
748 if (QuestionId == EFI_QUESTION_ID_INVALID) {\r
749 return VFR_RETURN_UNDEFINED;\r
750 }\r
751 mRef2->QuestionId = QuestionId;\r
752 return VFR_RETURN_SUCCESS;\r
753 }\r
754};\r
755\r
756class CIfrRef3 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
757private:\r
758 EFI_IFR_REF3 *mRef3;\r
759\r
760public:\r
761 CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef3, sizeof(EFI_IFR_REF3)),\r
762 CIfrOpHeader (EFI_IFR_REF_OP, &mRef3->Header, sizeof (EFI_IFR_REF3)), \r
763 CIfrQuestionHeader (&mRef3->Question) {\r
764 mRef3->FormId = 0;\r
765 mRef3->QuestionId = EFI_QUESTION_ID_INVALID;\r
766 memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID));\r
767 }\r
768\r
769 VOID SetFormId (IN EFI_FORM_ID FormId) {\r
770 mRef3->FormId = FormId;\r
771 }\r
772\r
773 VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {\r
774 mRef3->QuestionId = QuestionId;\r
775 }\r
776\r
777 VOID SetFormSetId (IN EFI_GUID FormSetId) {\r
778 mRef3->FormSetId = FormSetId;\r
779 }\r
780};\r
781\r
782class CIfrRef4 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
783private:\r
784 EFI_IFR_REF4 *mRef4;\r
785\r
786public:\r
787 CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef4, sizeof(EFI_IFR_REF3)),\r
788 CIfrOpHeader (EFI_IFR_REF_OP, &mRef4->Header, sizeof (EFI_IFR_REF3)), \r
789 CIfrQuestionHeader (&mRef4->Question) {\r
790 mRef4->FormId = 0;\r
791 mRef4->QuestionId = EFI_QUESTION_ID_INVALID;\r
792 memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID));\r
793 mRef4->DevicePath = EFI_STRING_ID_INVALID;\r
794 }\r
795\r
796 VOID SetFormId (IN EFI_FORM_ID FormId) {\r
797 mRef4->FormId = FormId;\r
798 }\r
799\r
800 VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {\r
801 mRef4->QuestionId = QuestionId;\r
802 }\r
803\r
804 VOID SetFormSetId (IN EFI_GUID FormSetId) {\r
805 mRef4->FormSetId = FormSetId;\r
806 }\r
807\r
808 VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {\r
809 mRef4->DevicePath = DevicePath;\r
810 }\r
811};\r
812\r
813class CIfrResetButton : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {\r
814private:\r
815 EFI_IFR_RESET_BUTTON *mResetButton;\r
816\r
817public:\r
818 CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP, (CHAR8 **)&mResetButton),\r
819 CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetButton->Header), \r
820 CIfrStatementHeader (&mResetButton->Question.Header) {\r
821 mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;\r
822 }\r
823\r
824 VOID SetDefaultId (IN UINT16 DefaultId) {\r
825 mResetButton->DefaultId = DefaultId;\r
826 }\r
827};\r
828\r
829class CIfrCheckBox : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
830private:\r
831 EFI_IFR_CHECKBOX *mCheckBox;\r
832\r
833public:\r
834 CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox),\r
835 CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Header), \r
836 CIfrQuestionHeader (&mCheckBox->Question) {\r
837 mCheckBox->Flags = EFI_IFR_CHECKBOX_DEFAULT;\r
838 gCurrentQuestion = this;\r
839 }\r
840\r
841 ~CIfrCheckBox () {\r
842 gCurrentQuestion = NULL;\r
843 }\r
844\r
845 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, UINT8 LFlags) {\r
846 EFI_VFR_RETURN_CODE Ret;\r
847\r
848 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
849 if (Ret != VFR_RETURN_SUCCESS) {\r
850 return Ret;\r
851 }\r
852\r
853 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT)) {\r
854 mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT;\r
855 }\r
856\r
857 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT_MFG)) {\r
858 mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT_MFG;\r
859 }\r
860\r
861 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
862 }\r
863};\r
864\r
865class CIfrAction : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
866private:\r
867 EFI_IFR_ACTION *mAction;\r
868\r
869public:\r
870 CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP, (CHAR8 **)&mAction),\r
871 CIfrOpHeader (EFI_IFR_ACTION_OP, &mAction->Header), \r
872 CIfrQuestionHeader (&mAction->Question) {\r
873 mAction->QuestionConfig = EFI_STRING_ID_INVALID;\r
874 }\r
875\r
876 VOID SetQuestionConfig (IN EFI_STRING_ID QuestionConfig) {\r
877 mAction->QuestionConfig = QuestionConfig;\r
878 }\r
879};\r
880\r
881class CIfrDate : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
882private:\r
883 EFI_IFR_DATE *mDate;\r
884\r
885public:\r
886 CIfrDate () : CIfrObj (EFI_IFR_DATE_OP, (CHAR8 **)&mDate),\r
887 CIfrOpHeader (EFI_IFR_DATE_OP, &mDate->Header),\r
888 CIfrQuestionHeader (&mDate->Question) {\r
889 mDate->Flags = 0;\r
890 }\r
891\r
892 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
893 EFI_VFR_RETURN_CODE Ret;\r
894\r
895 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
896 if (Ret != VFR_RETURN_SUCCESS) {\r
897 return Ret;\r
898 }\r
899\r
900 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_YEAR_SUPPRESS)) {\r
901 mDate->Flags |= EFI_QF_DATE_YEAR_SUPPRESS;\r
902 }\r
903\r
904 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_MONTH_SUPPRESS)) {\r
905 mDate->Flags |= EFI_QF_DATE_MONTH_SUPPRESS;\r
906 }\r
907\r
908 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_DAY_SUPPRESS)) {\r
909 mDate->Flags |= EFI_QF_DATE_DAY_SUPPRESS;\r
910 }\r
911\r
912 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_NORMAL)) {\r
913 mDate->Flags |= QF_DATE_STORAGE_NORMAL;\r
914 } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_TIME)) {\r
915 mDate->Flags |= QF_DATE_STORAGE_TIME;\r
916 } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_WAKEUP)) {\r
917 mDate->Flags |= QF_DATE_STORAGE_WAKEUP;\r
918 }\r
919\r
920 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
921 }\r
922};\r
923\r
924class CIfrNumeric : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {\r
925private:\r
926 EFI_IFR_NUMERIC *mNumeric;\r
927\r
928public:\r
929 CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric),\r
930 CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),\r
931 CIfrQuestionHeader (&mNumeric->Question),\r
932 CIfrMinMaxStepData (&mNumeric->data) {\r
933 mNumeric->Flags = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;\r
934 gCurrentQuestion = this;\r
935 }\r
936\r
937 ~CIfrNumeric () {\r
938 gCurrentQuestion = NULL;\r
939 }\r
940\r
941 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
942 EFI_VFR_RETURN_CODE Ret;\r
943\r
944 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
945 if (Ret != VFR_RETURN_SUCCESS) {\r
946 return Ret;\r
947 }\r
948\r
949 if (LFlags & EFI_IFR_DISPLAY) {\r
950 mNumeric->Flags = LFlags;\r
951 } else {\r
952 mNumeric->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;\r
953 }\r
954 return VFR_RETURN_SUCCESS;\r
955 }\r
956};\r
957\r
958class CIfrOneOf : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {\r
959private:\r
960 EFI_IFR_ONE_OF *mOneOf;\r
961\r
962public:\r
963 CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)&mOneOf),\r
964 CIfrOpHeader (EFI_IFR_ONE_OF_OP, &mOneOf->Header),\r
965 CIfrQuestionHeader (&mOneOf->Question),\r
966 CIfrMinMaxStepData (&mOneOf->data) {\r
967 mOneOf->Flags = 0;\r
968 gCurrentQuestion = this;\r
969 }\r
970\r
971 ~CIfrOneOf () {\r
972 gCurrentQuestion = NULL;\r
973 }\r
974\r
975 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
976 EFI_VFR_RETURN_CODE Ret;\r
977\r
978 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
979 if (Ret != VFR_RETURN_SUCCESS) {\r
980 return Ret;\r
981 }\r
982\r
983 if (LFlags & EFI_IFR_DISPLAY) {\r
984 mOneOf->Flags = LFlags;\r
985 } else {\r
986 mOneOf->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;\r
987 }\r
988 return VFR_RETURN_SUCCESS;\r
989 }\r
990};\r
991\r
992class CIfrString : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
993private:\r
994 EFI_IFR_STRING *mString;\r
995\r
996public:\r
997 CIfrString () : CIfrObj (EFI_IFR_STRING_OP, (CHAR8 **)&mString),\r
998 CIfrOpHeader (EFI_IFR_STRING_OP, &mString->Header),\r
999 CIfrQuestionHeader (&mString->Question) {\r
1000 mString->Flags = 0;\r
1001 mString->MinSize = 0;\r
1002 mString->MaxSize = 0;\r
1003 gCurrentQuestion = this;\r
1004 }\r
1005\r
1006 ~CIfrString () {\r
1007 gCurrentQuestion = NULL;\r
1008 }\r
1009\r
1010 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1011 EFI_VFR_RETURN_CODE Ret;\r
1012\r
1013 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1014 if (Ret != VFR_RETURN_SUCCESS) {\r
1015 return Ret;\r
1016 }\r
1017\r
1018 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_STRING_MULTI_LINE)) {\r
1019 mString->Flags |= EFI_IFR_STRING_MULTI_LINE;\r
1020 }\r
1021\r
1022 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1023 }\r
1024\r
1025 VOID SetMinSize (IN UINT8 Flags) {\r
1026 mString->MinSize = Flags;\r
1027 }\r
1028\r
1029 VOID SetMaxSize (IN UINT8 MaxSize) {\r
1030 mString->MaxSize = MaxSize;\r
1031 }\r
1032};\r
1033\r
1034class CIfrPassword : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1035private:\r
1036 EFI_IFR_PASSWORD *mPassword;\r
1037\r
1038public:\r
1039 CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP, (CHAR8 **)&mPassword),\r
1040 CIfrOpHeader (EFI_IFR_PASSWORD_OP, &mPassword->Header),\r
1041 CIfrQuestionHeader (&mPassword->Question) {\r
1042 mPassword->MinSize = 0;\r
1043 mPassword->MaxSize = 0;\r
1044 gCurrentQuestion = this;\r
1045 }\r
1046\r
1047 ~CIfrPassword () {\r
1048 gCurrentQuestion = NULL;\r
1049 }\r
1050\r
1051 VOID SetMinSize (IN UINT16 MinSize) {\r
1052 mPassword->MinSize = MinSize;\r
1053 }\r
1054\r
1055 VOID SetMaxSize (IN UINT16 MaxSize) {\r
1056 mPassword->MaxSize = MaxSize;\r
1057 }\r
1058};\r
1059\r
1060class CIfrOrderedList : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1061private:\r
1062 EFI_IFR_ORDERED_LIST *mOrderedList;\r
1063\r
1064public:\r
1065 CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP, (CHAR8 **)&mOrderedList),\r
1066 CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &mOrderedList->Header),\r
1067 CIfrQuestionHeader (&mOrderedList->Question) {\r
1068 mOrderedList->MaxContainers = 0;\r
1069 mOrderedList->Flags = 0;\r
1070 gCurrentQuestion = this;\r
1071 }\r
1072\r
1073 ~CIfrOrderedList () {\r
1074 gCurrentQuestion = NULL;\r
1075 }\r
1076\r
1077 VOID SetMaxContainers (IN UINT8 MaxContainers) {\r
1078 mOrderedList->MaxContainers = MaxContainers;\r
1079 }\r
1080\r
1081 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1082 EFI_VFR_RETURN_CODE Ret;\r
1083\r
1084 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1085 if (Ret != VFR_RETURN_SUCCESS) {\r
1086 return Ret;\r
1087 }\r
1088\r
1089 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_UNIQUE_SET)) {\r
1090 mOrderedList->Flags |= EFI_IFR_UNIQUE_SET;\r
1091 }\r
1092\r
1093 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_NO_EMPTY_SET)) {\r
1094 mOrderedList->Flags |= EFI_IFR_NO_EMPTY_SET;\r
1095 }\r
1096\r
1097 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1098 }\r
1099};\r
1100\r
1101class CIfrTime : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
1102private:\r
1103 EFI_IFR_TIME *mTime;\r
1104\r
1105public:\r
1106 CIfrTime () : CIfrObj (EFI_IFR_TIME_OP, (CHAR8 **)&mTime),\r
1107 CIfrOpHeader (EFI_IFR_TIME_OP, &mTime->Header),\r
1108 CIfrQuestionHeader (&mTime->Question) {\r
1109 mTime->Flags = 0;\r
1110 }\r
1111\r
1112 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {\r
1113 EFI_VFR_RETURN_CODE Ret;\r
1114\r
1115 Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
1116 if (Ret != VFR_RETURN_SUCCESS) {\r
1117 return Ret;\r
1118 }\r
1119\r
1120 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_HOUR_SUPPRESS)) {\r
1121 mTime->Flags |= QF_TIME_HOUR_SUPPRESS;\r
1122 }\r
1123\r
1124 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_MINUTE_SUPPRESS)) {\r
1125 mTime->Flags |= QF_TIME_MINUTE_SUPPRESS;\r
1126 }\r
1127\r
1128 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_SECOND_SUPPRESS)) {\r
1129 mTime->Flags |= QF_TIME_SECOND_SUPPRESS;\r
1130 }\r
1131\r
1132 if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_NORMAL)) {\r
1133 mTime->Flags |= QF_TIME_STORAGE_NORMAL;\r
1134 } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_TIME)) {\r
1135 mTime->Flags |= QF_TIME_STORAGE_TIME;\r
1136 } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_WAKEUP)) {\r
1137 mTime->Flags |= QF_TIME_STORAGE_WAKEUP;\r
1138 }\r
1139\r
1140 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1141 }\r
1142};\r
1143\r
1144class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {\r
1145private:\r
1146 EFI_IFR_DISABLE_IF *mDisableIf;\r
1147\r
1148public:\r
1149 CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP, (CHAR8 **)&mDisableIf),\r
1150 mDisableIf ((EFI_IFR_DISABLE_IF *) GetObjBinAddr()),\r
1151 CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &mDisableIf->Header) {}\r
1152};\r
1153\r
1154class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader {\r
1155private:\r
1156 EFI_IFR_SUPPRESS_IF *mSuppressIf;\r
1157\r
1158public:\r
1159 CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP, (CHAR8 **)&mSuppressIf),\r
1160 CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &mSuppressIf->Header) {}\r
1161};\r
1162\r
1163class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader {\r
1164private:\r
1165 EFI_IFR_GRAY_OUT_IF *mGrayOutIf;\r
1166\r
1167public:\r
1168 CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP, (CHAR8 **)&mGrayOutIf),\r
1169 CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &mGrayOutIf->Header) {}\r
1170};\r
1171\r
1172class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader {\r
1173private:\r
1174 EFI_IFR_INCONSISTENT_IF *mInconsistentIf;\r
1175\r
1176public:\r
1177 CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP, (CHAR8 **)&mInconsistentIf),\r
1178 CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &mInconsistentIf->Header) {\r
1179 mInconsistentIf->Error = EFI_STRING_ID_INVALID;\r
1180 }\r
1181\r
1182 VOID SetError (IN EFI_STRING_ID Error) {\r
1183 mInconsistentIf->Error = Error;\r
1184 }\r
1185};\r
1186\r
1187class CIfrNoSubmitIf : public CIfrObj, public CIfrOpHeader {\r
1188private:\r
1189 EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf;\r
1190\r
1191public:\r
1192 CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP, (CHAR8 **)&mNoSubmitIf),\r
1193 CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &mNoSubmitIf->Header) {\r
1194 mNoSubmitIf->Error = EFI_STRING_ID_INVALID;\r
1195 }\r
1196\r
1197 VOID SetError (IN EFI_STRING_ID Error) {\r
1198 mNoSubmitIf->Error = Error;\r
1199 }\r
1200};\r
1201\r
1202class CIfrRefresh : public CIfrObj, public CIfrOpHeader {\r
1203private:\r
1204 EFI_IFR_REFRESH *mRefresh;\r
1205\r
1206public:\r
1207 CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP, (CHAR8 **)&mRefresh),\r
1208 CIfrOpHeader (EFI_IFR_REFRESH_OP, &mRefresh->Header) {\r
1209 mRefresh->RefreshInterval = 0;\r
1210 }\r
1211\r
1212 VOID SetRefreshInterval (IN UINT8 RefreshInterval) {\r
1213 mRefresh->RefreshInterval = RefreshInterval;\r
1214 }\r
1215};\r
1216\r
1217class CIfrVarStoreDevice : public CIfrObj, public CIfrOpHeader {\r
1218private:\r
1219 EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice;\r
1220\r
1221public:\r
1222 CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP, (CHAR8 **)&mVarStoreDevice),\r
1223 CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &mVarStoreDevice->Header) {\r
1224 mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID;\r
1225 }\r
1226\r
1227 VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {\r
1228 mVarStoreDevice->DevicePath = DevicePath;\r
1229 }\r
1230};\r
1231\r
1232class CIfrOneOfOption : public CIfrObj, public CIfrOpHeader {\r
1233private:\r
1234 EFI_IFR_ONE_OF_OPTION *mOneOfOption;\r
1235\r
1236public:\r
1237 CIfrOneOfOption () : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)&mOneOfOption),\r
1238 CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &mOneOfOption->Header) {\r
1239 mOneOfOption->Flags = 0;\r
1240 mOneOfOption->Option = EFI_STRING_ID_INVALID;\r
1241 mOneOfOption->Type = EFI_IFR_TYPE_OTHER;\r
1242 memset (&mOneOfOption->Value, 0, sizeof (mOneOfOption->Value));\r
1243 }\r
1244\r
1245 VOID SetOption (IN EFI_STRING_ID Option) {\r
1246 mOneOfOption->Option = Option;\r
1247 }\r
1248\r
1249 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {\r
1250 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT)) {\r
1251 mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT;\r
1252 }\r
1253\r
1254 if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT_MFG)) {\r
1255 mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT_MFG;\r
1256 }\r
1257\r
1258 if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_8)) {\r
1259 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_8);\r
1260 mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_8;\r
1261 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_16)) {\r
1262 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_16);\r
1263 mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_16;\r
1264 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_32)) {\r
1265 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_32);\r
1266 mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_32;\r
1267 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_64)) {\r
1268 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_64);\r
1269 mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_64;\r
1270 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_BOOLEAN)) {\r
1271 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_BOOLEAN);\r
1272 mOneOfOption->Flags |= EFI_IFR_TYPE_BOOLEAN;\r
1273 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_TIME)) {\r
1274 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_TIME);\r
1275 mOneOfOption->Flags |= EFI_IFR_TYPE_TIME;\r
1276 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_DATE)) {\r
1277 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_DATE);\r
1278 mOneOfOption->Flags |= EFI_IFR_TYPE_DATE;\r
1279 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_STRING)) {\r
1280 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_STRING);\r
1281 mOneOfOption->Flags |= EFI_IFR_TYPE_STRING;\r
1282 } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_OTHER)) {\r
1283 _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_OTHER);\r
1284 mOneOfOption->Flags |= EFI_IFR_TYPE_OTHER;\r
1285 }\r
1286\r
1287 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
1288 }\r
1289\r
1290 VOID SetType (IN UINT8 Type) {\r
1291 mOneOfOption->Type = Type;\r
1292 }\r
1293\r
1294 VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {\r
1295 mOneOfOption->Value = Value;\r
1296 }\r
1297\r
1298 UINT8 GetFlags (VOID) {\r
1299 return mOneOfOption->Flags;\r
1300 }\r
1301};\r
1302\r
1303static EFI_GUID IfrTianoGuid = EFI_IFR_TIANO_GUID;\r
1304\r
1305class CIfrClass : public CIfrObj, public CIfrOpHeader {\r
1306private:\r
1307 EFI_IFR_GUID_CLASS *mClass;\r
1308\r
1309public:\r
1310 CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mClass, sizeof (EFI_IFR_GUID_CLASS)),\r
1311 CIfrOpHeader (EFI_IFR_GUID_OP, &mClass->Header, sizeof (EFI_IFR_GUID_CLASS)) {\r
1312 mClass->ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS;\r
1313 mClass->Guid = IfrTianoGuid;\r
1314 mClass->Class = EFI_NON_DEVICE_CLASS;\r
1315 }\r
1316\r
1317 VOID SetClass (IN UINT16 Class) {\r
1318 mClass->Class = Class;\r
1319 }\r
1320};\r
1321\r
1322class CIfrSubClass : public CIfrObj, public CIfrOpHeader {\r
1323private:\r
1324 EFI_IFR_GUID_SUBCLASS *mSubClass;\r
1325\r
1326public:\r
1327 CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mSubClass, sizeof (EFI_IFR_GUID_SUBCLASS)),\r
1328 CIfrOpHeader (EFI_IFR_GUID_OP, &mSubClass->Header, sizeof (EFI_IFR_GUID_SUBCLASS)) {\r
1329 mSubClass->ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS;\r
1330 mSubClass->Guid = IfrTianoGuid;\r
1331 mSubClass->SubClass = EFI_SETUP_APPLICATION_SUBCLASS;\r
1332 }\r
1333\r
1334 VOID SetSubClass (IN UINT16 SubClass) {\r
1335 mSubClass->SubClass = SubClass;\r
1336 }\r
1337};\r
1338\r
1339class CIfrLabel : public CIfrObj, public CIfrOpHeader {\r
1340private:\r
1341 EFI_IFR_GUID_LABEL *mLabel;\r
1342\r
1343public:\r
1344 CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mLabel, sizeof (EFI_IFR_GUID_LABEL)),\r
1345 CIfrOpHeader (EFI_IFR_GUID_OP, &mLabel->Header, sizeof (EFI_IFR_GUID_LABEL)) {\r
1346 mLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
1347 mLabel->Guid = IfrTianoGuid;\r
1348 }\r
1349\r
1350 VOID SetNumber (IN UINT16 Number) {\r
1351 mLabel->Number = Number;\r
1352 }\r
1353};\r
1354\r
1355class CIfrBanner : public CIfrObj, public CIfrOpHeader {\r
1356private:\r
1357 EFI_IFR_GUID_BANNER *mBanner;\r
1358\r
1359public:\r
1360 CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mBanner, sizeof (EFI_IFR_GUID_BANNER)),\r
1361 CIfrOpHeader (EFI_IFR_GUID_OP, &mBanner->Header, sizeof (EFI_IFR_GUID_BANNER)) {\r
1362 mBanner->ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;\r
1363 mBanner->Guid = IfrTianoGuid;\r
1364 }\r
1365\r
1366 VOID SetTitle (IN EFI_STRING_ID StringId) {\r
1367 mBanner->Title = StringId;\r
1368 }\r
1369\r
1370 VOID SetLine (IN UINT16 Line) {\r
1371 mBanner->LineNumber = Line;\r
1372 }\r
1373\r
1374 VOID SetAlign (IN UINT8 Align) {\r
1375 mBanner->Alignment = Align;\r
1376 }\r
1377};\r
1378\r
1379class CIfrTimeout : public CIfrObj, public CIfrOpHeader {\r
1380private:\r
1381 EFI_IFR_GUID_TIMEOUT *mTimeout;\r
1382\r
1383public:\r
1384 CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mTimeout, sizeof (EFI_IFR_GUID_TIMEOUT)),\r
1385 CIfrOpHeader (EFI_IFR_GUID_OP, &mTimeout->Header, sizeof (EFI_IFR_GUID_TIMEOUT)) {\r
1386 mTimeout->ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT;\r
1387 mTimeout->Guid = IfrTianoGuid;\r
1388 mTimeout->TimeOut = Timeout;\r
1389 }\r
1390\r
1391 VOID SetTimeout (IN UINT16 Timeout) {\r
1392 mTimeout->TimeOut = Timeout;\r
1393 }\r
1394};\r
1395\r
1396class CIfrDup : public CIfrObj, public CIfrOpHeader {\r
1397private:\r
1398 EFI_IFR_DUP *mDup;\r
1399\r
1400public:\r
1401 CIfrDup (\r
1402 IN UINT32 LineNo\r
1403 ) : CIfrObj (EFI_IFR_DUP_OP, (CHAR8 **)&mDup),\r
1404 CIfrOpHeader (EFI_IFR_DUP_OP, &mDup->Header) {\r
1405 SetLineNo (LineNo);\r
1406 }\r
1407};\r
1408\r
1409class CIfrEqIdId : public CIfrObj, public CIfrOpHeader {\r
1410private:\r
1411 EFI_IFR_EQ_ID_ID *mEqIdId;\r
1412\r
1413public:\r
1414 CIfrEqIdId (\r
1415 IN UINT32 LineNo\r
1416 ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP, (CHAR8 **)&mEqIdId),\r
1417 CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &mEqIdId->Header) {\r
1418 SetLineNo (LineNo);\r
1419 mEqIdId->QuestionId1 = EFI_QUESTION_ID_INVALID;\r
1420 mEqIdId->QuestionId2 = EFI_QUESTION_ID_INVALID;\r
1421 }\r
1422\r
1423 VOID SetQuestionId1 (\r
1424 IN EFI_QUESTION_ID QuestionId,\r
1425 IN INT8 *VarIdStr,\r
1426 IN UINT32 LineNo\r
1427 ) {\r
1428 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
1429 mEqIdId->QuestionId1 = QuestionId;\r
1430 } else {\r
1431 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId1), sizeof (EFI_QUESTION_ID), LineNo);\r
1432 }\r
1433 }\r
1434\r
1435 VOID SetQuestionId2 (\r
1436 IN EFI_QUESTION_ID QuestionId,\r
1437 IN INT8 *VarIdStr,\r
1438 IN UINT32 LineNo\r
1439 ) {\r
1440 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
1441 mEqIdId->QuestionId2 = QuestionId;\r
1442 } else {\r
1443 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId2), sizeof (EFI_QUESTION_ID), LineNo);\r
1444 }\r
1445 }\r
1446};\r
1447\r
1448class CIfrEqIdVal : public CIfrObj, public CIfrOpHeader {\r
1449private:\r
1450 EFI_IFR_EQ_ID_VAL *mEqIdVal;\r
1451\r
1452public:\r
1453 CIfrEqIdVal (\r
1454 IN UINT32 LineNo\r
1455 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP, (CHAR8 **)&mEqIdVal),\r
1456 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &mEqIdVal->Header) {\r
1457 SetLineNo (LineNo);\r
1458 mEqIdVal->QuestionId = EFI_QUESTION_ID_INVALID;\r
1459 }\r
1460\r
1461 VOID SetQuestionId (\r
1462 IN EFI_QUESTION_ID QuestionId,\r
1463 IN INT8 *VarIdStr,\r
1464 IN UINT32 LineNo\r
1465 ) {\r
1466 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
1467 mEqIdVal->QuestionId = QuestionId;\r
1468 } else {\r
1469 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVal->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);\r
1470 }\r
1471 }\r
1472\r
1473 VOID SetValue (IN UINT16 Value) {\r
1474 mEqIdVal->Value = Value;\r
1475 }\r
1476};\r
1477\r
1478class CIfrEqIdList : public CIfrObj, public CIfrOpHeader {\r
1479private:\r
1480 EFI_IFR_EQ_ID_LIST *mEqIdVList;\r
1481\r
1482public:\r
1483 CIfrEqIdList (\r
1484 IN UINT32 LineNo\r
1485 ) : CIfrObj (EFI_IFR_EQ_ID_LIST_OP, (CHAR8 **)&mEqIdVList, sizeof (EFI_IFR_EQ_ID_LIST), TRUE),\r
1486 CIfrOpHeader (EFI_IFR_EQ_ID_LIST_OP, &mEqIdVList->Header) {\r
1487 SetLineNo (LineNo);\r
1488 mEqIdVList->QuestionId = EFI_QUESTION_ID_INVALID;\r
1489 mEqIdVList->ListLength = 0;\r
1490 mEqIdVList->ValueList[0] = 0;\r
1491 }\r
1492\r
1493 VOID SetQuestionId (\r
1494 IN EFI_QUESTION_ID QuestionId,\r
1495 IN INT8 *VarIdStr,\r
1496 IN UINT32 LineNo\r
1497 ) {\r
1498 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
1499 mEqIdVList->QuestionId = QuestionId;\r
1500 } else {\r
1501 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVList->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);\r
1502 }\r
1503 }\r
1504\r
1505 VOID SetListLength (IN UINT16 ListLength) {\r
1506 mEqIdVList->ListLength = ListLength;\r
1507 }\r
1508\r
1509 VOID SetValueList (IN UINT16 Index, IN UINT16 Value) {\r
1510 if (Index == 0) {\r
1511 mEqIdVList->ValueList[0] = Value;\r
1512 return;\r
1513 }\r
1514\r
1515 if (ExpendObjBin (sizeof (UINT16)) ==TRUE) {\r
1516 IncLength (sizeof (UINT16));\r
1517 mEqIdVList->ValueList[Index] = Value;\r
1518 }\r
1519 }\r
1520};\r
1521\r
1522class CIfrQuestionRef1 : public CIfrObj, public CIfrOpHeader {\r
1523private:\r
1524 EFI_IFR_QUESTION_REF1 *mQuestionRef1;\r
1525\r
1526public:\r
1527 CIfrQuestionRef1 (\r
1528 IN UINT32 LineNo\r
1529 ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP, (CHAR8 **)&mQuestionRef1),\r
1530 CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &mQuestionRef1->Header) {\r
1531 SetLineNo (LineNo);\r
1532 mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID;\r
1533 }\r
1534\r
1535 VOID SetQuestionId (\r
1536 IN EFI_QUESTION_ID QuestionId,\r
1537 IN INT8 *VarIdStr,\r
1538 IN UINT32 LineNo\r
1539 ) {\r
1540 if (QuestionId != EFI_QUESTION_ID_INVALID) {\r
1541 mQuestionRef1->QuestionId = QuestionId;\r
1542 } else {\r
1543 gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mQuestionRef1->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);\r
1544 }\r
1545 }\r
1546};\r
1547\r
1548class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader {\r
1549private:\r
1550 EFI_IFR_QUESTION_REF2 *mQuestionRef2;\r
1551\r
1552public:\r
1553 CIfrQuestionRef2 (\r
1554 IN UINT32 LineNo\r
1555 ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP, (CHAR8 **)&mQuestionRef2),\r
1556 CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &mQuestionRef2->Header) {\r
1557 SetLineNo (LineNo);\r
1558 }\r
1559};\r
1560\r
1561class CIfrQuestionRef3 : public CIfrObj, public CIfrOpHeader {\r
1562private:\r
1563 EFI_IFR_QUESTION_REF3 *mQuestionRef3;\r
1564\r
1565public:\r
1566 CIfrQuestionRef3 (\r
1567 IN UINT32 LineNo\r
1568 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3),\r
1569 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3->Header) {\r
1570 SetLineNo (LineNo);\r
1571 }\r
1572};\r
1573\r
1574class CIfrQuestionRef3_2 : public CIfrObj, public CIfrOpHeader {\r
1575private:\r
1576 EFI_IFR_QUESTION_REF3_2 *mQuestionRef3_2;\r
1577\r
1578public:\r
1579 CIfrQuestionRef3_2 (\r
1580 IN UINT32 LineNo\r
1581 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_2, sizeof (EFI_IFR_QUESTION_REF3_2)),\r
1582 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_2->Header, sizeof (EFI_IFR_QUESTION_REF3_2)) {\r
1583 SetLineNo (LineNo);\r
1584 mQuestionRef3_2->DevicePath = EFI_STRING_ID_INVALID;\r
1585 }\r
1586\r
1587 VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {\r
1588 mQuestionRef3_2->DevicePath = DevicePath;\r
1589 }\r
1590};\r
1591\r
1592class CIfrQuestionRef3_3 : public CIfrObj, public CIfrOpHeader {\r
1593private:\r
1594 EFI_IFR_QUESTION_REF3_3 *mQuestionRef3_3;\r
1595\r
1596public:\r
1597 CIfrQuestionRef3_3 (\r
1598 IN UINT32 LineNo\r
1599 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_3, sizeof (EFI_IFR_QUESTION_REF3_3)),\r
1600 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_3->Header, sizeof (EFI_IFR_QUESTION_REF3_3)) {\r
1601 SetLineNo (LineNo);\r
1602 mQuestionRef3_3->DevicePath = EFI_STRING_ID_INVALID;\r
1603 memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID));\r
1604 }\r
1605\r
1606 VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {\r
1607 mQuestionRef3_3->DevicePath = DevicePath;\r
1608 }\r
1609\r
1610 VOID SetGuid (IN EFI_GUID *Guid) {\r
1611 mQuestionRef3_3->Guid = *Guid;\r
1612 }\r
1613};\r
1614\r
1615class CIfrRuleRef : public CIfrObj, public CIfrOpHeader {\r
1616private:\r
1617 EFI_IFR_RULE_REF *mRuleRef;\r
1618\r
1619public:\r
1620 CIfrRuleRef (\r
1621 IN UINT32 LineNo\r
1622 ) : CIfrObj (EFI_IFR_RULE_REF_OP, (CHAR8 **)&mRuleRef),\r
1623 CIfrOpHeader (EFI_IFR_RULE_REF_OP, &mRuleRef->Header) {\r
1624 SetLineNo (LineNo);\r
1625 mRuleRef->RuleId = EFI_RULE_ID_INVALID;\r
1626 }\r
1627\r
1628 VOID SetRuleId (IN UINT8 RuleId) {\r
1629 mRuleRef->RuleId = RuleId;\r
1630 }\r
1631};\r
1632\r
1633class CIfrStringRef1 : public CIfrObj, public CIfrOpHeader {\r
1634private:\r
1635 EFI_IFR_STRING_REF1 *mStringRef1;\r
1636\r
1637public:\r
1638 CIfrStringRef1 (\r
1639 IN UINT32 LineNo\r
1640 ) : CIfrObj (EFI_IFR_STRING_REF1_OP, (CHAR8 **)&mStringRef1),\r
1641 CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &mStringRef1->Header) {\r
1642 SetLineNo (LineNo);\r
1643 mStringRef1->StringId = EFI_STRING_ID_INVALID;\r
1644 }\r
1645\r
1646 VOID SetStringId (IN EFI_STRING_ID StringId) {\r
1647 mStringRef1->StringId = StringId;\r
1648 }\r
1649};\r
1650\r
1651class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader {\r
1652private:\r
1653 EFI_IFR_STRING_REF2 *mStringRef2;\r
1654\r
1655public:\r
1656 CIfrStringRef2 (\r
1657 IN UINT32 LineNo\r
1658 ) : CIfrObj (EFI_IFR_STRING_REF2_OP, (CHAR8 **)&mStringRef2),\r
1659 CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &mStringRef2->Header) {\r
1660 SetLineNo (LineNo);\r
1661 }\r
1662};\r
1663\r
1664class CIfrThis : public CIfrObj, public CIfrOpHeader {\r
1665private:\r
1666 EFI_IFR_THIS *mThis;\r
1667\r
1668public:\r
1669 CIfrThis (\r
1670 IN UINT32 LineNo\r
1671 ) : CIfrObj (EFI_IFR_THIS_OP, (CHAR8 **)&mThis),\r
1672 CIfrOpHeader (EFI_IFR_THIS_OP, &mThis->Header) {\r
1673 SetLineNo (LineNo);\r
1674 }\r
1675};\r
1676\r
1677class CIfrUint8 : public CIfrObj, public CIfrOpHeader {\r
1678private:\r
1679 EFI_IFR_UINT8 *mUint8;\r
1680\r
1681public:\r
1682 CIfrUint8 (\r
1683 IN UINT32 LineNo\r
1684 ) : CIfrObj (EFI_IFR_UINT8_OP, (CHAR8 **)&mUint8),\r
1685 CIfrOpHeader (EFI_IFR_UINT8_OP, &mUint8->Header) {\r
1686 SetLineNo (LineNo);\r
1687 }\r
1688\r
1689 VOID SetValue (IN UINT8 Value) {\r
1690 mUint8->Value = Value;\r
1691 }\r
1692};\r
1693\r
1694class CIfrUint16 : public CIfrObj, public CIfrOpHeader {\r
1695private:\r
1696 EFI_IFR_UINT16 *mUint16;\r
1697\r
1698public:\r
1699 CIfrUint16 (\r
1700 IN UINT32 LineNo\r
1701 ) : CIfrObj (EFI_IFR_UINT16_OP, (CHAR8 **)&mUint16),\r
1702 CIfrOpHeader (EFI_IFR_UINT16_OP, &mUint16->Header) {\r
1703 SetLineNo (LineNo);\r
1704 }\r
1705\r
1706 VOID SetValue (IN UINT16 Value) {\r
1707 mUint16->Value = Value;\r
1708 }\r
1709};\r
1710\r
1711class CIfrUint32 : public CIfrObj, public CIfrOpHeader {\r
1712private:\r
1713 EFI_IFR_UINT32 *mUint32;\r
1714\r
1715public:\r
1716 CIfrUint32 (\r
1717 IN UINT32 LineNo\r
1718 ) : CIfrObj (EFI_IFR_UINT32_OP, (CHAR8 **)&mUint32),\r
1719 CIfrOpHeader (EFI_IFR_UINT32_OP, &mUint32->Header) {\r
1720 SetLineNo (LineNo);\r
1721 }\r
1722\r
1723 VOID SetValue (IN UINT32 Value) {\r
1724 mUint32->Value = Value;\r
1725 }\r
1726};\r
1727\r
1728class CIfrUint64 : public CIfrObj, public CIfrOpHeader {\r
1729private:\r
1730 EFI_IFR_UINT64 *mUint64;\r
1731\r
1732public:\r
1733 CIfrUint64 (\r
1734 IN UINT32 LineNo\r
1735 ) : CIfrObj (EFI_IFR_UINT64_OP, (CHAR8 **)&mUint64),\r
1736 CIfrOpHeader (EFI_IFR_UINT64_OP, &mUint64->Header) {\r
1737 SetLineNo (LineNo);\r
1738 }\r
1739\r
1740 VOID SetValue (IN UINT64 Value) {\r
1741 mUint64->Value = Value;\r
1742 }\r
1743};\r
1744\r
1745class CIfrTrue : public CIfrObj, public CIfrOpHeader {\r
1746private:\r
1747 EFI_IFR_TRUE *mTrue;\r
1748\r
1749public:\r
1750 CIfrTrue (\r
1751 IN UINT32 LineNo\r
1752 ) : CIfrObj (EFI_IFR_TRUE_OP, (CHAR8 **)&mTrue),\r
1753 CIfrOpHeader (EFI_IFR_TRUE_OP, &mTrue->Header) {\r
1754 SetLineNo (LineNo);\r
1755 }\r
1756};\r
1757\r
1758class CIfrFalse : public CIfrObj, public CIfrOpHeader {\r
1759private:\r
1760 EFI_IFR_FALSE *mFalse;\r
1761\r
1762public:\r
1763 CIfrFalse (\r
1764 IN UINT32 LineNo\r
1765 ) : CIfrObj (EFI_IFR_FALSE_OP, (CHAR8 **)&mFalse),\r
1766 CIfrOpHeader (EFI_IFR_FALSE_OP, &mFalse->Header) {\r
1767 SetLineNo (LineNo);\r
1768 }\r
1769};\r
1770\r
1771class CIfrOne : public CIfrObj, public CIfrOpHeader {\r
1772private:\r
1773 EFI_IFR_ONE *mOne;\r
1774\r
1775public:\r
1776 CIfrOne (\r
1777 IN UINT32 LineNo\r
1778 ) : CIfrObj (EFI_IFR_ONE_OP, (CHAR8 **)&mOne),\r
1779 CIfrOpHeader (EFI_IFR_ONE_OP, &mOne->Header) {\r
1780 SetLineNo (LineNo);\r
1781 }\r
1782};\r
1783\r
1784class CIfrOnes : public CIfrObj, public CIfrOpHeader {\r
1785private:\r
1786 EFI_IFR_ONES *mOnes;\r
1787\r
1788public:\r
1789 CIfrOnes (\r
1790 IN UINT32 LineNo\r
1791 ) : CIfrObj (EFI_IFR_ONES_OP, (CHAR8 **)&mOnes),\r
1792 CIfrOpHeader (EFI_IFR_ONES_OP, &mOnes->Header) {\r
1793 SetLineNo (LineNo);\r
1794 }\r
1795};\r
1796\r
1797class CIfrZero : public CIfrObj, public CIfrOpHeader {\r
1798private:\r
1799 EFI_IFR_ZERO *mZero;\r
1800\r
1801public:\r
1802 CIfrZero (\r
1803 IN UINT32 LineNo\r
1804 ) : CIfrObj (EFI_IFR_ZERO_OP, (CHAR8 **)&mZero),\r
1805 CIfrOpHeader (EFI_IFR_ZERO_OP, &mZero->Header) {\r
1806 SetLineNo (LineNo);\r
1807 }\r
1808};\r
1809\r
1810class CIfrUndefined : public CIfrObj, public CIfrOpHeader {\r
1811private:\r
1812 EFI_IFR_UNDEFINED *mUndefined;\r
1813\r
1814public:\r
1815 CIfrUndefined (\r
1816 IN UINT32 LineNo\r
1817 ) : CIfrObj (EFI_IFR_UNDEFINED_OP, (CHAR8 **)&mUndefined),\r
1818 CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &mUndefined->Header) {\r
1819 SetLineNo (LineNo);\r
1820 }\r
1821};\r
1822\r
1823class CIfrVersion : public CIfrObj, public CIfrOpHeader {\r
1824private:\r
1825 EFI_IFR_VERSION *mVersion;\r
1826\r
1827public:\r
1828 CIfrVersion (\r
1829 IN UINT32 LineNo\r
1830 ) : CIfrObj (EFI_IFR_VERSION_OP, (CHAR8 **)&mVersion),\r
1831 CIfrOpHeader (EFI_IFR_VERSION_OP, &mVersion->Header) {\r
1832 SetLineNo (LineNo);\r
1833 }\r
1834};\r
1835\r
1836class CIfrLength : public CIfrObj, public CIfrOpHeader {\r
1837private:\r
1838 EFI_IFR_LENGTH *mLength;\r
1839\r
1840public:\r
1841 CIfrLength (\r
1842 IN UINT32 LineNo\r
1843 ) : CIfrObj (EFI_IFR_LENGTH_OP, (CHAR8 **)&mLength),\r
1844 CIfrOpHeader (EFI_IFR_LENGTH_OP, &mLength->Header) {\r
1845 SetLineNo (LineNo);\r
1846 }\r
1847};\r
1848\r
1849class CIfrNot : public CIfrObj, public CIfrOpHeader {\r
1850private:\r
1851 EFI_IFR_NOT *mNot;\r
1852\r
1853public:\r
1854 CIfrNot (\r
1855 IN UINT32 LineNo\r
1856 ) : CIfrObj (EFI_IFR_NOT_OP, (CHAR8 **)&mNot),\r
1857 CIfrOpHeader (EFI_IFR_NOT_OP, &mNot->Header) {\r
1858 SetLineNo (LineNo);\r
1859 }\r
1860};\r
1861\r
1862class CIfrBitWiseNot : public CIfrObj, public CIfrOpHeader {\r
1863private:\r
1864 EFI_IFR_BITWISE_NOT *mBitWise;\r
1865\r
1866public:\r
1867 CIfrBitWiseNot (\r
1868 IN UINT32 LineNo\r
1869 ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP, (CHAR8 **)&mBitWise),\r
1870 CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &mBitWise->Header) {\r
1871 SetLineNo (LineNo);\r
1872 }\r
1873};\r
1874\r
1875class CIfrToBoolean : public CIfrObj, public CIfrOpHeader {\r
1876private:\r
1877 EFI_IFR_TO_BOOLEAN *mToBoolean;\r
1878\r
1879public:\r
1880 CIfrToBoolean (\r
1881 IN UINT32 LineNo\r
1882 ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP, (CHAR8 **)&mToBoolean),\r
1883 CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &mToBoolean->Header) {\r
1884 SetLineNo (LineNo);\r
1885 }\r
1886};\r
1887\r
1888class CIfrToString : public CIfrObj, public CIfrOpHeader {\r
1889private:\r
1890 EFI_IFR_TO_STRING *mToString;\r
1891\r
1892public:\r
1893 CIfrToString (\r
1894 IN UINT32 LineNo\r
1895 ) : CIfrObj (EFI_IFR_TO_STRING_OP, (CHAR8 **)&mToString),\r
1896 CIfrOpHeader (EFI_IFR_TO_STRING_OP, &mToString->Header) {\r
1897 SetLineNo (LineNo);\r
1898 }\r
1899\r
1900 VOID SetFormat (IN UINT8 Format) {\r
1901 mToString->Format = Format;\r
1902 }\r
1903};\r
1904\r
1905class CIfrToUint : public CIfrObj, public CIfrOpHeader {\r
1906private:\r
1907 EFI_IFR_TO_UINT *mToUint;\r
1908\r
1909public:\r
1910 CIfrToUint (\r
1911 IN UINT32 LineNo\r
1912 ) : CIfrObj (EFI_IFR_TO_UINT_OP, (CHAR8 **)&mToUint),\r
1913 CIfrOpHeader (EFI_IFR_TO_UINT_OP, &mToUint->Header) {\r
1914 SetLineNo (LineNo);\r
1915 }\r
1916};\r
1917\r
1918class CIfrToUpper : public CIfrObj, public CIfrOpHeader {\r
1919private:\r
1920 EFI_IFR_TO_UPPER *mToUpper;\r
1921\r
1922public:\r
1923 CIfrToUpper (\r
1924 IN UINT32 LineNo\r
1925 ) : CIfrObj (EFI_IFR_TO_UPPER_OP, (CHAR8 **)&mToUpper),\r
1926 CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &mToUpper->Header) {\r
1927 SetLineNo (LineNo);\r
1928 }\r
1929};\r
1930\r
1931class CIfrToLower : public CIfrObj, public CIfrOpHeader {\r
1932private:\r
1933 EFI_IFR_TO_LOWER *mToLower;\r
1934\r
1935public:\r
1936 CIfrToLower (\r
1937 IN UINT32 LineNo\r
1938 ) : CIfrObj (EFI_IFR_TO_LOWER_OP, (CHAR8 **)&mToLower),\r
1939 CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &mToLower->Header) {\r
1940 SetLineNo (LineNo);\r
1941 }\r
1942};\r
1943\r
1944class CIfrAdd : public CIfrObj, public CIfrOpHeader {\r
1945private:\r
1946 EFI_IFR_ADD *mAdd;\r
1947\r
1948public:\r
1949 CIfrAdd (\r
1950 IN UINT32 LineNo\r
1951 ) : CIfrObj (EFI_IFR_ADD_OP, (CHAR8 **)&mAdd),\r
1952 CIfrOpHeader (EFI_IFR_ADD_OP, &mAdd->Header) {\r
1953 SetLineNo (LineNo);\r
1954 }\r
1955};\r
1956\r
1957class CIfrBitWiseAnd : public CIfrObj, public CIfrOpHeader {\r
1958private:\r
1959 EFI_IFR_BITWISE_AND *mBitWiseAnd;\r
1960\r
1961public:\r
1962 CIfrBitWiseAnd (\r
1963 IN UINT32 LineNo\r
1964 ) : CIfrObj (EFI_IFR_BITWISE_AND_OP, (CHAR8 **)&mBitWiseAnd),\r
1965 CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &mBitWiseAnd->Header) {\r
1966 SetLineNo(LineNo);\r
1967 }\r
1968};\r
1969\r
1970class CIfrBitWiseOr : public CIfrObj, public CIfrOpHeader {\r
1971private:\r
1972 EFI_IFR_BITWISE_OR *mBitWiseOr;\r
1973\r
1974public:\r
1975 CIfrBitWiseOr (\r
1976 IN UINT32 LineNo\r
1977 ) : CIfrObj (EFI_IFR_BITWISE_OR_OP, (CHAR8 **)&mBitWiseOr),\r
1978 CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &mBitWiseOr->Header) {\r
1979 SetLineNo (LineNo);\r
1980 }\r
1981};\r
1982\r
1983class CIfrAnd : public CIfrObj, public CIfrOpHeader {\r
1984private:\r
1985 EFI_IFR_AND *mAnd;\r
1986\r
1987public:\r
1988 CIfrAnd (\r
1989 IN UINT32 LineNo\r
1990 ) : CIfrObj (EFI_IFR_AND_OP, (CHAR8 **)&mAnd),\r
1991 CIfrOpHeader (EFI_IFR_AND_OP, &mAnd->Header) {\r
1992 SetLineNo (LineNo);\r
1993 }\r
1994};\r
1995\r
1996class CIfrCatenate : public CIfrObj, public CIfrOpHeader {\r
1997private:\r
1998 EFI_IFR_CATENATE *mCatenate;\r
1999\r
2000public:\r
2001 CIfrCatenate (\r
2002 IN UINT32 LineNo\r
2003 ) : CIfrObj (EFI_IFR_CATENATE_OP, (CHAR8 **)&mCatenate),\r
2004 CIfrOpHeader (EFI_IFR_CATENATE_OP, &mCatenate->Header) {\r
2005 SetLineNo (LineNo);\r
2006 }\r
2007};\r
2008\r
2009class CIfrDivide : public CIfrObj, public CIfrOpHeader {\r
2010private:\r
2011 EFI_IFR_DIVIDE *mDivide;\r
2012\r
2013public:\r
2014 CIfrDivide (\r
2015 IN UINT32 LineNo\r
2016 ) : CIfrObj (EFI_IFR_DIVIDE_OP, (CHAR8 **)&mDivide),\r
2017 CIfrOpHeader (EFI_IFR_DIVIDE_OP, &mDivide->Header) {\r
2018 SetLineNo (LineNo);\r
2019 }\r
2020};\r
2021\r
2022class CIfrEqual : public CIfrObj, public CIfrOpHeader {\r
2023private:\r
2024 EFI_IFR_EQUAL *mEqual;\r
2025\r
2026public:\r
2027 CIfrEqual (\r
2028 IN UINT32 LineNo\r
2029 ) : CIfrObj (EFI_IFR_EQUAL_OP, (CHAR8 **)&mEqual),\r
2030 CIfrOpHeader (EFI_IFR_EQUAL_OP, &mEqual->Header) {\r
2031 SetLineNo (LineNo);\r
2032 }\r
2033};\r
2034\r
2035class CIfrGreaterEqual : public CIfrObj, public CIfrOpHeader {\r
2036private:\r
2037 EFI_IFR_GREATER_EQUAL *mGreaterEqual;\r
2038\r
2039public:\r
2040 CIfrGreaterEqual (\r
2041 IN UINT32 LineNo\r
2042 ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP, (CHAR8 **)&mGreaterEqual),\r
2043 CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &mGreaterEqual->Header) {\r
2044 SetLineNo (LineNo);\r
2045 }\r
2046};\r
2047\r
2048class CIfrGreaterThan : public CIfrObj, public CIfrOpHeader {\r
2049private:\r
2050 EFI_IFR_GREATER_THAN *mGreaterThan;\r
2051\r
2052public:\r
2053 CIfrGreaterThan (\r
2054 IN UINT32 LineNo\r
2055 ) : CIfrObj (EFI_IFR_GREATER_THAN_OP, (CHAR8 **)&mGreaterThan),\r
2056 CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &mGreaterThan->Header) {\r
2057 SetLineNo (LineNo);\r
2058 }\r
2059};\r
2060\r
2061class CIfrLessEqual : public CIfrObj, public CIfrOpHeader {\r
2062private:\r
2063 EFI_IFR_LESS_EQUAL *mLessEqual;\r
2064\r
2065public:\r
2066 CIfrLessEqual (\r
2067 IN UINT32 LineNo\r
2068 ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP, (CHAR8 **)&mLessEqual),\r
2069 CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &mLessEqual->Header) {\r
2070 SetLineNo (LineNo);\r
2071 }\r
2072};\r
2073\r
2074class CIfrLessThan : public CIfrObj, public CIfrOpHeader {\r
2075private:\r
2076 EFI_IFR_LESS_THAN *mLessThan;\r
2077\r
2078public:\r
2079 CIfrLessThan (\r
2080 IN UINT32 LineNo\r
2081 ) : CIfrObj (EFI_IFR_LESS_THAN_OP, (CHAR8 **)&mLessThan),\r
2082 CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &mLessThan->Header) {\r
2083 SetLineNo (LineNo);\r
2084 }\r
2085};\r
2086\r
2087class CIfrMatch : public CIfrObj, public CIfrOpHeader {\r
2088private:\r
2089 EFI_IFR_MATCH *mMatch;\r
2090\r
2091public:\r
2092 CIfrMatch (\r
2093 IN UINT32 LineNo\r
2094 ) : CIfrObj (EFI_IFR_MATCH_OP, (CHAR8 **)&mMatch),\r
2095 CIfrOpHeader (EFI_IFR_MATCH_OP, &mMatch->Header) {\r
2096 SetLineNo (LineNo);\r
2097 }\r
2098};\r
2099\r
2100class CIfrMultiply : public CIfrObj, public CIfrOpHeader {\r
2101private:\r
2102 EFI_IFR_MULTIPLY *mMultiply;\r
2103\r
2104public:\r
2105 CIfrMultiply (\r
2106 IN UINT32 LineNo\r
2107 ) : CIfrObj (EFI_IFR_MULTIPLY_OP, (CHAR8 **)&mMultiply),\r
2108 CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &mMultiply->Header) {\r
2109 SetLineNo (LineNo);\r
2110 }\r
2111};\r
2112\r
2113class CIfrModulo : public CIfrObj, public CIfrOpHeader {\r
2114private:\r
2115 EFI_IFR_MODULO *mModulo;\r
2116\r
2117public:\r
2118 CIfrModulo (\r
2119 IN UINT32 LineNo\r
2120 ) : CIfrObj (EFI_IFR_MODULO_OP, (CHAR8 **)&mModulo),\r
2121 CIfrOpHeader (EFI_IFR_MODULO_OP, &mModulo->Header) {\r
2122 SetLineNo (LineNo);\r
2123 }\r
2124};\r
2125\r
2126class CIfrNotEqual : public CIfrObj, public CIfrOpHeader {\r
2127private:\r
2128 EFI_IFR_NOT_EQUAL *mNotEqual;\r
2129\r
2130public:\r
2131 CIfrNotEqual (\r
2132 IN UINT32 LineNo\r
2133 ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP, (CHAR8 **)&mNotEqual),\r
2134 CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &mNotEqual->Header) {\r
2135 SetLineNo (LineNo);\r
2136 }\r
2137};\r
2138\r
2139class CIfrOr : public CIfrObj, public CIfrOpHeader {\r
2140private:\r
2141 EFI_IFR_OR *mOr;\r
2142\r
2143public:\r
2144 CIfrOr (\r
2145 IN UINT32 LineNo\r
2146 ) : CIfrObj (EFI_IFR_OR_OP, (CHAR8 **)&mOr),\r
2147 CIfrOpHeader (EFI_IFR_OR_OP, &mOr->Header) {\r
2148 SetLineNo (LineNo);\r
2149 }\r
2150};\r
2151\r
2152class CIfrShiftLeft : public CIfrObj, public CIfrOpHeader {\r
2153private:\r
2154 EFI_IFR_SHIFT_LEFT *mShiftLeft;\r
2155\r
2156public:\r
2157 CIfrShiftLeft (\r
2158 IN UINT32 LineNo\r
2159 ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP, (CHAR8 **)&mShiftLeft),\r
2160 CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &mShiftLeft->Header) {\r
2161 SetLineNo (LineNo);\r
2162 }\r
2163};\r
2164\r
2165class CIfrShiftRight : public CIfrObj, public CIfrOpHeader {\r
2166private:\r
2167 EFI_IFR_SHIFT_RIGHT *mShiftRight;\r
2168\r
2169public:\r
2170 CIfrShiftRight (\r
2171 IN UINT32 LineNo\r
2172 ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP, (CHAR8 **)&mShiftRight),\r
2173 CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &mShiftRight->Header) {\r
2174 SetLineNo (LineNo);\r
2175 }\r
2176};\r
2177\r
2178class CIfrSubtract : public CIfrObj, public CIfrOpHeader {\r
2179private:\r
2180 EFI_IFR_SUBTRACT *mSubtract;\r
2181\r
2182public:\r
2183 CIfrSubtract (\r
2184 IN UINT32 LineNo\r
2185 ) : CIfrObj (EFI_IFR_SUBTRACT_OP, (CHAR8 **)&mSubtract),\r
2186 CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &mSubtract->Header) {\r
2187 SetLineNo (LineNo);\r
2188 }\r
2189};\r
2190\r
2191class CIfrConditional : public CIfrObj, public CIfrOpHeader {\r
2192private:\r
2193 EFI_IFR_CONDITIONAL *mConditional;\r
2194\r
2195public:\r
2196 CIfrConditional (\r
2197 IN UINT32 LineNo\r
2198 ) : CIfrObj (EFI_IFR_CONDITIONAL_OP, (CHAR8 **)&mConditional),\r
2199 CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &mConditional->Header) {\r
2200 SetLineNo (LineNo);\r
2201 }\r
2202};\r
2203\r
2204class CIfrFind : public CIfrObj, public CIfrOpHeader {\r
2205private:\r
2206 EFI_IFR_FIND *mFind;\r
2207\r
2208public:\r
2209 CIfrFind (\r
2210 IN UINT32 LineNo\r
2211 ) : CIfrObj (EFI_IFR_FIND_OP, (CHAR8 **)&mFind),\r
2212 CIfrOpHeader (EFI_IFR_FIND_OP, &mFind->Header) {\r
2213 SetLineNo (LineNo);\r
2214 }\r
2215\r
2216 VOID SetFormat (IN UINT8 Format) {\r
2217 mFind->Format = Format;\r
2218 }\r
2219};\r
2220\r
2221class CIfrMid : public CIfrObj, public CIfrOpHeader {\r
2222private:\r
2223 EFI_IFR_MID *mMid;\r
2224\r
2225public:\r
2226 CIfrMid (\r
2227 IN UINT32 LineNo\r
2228 ) : CIfrObj (EFI_IFR_MID_OP, (CHAR8 **)&mMid),\r
2229 CIfrOpHeader (EFI_IFR_MID_OP, &mMid->Header) {\r
2230 SetLineNo (LineNo);\r
2231 }\r
2232};\r
2233\r
2234class CIfrToken : public CIfrObj, public CIfrOpHeader {\r
2235private:\r
2236 EFI_IFR_TOKEN *mToken;\r
2237\r
2238public:\r
2239 CIfrToken (\r
2240 IN UINT32 LineNo\r
2241 ) : CIfrObj (EFI_IFR_TOKEN_OP, (CHAR8 **)&mToken),\r
2242 CIfrOpHeader (EFI_IFR_TOKEN_OP, &mToken->Header) {\r
2243 SetLineNo (LineNo);\r
2244 }\r
2245};\r
2246\r
2247class CIfrSpan : public CIfrObj, public CIfrOpHeader {\r
2248private:\r
2249 EFI_IFR_SPAN *mSpan;\r
2250\r
2251public:\r
2252 CIfrSpan (\r
2253 IN UINT32 LineNo\r
2254 ) : CIfrObj (EFI_IFR_SPAN_OP, (CHAR8 **)&mSpan),\r
2255 CIfrOpHeader (EFI_IFR_SPAN_OP, &mSpan->Header) {\r
2256 SetLineNo (LineNo);\r
2257 mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING;\r
2258 }\r
2259\r
2260 EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {\r
2261 if (_IS_EQUAL (LFlags, EFI_IFR_FLAGS_FIRST_MATCHING)) {\r
2262 mSpan->Flags |= EFI_IFR_FLAGS_FIRST_MATCHING;\r
2263 } else if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_FIRST_NON_MATCHING)) {\r
2264 mSpan->Flags |= EFI_IFR_FLAGS_FIRST_NON_MATCHING;\r
2265 }\r
2266\r
2267 return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;\r
2268 }\r
2269};\r
2270\r
2271#endif\r
EFI Development Kit II mirror for PVE