BaseTools/Source/C/VfrCompile/VfrUtilityLib.h

   1 /** @file
   2
   3   Vfr common library functions.
   4
   5 Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #ifndef _VFRUTILITYLIB_H_
  17 #define _VFRUTILITYLIB_H_
  18
  19 #include "string.h"
  20 #include "Common/UefiBaseTypes.h"
  21 #include "EfiVfr.h"
  22 #include "VfrError.h"
  23
  24 extern BOOLEAN  VfrCompatibleMode;
  25 static EFI_GUID gEdkiiIfrBitVarGuid = EDKII_IFR_BIT_VARSTORE_GUID;
  26
  27 #define MAX_BIT_WIDTH                      32
  28 #define MAX_NAME_LEN                       64
  29 #define MAX_STRING_LEN                     0x100
  30 #define DEFAULT_ALIGN                      1
  31 #define DEFAULT_PACK_ALIGN                 0x8
  32 #define DEFAULT_NAME_TABLE_ITEMS           1024
  33
  34 #define EFI_BITS_SHIFT_PER_UINT32          0x5
  35 #define EFI_BITS_PER_UINT32                (1 << EFI_BITS_SHIFT_PER_UINT32)
  36
  37 #define BUFFER_SAFE_FREE(Buf)              do { if ((Buf) != NULL) { delete (Buf); } } while (0);
  38 #define ARRAY_SAFE_FREE(Buf)               do { if ((Buf) != NULL) { delete[] (Buf); } } while (0);
  39
  40
  41 class CVfrBinaryOutput {
  42 public:
  43   virtual VOID WriteLine (IN FILE *, IN UINT32, IN CONST CHAR8 *, IN CHAR8 *, IN UINT32);
  44   virtual VOID WriteEnd (IN FILE *, IN UINT32, IN CONST CHAR8 *, IN CHAR8 *, IN UINT32);
  45 };
  46
  47 UINT32
  48 _STR2U32 (
  49   IN CHAR8 *Str
  50   );
  51
  52 struct SConfigInfo {
  53   UINT16             mOffset;
  54   UINT16             mWidth;
  55   UINT8              *mValue;
  56   SConfigInfo        *mNext;
  57
  58   SConfigInfo (IN UINT8, IN UINT16, IN UINT32, IN EFI_IFR_TYPE_VALUE);
  59   ~SConfigInfo (VOID);
  60
  61 private:
  62   SConfigInfo (IN CONST SConfigInfo&);             // Prevent copy-construction
  63   SConfigInfo& operator= (IN CONST SConfigInfo&);  // Prevent assignment
  64 };
  65
  66 struct SConfigItem {
  67   CHAR8         *mName;         // varstore name
  68   EFI_GUID      *mGuid;         // varstore guid, varstore name + guid deside one varstore
  69   CHAR8         *mId;           // default ID
  70   SConfigInfo   *mInfoStrList;  // list of Offset/Value in the varstore
  71   SConfigItem   *mNext;
  72
  73 public:
  74   SConfigItem (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *);
  75   SConfigItem (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT8, IN UINT16, IN UINT16, IN EFI_IFR_TYPE_VALUE);
  76   virtual ~SConfigItem ();
  77
  78 private:
  79   SConfigItem (IN CONST SConfigItem&);             // Prevent copy-construction
  80   SConfigItem& operator= (IN CONST SConfigItem&);  // Prevent assignment
  81 };
  82
  83 class CVfrBufferConfig {
  84 private:
  85   SConfigItem *mItemListHead;
  86   SConfigItem *mItemListTail;
  87   SConfigItem *mItemListPos;
  88
  89 public:
  90   CVfrBufferConfig (VOID);
  91   virtual ~CVfrBufferConfig (VOID);
  92
  93   virtual UINT8   Register (IN CHAR8 *, IN EFI_GUID *,IN CHAR8 *Info = NULL);
  94   virtual VOID    Open (VOID);
  95   virtual BOOLEAN Eof(VOID);
  96   virtual UINT8   Select (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *Info = NULL);
  97   virtual UINT8   Write (IN CONST CHAR8, IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT8, IN UINT16, IN UINT32, IN EFI_IFR_TYPE_VALUE);
  98 #if 0
  99   virtual UINT8   Read (OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **);
 100 #endif
 101   virtual VOID    Close (VOID);
 102   virtual VOID    OutputCFile (IN FILE *, IN CHAR8 *);
 103
 104 private:
 105   CVfrBufferConfig (IN CONST CVfrBufferConfig&);             // Prevent copy-construction
 106   CVfrBufferConfig& operator= (IN CONST CVfrBufferConfig&);  // Prevent assignment
 107 };
 108
 109 extern CVfrBufferConfig gCVfrBufferConfig;
 110
 111 #define ALIGN_STUFF(Size, Align) ((Align) - (Size) % (Align))
 112 #define INVALID_ARRAY_INDEX      0xFFFFFFFF
 113
 114 struct SVfrDataType;
 115
 116 struct SVfrDataField {
 117   CHAR8                     mFieldName[MAX_NAME_LEN];
 118   SVfrDataType              *mFieldType;
 119   UINT32                    mOffset;
 120   UINT32                    mArrayNum;
 121   BOOLEAN                   mIsBitField;
 122   UINT8                     mBitWidth;
 123   UINT32                    mBitOffset;
 124   SVfrDataField             *mNext;
 125 };
 126
 127 struct SVfrDataType {
 128   CHAR8                     mTypeName[MAX_NAME_LEN];
 129   UINT8                     mType;
 130   UINT32                    mAlign;
 131   UINT32                    mTotalSize;
 132   BOOLEAN                   mHasBitField;
 133   SVfrDataField             *mMembers;
 134   SVfrDataType              *mNext;
 135 };
 136
 137 #define VFR_PACK_ASSIGN     0x01
 138 #define VFR_PACK_SHOW       0x02
 139 #define VFR_PACK_PUSH       0x04
 140 #define VFR_PACK_POP        0x08
 141
 142 #define PACKSTACK_MAX_SIZE  0x400
 143
 144 struct SVfrPackStackNode {
 145   CHAR8                     *mIdentifier;
 146   UINT32                    mNumber;
 147   SVfrPackStackNode         *mNext;
 148
 149   SVfrPackStackNode (IN CHAR8 *Identifier, IN UINT32 Number) {
 150     mIdentifier = NULL;
 151     mNumber     = Number;
 152     mNext       = NULL;
 153
 154     if (Identifier != NULL) {
 155       mIdentifier = new CHAR8[strlen (Identifier) + 1];
 156       strcpy (mIdentifier, Identifier);
 157     }
 158   }
 159
 160   ~SVfrPackStackNode (VOID) {
 161     if (mIdentifier != NULL) {
 162       delete[] mIdentifier;
 163     }
 164     mNext = NULL;
 165   }
 166
 167   bool Match (IN CHAR8 *Identifier) {
 168     if (Identifier == NULL) {
 169       return TRUE;
 170     } else if (mIdentifier == NULL) {
 171       return FALSE;
 172     } else if (strcmp (Identifier, mIdentifier) == 0) {
 173       return TRUE;
 174     } else {
 175       return FALSE;
 176     }
 177   }
 178
 179 private:
 180   SVfrPackStackNode (IN CONST SVfrPackStackNode&);             // Prevent copy-construction
 181   SVfrPackStackNode& operator= (IN CONST SVfrPackStackNode&);  // Prevent assignment
 182 };
 183
 184 class CVfrVarDataTypeDB {
 185 private:
 186   UINT32                    mPackAlign;
 187   SVfrPackStackNode         *mPackStack;
 188
 189 public:
 190   EFI_VFR_RETURN_CODE       Pack (IN UINT32, IN UINT8, IN CHAR8 *Identifier = NULL, IN UINT32 Number = DEFAULT_PACK_ALIGN);
 191
 192 private:
 193   SVfrDataType              *mDataTypeList;
 194
 195   SVfrDataType              *mNewDataType;
 196   SVfrDataType              *mCurrDataType;
 197   SVfrDataField             *mCurrDataField;
 198
 199   VOID InternalTypesListInit (VOID);
 200   VOID RegisterNewType (IN SVfrDataType *);
 201
 202   EFI_VFR_RETURN_CODE ExtractStructTypeName (IN CHAR8 *&, OUT CHAR8 *);
 203   EFI_VFR_RETURN_CODE GetTypeField (IN CONST CHAR8 *, IN SVfrDataType *, IN SVfrDataField *&);
 204   EFI_VFR_RETURN_CODE GetFieldOffset (IN SVfrDataField *, IN UINT32, OUT UINT32 &, IN BOOLEAN);
 205   UINT8               GetFieldWidth (IN SVfrDataField *);
 206   UINT32              GetFieldSize (IN SVfrDataField *, IN UINT32, IN BOOLEAN);
 207
 208 public:
 209   CVfrVarDataTypeDB (VOID);
 210   ~CVfrVarDataTypeDB (VOID);
 211
 212   VOID                DeclareDataTypeBegin (VOID);
 213   EFI_VFR_RETURN_CODE SetNewTypeName (IN CHAR8 *);
 214   EFI_VFR_RETURN_CODE DataTypeAddField (IN CHAR8 *, IN CHAR8 *, IN UINT32, IN BOOLEAN);
 215   EFI_VFR_RETURN_CODE DataTypeAddBitField (IN CHAR8 *, IN CHAR8 *, IN UINT32, IN BOOLEAN);
 216   VOID                DeclareDataTypeEnd (VOID);
 217
 218   EFI_VFR_RETURN_CODE GetDataType (IN CHAR8 *, OUT SVfrDataType **);
 219   EFI_VFR_RETURN_CODE GetDataTypeSize (IN CHAR8 *, OUT UINT32 *);
 220   EFI_VFR_RETURN_CODE GetDataTypeSize (IN UINT8, OUT UINT32 *);
 221   EFI_VFR_RETURN_CODE GetDataFieldInfo (IN CHAR8 *, OUT UINT16 &, OUT UINT8 &, OUT UINT32 &, OUT BOOLEAN &);
 222
 223   EFI_VFR_RETURN_CODE GetUserDefinedTypeNameList (OUT CHAR8 ***, OUT UINT32 *);
 224   EFI_VFR_RETURN_CODE ExtractFieldNameAndArrary (IN CHAR8 *&, OUT CHAR8 *, OUT UINT32 &);
 225   BOOLEAN             DataTypeHasBitField (IN  CHAR8 *);
 226   BOOLEAN             IsThisBitField (IN  CHAR8 *);
 227
 228   BOOLEAN             IsTypeNameDefined (IN CHAR8 *);
 229
 230   VOID                Dump(IN FILE *);
 231   //
 232   // First the declared
 233   //
 234   CHAR8               *mFirstNewDataTypeName;
 235 #ifdef CVFR_VARDATATYPEDB_DEBUG
 236   VOID ParserDB ();
 237 #endif
 238
 239 private:
 240   CVfrVarDataTypeDB (IN CONST CVfrVarDataTypeDB&);             // Prevent copy-construction
 241   CVfrVarDataTypeDB& operator= (IN CONST CVfrVarDataTypeDB&);  // Prevent assignment
 242 };
 243
 244 extern CVfrVarDataTypeDB  gCVfrVarDataTypeDB;
 245
 246 typedef enum {
 247   EFI_VFR_VARSTORE_INVALID,
 248   EFI_VFR_VARSTORE_BUFFER,
 249   EFI_VFR_VARSTORE_EFI,
 250   EFI_VFR_VARSTORE_NAME,
 251   EFI_VFR_VARSTORE_BUFFER_BITS
 252 } EFI_VFR_VARSTORE_TYPE;
 253
 254 struct SVfrVarStorageNode {
 255   EFI_GUID                  mGuid;
 256   CHAR8                     *mVarStoreName;
 257   EFI_VARSTORE_ID           mVarStoreId;
 258   BOOLEAN                   mAssignedFlag; //Create varstore opcode
 259   struct SVfrVarStorageNode *mNext;
 260
 261   EFI_VFR_VARSTORE_TYPE     mVarStoreType;
 262   union {
 263     // EFI Variable
 264     struct {
 265       EFI_STRING_ID           mEfiVarName;
 266       UINT32                  mEfiVarSize;
 267     } mEfiVar;
 268
 269     // Buffer Storage
 270     SVfrDataType            *mDataType;
 271
 272     // NameValue Storage
 273         struct {
 274       EFI_STRING_ID         *mNameTable;
 275       UINT32                mTableSize;
 276     } mNameSpace;
 277   } mStorageInfo;
 278
 279 public:
 280   SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN EFI_STRING_ID, IN UINT32, IN BOOLEAN Flag = TRUE);
 281   SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN SVfrDataType *,IN BOOLEAN, IN BOOLEAN Flag = TRUE);
 282   SVfrVarStorageNode (IN CHAR8 *, IN EFI_VARSTORE_ID);
 283   ~SVfrVarStorageNode (VOID);
 284
 285 private:
 286   SVfrVarStorageNode (IN CONST SVfrVarStorageNode&);             // Prevent copy-construction
 287   SVfrVarStorageNode& operator= (IN CONST SVfrVarStorageNode&);  // Prevent assignment
 288 };
 289
 290 struct EFI_VARSTORE_INFO {
 291   EFI_VARSTORE_ID           mVarStoreId;
 292   union {
 293     EFI_STRING_ID           mVarName;
 294     UINT16                  mVarOffset;
 295   } mInfo;
 296   UINT8                     mVarType;
 297   UINT32                    mVarTotalSize;
 298   BOOLEAN                   mIsBitVar;
 299
 300   EFI_VARSTORE_INFO (VOID);
 301   EFI_VARSTORE_INFO (IN EFI_VARSTORE_INFO &);
 302   EFI_VARSTORE_INFO& operator=(IN CONST EFI_VARSTORE_INFO &);
 303   BOOLEAN operator == (IN EFI_VARSTORE_INFO *);
 304 };
 305
 306 struct BufferVarStoreFieldInfoNode {
 307   EFI_VARSTORE_INFO  mVarStoreInfo;
 308   struct BufferVarStoreFieldInfoNode *mNext;
 309
 310   BufferVarStoreFieldInfoNode( IN EFI_VARSTORE_INFO  *Info );
 311   ~BufferVarStoreFieldInfoNode ();
 312 };
 313
 314 #define EFI_VARSTORE_ID_MAX              0xFFFF
 315 #define EFI_FREE_VARSTORE_ID_BITMAP_SIZE ((EFI_VARSTORE_ID_MAX + 1) / EFI_BITS_PER_UINT32)
 316
 317 class CVfrDataStorage {
 318 private:
 319   UINT32                    mFreeVarStoreIdBitMap[EFI_FREE_VARSTORE_ID_BITMAP_SIZE];
 320
 321   struct SVfrVarStorageNode *mBufferVarStoreList;
 322   struct SVfrVarStorageNode *mEfiVarStoreList;
 323   struct SVfrVarStorageNode *mNameVarStoreList;
 324
 325   struct SVfrVarStorageNode *mCurrVarStorageNode;
 326   struct SVfrVarStorageNode *mNewVarStorageNode;
 327   BufferVarStoreFieldInfoNode    *mBufferFieldInfoListHead;
 328   BufferVarStoreFieldInfoNode    *mBufferFieldInfoListTail;
 329
 330 private:
 331
 332   EFI_VARSTORE_ID GetFreeVarStoreId (EFI_VFR_VARSTORE_TYPE VarType = EFI_VFR_VARSTORE_BUFFER);
 333   BOOLEAN         ChekVarStoreIdFree (IN EFI_VARSTORE_ID);
 334   VOID            MarkVarStoreIdUsed (IN EFI_VARSTORE_ID);
 335   VOID            MarkVarStoreIdUnused (IN EFI_VARSTORE_ID);
 336   EFI_VARSTORE_ID CheckGuidField (IN SVfrVarStorageNode *,
 337                                   IN EFI_GUID *,
 338                                   IN BOOLEAN *,
 339                                   OUT EFI_VFR_RETURN_CODE *);
 340
 341 public:
 342   CVfrDataStorage ();
 343   ~CVfrDataStorage ();
 344
 345   SVfrVarStorageNode * GetBufferVarStoreList () {
 346     return mBufferVarStoreList;
 347   }
 348   SVfrVarStorageNode * GetEfiVarStoreList () {
 349     return mEfiVarStoreList;
 350   }
 351   EFI_VFR_RETURN_CODE DeclareNameVarStoreBegin (CHAR8 *, EFI_VARSTORE_ID);
 352   EFI_VFR_RETURN_CODE NameTableAddItem (EFI_STRING_ID);
 353   EFI_VFR_RETURN_CODE DeclareNameVarStoreEnd (EFI_GUID *);
 354
 355   EFI_VFR_RETURN_CODE DeclareEfiVarStore (IN CHAR8 *, IN EFI_GUID *, IN EFI_STRING_ID, IN UINT32, IN BOOLEAN Flag = TRUE);
 356
 357   EFI_VFR_RETURN_CODE DeclareBufferVarStore (IN CHAR8 *, IN EFI_GUID *, IN CVfrVarDataTypeDB *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN BOOLEAN, IN BOOLEAN Flag = TRUE);
 358
 359   EFI_VFR_RETURN_CODE GetVarStoreId (IN CHAR8 *, OUT EFI_VARSTORE_ID *, IN EFI_GUID *VarGuid = NULL);
 360   EFI_VFR_VARSTORE_TYPE GetVarStoreType (IN EFI_VARSTORE_ID);
 361   EFI_GUID *          GetVarStoreGuid (IN  EFI_VARSTORE_ID);
 362   EFI_VFR_RETURN_CODE GetVarStoreName (IN EFI_VARSTORE_ID, OUT CHAR8 **);
 363   EFI_VFR_RETURN_CODE GetVarStoreByDataType (IN CHAR8 *, OUT SVfrVarStorageNode **, IN EFI_GUID *VarGuid = NULL);
 364
 365   EFI_VFR_RETURN_CODE GetBufferVarStoreDataTypeName (IN EFI_VARSTORE_ID, OUT CHAR8 **);
 366   EFI_VFR_RETURN_CODE GetEfiVarStoreInfo (IN EFI_VARSTORE_INFO *);
 367   EFI_VFR_RETURN_CODE GetNameVarStoreInfo (IN EFI_VARSTORE_INFO *, IN UINT32);
 368   EFI_VFR_RETURN_CODE AddBufferVarStoreFieldInfo (IN EFI_VARSTORE_INFO *);
 369   EFI_VFR_RETURN_CODE GetBufferVarStoreFieldInfo (IN OUT EFI_VARSTORE_INFO *);
 370
 371 private:
 372   CVfrDataStorage (IN CONST CVfrDataStorage&);             // Prevent copy-construction
 373   CVfrDataStorage& operator= (IN CONST CVfrDataStorage&);  // Prevent assignment
 374 };
 375
 376 extern CVfrDataStorage gCVfrDataStorage;
 377
 378 #define EFI_QUESTION_ID_MAX              0xFFFF
 379 #define EFI_FREE_QUESTION_ID_BITMAP_SIZE ((EFI_QUESTION_ID_MAX + 1) / EFI_BITS_PER_UINT32)
 380 #define EFI_QUESTION_ID_INVALID          0x0
 381
 382 #define DATE_YEAR_BITMASK                0x0000FFFF
 383 #define DATE_MONTH_BITMASK               0x00FF0000
 384 #define DATE_DAY_BITMASK                 0xFF000000
 385 #define TIME_HOUR_BITMASK                0x000000FF
 386 #define TIME_MINUTE_BITMASK              0x0000FF00
 387 #define TIME_SECOND_BITMASK              0x00FF0000
 388
 389 struct SVfrQuestionNode {
 390   CHAR8                     *mName;
 391   CHAR8                     *mVarIdStr;
 392   EFI_QUESTION_ID           mQuestionId;
 393   UINT32                    mBitMask;
 394   SVfrQuestionNode          *mNext;
 395   EFI_QUESION_TYPE          mQtype;
 396
 397   SVfrQuestionNode (IN CHAR8 *, IN CHAR8 *, IN UINT32 BitMask = 0);
 398   ~SVfrQuestionNode ();
 399
 400 private:
 401   SVfrQuestionNode (IN CONST SVfrQuestionNode&);             // Prevent copy-construction
 402   SVfrQuestionNode& operator= (IN CONST SVfrQuestionNode&);  // Prevent assignment
 403 };
 404
 405 class CVfrQuestionDB {
 406 private:
 407   SVfrQuestionNode          *mQuestionList;
 408   UINT32                    mFreeQIdBitMap[EFI_FREE_QUESTION_ID_BITMAP_SIZE];
 409
 410 private:
 411   EFI_QUESTION_ID GetFreeQuestionId (VOID);
 412   BOOLEAN         ChekQuestionIdFree (IN EFI_QUESTION_ID);
 413   VOID            MarkQuestionIdUsed (IN EFI_QUESTION_ID);
 414   VOID            MarkQuestionIdUnused (IN EFI_QUESTION_ID);
 415
 416 public:
 417   CVfrQuestionDB ();
 418   ~CVfrQuestionDB();
 419
 420   EFI_VFR_RETURN_CODE RegisterQuestion (IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 421   VOID                RegisterOldDateQuestion (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 422   VOID                RegisterNewDateQuestion (IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 423   VOID                RegisterOldTimeQuestion (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 424   VOID                RegisterNewTimeQuestion (IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 425   VOID                RegisterRefQuestion (IN CHAR8 *, IN CHAR8 *, IN OUT EFI_QUESTION_ID &);
 426   EFI_VFR_RETURN_CODE UpdateQuestionId (IN EFI_QUESTION_ID, IN EFI_QUESTION_ID);
 427   VOID                GetQuestionId (IN CHAR8 *, IN CHAR8 *, OUT EFI_QUESTION_ID &, OUT UINT32 &, OUT EFI_QUESION_TYPE *QType = NULL);
 428   EFI_VFR_RETURN_CODE FindQuestion (IN EFI_QUESTION_ID);
 429   EFI_VFR_RETURN_CODE FindQuestion (IN CHAR8 *);
 430   VOID                PrintAllQuestion (IN VOID);
 431   VOID                ResetInit (IN VOID);
 432
 433   VOID SetCompatibleMode (IN BOOLEAN Mode) {
 434     VfrCompatibleMode = Mode;
 435   }
 436
 437 private:
 438   CVfrQuestionDB (IN CONST CVfrQuestionDB&);             // Prevent copy-construction
 439   CVfrQuestionDB& operator= (IN CONST CVfrQuestionDB&);  // Prevent assignment
 440 };
 441
 442 struct SVfrDefaultStoreNode {
 443   EFI_IFR_DEFAULTSTORE      *mObjBinAddr;
 444   CHAR8                     *mRefName;
 445   EFI_STRING_ID             mDefaultStoreNameId;
 446   UINT16                    mDefaultId;
 447
 448   SVfrDefaultStoreNode      *mNext;
 449
 450   SVfrDefaultStoreNode (IN EFI_IFR_DEFAULTSTORE *, IN CHAR8 *, IN EFI_STRING_ID, IN UINT16);
 451   ~SVfrDefaultStoreNode();
 452
 453 private:
 454   SVfrDefaultStoreNode (IN CONST SVfrDefaultStoreNode&);             // Prevent copy-construction
 455   SVfrDefaultStoreNode& operator= (IN CONST SVfrDefaultStoreNode&);  // Prevent assignment
 456 };
 457
 458 class CVfrDefaultStore {
 459 private:
 460   SVfrDefaultStoreNode      *mDefaultStoreList;
 461
 462 public:
 463   CVfrDefaultStore ();
 464   ~CVfrDefaultStore ();
 465
 466   EFI_VFR_RETURN_CODE RegisterDefaultStore (IN CHAR8 *, IN CHAR8 *, IN EFI_STRING_ID, IN UINT16);
 467   EFI_VFR_RETURN_CODE ReRegisterDefaultStoreById (IN UINT16, IN CHAR8 *, IN EFI_STRING_ID);
 468   BOOLEAN             DefaultIdRegistered (IN UINT16);
 469   EFI_VFR_RETURN_CODE GetDefaultId (IN CHAR8 *, OUT UINT16 *);
 470   EFI_VFR_RETURN_CODE BufferVarStoreAltConfigAdd (IN EFI_VARSTORE_ID, IN EFI_VARSTORE_INFO &, IN CHAR8 *, IN EFI_GUID *, IN UINT8, IN EFI_IFR_TYPE_VALUE);
 471
 472 private:
 473   CVfrDefaultStore (IN CONST CVfrDefaultStore&);             // Prevent copy-construction
 474   CVfrDefaultStore& operator= (IN CONST CVfrDefaultStore&);  // Prevent assignment
 475 };
 476
 477 extern CVfrDefaultStore gCVfrDefaultStore;
 478
 479 #define EFI_RULE_ID_START    0x01
 480 #define EFI_RULE_ID_INVALID  0x00
 481
 482 struct SVfrRuleNode {
 483   UINT8                     mRuleId;
 484   CHAR8                     *mRuleName;
 485   SVfrRuleNode              *mNext;
 486
 487   SVfrRuleNode(IN CHAR8 *, IN UINT8);
 488   ~SVfrRuleNode();
 489
 490 private:
 491   SVfrRuleNode (IN CONST SVfrRuleNode&);             // Prevent copy-construction
 492   SVfrRuleNode& operator= (IN CONST SVfrRuleNode&);  // Prevent assignment
 493 };
 494
 495 class CVfrRulesDB {
 496 private:
 497   SVfrRuleNode              *mRuleList;
 498   UINT8                     mFreeRuleId;
 499
 500 public:
 501   CVfrRulesDB ();
 502   ~CVfrRulesDB();
 503
 504   VOID RegisterRule (IN CHAR8 *);
 505   UINT8 GetRuleId (IN CHAR8 *);
 506
 507 private:
 508   CVfrRulesDB (IN CONST CVfrRulesDB&);             // Prevent copy-construction
 509   CVfrRulesDB& operator= (IN CONST CVfrRulesDB&);  // Prevent assignment
 510 };
 511
 512 class CVfrStringDB {
 513 private:
 514   CHAR8   *mStringFileName;
 515
 516   EFI_STATUS FindStringBlock (
 517     IN  UINT8            *StringData,
 518     IN  EFI_STRING_ID    StringId,
 519     OUT UINT32           *StringTextOffset,
 520     OUT UINT8            *BlockType
 521     );
 522
 523   UINT32 GetUnicodeStringTextSize (
 524     IN  UINT8            *StringSrc
 525     );
 526
 527   BOOLEAN GetBestLanguage (
 528     IN CONST CHAR8  *SupportedLanguages,
 529     IN CHAR8        *Language
 530     );
 531
 532 public:
 533   CVfrStringDB ();
 534   ~CVfrStringDB ();
 535
 536   VOID SetStringFileName (
 537     IN CHAR8 *StringFileName
 538     );
 539
 540   CHAR8 * GetVarStoreNameFormStringId (
 541     IN EFI_STRING_ID StringId
 542     );
 543
 544 private:
 545   CVfrStringDB (IN CONST CVfrStringDB&);             // Prevent copy-construction
 546   CVfrStringDB& operator= (IN CONST CVfrStringDB&);  // Prevent assignment
 547 };
 548
 549 #endif