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