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