BaseTools/Source/C/VfrCompile/VfrUtilityLib.h

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