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