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