BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp

   1 /** @file
   2
   3   Vfr common library functions.
   4
   5 Copyright (c) 2004 - 2016, 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 #include "stdio.h"
  17 #include "stdlib.h"
  18 #include "CommonLib.h"
  19 #include "VfrUtilityLib.h"
  20 #include "VfrFormPkg.h"
  21
  22 VOID
  23 CVfrBinaryOutput::WriteLine (
  24   IN FILE         *pFile,
  25   IN UINT32       LineBytes,
  26   IN CONST CHAR8  *LineHeader,
  27   IN CHAR8        *BlkBuf,
  28   IN UINT32       BlkSize
  29   )
  30 {
  31   UINT32    Index;
  32
  33   if ((pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
  34     return;
  35   }
  36
  37   for (Index = 0; Index < BlkSize; Index++) {
  38     if ((Index % LineBytes) == 0) {
  39       fprintf (pFile, "\n%s", LineHeader);
  40     }
  41     fprintf (pFile, "0x%02X,  ", (UINT8)BlkBuf[Index]);
  42   }
  43 }
  44
  45 VOID
  46 CVfrBinaryOutput::WriteEnd (
  47   IN FILE         *pFile,
  48   IN UINT32       LineBytes,
  49   IN CONST CHAR8  *LineHeader,
  50   IN CHAR8        *BlkBuf,
  51   IN UINT32       BlkSize
  52   )
  53 {
  54   UINT32    Index;
  55
  56   if ((BlkSize == 0) || (pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
  57     return;
  58   }
  59
  60   for (Index = 0; Index < BlkSize - 1; Index++) {
  61     if ((Index % LineBytes) == 0) {
  62       fprintf (pFile, "\n%s", LineHeader);
  63     }
  64     fprintf (pFile, "0x%02X,  ", (UINT8)BlkBuf[Index]);
  65   }
  66
  67   if ((Index % LineBytes) == 0) {
  68     fprintf (pFile, "\n%s", LineHeader);
  69   }
  70   fprintf (pFile, "0x%02X\n", (UINT8)BlkBuf[Index]);
  71 }
  72
  73 SConfigInfo::SConfigInfo (
  74   IN UINT8              Type,
  75   IN UINT16             Offset,
  76   IN UINT32             Width,
  77   IN EFI_IFR_TYPE_VALUE Value
  78   )
  79 {
  80   mNext   = NULL;
  81   mOffset = Offset;
  82   mWidth  = (UINT16)Width;
  83   mValue  = new UINT8[mWidth];
  84   if (mValue == NULL) {
  85     return;
  86   }
  87
  88   switch (Type) {
  89   case EFI_IFR_TYPE_NUM_SIZE_8 :
  90     memcpy (mValue, &Value.u8, mWidth);
  91     break;
  92   case EFI_IFR_TYPE_NUM_SIZE_16 :
  93     memcpy (mValue, &Value.u16, mWidth);
  94     break;
  95   case EFI_IFR_TYPE_NUM_SIZE_32 :
  96     memcpy (mValue, &Value.u32, mWidth);
  97     break;
  98   case EFI_IFR_TYPE_NUM_SIZE_64 :
  99     memcpy (mValue, &Value.u64, mWidth);
 100     break;
 101   case EFI_IFR_TYPE_BOOLEAN :
 102     memcpy (mValue, &Value.b, mWidth);
 103     break;
 104   case EFI_IFR_TYPE_TIME :
 105     memcpy (mValue, &Value.time, mWidth);
 106     break;
 107   case EFI_IFR_TYPE_DATE :
 108     memcpy (mValue, &Value.date, mWidth);
 109     break;
 110   case EFI_IFR_TYPE_STRING :
 111     memcpy (mValue, &Value.string, mWidth);
 112     break;
 113   case EFI_IFR_TYPE_BUFFER :
 114     memcpy (mValue, &Value.u8, mWidth);
 115     break;
 116
 117   case EFI_IFR_TYPE_OTHER :
 118     return;
 119   }
 120 }
 121
 122 SConfigInfo::~SConfigInfo (
 123   VOID
 124   )
 125 {
 126   ARRAY_SAFE_FREE (mValue);
 127 }
 128
 129 SConfigItem::SConfigItem (
 130   IN CHAR8               *Name,
 131   IN EFI_GUID            *Guid,
 132   IN CHAR8               *Id
 133   )
 134 {
 135   mName          = NULL;
 136   mGuid          = NULL;
 137   mId            = NULL;
 138   mInfoStrList = NULL;
 139   mNext        = NULL;
 140
 141   if (Name != NULL) {
 142     if ((mName = new CHAR8[strlen (Name) + 1]) != NULL) {
 143       strcpy (mName, Name);
 144     }
 145   }
 146
 147   if (Guid != NULL) {
 148     if ((mGuid = (EFI_GUID *) new CHAR8[sizeof (EFI_GUID)]) != NULL) {
 149       memcpy (mGuid, Guid, sizeof (EFI_GUID));
 150     }
 151   }
 152
 153   if (Id != NULL) {
 154     if ((mId = new CHAR8[strlen (Id) + 1]) != NULL) {
 155       strcpy (mId, Id);
 156     }
 157   }
 158 }
 159
 160 SConfigItem::SConfigItem (
 161   IN CHAR8               *Name,
 162   IN EFI_GUID            *Guid,
 163   IN CHAR8               *Id,
 164   IN UINT8               Type,
 165   IN UINT16              Offset,
 166   IN UINT16              Width,
 167   IN EFI_IFR_TYPE_VALUE  Value
 168   )
 169 {
 170   mName        = NULL;
 171   mGuid        = NULL;
 172   mId          = NULL;
 173   mInfoStrList = NULL;
 174   mNext        = NULL;
 175
 176   if (Name != NULL) {
 177     if ((mName = new CHAR8[strlen (Name) + 1]) != NULL) {
 178       strcpy (mName, Name);
 179     }
 180   }
 181
 182   if (Guid != NULL) {
 183     if ((mGuid = (EFI_GUID *) new CHAR8[sizeof (EFI_GUID)]) != NULL) {
 184       memcpy (mGuid, Guid, sizeof (EFI_GUID));
 185     }
 186   }
 187
 188   if (Id != NULL) {
 189     if ((mId = new CHAR8[strlen (Id) + 1]) != NULL) {
 190       strcpy (mId, Id);
 191     }
 192   }
 193
 194   mInfoStrList = new SConfigInfo(Type, Offset, Width, Value);
 195 }
 196
 197 SConfigItem::~SConfigItem (
 198   VOID
 199   )
 200 {
 201   SConfigInfo  *Info;
 202
 203   ARRAY_SAFE_FREE (mName);
 204   ARRAY_SAFE_FREE (mGuid);
 205   ARRAY_SAFE_FREE (mId);
 206   while (mInfoStrList != NULL) {
 207     Info = mInfoStrList;
 208     mInfoStrList = mInfoStrList->mNext;
 209
 210     BUFFER_SAFE_FREE (Info);
 211   }
 212 }
 213
 214 UINT8
 215 CVfrBufferConfig::Register (
 216   IN CHAR8               *Name,
 217   IN EFI_GUID            *Guid,
 218   IN CHAR8               *Id
 219   )
 220 {
 221   SConfigItem *pNew;
 222
 223   if (Select (Name, Guid) == 0) {
 224     return 1;
 225   }
 226
 227   if ((pNew = new SConfigItem (Name, Guid, Id)) == NULL) {
 228     return 2;
 229   }
 230
 231   if (mItemListHead == NULL) {
 232     mItemListHead = pNew;
 233     mItemListTail = pNew;
 234   } else {
 235     mItemListTail->mNext = pNew;
 236     mItemListTail = pNew;
 237   }
 238   mItemListPos    = pNew;
 239
 240   return 0;
 241 }
 242
 243 VOID
 244 CVfrBufferConfig::Open (
 245   VOID
 246   )
 247 {
 248   mItemListPos = mItemListHead;
 249 }
 250
 251 BOOLEAN
 252 CVfrBufferConfig::Eof(
 253   VOID
 254   )
 255 {
 256   return (mItemListPos == NULL) ? TRUE : FALSE;
 257 }
 258
 259 UINT8
 260 CVfrBufferConfig::Select (
 261   IN CHAR8    *Name,
 262   IN EFI_GUID *Guid,
 263   IN CHAR8    *Id
 264   )
 265 {
 266   SConfigItem *p;
 267
 268   if (Name == NULL || Guid == NULL) {
 269     mItemListPos = mItemListHead;
 270     return 0;
 271   } else {
 272     for (p = mItemListHead; p != NULL; p = p->mNext) {
 273       if ((strcmp (p->mName, Name) != 0) || (memcmp (p->mGuid, Guid, sizeof (EFI_GUID)) != 0)) {
 274         continue;
 275       }
 276
 277       if (Id != NULL) {
 278         if (p->mId == NULL || strcmp (p->mId, Id) != 0) {
 279           continue;
 280         }
 281       } else if (p->mId != NULL) {
 282         continue;
 283       }
 284
 285       mItemListPos = p;
 286       return 0;
 287     }
 288   }
 289
 290   return 1;
 291 }
 292
 293 UINT8
 294 CVfrBufferConfig::Write (
 295   IN CONST CHAR8         Mode,
 296   IN CHAR8               *Name,
 297   IN EFI_GUID            *Guid,
 298   IN CHAR8               *Id,
 299   IN UINT8               Type,
 300   IN UINT16              Offset,
 301   IN UINT32              Width,
 302   IN EFI_IFR_TYPE_VALUE  Value
 303   )
 304 {
 305   UINT8         Ret;
 306   SConfigItem   *pItem;
 307   SConfigInfo   *pInfo;
 308
 309   if ((Ret = Select (Name, Guid)) != 0) {
 310     return Ret;
 311   }
 312
 313   switch (Mode) {
 314   case 'a' : // add
 315     if (Select (Name, Guid, Id) != 0) {
 316       if ((pItem = new SConfigItem (Name, Guid, Id, Type, Offset, (UINT16) Width, Value)) == NULL) {
 317         return 2;
 318       }
 319       if (mItemListHead == NULL) {
 320         mItemListHead = pItem;
 321         mItemListTail = pItem;
 322       } else {
 323         mItemListTail->mNext = pItem;
 324         mItemListTail = pItem;
 325       }
 326       mItemListPos = pItem;
 327     } else {
 328       // tranverse the list to find out if there's already the value for the same offset
 329       for (pInfo = mItemListPos->mInfoStrList; pInfo != NULL; pInfo = pInfo->mNext) {
 330         if (pInfo->mOffset == Offset) {
 331           return 0;
 332         }
 333       }
 334       if((pInfo = new SConfigInfo (Type, Offset, Width, Value)) == NULL) {
 335         return 2;
 336       }
 337       pInfo->mNext = mItemListPos->mInfoStrList;
 338       mItemListPos->mInfoStrList = pInfo;
 339     }
 340     break;
 341
 342   case 'd' : // delete
 343     if (mItemListHead == mItemListPos) {
 344       mItemListHead = mItemListPos->mNext;
 345       delete mItemListPos;
 346       break;
 347     }
 348
 349     for (pItem = mItemListHead; pItem->mNext != mItemListPos; pItem = pItem->mNext)
 350       ;
 351
 352     pItem->mNext = mItemListPos->mNext;
 353     if (mItemListTail == mItemListPos) {
 354       mItemListTail = pItem;
 355     }
 356     delete mItemListPos;
 357     mItemListPos = pItem->mNext;
 358     break;
 359
 360   case 'i' : // set info
 361     if (mItemListPos->mId != NULL) {
 362       delete mItemListPos->mId;
 363     }
 364     mItemListPos->mId = NULL;
 365     if (Id != NULL) {
 366       if ((mItemListPos->mId = new CHAR8[strlen (Id) + 1]) == NULL) {
 367         return 2;
 368       }
 369       strcpy (mItemListPos->mId, Id);
 370     }
 371     break;
 372
 373   default :
 374     return 1;
 375   }
 376
 377   return 0;
 378 }
 379
 380
 381 VOID
 382 CVfrBufferConfig::Close (
 383   VOID
 384   )
 385 {
 386   mItemListPos = NULL;
 387 }
 388
 389 #define BYTES_PRE_LINE 0x10
 390
 391 VOID
 392 CVfrBufferConfig::OutputCFile (
 393   IN FILE  *pFile,
 394   IN CHAR8 *BaseName
 395   )
 396 {
 397   CVfrBinaryOutput Output;
 398   SConfigItem      *Item;
 399   SConfigInfo      *Info;
 400   UINT32           TotalLen;
 401
 402   if (pFile == NULL) {
 403     return;
 404   }
 405
 406   for (Item = mItemListHead; Item != NULL; Item = Item->mNext) {
 407     if (Item->mId != NULL || Item->mInfoStrList == NULL) {
 408       continue;
 409     }
 410     fprintf (pFile, "\nunsigned char %s%sBlockName[] = {", BaseName, Item->mName);
 411
 412     TotalLen = sizeof (UINT32);
 413     for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) {
 414       TotalLen += sizeof (UINT16) * 2;
 415     }
 416     Output.WriteLine (pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&TotalLen, sizeof (UINT32));
 417
 418     for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) {
 419       fprintf (pFile, "\n");
 420       Output.WriteLine (pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&Info->mOffset, sizeof (UINT16));
 421       Output.WriteLine (pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&Info->mWidth, sizeof (UINT16));
 422     }
 423     fprintf (pFile, "\n};\n");
 424   }
 425
 426   for (Item = mItemListHead; Item != NULL; Item = Item->mNext) {
 427     if (Item->mId != NULL && Item->mInfoStrList != NULL) {
 428       fprintf (pFile, "\nunsigned char %s%sDefault%s[] = {", BaseName, Item->mName, Item->mId);
 429
 430       TotalLen = sizeof (UINT32);
 431       for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) {
 432         TotalLen += Info->mWidth + sizeof (UINT16) * 2;
 433       }
 434       Output.WriteLine (pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&TotalLen, sizeof (UINT32));
 435
 436       for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) {
 437         fprintf (pFile, "\n");
 438         Output.WriteLine (pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&Info->mOffset, sizeof (UINT16));
 439         Output.WriteLine (pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&Info->mWidth, sizeof (UINT16));
 440         if (Info->mNext == NULL) {
 441           Output.WriteEnd (pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)Info->mValue, Info->mWidth);
 442         } else {
 443           Output.WriteLine (pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)Info->mValue, Info->mWidth);
 444         }
 445       }
 446       fprintf (pFile, "\n};\n");
 447     }
 448   }
 449 }
 450
 451 CVfrBufferConfig::CVfrBufferConfig (
 452   VOID
 453   )
 454 {
 455   mItemListHead = NULL;
 456   mItemListTail = NULL;
 457   mItemListPos  = NULL;
 458 }
 459
 460 CVfrBufferConfig::~CVfrBufferConfig (
 461   VOID
 462   )
 463 {
 464   SConfigItem *p;
 465
 466   while (mItemListHead != NULL) {
 467     p = mItemListHead;
 468     mItemListHead = mItemListHead->mNext;
 469     delete p;
 470   }
 471
 472   mItemListHead = NULL;
 473   mItemListTail = NULL;
 474   mItemListPos  = NULL;
 475 }
 476
 477 CVfrBufferConfig gCVfrBufferConfig;
 478
 479 static struct {
 480   CONST CHAR8  *mTypeName;
 481   UINT8  mType;
 482   UINT32 mSize;
 483   UINT32 mAlign;
 484 } gInternalTypesTable [] = {
 485   {"UINT64",        EFI_IFR_TYPE_NUM_SIZE_64, sizeof (UINT64),       sizeof (UINT64)},
 486   {"UINT32",        EFI_IFR_TYPE_NUM_SIZE_32, sizeof (UINT32),       sizeof (UINT32)},
 487   {"UINT16",        EFI_IFR_TYPE_NUM_SIZE_16, sizeof (UINT16),       sizeof (UINT16)},
 488   {"UINT8",         EFI_IFR_TYPE_NUM_SIZE_8,  sizeof (UINT8),        sizeof (UINT8)},
 489   {"BOOLEAN",       EFI_IFR_TYPE_BOOLEAN,     sizeof (BOOLEAN),      sizeof (BOOLEAN)},
 490   {"EFI_HII_DATE",  EFI_IFR_TYPE_DATE,        sizeof (EFI_HII_DATE), sizeof (UINT16)},
 491   {"EFI_STRING_ID", EFI_IFR_TYPE_STRING,      sizeof (EFI_STRING_ID),sizeof (EFI_STRING_ID)},
 492   {"EFI_HII_TIME",  EFI_IFR_TYPE_TIME,        sizeof (EFI_HII_TIME), sizeof (UINT8)},
 493   {"EFI_HII_REF",   EFI_IFR_TYPE_REF,         sizeof (EFI_HII_REF),  sizeof (EFI_GUID)},
 494   {NULL,            EFI_IFR_TYPE_OTHER,       0,                     0}
 495 };
 496
 497 STATIC
 498 BOOLEAN
 499 _IS_INTERNAL_TYPE (
 500   IN CHAR8 *TypeName
 501   )
 502 {
 503   UINT32  Index;
 504
 505   if (TypeName == NULL) {
 506     return FALSE;
 507   }
 508
 509   for (Index = 0; gInternalTypesTable[Index].mTypeName != NULL; Index++) {
 510     if (strcmp (TypeName, gInternalTypesTable[Index].mTypeName) == 0) {
 511       return TRUE;
 512     }
 513   }
 514
 515   return FALSE;
 516 }
 517
 518 STATIC
 519 CHAR8 *
 520 TrimHex (
 521   IN  CHAR8   *Str,
 522   OUT bool    *IsHex
 523   )
 524 {
 525   *IsHex = FALSE;
 526
 527   while (*Str && *Str == ' ') {
 528     Str++;
 529   }
 530   while (*Str && *Str == '0') {
 531     Str++;
 532   }
 533   if (*Str && (*Str == 'x' || *Str == 'X')) {
 534     Str++;
 535     *IsHex = TRUE;
 536   }
 537
 538   return Str;
 539 }
 540
 541 UINT32
 542 _STR2U32 (
 543   IN CHAR8 *Str
 544   )
 545 {
 546   bool    IsHex;
 547   UINT32  Value;
 548   CHAR8    c;
 549
 550   Str = TrimHex (Str, &IsHex);
 551   for (Value = 0; (c = *Str) != '\0'; Str++) {
 552     //
 553     // BUG: does not handle overflow here
 554     //
 555         (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
 556
 557     if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
 558       Value += (c - 'a' + 10);
 559     }
 560     if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {
 561       Value += (c - 'A' + 10);
 562     }
 563     if (c >= '0' && c <= '9') {
 564       Value += (c - '0');
 565     }
 566   }
 567
 568   return Value;
 569 }
 570
 571 VOID
 572 CVfrVarDataTypeDB::RegisterNewType (
 573   IN SVfrDataType  *New
 574   )
 575 {
 576   New->mNext               = mDataTypeList;
 577   mDataTypeList            = New;
 578 }
 579
 580 EFI_VFR_RETURN_CODE
 581 CVfrVarDataTypeDB::ExtractStructTypeName (
 582   IN  CHAR8 *&VarStr,
 583   OUT CHAR8 *TName
 584   )
 585 {
 586   if (TName == NULL) {
 587     return VFR_RETURN_FATAL_ERROR;
 588   }
 589
 590   while((*VarStr != '\0') && (*VarStr != '.')) {
 591     *TName = *VarStr;
 592     VarStr++;
 593     TName++;
 594   }
 595   *TName = '\0';
 596   if (*VarStr == '.') {
 597     VarStr++;
 598   }
 599
 600   return VFR_RETURN_SUCCESS;
 601 }
 602
 603 EFI_VFR_RETURN_CODE
 604 CVfrVarDataTypeDB::ExtractFieldNameAndArrary (
 605   IN  CHAR8   *&VarStr,
 606   IN  CHAR8   *FName,
 607   OUT UINT32 &ArrayIdx
 608   )
 609 {
 610   UINT32 Idx;
 611   CHAR8   ArrayStr[MAX_NAME_LEN + 1];
 612
 613   ArrayIdx = INVALID_ARRAY_INDEX;
 614
 615   if (FName == NULL) {
 616     return VFR_RETURN_FATAL_ERROR;
 617   }
 618
 619   while((*VarStr != '\0') &&
 620         (*VarStr != '.') &&
 621         (*VarStr != '[') &&
 622         (*VarStr != ']')) {
 623     *FName = *VarStr;
 624     VarStr++;
 625     FName++;
 626   }
 627   *FName = '\0';
 628
 629   switch (*VarStr) {
 630   case '.' :
 631     VarStr++;
 632   case '\0':
 633     return VFR_RETURN_SUCCESS;
 634   case '[' :
 635     VarStr++;
 636     for (Idx = 0; (Idx < MAX_NAME_LEN) && (*VarStr != '\0') && (*VarStr != ']'); VarStr++, Idx++) {
 637       ArrayStr[Idx] = *VarStr;
 638     }
 639     ArrayStr[Idx] = '\0';
 640
 641     if ((*VarStr != ']') && (ArrayStr[0] == '\0')) {
 642       return VFR_RETURN_DATA_STRING_ERROR;
 643     }
 644     ArrayIdx = _STR2U32 (ArrayStr);
 645     if (*VarStr == ']') {
 646       VarStr++;
 647     }
 648     if (*VarStr == '.') {
 649       VarStr++;
 650     }
 651     return VFR_RETURN_SUCCESS;
 652   case ']':
 653     return VFR_RETURN_DATA_STRING_ERROR;
 654   }
 655
 656   return VFR_RETURN_SUCCESS;
 657 }
 658
 659 EFI_VFR_RETURN_CODE
 660 CVfrVarDataTypeDB::GetTypeField (
 661   IN  CONST CHAR8   *FName,
 662   IN  SVfrDataType  *Type,
 663   OUT SVfrDataField *&Field
 664   )
 665 {
 666   SVfrDataField  *pField = NULL;
 667
 668   if ((FName == NULL) || (Type == NULL)) {
 669     return VFR_RETURN_FATAL_ERROR;
 670   }
 671
 672   for (pField = Type->mMembers; pField != NULL; pField = pField->mNext) {
 673     //
 674     // For type EFI_IFR_TYPE_TIME, because field name is not correctly wrote,
 675     // add code to adjust it.
 676     //
 677     if (Type->mType == EFI_IFR_TYPE_TIME) {
 678       if (strcmp (FName, "Hour") == 0) {
 679         FName = "Hours";
 680       } else if (strcmp (FName, "Minute") == 0) {
 681         FName = "Minuts";
 682       } else if (strcmp (FName, "Second") == 0) {
 683         FName = "Seconds";
 684       }
 685     }
 686
 687     if (strcmp (pField->mFieldName, FName) == 0) {
 688       Field = pField;
 689       return VFR_RETURN_SUCCESS;
 690     }
 691   }
 692
 693   return VFR_RETURN_UNDEFINED;
 694 }
 695
 696 EFI_VFR_RETURN_CODE
 697 CVfrVarDataTypeDB::GetFieldOffset (
 698   IN  SVfrDataField *Field,
 699   IN  UINT32        ArrayIdx,
 700   OUT UINT32        &Offset
 701   )
 702 {
 703   if (Field == NULL) {
 704     return VFR_RETURN_FATAL_ERROR;
 705   }
 706
 707   //
 708   // Framework Vfr file Array Index is from 1.
 709   // But Uefi Vfr file Array Index is from 0.
 710   //
 711   if (VfrCompatibleMode && ArrayIdx != INVALID_ARRAY_INDEX) {
 712     if (ArrayIdx == 0) {
 713       return VFR_RETURN_ERROR_ARRARY_NUM;
 714     }
 715     ArrayIdx = ArrayIdx - 1;
 716   }
 717
 718   if ((ArrayIdx != INVALID_ARRAY_INDEX) && ((Field->mArrayNum == 0) || (Field->mArrayNum <= ArrayIdx))) {
 719     return VFR_RETURN_ERROR_ARRARY_NUM;
 720   }
 721
 722   //
 723   // Be compatible with the current usage
 724   // If ArraryIdx is not specified, the first one is used.
 725   //
 726   // if ArrayNum is larger than zero, ArraryIdx must be specified.
 727   //
 728   // if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum > 0)) {
 729   //   return VFR_RETURN_ERROR_ARRARY_NUM;
 730   // }
 731   //
 732
 733   Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == INVALID_ARRAY_INDEX) ? 0 : ArrayIdx);
 734   return VFR_RETURN_SUCCESS;
 735 }
 736
 737 UINT8
 738 CVfrVarDataTypeDB::GetFieldWidth (
 739   IN SVfrDataField *Field
 740   )
 741 {
 742   if (Field == NULL) {
 743     return 0;
 744   }
 745
 746   return Field->mFieldType->mType;
 747 }
 748
 749 UINT32
 750 CVfrVarDataTypeDB::GetFieldSize (
 751   IN SVfrDataField *Field,
 752   IN UINT32       ArrayIdx
 753   )
 754 {
 755   if (Field == NULL) {
 756     return VFR_RETURN_FATAL_ERROR;
 757   }
 758
 759   if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum != 0)) {
 760     return Field->mFieldType->mTotalSize * Field->mArrayNum;
 761   } else {
 762     return Field->mFieldType->mTotalSize;
 763   }
 764 }
 765
 766 VOID
 767 CVfrVarDataTypeDB::InternalTypesListInit (
 768   VOID
 769   )
 770 {
 771   SVfrDataType *New   = NULL;
 772   UINT32       Index;
 773
 774   for (Index = 0; gInternalTypesTable[Index].mTypeName != NULL; Index++) {
 775     New                 = new SVfrDataType;
 776     if (New != NULL) {
 777       strcpy (New->mTypeName, gInternalTypesTable[Index].mTypeName);
 778       New->mType        = gInternalTypesTable[Index].mType;
 779       New->mAlign       = gInternalTypesTable[Index].mAlign;
 780       New->mTotalSize   = gInternalTypesTable[Index].mSize;
 781       if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_DATE") == 0) {
 782         SVfrDataField *pYearField  = new SVfrDataField;
 783         SVfrDataField *pMonthField = new SVfrDataField;
 784         SVfrDataField *pDayField   = new SVfrDataField;
 785
 786         strcpy (pYearField->mFieldName, "Year");
 787         GetDataType ((CHAR8 *)"UINT16", &pYearField->mFieldType);
 788         pYearField->mOffset      = 0;
 789         pYearField->mNext        = pMonthField;
 790         pYearField->mArrayNum    = 0;
 791
 792         strcpy (pMonthField->mFieldName, "Month");
 793         GetDataType ((CHAR8 *)"UINT8", &pMonthField->mFieldType);
 794         pMonthField->mOffset     = 2;
 795         pMonthField->mNext       = pDayField;
 796         pMonthField->mArrayNum   = 0;
 797
 798         strcpy (pDayField->mFieldName, "Day");
 799         GetDataType ((CHAR8 *)"UINT8", &pDayField->mFieldType);
 800         pDayField->mOffset       = 3;
 801         pDayField->mNext         = NULL;
 802         pDayField->mArrayNum     = 0;
 803
 804         New->mMembers            = pYearField;
 805       } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_TIME") == 0) {
 806         SVfrDataField *pHoursField   = new SVfrDataField;
 807         SVfrDataField *pMinutesField = new SVfrDataField;
 808         SVfrDataField *pSecondsField = new SVfrDataField;
 809
 810         strcpy (pHoursField->mFieldName, "Hours");
 811         GetDataType ((CHAR8 *)"UINT8", &pHoursField->mFieldType);
 812         pHoursField->mOffset     = 0;
 813         pHoursField->mNext       = pMinutesField;
 814         pHoursField->mArrayNum   = 0;
 815
 816         strcpy (pMinutesField->mFieldName, "Minutes");
 817         GetDataType ((CHAR8 *)"UINT8", &pMinutesField->mFieldType);
 818         pMinutesField->mOffset   = 1;
 819         pMinutesField->mNext     = pSecondsField;
 820         pMinutesField->mArrayNum = 0;
 821
 822         strcpy (pSecondsField->mFieldName, "Seconds");
 823         GetDataType ((CHAR8 *)"UINT8", &pSecondsField->mFieldType);
 824         pSecondsField->mOffset   = 2;
 825         pSecondsField->mNext     = NULL;
 826         pSecondsField->mArrayNum = 0;
 827
 828         New->mMembers            = pHoursField;
 829       } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_REF") == 0) {
 830         SVfrDataField *pQuestionIdField   = new SVfrDataField;
 831         SVfrDataField *pFormIdField       = new SVfrDataField;
 832         SVfrDataField *pFormSetGuidField  = new SVfrDataField;
 833         SVfrDataField *pDevicePathField   = new SVfrDataField;
 834
 835         strcpy (pQuestionIdField->mFieldName, "QuestionId");
 836         GetDataType ((CHAR8 *)"UINT16", &pQuestionIdField->mFieldType);
 837         pQuestionIdField->mOffset     = 0;
 838         pQuestionIdField->mNext       = pFormIdField;
 839         pQuestionIdField->mArrayNum   = 0;
 840
 841         strcpy (pFormIdField->mFieldName, "FormId");
 842         GetDataType ((CHAR8 *)"UINT16", &pFormIdField->mFieldType);
 843         pFormIdField->mOffset   = 2;
 844         pFormIdField->mNext     = pFormSetGuidField;
 845         pFormIdField->mArrayNum = 0;
 846
 847         strcpy (pFormSetGuidField->mFieldName, "FormSetGuid");
 848         GetDataType ((CHAR8 *)"EFI_GUID", &pFormSetGuidField->mFieldType);
 849         pFormSetGuidField->mOffset   = 4;
 850         pFormSetGuidField->mNext     = pDevicePathField;
 851         pFormSetGuidField->mArrayNum = 0;
 852
 853         strcpy (pDevicePathField->mFieldName, "DevicePath");
 854         GetDataType ((CHAR8 *)"EFI_STRING_ID", &pDevicePathField->mFieldType);
 855         pDevicePathField->mOffset   = 20;
 856         pDevicePathField->mNext     = NULL;
 857         pDevicePathField->mArrayNum = 0;
 858
 859         New->mMembers            = pQuestionIdField;
 860       } else {
 861         New->mMembers            = NULL;
 862       }
 863       New->mNext                 = NULL;
 864       RegisterNewType (New);
 865       New                        = NULL;
 866     }
 867   }
 868 }
 869
 870 CVfrVarDataTypeDB::CVfrVarDataTypeDB (
 871   VOID
 872   )
 873 {
 874   mDataTypeList  = NULL;
 875   mNewDataType   = NULL;
 876   mCurrDataField = NULL;
 877   mPackAlign     = DEFAULT_PACK_ALIGN;
 878   mPackStack     = NULL;
 879   mFirstNewDataTypeName = NULL;
 880
 881   InternalTypesListInit ();
 882 }
 883
 884 CVfrVarDataTypeDB::~CVfrVarDataTypeDB (
 885   VOID
 886   )
 887 {
 888   SVfrDataType      *pType;
 889   SVfrDataField     *pField;
 890   SVfrPackStackNode *pPack;
 891
 892   if (mNewDataType != NULL) {
 893     delete mNewDataType;
 894   }
 895
 896   while (mDataTypeList != NULL) {
 897     pType = mDataTypeList;
 898     mDataTypeList = mDataTypeList->mNext;
 899     while(pType->mMembers != NULL) {
 900       pField = pType->mMembers;
 901       pType->mMembers = pType->mMembers->mNext;
 902       delete pField;
 903     }
 904         delete pType;
 905   }
 906
 907   while (mPackStack != NULL) {
 908     pPack = mPackStack;
 909     mPackStack = mPackStack->mNext;
 910     delete pPack;
 911   }
 912 }
 913
 914 EFI_VFR_RETURN_CODE
 915 CVfrVarDataTypeDB::Pack (
 916   IN UINT32         LineNum,
 917   IN UINT8          Action,
 918   IN CHAR8           *Identifier,
 919   IN UINT32         Number
 920   )
 921 {
 922   UINT32            PackAlign;
 923   CHAR8             Msg[MAX_STRING_LEN] = {0, };
 924
 925   if (Action & VFR_PACK_SHOW) {
 926     sprintf (Msg, "value of pragma pack(show) == %d", mPackAlign);
 927     gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Warning", Msg);
 928   }
 929
 930   if (Action & VFR_PACK_PUSH) {
 931     SVfrPackStackNode *pNew = NULL;
 932
 933     if ((pNew = new SVfrPackStackNode (Identifier, mPackAlign)) == NULL) {
 934       return VFR_RETURN_FATAL_ERROR;
 935     }
 936     pNew->mNext = mPackStack;
 937     mPackStack  = pNew;
 938   }
 939
 940   if (Action & VFR_PACK_POP) {
 941     SVfrPackStackNode *pNode = NULL;
 942
 943     if (mPackStack == NULL) {
 944       gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Error", "#pragma pack(pop...) : more pops than pushes");
 945     }
 946
 947     for (pNode = mPackStack; pNode != NULL; pNode = pNode->mNext) {
 948       if (pNode->Match (Identifier) == TRUE) {
 949         mPackAlign = pNode->mNumber;
 950         mPackStack = pNode->mNext;
 951       }
 952     }
 953   }
 954
 955   if (Action & VFR_PACK_ASSIGN) {
 956     PackAlign = (Number > 1) ? Number + Number % 2 : Number;
 957     if ((PackAlign == 0) || (PackAlign > 16)) {
 958       gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Error", "expected pragma parameter to be '1', '2', '4', '8', or '16'");
 959     } else {
 960       mPackAlign = PackAlign;
 961     }
 962   }
 963
 964   return VFR_RETURN_SUCCESS;
 965 }
 966
 967 VOID
 968 CVfrVarDataTypeDB::DeclareDataTypeBegin (
 969   VOID
 970   )
 971 {
 972   SVfrDataType *pNewType = NULL;
 973
 974   pNewType               = new SVfrDataType;
 975   pNewType->mTypeName[0] = '\0';
 976   pNewType->mType        = EFI_IFR_TYPE_OTHER;
 977   pNewType->mAlign       = DEFAULT_ALIGN;
 978   pNewType->mTotalSize   = 0;
 979   pNewType->mMembers     = NULL;
 980   pNewType->mNext        = NULL;
 981
 982   mNewDataType           = pNewType;
 983 }
 984
 985 EFI_VFR_RETURN_CODE
 986 CVfrVarDataTypeDB::SetNewTypeName (
 987   IN CHAR8   *TypeName
 988   )
 989 {
 990   SVfrDataType *pType;
 991
 992   if (mNewDataType == NULL) {
 993     return VFR_RETURN_ERROR_SKIPED;
 994   }
 995   if (TypeName == NULL) {
 996     return VFR_RETURN_FATAL_ERROR;
 997   }
 998   if (strlen(TypeName) >= MAX_NAME_LEN) {
 999     return VFR_RETURN_INVALID_PARAMETER;
1000   }
1001
1002   for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) {
1003     if (strcmp(pType->mTypeName, TypeName) == 0) {
1004       return VFR_RETURN_REDEFINED;
1005     }
1006   }
1007
1008   strcpy(mNewDataType->mTypeName, TypeName);
1009   return VFR_RETURN_SUCCESS;
1010 }
1011
1012 EFI_VFR_RETURN_CODE
1013 CVfrVarDataTypeDB::DataTypeAddField (
1014   IN CHAR8   *FieldName,
1015   IN CHAR8   *TypeName,
1016   IN UINT32 ArrayNum
1017   )
1018 {
1019   SVfrDataField       *pNewField  = NULL;
1020   SVfrDataType        *pFieldType = NULL;
1021   SVfrDataField       *pTmp;
1022   UINT32              Align;
1023
1024   CHECK_ERROR_RETURN (GetDataType (TypeName, &pFieldType), VFR_RETURN_SUCCESS);
1025
1026   if (strlen (FieldName) >= MAX_NAME_LEN) {
1027    return VFR_RETURN_INVALID_PARAMETER;
1028   }
1029
1030   for (pTmp = mNewDataType->mMembers; pTmp != NULL; pTmp = pTmp->mNext) {
1031     if (strcmp (pTmp->mFieldName, FieldName) == 0) {
1032       return VFR_RETURN_REDEFINED;
1033     }
1034   }
1035
1036   Align = MIN (mPackAlign, pFieldType->mAlign);
1037
1038   if ((pNewField = new SVfrDataField) == NULL) {
1039     return VFR_RETURN_OUT_FOR_RESOURCES;
1040   }
1041   strcpy (pNewField->mFieldName, FieldName);
1042   pNewField->mFieldType    = pFieldType;
1043   pNewField->mArrayNum     = ArrayNum;
1044   if ((mNewDataType->mTotalSize % Align) == 0) {
1045     pNewField->mOffset     = mNewDataType->mTotalSize;
1046   } else {
1047     pNewField->mOffset     = mNewDataType->mTotalSize + ALIGN_STUFF(mNewDataType->mTotalSize, Align);
1048   }
1049   if (mNewDataType->mMembers == NULL) {
1050     mNewDataType->mMembers = pNewField;
1051     pNewField->mNext       = NULL;
1052   } else {
1053     for (pTmp = mNewDataType->mMembers; pTmp->mNext != NULL; pTmp = pTmp->mNext)
1054       ;
1055     pTmp->mNext            = pNewField;
1056     pNewField->mNext       = NULL;
1057   }
1058
1059   mNewDataType->mAlign     = MIN (mPackAlign, MAX (pFieldType->mAlign, mNewDataType->mAlign));
1060   mNewDataType->mTotalSize = pNewField->mOffset + (pNewField->mFieldType->mTotalSize) * ((ArrayNum == 0) ? 1 : ArrayNum);
1061
1062   return VFR_RETURN_SUCCESS;
1063 }
1064
1065 VOID
1066 CVfrVarDataTypeDB::DeclareDataTypeEnd (
1067   VOID
1068   )
1069 {
1070   if (mNewDataType->mTypeName[0] == '\0') {
1071     return;
1072   }
1073
1074   if ((mNewDataType->mTotalSize % mNewDataType->mAlign) !=0) {
1075     mNewDataType->mTotalSize += ALIGN_STUFF (mNewDataType->mTotalSize, mNewDataType->mAlign);
1076   }
1077
1078   RegisterNewType (mNewDataType);
1079   if (mFirstNewDataTypeName == NULL) {
1080     mFirstNewDataTypeName = mNewDataType->mTypeName;
1081   }
1082
1083   mNewDataType             = NULL;
1084 }
1085
1086 EFI_VFR_RETURN_CODE
1087 CVfrVarDataTypeDB::GetDataType (
1088   IN  CHAR8         *TypeName,
1089   OUT SVfrDataType **DataType
1090   )
1091 {
1092   SVfrDataType *pDataType = NULL;
1093
1094   if (TypeName == NULL) {
1095     return VFR_RETURN_ERROR_SKIPED;
1096   }
1097
1098   if (DataType == NULL) {
1099     return VFR_RETURN_FATAL_ERROR;
1100   }
1101
1102   *DataType = NULL;
1103
1104   for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) {
1105     if (strcmp (TypeName, pDataType->mTypeName) == 0) {
1106       *DataType = pDataType;
1107       return VFR_RETURN_SUCCESS;
1108     }
1109   }
1110
1111   return VFR_RETURN_UNDEFINED;
1112 }
1113
1114 EFI_VFR_RETURN_CODE
1115 CVfrVarDataTypeDB::GetDataTypeSize (
1116   IN  UINT8   DataType,
1117   OUT UINT32 *Size
1118   )
1119 {
1120   SVfrDataType *pDataType = NULL;
1121
1122   if (Size == NULL) {
1123     return VFR_RETURN_FATAL_ERROR;
1124   }
1125
1126   *Size    = 0;
1127   DataType = DataType & 0x0F;
1128
1129   //
1130   // For user defined data type, the size can't be got by this function.
1131   //
1132   if (DataType == EFI_IFR_TYPE_OTHER) {
1133     return VFR_RETURN_SUCCESS;
1134   }
1135
1136   for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) {
1137     if (DataType == pDataType->mType) {
1138       *Size = pDataType->mTotalSize;
1139       return VFR_RETURN_SUCCESS;
1140     }
1141   }
1142
1143   return VFR_RETURN_UNDEFINED;
1144 }
1145
1146 EFI_VFR_RETURN_CODE
1147 CVfrVarDataTypeDB::GetDataTypeSize (
1148   IN  CHAR8   *TypeName,
1149   OUT UINT32 *Size
1150   )
1151 {
1152   SVfrDataType *pDataType = NULL;
1153
1154   if (Size == NULL) {
1155     return VFR_RETURN_FATAL_ERROR;
1156   }
1157
1158   *Size = 0;
1159
1160   for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) {
1161     if (strcmp (TypeName, pDataType->mTypeName) == 0) {
1162       *Size = pDataType->mTotalSize;
1163       return VFR_RETURN_SUCCESS;
1164     }
1165   }
1166
1167   return VFR_RETURN_UNDEFINED;
1168 }
1169
1170 EFI_VFR_RETURN_CODE
1171 CVfrVarDataTypeDB::GetDataFieldInfo (
1172   IN  CHAR8     *VarStr,
1173   OUT UINT16   &Offset,
1174   OUT UINT8    &Type,
1175   OUT UINT32   &Size
1176   )
1177 {
1178   CHAR8               TName[MAX_NAME_LEN], FName[MAX_NAME_LEN];
1179   UINT32              ArrayIdx, Tmp;
1180   SVfrDataType        *pType  = NULL;
1181   SVfrDataField       *pField = NULL;
1182
1183   Offset = 0;
1184   Type   = EFI_IFR_TYPE_OTHER;
1185   Size   = 0;
1186
1187   CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName), VFR_RETURN_SUCCESS);
1188   CHECK_ERROR_RETURN (GetDataType (TName, &pType), VFR_RETURN_SUCCESS);
1189
1190   //
1191   // if it is not struct data type
1192   //
1193   Type  = pType->mType;
1194   Size  = pType->mTotalSize;
1195
1196   while (*VarStr != '\0') {
1197         CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), VFR_RETURN_SUCCESS);
1198     CHECK_ERROR_RETURN(GetTypeField (FName, pType, pField), VFR_RETURN_SUCCESS);
1199     pType  = pField->mFieldType;
1200     CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp), VFR_RETURN_SUCCESS);
1201     Offset = (UINT16) (Offset + Tmp);
1202     Type   = GetFieldWidth (pField);
1203     Size   = GetFieldSize (pField, ArrayIdx);
1204   }
1205   return VFR_RETURN_SUCCESS;
1206 }
1207
1208 EFI_VFR_RETURN_CODE
1209 CVfrVarDataTypeDB::GetUserDefinedTypeNameList  (
1210   OUT CHAR8      ***NameList,
1211   OUT UINT32    *ListSize
1212   )
1213 {
1214   UINT32       Index;
1215   SVfrDataType *pType;
1216
1217   if ((NameList == NULL) || (ListSize == NULL)) {
1218     return VFR_RETURN_FATAL_ERROR;
1219   }
1220
1221   *NameList = NULL;
1222   *ListSize = 0;
1223
1224   for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) {
1225     if (_IS_INTERNAL_TYPE(pType->mTypeName) == FALSE) {
1226       (*ListSize)++;
1227     }
1228   }
1229
1230   if (*ListSize == 0) {
1231     return VFR_RETURN_SUCCESS;
1232   }
1233
1234   if ((*NameList = new CHAR8*[*ListSize]) == NULL) {
1235     *ListSize = 0;
1236     return VFR_RETURN_OUT_FOR_RESOURCES;
1237   }
1238
1239   for (Index = 0, pType = mDataTypeList; pType != NULL; pType = pType->mNext, Index++) {
1240     if (_IS_INTERNAL_TYPE(pType->mTypeName) == FALSE) {
1241       (*NameList)[Index] = pType->mTypeName;
1242     }
1243   }
1244   return VFR_RETURN_SUCCESS;
1245 }
1246
1247 BOOLEAN
1248 CVfrVarDataTypeDB::IsTypeNameDefined (
1249   IN CHAR8 *TypeName
1250   )
1251 {
1252   SVfrDataType *pType;
1253
1254   if (TypeName == NULL) {
1255     return FALSE;
1256   }
1257
1258   for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) {
1259     if (strcmp (pType->mTypeName, TypeName) == 0) {
1260       return TRUE;
1261     }
1262   }
1263
1264   return FALSE;
1265 }
1266
1267 VOID
1268 CVfrVarDataTypeDB::Dump (
1269   IN FILE         *File
1270   )
1271 {
1272   SVfrDataType  *pTNode;
1273   SVfrDataField *pFNode;
1274
1275   fprintf (File, "\n\n***************************************************************\n");
1276   fprintf (File, "\t\tmPackAlign = %x\n", mPackAlign);
1277   for (pTNode = mDataTypeList; pTNode != NULL; pTNode = pTNode->mNext) {
1278     fprintf (File, "\t\tstruct %s : mAlign [%d] mTotalSize [0x%x]\n\n", pTNode->mTypeName, pTNode->mAlign, pTNode->mTotalSize);
1279     fprintf (File, "\t\tstruct %s {\n", pTNode->mTypeName);
1280     for (pFNode = pTNode->mMembers; pFNode != NULL; pFNode = pFNode->mNext) {
1281       if (pFNode->mArrayNum > 0) {
1282         fprintf (File, "\t\t\t+%08d[%08x] %s[%d] <%s>\n", pFNode->mOffset, pFNode->mOffset,
1283                   pFNode->mFieldName, pFNode->mArrayNum, pFNode->mFieldType->mTypeName);
1284       } else {
1285         fprintf (File, "\t\t\t+%08d[%08x] %s <%s>\n", pFNode->mOffset, pFNode->mOffset,
1286                   pFNode->mFieldName, pFNode->mFieldType->mTypeName);
1287       }
1288     }
1289     fprintf (File, "\t\t};\n");
1290   fprintf (File, "---------------------------------------------------------------\n");
1291   }
1292   fprintf (File, "***************************************************************\n");
1293 }
1294
1295 #ifdef CVFR_VARDATATYPEDB_DEBUG
1296 VOID
1297 CVfrVarDataTypeDB::ParserDB (
1298   VOID
1299   )
1300 {
1301   SVfrDataType  *pTNode;
1302   SVfrDataField *pFNode;
1303
1304   printf ("***************************************************************\n");
1305   printf ("\t\tmPackAlign = %x\n", mPackAlign);
1306   for (pTNode = mDataTypeList; pTNode != NULL; pTNode = pTNode->mNext) {
1307     printf ("\t\tstruct %s : mAlign [%x] mTotalSize [%x]\n\n", pTNode->mTypeName, pTNode->mAlign, pTNode->mTotalSize);
1308     printf ("\t\tstruct %s {\n", pTNode->mTypeName);
1309     for (pFNode = pTNode->mMembers; pFNode != NULL; pFNode = pFNode->mNext) {
1310       printf ("\t\t\t%s\t%s\n", pFNode->mFieldType->mTypeName, pFNode->mFieldName);
1311     }
1312     printf ("\t\t};\n");
1313         printf ("---------------------------------------------------------------\n");
1314   }
1315   printf ("***************************************************************\n");
1316 }
1317 #endif
1318
1319 SVfrVarStorageNode::SVfrVarStorageNode (
1320   IN EFI_GUID              *Guid,
1321   IN CHAR8                 *StoreName,
1322   IN EFI_VARSTORE_ID       VarStoreId,
1323   IN EFI_STRING_ID         VarName,
1324   IN UINT32                VarSize,
1325   IN BOOLEAN               Flag
1326   )
1327 {
1328   if (Guid != NULL) {
1329     mGuid = *Guid;
1330   } else {
1331     memset (&mGuid, 0, sizeof (EFI_GUID));
1332   }
1333   if (StoreName != NULL) {
1334     mVarStoreName = new CHAR8[strlen(StoreName) + 1];
1335     strcpy (mVarStoreName, StoreName);
1336   } else {
1337     mVarStoreName = NULL;
1338   }
1339   mNext                            = NULL;
1340   mVarStoreId                      = VarStoreId;
1341   mVarStoreType                    = EFI_VFR_VARSTORE_EFI;
1342   mStorageInfo.mEfiVar.mEfiVarName = VarName;
1343   mStorageInfo.mEfiVar.mEfiVarSize = VarSize;
1344   mAssignedFlag                    = Flag;
1345 }
1346
1347 SVfrVarStorageNode::SVfrVarStorageNode (
1348   IN EFI_GUID              *Guid,
1349   IN CHAR8                 *StoreName,
1350   IN EFI_VARSTORE_ID       VarStoreId,
1351   IN SVfrDataType          *DataType,
1352   IN BOOLEAN               Flag
1353   )
1354 {
1355   if (Guid != NULL) {
1356     mGuid = *Guid;
1357   } else {
1358     memset (&mGuid, 0, sizeof (EFI_GUID));
1359   }
1360   if (StoreName != NULL) {
1361     mVarStoreName = new CHAR8[strlen(StoreName) + 1];
1362     strcpy (mVarStoreName, StoreName);
1363   } else {
1364     mVarStoreName = NULL;
1365   }
1366   mNext                    = NULL;
1367   mVarStoreId              = VarStoreId;
1368   mVarStoreType            = EFI_VFR_VARSTORE_BUFFER;
1369   mStorageInfo.mDataType   = DataType;
1370   mAssignedFlag            = Flag;
1371 }
1372
1373 SVfrVarStorageNode::SVfrVarStorageNode (
1374   IN CHAR8                 *StoreName,
1375   IN EFI_VARSTORE_ID       VarStoreId
1376   )
1377 {
1378   if (StoreName != NULL) {
1379     mVarStoreName = new CHAR8[strlen(StoreName) + 1];
1380     strcpy (mVarStoreName, StoreName);
1381   } else {
1382     mVarStoreName = NULL;
1383   }
1384   mNext                              = NULL;
1385   mVarStoreId                        = VarStoreId;
1386   mVarStoreType                      = EFI_VFR_VARSTORE_NAME;
1387   mStorageInfo.mNameSpace.mNameTable = new EFI_VARSTORE_ID[DEFAULT_NAME_TABLE_ITEMS];
1388   mStorageInfo.mNameSpace.mTableSize = 0;
1389 }
1390
1391 SVfrVarStorageNode::~SVfrVarStorageNode (
1392   VOID
1393   )
1394 {
1395   if (mVarStoreName != NULL) {
1396     delete[] mVarStoreName;
1397   }
1398
1399   if (mVarStoreType == EFI_VFR_VARSTORE_NAME) {
1400     delete mStorageInfo.mNameSpace.mNameTable;
1401   }
1402 }
1403
1404 CVfrDataStorage::CVfrDataStorage (
1405   VOID
1406   )
1407 {
1408   UINT32 Index;
1409
1410   for (Index = 0; Index < EFI_FREE_VARSTORE_ID_BITMAP_SIZE; Index++) {
1411     mFreeVarStoreIdBitMap[Index] = 0;
1412   }
1413
1414   // Question ID 0 is reserved.
1415   mFreeVarStoreIdBitMap[0] = 0x80000000;
1416
1417   mBufferVarStoreList      = NULL;
1418   mEfiVarStoreList         = NULL;
1419   mNameVarStoreList        = NULL;
1420   mCurrVarStorageNode      = NULL;
1421   mNewVarStorageNode       = NULL;
1422   mBufferFieldInfoListHead = NULL;
1423   mBufferFieldInfoListTail = NULL;
1424 }
1425
1426 CVfrDataStorage::~CVfrDataStorage (
1427   VOID
1428   )
1429 {
1430   SVfrVarStorageNode *pNode;
1431
1432   while (mBufferVarStoreList != NULL) {
1433     pNode = mBufferVarStoreList;
1434     mBufferVarStoreList = mBufferVarStoreList->mNext;
1435     delete pNode;
1436   }
1437   while (mEfiVarStoreList != NULL) {
1438     pNode = mEfiVarStoreList;
1439     mEfiVarStoreList = mEfiVarStoreList->mNext;
1440     delete pNode;
1441   }
1442   while (mNameVarStoreList != NULL) {
1443     pNode = mNameVarStoreList;
1444     mNameVarStoreList = mNameVarStoreList->mNext;
1445     delete pNode;
1446   }
1447   if (mNewVarStorageNode != NULL) {
1448     delete mNewVarStorageNode;
1449   }
1450 }
1451
1452 EFI_VARSTORE_ID
1453 CVfrDataStorage::GetFreeVarStoreId (
1454   EFI_VFR_VARSTORE_TYPE VarType
1455   )
1456 {
1457   UINT32  Index, Mask, Offset;
1458
1459   //
1460   // Assign the different ID range for the different type VarStore to support Framework Vfr
1461   //
1462   Index = 0;
1463   if ((!VfrCompatibleMode) || (VarType == EFI_VFR_VARSTORE_BUFFER)) {
1464     Index = 0;
1465   } else if (VarType == EFI_VFR_VARSTORE_EFI) {
1466     Index = 1;
1467   } else if (VarType == EFI_VFR_VARSTORE_NAME) {
1468     Index = 2;
1469   }
1470
1471   for (; Index < EFI_FREE_VARSTORE_ID_BITMAP_SIZE; Index++) {
1472     if (mFreeVarStoreIdBitMap[Index] != 0xFFFFFFFF) {
1473       break;
1474     }
1475   }
1476
1477   if (Index == EFI_FREE_VARSTORE_ID_BITMAP_SIZE) {
1478     return EFI_VARSTORE_ID_INVALID;
1479   }
1480
1481   for (Offset = 0, Mask = 0x80000000; Mask != 0; Mask >>= 1, Offset++) {
1482     if ((mFreeVarStoreIdBitMap[Index] & Mask) == 0) {
1483       mFreeVarStoreIdBitMap[Index] |= Mask;
1484       return (EFI_VARSTORE_ID)((Index << EFI_BITS_SHIFT_PER_UINT32) + Offset);
1485     }
1486   }
1487
1488   return EFI_VARSTORE_ID_INVALID;
1489 }
1490
1491 BOOLEAN
1492 CVfrDataStorage::ChekVarStoreIdFree (
1493   IN EFI_VARSTORE_ID VarStoreId
1494   )
1495 {
1496   UINT32 Index  = (VarStoreId / EFI_BITS_PER_UINT32);
1497   UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32);
1498
1499   return (mFreeVarStoreIdBitMap[Index] & (0x80000000 >> Offset)) == 0;
1500 }
1501
1502 VOID
1503 CVfrDataStorage::MarkVarStoreIdUsed (
1504   IN EFI_VARSTORE_ID VarStoreId
1505   )
1506 {
1507   UINT32 Index  = (VarStoreId / EFI_BITS_PER_UINT32);
1508   UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32);
1509
1510   mFreeVarStoreIdBitMap[Index] |= (0x80000000 >> Offset);
1511 }
1512
1513 VOID
1514 CVfrDataStorage::MarkVarStoreIdUnused (
1515   IN EFI_VARSTORE_ID VarStoreId
1516   )
1517 {
1518   UINT32 Index  = (VarStoreId / EFI_BITS_PER_UINT32);
1519   UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32);
1520
1521   mFreeVarStoreIdBitMap[Index] &= ~(0x80000000 >> Offset);
1522 }
1523
1524 EFI_VFR_RETURN_CODE
1525 CVfrDataStorage::DeclareNameVarStoreBegin (
1526   IN CHAR8           *StoreName,
1527   IN EFI_VARSTORE_ID VarStoreId
1528   )
1529 {
1530   SVfrVarStorageNode *pNode = NULL;
1531   EFI_VARSTORE_ID    TmpVarStoreId;
1532
1533   if (StoreName == NULL) {
1534     return VFR_RETURN_FATAL_ERROR;
1535   }
1536
1537   if (GetVarStoreId (StoreName, &TmpVarStoreId) == VFR_RETURN_SUCCESS) {
1538     return VFR_RETURN_REDEFINED;
1539   }
1540
1541   if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
1542     VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_NAME);
1543   } else {
1544     if (ChekVarStoreIdFree (VarStoreId) == FALSE) {
1545       return VFR_RETURN_VARSTOREID_REDEFINED;
1546     }
1547     MarkVarStoreIdUsed (VarStoreId);
1548   }
1549
1550   if ((pNode = new SVfrVarStorageNode (StoreName, VarStoreId)) == NULL) {
1551     return VFR_RETURN_UNDEFINED;
1552   }
1553
1554   mNewVarStorageNode = pNode;
1555
1556   return VFR_RETURN_SUCCESS;
1557 }
1558
1559 EFI_VFR_RETURN_CODE
1560 CVfrDataStorage::NameTableAddItem (
1561   IN EFI_STRING_ID  Item
1562   )
1563 {
1564   EFI_VARSTORE_ID *NewTable, *OldTable;
1565   UINT32          TableSize;
1566
1567   OldTable  = mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable;
1568   TableSize = mNewVarStorageNode->mStorageInfo.mNameSpace.mTableSize;
1569
1570   if ((TableSize != 0) && ((TableSize % DEFAULT_NAME_TABLE_ITEMS) == 0)) {
1571     if ((NewTable = new EFI_VARSTORE_ID[TableSize + DEFAULT_NAME_TABLE_ITEMS]) == NULL) {
1572       return VFR_RETURN_OUT_FOR_RESOURCES;
1573     }
1574     memcpy (NewTable, OldTable, TableSize);
1575     mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable = NewTable;
1576   }
1577
1578   mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable[TableSize++] = Item;
1579   mNewVarStorageNode->mStorageInfo.mNameSpace.mTableSize = TableSize;
1580
1581   return VFR_RETURN_SUCCESS;
1582 }
1583
1584 EFI_VFR_RETURN_CODE
1585 CVfrDataStorage::DeclareNameVarStoreEnd (
1586   IN EFI_GUID *Guid
1587   )
1588 {
1589   mNewVarStorageNode->mGuid = *Guid;
1590   mNewVarStorageNode->mNext = mNameVarStoreList;
1591   mNameVarStoreList         = mNewVarStorageNode;
1592
1593   mNewVarStorageNode        = NULL;
1594
1595   return VFR_RETURN_SUCCESS;
1596 }
1597
1598 EFI_VFR_RETURN_CODE
1599 CVfrDataStorage::DeclareEfiVarStore (
1600   IN CHAR8          *StoreName,
1601   IN EFI_GUID       *Guid,
1602   IN EFI_STRING_ID  NameStrId,
1603   IN UINT32         VarSize,
1604   IN BOOLEAN        Flag
1605   )
1606 {
1607   SVfrVarStorageNode *pNode;
1608   EFI_VARSTORE_ID    VarStoreId;
1609
1610   if ((StoreName == NULL) || (Guid == NULL)) {
1611     return VFR_RETURN_FATAL_ERROR;
1612   }
1613
1614   if (VarSize > sizeof (UINT64)) {
1615     return VFR_RETURN_EFIVARSTORE_SIZE_ERROR;
1616   }
1617
1618   if (GetVarStoreId (StoreName, &VarStoreId, Guid) == VFR_RETURN_SUCCESS) {
1619     return VFR_RETURN_REDEFINED;
1620   }
1621
1622   VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_EFI);
1623   if ((pNode = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, NameStrId, VarSize, Flag)) == NULL) {
1624     return VFR_RETURN_OUT_FOR_RESOURCES;
1625   }
1626
1627   pNode->mNext       = mEfiVarStoreList;
1628   mEfiVarStoreList   = pNode;
1629
1630   return VFR_RETURN_SUCCESS;
1631 }
1632
1633 EFI_VFR_RETURN_CODE
1634 CVfrDataStorage::DeclareBufferVarStore (
1635   IN CHAR8             *StoreName,
1636   IN EFI_GUID          *Guid,
1637   IN CVfrVarDataTypeDB *DataTypeDB,
1638   IN CHAR8             *TypeName,
1639   IN EFI_VARSTORE_ID   VarStoreId,
1640   IN BOOLEAN           Flag
1641   )
1642 {
1643   SVfrVarStorageNode   *pNew = NULL;
1644   SVfrDataType         *pDataType = NULL;
1645   EFI_VARSTORE_ID      TempVarStoreId;
1646
1647   if ((StoreName == NULL) || (Guid == NULL) || (DataTypeDB == NULL)) {
1648     return VFR_RETURN_FATAL_ERROR;
1649   }
1650
1651   if (GetVarStoreId (StoreName, &TempVarStoreId, Guid) == VFR_RETURN_SUCCESS) {
1652     return VFR_RETURN_REDEFINED;
1653   }
1654
1655   CHECK_ERROR_RETURN(DataTypeDB->GetDataType (TypeName, &pDataType), VFR_RETURN_SUCCESS);
1656
1657   if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
1658     VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_BUFFER);
1659   } else {
1660     if (ChekVarStoreIdFree (VarStoreId) == FALSE) {
1661       return VFR_RETURN_VARSTOREID_REDEFINED;
1662     }
1663     MarkVarStoreIdUsed (VarStoreId);
1664   }
1665
1666   if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, Flag)) == NULL) {
1667     return VFR_RETURN_OUT_FOR_RESOURCES;
1668   }
1669
1670   pNew->mNext         = mBufferVarStoreList;
1671   mBufferVarStoreList = pNew;
1672
1673   if (gCVfrBufferConfig.Register(StoreName, Guid) != 0) {
1674     return VFR_RETURN_FATAL_ERROR;
1675   }
1676
1677   return VFR_RETURN_SUCCESS;
1678 }
1679
1680 EFI_VFR_RETURN_CODE
1681 CVfrDataStorage::GetVarStoreByDataType (
1682   IN  CHAR8              *DataTypeName,
1683   OUT SVfrVarStorageNode **VarNode,
1684   IN  EFI_GUID           *VarGuid
1685   )
1686 {
1687   SVfrVarStorageNode    *pNode;
1688   SVfrVarStorageNode    *MatchNode;
1689
1690   //
1691   // Framework VFR uses Data type name as varstore name, so don't need check again.
1692   //
1693   if (VfrCompatibleMode) {
1694     return VFR_RETURN_UNDEFINED;
1695   }
1696
1697   MatchNode = NULL;
1698   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1699     if (strcmp (pNode->mStorageInfo.mDataType->mTypeName, DataTypeName) != 0) {
1700       continue;
1701     }
1702
1703     if ((VarGuid != NULL)) {
1704       if (memcmp (VarGuid, &pNode->mGuid, sizeof (EFI_GUID)) == 0) {
1705         *VarNode = pNode;
1706         return VFR_RETURN_SUCCESS;
1707       }
1708     } else {
1709       if (MatchNode == NULL) {
1710         MatchNode = pNode;
1711       } else {
1712         //
1713         // More than one varstores referred the same data structures.
1714         //
1715         return VFR_RETURN_VARSTORE_DATATYPE_REDEFINED_ERROR;
1716       }
1717     }
1718   }
1719
1720   if (MatchNode == NULL) {
1721     return VFR_RETURN_UNDEFINED;
1722   }
1723
1724   *VarNode = MatchNode;
1725   return VFR_RETURN_SUCCESS;
1726 }
1727
1728 EFI_VARSTORE_ID
1729 CVfrDataStorage::CheckGuidField (
1730   IN  SVfrVarStorageNode   *pNode,
1731   IN  EFI_GUID             *StoreGuid,
1732   IN  BOOLEAN              *HasFoundOne,
1733   OUT EFI_VFR_RETURN_CODE  *ReturnCode
1734   )
1735 {
1736   if (StoreGuid != NULL) {
1737     //
1738     // If has guid info, compare the guid filed.
1739     //
1740     if (memcmp (StoreGuid, &pNode->mGuid, sizeof (EFI_GUID)) == 0) {
1741       //
1742       // Both name and guid are same, this this varstore.
1743       //
1744       mCurrVarStorageNode = pNode;
1745       *ReturnCode = VFR_RETURN_SUCCESS;
1746       return TRUE;
1747     }
1748   } else {
1749     //
1750     // Not has Guid field, check whether this name is the only one.
1751     //
1752     if (*HasFoundOne) {
1753       //
1754       // The name has conflict, return name redefined.
1755       //
1756       *ReturnCode = VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR;
1757       return TRUE;
1758     }
1759
1760     *HasFoundOne = TRUE;
1761     mCurrVarStorageNode = pNode;
1762   }
1763
1764   return FALSE;
1765 }
1766
1767 /**
1768   Base on the input store name and guid to find the varstore id.
1769
1770   If both name and guid are inputed, base on the name and guid to
1771   found the varstore. If only name inputed, base on the name to
1772   found the varstore and go on to check whether more than one varstore
1773   has the same name. If only has found one varstore, return this
1774   varstore; if more than one varstore has same name, return varstore
1775   name redefined error. If no varstore found by varstore name, call
1776   function GetVarStoreByDataType and use inputed varstore name as
1777   data type name to search.
1778 **/
1779 EFI_VFR_RETURN_CODE
1780 CVfrDataStorage::GetVarStoreId (
1781   IN  CHAR8           *StoreName,
1782   OUT EFI_VARSTORE_ID *VarStoreId,
1783   IN  EFI_GUID        *StoreGuid
1784   )
1785 {
1786   EFI_VFR_RETURN_CODE   ReturnCode;
1787   SVfrVarStorageNode    *pNode;
1788   BOOLEAN               HasFoundOne = FALSE;
1789
1790   mCurrVarStorageNode = NULL;
1791
1792   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1793     if (strcmp (pNode->mVarStoreName, StoreName) == 0) {
1794       if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {
1795         *VarStoreId = mCurrVarStorageNode->mVarStoreId;
1796         return ReturnCode;
1797       }
1798     }
1799   }
1800
1801   for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1802     if (strcmp (pNode->mVarStoreName, StoreName) == 0) {
1803       if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {
1804         *VarStoreId = mCurrVarStorageNode->mVarStoreId;
1805         return ReturnCode;
1806       }
1807     }
1808   }
1809
1810   for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1811     if (strcmp (pNode->mVarStoreName, StoreName) == 0) {
1812       if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {
1813         *VarStoreId = mCurrVarStorageNode->mVarStoreId;
1814         return ReturnCode;
1815       }
1816     }
1817   }
1818
1819   if (HasFoundOne) {
1820     *VarStoreId = mCurrVarStorageNode->mVarStoreId;
1821     return VFR_RETURN_SUCCESS;
1822   }
1823
1824   *VarStoreId         = EFI_VARSTORE_ID_INVALID;
1825
1826   //
1827   // Assume that Data strucutre name is used as StoreName, and check again.
1828   //
1829   ReturnCode = GetVarStoreByDataType (StoreName, &pNode, StoreGuid);
1830   if (pNode != NULL) {
1831     mCurrVarStorageNode = pNode;
1832     *VarStoreId = pNode->mVarStoreId;
1833   }
1834
1835   return ReturnCode;
1836 }
1837
1838 EFI_VFR_RETURN_CODE
1839 CVfrDataStorage::GetBufferVarStoreDataTypeName (
1840   IN  EFI_VARSTORE_ID        VarStoreId,
1841   OUT CHAR8                  **DataTypeName
1842   )
1843 {
1844   SVfrVarStorageNode    *pNode;
1845
1846   if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
1847     return VFR_RETURN_FATAL_ERROR;
1848   }
1849
1850   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1851     if (pNode->mVarStoreId == VarStoreId) {
1852       *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName;
1853       return VFR_RETURN_SUCCESS;
1854     }
1855   }
1856
1857   return VFR_RETURN_UNDEFINED;
1858 }
1859
1860 EFI_VFR_VARSTORE_TYPE
1861 CVfrDataStorage::GetVarStoreType (
1862   IN  EFI_VARSTORE_ID        VarStoreId
1863   )
1864 {
1865   SVfrVarStorageNode    *pNode;
1866   EFI_VFR_VARSTORE_TYPE VarStoreType;
1867
1868   VarStoreType = EFI_VFR_VARSTORE_INVALID;
1869
1870   if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
1871     return VarStoreType;
1872   }
1873
1874   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1875     if (pNode->mVarStoreId == VarStoreId) {
1876       VarStoreType = pNode->mVarStoreType;
1877       return VarStoreType;
1878     }
1879   }
1880
1881   for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1882     if (pNode->mVarStoreId == VarStoreId) {
1883       VarStoreType = pNode->mVarStoreType;
1884       return VarStoreType;
1885     }
1886   }
1887
1888   for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1889     if (pNode->mVarStoreId == VarStoreId) {
1890       VarStoreType = pNode->mVarStoreType;
1891       return VarStoreType;
1892     }
1893   }
1894
1895   return VarStoreType;
1896 }
1897
1898 EFI_GUID *
1899 CVfrDataStorage::GetVarStoreGuid (
1900   IN  EFI_VARSTORE_ID        VarStoreId
1901   )
1902 {
1903   SVfrVarStorageNode    *pNode;
1904   EFI_GUID              *VarGuid;
1905
1906   VarGuid = NULL;
1907
1908   if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
1909     return VarGuid;
1910   }
1911
1912   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1913     if (pNode->mVarStoreId == VarStoreId) {
1914       VarGuid = &pNode->mGuid;
1915       return VarGuid;
1916     }
1917   }
1918
1919   for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1920     if (pNode->mVarStoreId == VarStoreId) {
1921       VarGuid = &pNode->mGuid;
1922       return VarGuid;
1923     }
1924   }
1925
1926   for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1927     if (pNode->mVarStoreId == VarStoreId) {
1928       VarGuid = &pNode->mGuid;
1929       return VarGuid;
1930     }
1931   }
1932
1933   return VarGuid;
1934 }
1935
1936 EFI_VFR_RETURN_CODE
1937 CVfrDataStorage::GetVarStoreName (
1938   IN  EFI_VARSTORE_ID VarStoreId,
1939   OUT CHAR8           **VarStoreName
1940   )
1941 {
1942   SVfrVarStorageNode    *pNode;
1943
1944   if (VarStoreName == NULL) {
1945     return VFR_RETURN_FATAL_ERROR;
1946   }
1947
1948   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1949     if (pNode->mVarStoreId == VarStoreId) {
1950       *VarStoreName = pNode->mVarStoreName;
1951       return VFR_RETURN_SUCCESS;
1952     }
1953   }
1954
1955   for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1956     if (pNode->mVarStoreId == VarStoreId) {
1957       *VarStoreName = pNode->mVarStoreName;
1958       return VFR_RETURN_SUCCESS;
1959     }
1960   }
1961
1962   for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1963     if (pNode->mVarStoreId == VarStoreId) {
1964       *VarStoreName = pNode->mVarStoreName;
1965       return VFR_RETURN_SUCCESS;
1966     }
1967   }
1968
1969   *VarStoreName = NULL;
1970   return VFR_RETURN_UNDEFINED;
1971 }
1972
1973 EFI_VFR_RETURN_CODE
1974 CVfrDataStorage::GetEfiVarStoreInfo (
1975   IN OUT EFI_VARSTORE_INFO  *Info
1976   )
1977 {
1978   if (Info == NULL) {
1979     return VFR_RETURN_FATAL_ERROR;
1980   }
1981
1982   if (mCurrVarStorageNode == NULL) {
1983     return VFR_RETURN_GET_EFIVARSTORE_ERROR;
1984   }
1985
1986   Info->mInfo.mVarName = mCurrVarStorageNode->mStorageInfo.mEfiVar.mEfiVarName;
1987   Info->mVarTotalSize  = mCurrVarStorageNode->mStorageInfo.mEfiVar.mEfiVarSize;
1988   switch (Info->mVarTotalSize) {
1989   case 1:
1990     Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_8;
1991     break;
1992   case 2:
1993     Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_16;
1994     break;
1995   case 4:
1996     Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_32;
1997     break;
1998   case 8:
1999     Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_64;
2000     break;
2001   default :
2002     return VFR_RETURN_FATAL_ERROR;
2003   }
2004
2005   return VFR_RETURN_SUCCESS;
2006 }
2007
2008 EFI_VFR_RETURN_CODE
2009 CVfrDataStorage::AddBufferVarStoreFieldInfo (
2010   IN EFI_VARSTORE_INFO  *Info
2011   )
2012 {
2013   BufferVarStoreFieldInfoNode *pNew;
2014
2015   if ((pNew = new BufferVarStoreFieldInfoNode(Info)) == NULL) {
2016     return VFR_RETURN_FATAL_ERROR;
2017   }
2018
2019   if (mBufferFieldInfoListHead == NULL) {
2020     mBufferFieldInfoListHead = pNew;
2021     mBufferFieldInfoListTail= pNew;
2022   } else {
2023     mBufferFieldInfoListTail->mNext = pNew;
2024     mBufferFieldInfoListTail = pNew;
2025   }
2026
2027   return VFR_RETURN_SUCCESS;
2028 }
2029
2030 EFI_VFR_RETURN_CODE
2031 CVfrDataStorage::GetBufferVarStoreFieldInfo (
2032   IN OUT EFI_VARSTORE_INFO  *Info
2033   )
2034 {
2035   BufferVarStoreFieldInfoNode *pNode;
2036
2037   pNode = mBufferFieldInfoListHead;
2038   while (pNode != NULL) {
2039     if (Info->mVarStoreId == pNode->mVarStoreInfo.mVarStoreId &&
2040       Info->mInfo.mVarOffset == pNode->mVarStoreInfo.mInfo.mVarOffset) {
2041       Info->mVarTotalSize = pNode->mVarStoreInfo.mVarTotalSize;
2042       Info->mVarType      = pNode->mVarStoreInfo.mVarType;
2043       return VFR_RETURN_SUCCESS;
2044     }
2045     pNode = pNode->mNext;
2046   }
2047   return VFR_RETURN_FATAL_ERROR;
2048 }
2049
2050 EFI_VFR_RETURN_CODE
2051 CVfrDataStorage::GetNameVarStoreInfo (
2052   OUT EFI_VARSTORE_INFO  *Info,
2053   IN  UINT32             Index
2054   )
2055 {
2056   if (Info == NULL) {
2057     return VFR_RETURN_FATAL_ERROR;
2058   }
2059
2060   if (mCurrVarStorageNode == NULL) {
2061     return VFR_RETURN_GET_NVVARSTORE_ERROR;
2062   }
2063
2064   //
2065   // Framework Vfr file Index is from 1, but Uefi Vfr file Index is from 0.
2066   //
2067   if (VfrCompatibleMode) {
2068     if (Index == 0) {
2069       return VFR_RETURN_ERROR_ARRARY_NUM;
2070     }
2071     Index --;
2072   }
2073
2074   Info->mInfo.mVarName = mCurrVarStorageNode->mStorageInfo.mNameSpace.mNameTable[Index];
2075
2076   return VFR_RETURN_SUCCESS;
2077 }
2078
2079 SVfrDefaultStoreNode::SVfrDefaultStoreNode (
2080   IN EFI_IFR_DEFAULTSTORE *ObjBinAddr,
2081   IN CHAR8                *RefName,
2082   IN EFI_STRING_ID        DefaultStoreNameId,
2083   IN UINT16               DefaultId
2084   )
2085 {
2086   mObjBinAddr = ObjBinAddr;
2087
2088   if (RefName != NULL) {
2089     mRefName          = new CHAR8[strlen (RefName) + 1];
2090     strcpy (mRefName, RefName);
2091   } else {
2092     mRefName          = NULL;
2093   }
2094
2095   mNext               = NULL;
2096   mDefaultId          = DefaultId;
2097   mDefaultStoreNameId = DefaultStoreNameId;
2098 }
2099
2100 SVfrDefaultStoreNode::~SVfrDefaultStoreNode (
2101   VOID
2102   )
2103 {
2104   if (mRefName != NULL) {
2105     delete[] mRefName;
2106   }
2107 }
2108
2109 CVfrDefaultStore::CVfrDefaultStore (
2110   VOID
2111   )
2112 {
2113   mDefaultStoreList = NULL;
2114 }
2115
2116 CVfrDefaultStore::~CVfrDefaultStore (
2117   VOID
2118   )
2119 {
2120   SVfrDefaultStoreNode *pTmp = NULL;
2121
2122   while (mDefaultStoreList != NULL) {
2123     pTmp = mDefaultStoreList;
2124     mDefaultStoreList = mDefaultStoreList->mNext;
2125     delete pTmp;
2126   }
2127 }
2128
2129 EFI_VFR_RETURN_CODE
2130 CVfrDefaultStore::RegisterDefaultStore (
2131   IN CHAR8                *ObjBinAddr,
2132   IN CHAR8                *RefName,
2133   IN EFI_STRING_ID        DefaultStoreNameId,
2134   IN UINT16               DefaultId
2135   )
2136 {
2137   SVfrDefaultStoreNode *pNode = NULL;
2138
2139   if (RefName == NULL) {
2140     return VFR_RETURN_FATAL_ERROR;
2141   }
2142
2143   for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) {
2144     if (strcmp (pNode->mRefName, RefName) == 0) {
2145       return VFR_RETURN_REDEFINED;
2146     }
2147   }
2148
2149   if ((pNode = new SVfrDefaultStoreNode ((EFI_IFR_DEFAULTSTORE *)ObjBinAddr, RefName, DefaultStoreNameId, DefaultId)) == NULL) {
2150     return VFR_RETURN_OUT_FOR_RESOURCES;
2151   }
2152
2153   pNode->mNext               = mDefaultStoreList;
2154   mDefaultStoreList          = pNode;
2155
2156   return VFR_RETURN_SUCCESS;
2157 }
2158
2159 /*
2160  * assign new reference name or new default store name id only if
2161  * the original is invalid
2162  */
2163 EFI_VFR_RETURN_CODE
2164 CVfrDefaultStore::ReRegisterDefaultStoreById (
2165   IN UINT16          DefaultId,
2166   IN CHAR8           *RefName,
2167   IN EFI_STRING_ID   DefaultStoreNameId
2168   )
2169 {
2170   SVfrDefaultStoreNode *pNode = NULL;
2171
2172   for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) {
2173     if (pNode->mDefaultId == DefaultId) {
2174       break;
2175     }
2176   }
2177
2178   if (pNode == NULL) {
2179     return VFR_RETURN_UNDEFINED;
2180   } else {
2181     if (pNode->mDefaultStoreNameId == EFI_STRING_ID_INVALID) {
2182       pNode->mDefaultStoreNameId  = DefaultStoreNameId;
2183       if (pNode->mObjBinAddr != NULL) {
2184         pNode->mObjBinAddr->DefaultName = DefaultStoreNameId;
2185       }
2186     } else {
2187       return VFR_RETURN_REDEFINED;
2188     }
2189
2190     if (RefName != NULL) {
2191       delete pNode->mRefName;
2192       pNode->mRefName = new CHAR8[strlen (RefName) + 1];
2193       if (pNode->mRefName != NULL) {
2194         strcpy (pNode->mRefName, RefName);
2195       }
2196     }
2197   }
2198
2199   return VFR_RETURN_SUCCESS;
2200 }
2201
2202 BOOLEAN
2203 CVfrDefaultStore::DefaultIdRegistered (
2204   IN UINT16          DefaultId
2205   )
2206 {
2207   SVfrDefaultStoreNode *pNode = NULL;
2208
2209   for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) {
2210     if (pNode->mDefaultId == DefaultId) {
2211       return TRUE;
2212     }
2213   }
2214
2215   return FALSE;
2216 }
2217
2218 EFI_VFR_RETURN_CODE
2219 CVfrDefaultStore::GetDefaultId (
2220   IN  CHAR8           *RefName,
2221   OUT UINT16          *DefaultId
2222   )
2223 {
2224   SVfrDefaultStoreNode *pTmp = NULL;
2225
2226   if (DefaultId == NULL) {
2227     return VFR_RETURN_FATAL_ERROR;
2228   }
2229
2230   for (pTmp = mDefaultStoreList; pTmp != NULL; pTmp = pTmp->mNext) {
2231     if (strcmp (pTmp->mRefName, RefName) == 0) {
2232       *DefaultId = pTmp->mDefaultId;
2233       return VFR_RETURN_SUCCESS;
2234     }
2235   }
2236
2237   return VFR_RETURN_UNDEFINED;
2238 }
2239
2240 EFI_VFR_RETURN_CODE
2241 CVfrDefaultStore::BufferVarStoreAltConfigAdd (
2242   IN EFI_VARSTORE_ID    DefaultId,
2243   IN EFI_VARSTORE_INFO  &Info,
2244   IN CHAR8              *VarStoreName,
2245   IN EFI_GUID           *VarStoreGuid,
2246   IN UINT8              Type,
2247   IN EFI_IFR_TYPE_VALUE Value
2248   )
2249 {
2250   SVfrDefaultStoreNode  *pNode = NULL;
2251   CHAR8                 NewAltCfg[2 * 2 * sizeof (UINT16) + 1] = {0,};
2252   INTN                  Returnvalue = 0;
2253
2254   if (VarStoreName == NULL) {
2255     return VFR_RETURN_FATAL_ERROR;
2256   }
2257
2258   for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) {
2259     if (pNode->mDefaultId == DefaultId) {
2260       break;
2261     }
2262   }
2263
2264   if (pNode == NULL) {
2265     return VFR_RETURN_UNDEFINED;
2266   }
2267
2268   gCVfrBufferConfig.Open ();
2269
2270   sprintf (NewAltCfg, "%04x", pNode->mDefaultId);
2271   if ((Returnvalue = gCVfrBufferConfig.Select(VarStoreName, VarStoreGuid)) == 0) {
2272     if ((Returnvalue = gCVfrBufferConfig.Write ('a', VarStoreName, VarStoreGuid, NewAltCfg, Type, Info.mInfo.mVarOffset, Info.mVarTotalSize, Value)) != 0) {
2273       goto WriteError;
2274     }
2275   }
2276
2277   gCVfrBufferConfig.Close ();
2278
2279   return VFR_RETURN_SUCCESS;
2280
2281 WriteError:
2282   gCVfrBufferConfig.Close ();
2283   return (EFI_VFR_RETURN_CODE)Returnvalue;
2284 }
2285
2286 SVfrRuleNode::SVfrRuleNode (
2287   IN CHAR8        *RuleName,
2288   IN UINT8       RuleId
2289   )
2290 {
2291   if (RuleName != NULL) {
2292     mRuleName = new CHAR8[strlen (RuleName) + 1];
2293     strcpy (mRuleName, RuleName);
2294   } else {
2295     mRuleName = NULL;
2296   }
2297
2298   mNext       = NULL;
2299   mRuleId     = RuleId;
2300 }
2301
2302 SVfrRuleNode::~SVfrRuleNode (
2303   VOID
2304   )
2305 {
2306   if (mRuleName != NULL) {
2307     delete[] mRuleName;
2308   }
2309 }
2310
2311 CVfrRulesDB::CVfrRulesDB ()
2312 {
2313   mRuleList   = NULL;
2314   mFreeRuleId = EFI_VARSTORE_ID_START;
2315 }
2316
2317 CVfrRulesDB::~CVfrRulesDB ()
2318 {
2319   SVfrRuleNode *pNode;
2320
2321   while(mRuleList != NULL) {
2322     pNode = mRuleList;
2323     mRuleList = mRuleList->mNext;
2324     delete pNode;
2325   }
2326 }
2327
2328 VOID
2329 CVfrRulesDB::RegisterRule (
2330   IN CHAR8  *RuleName
2331   )
2332 {
2333   SVfrRuleNode *pNew;
2334
2335   if (RuleName == NULL) {
2336     return ;
2337   }
2338
2339   if ((pNew = new SVfrRuleNode (RuleName, mFreeRuleId)) == NULL) {
2340     return ;
2341   }
2342
2343   mFreeRuleId++;
2344
2345   pNew->mNext = mRuleList;
2346   mRuleList   = pNew;
2347 }
2348
2349 UINT8
2350 CVfrRulesDB::GetRuleId (
2351   IN CHAR8  *RuleName
2352   )
2353 {
2354   SVfrRuleNode *pNode;
2355
2356   if (RuleName == NULL) {
2357     return EFI_RULE_ID_INVALID;
2358   }
2359
2360   for (pNode = mRuleList; pNode != NULL; pNode = pNode->mNext) {
2361     if (strcmp (pNode->mRuleName, RuleName) == 0) {
2362       return pNode->mRuleId;
2363     }
2364   }
2365
2366   return EFI_RULE_ID_INVALID;
2367 }
2368
2369 CVfrRulesDB gCVfrRulesDB;
2370
2371 EFI_VARSTORE_INFO::EFI_VARSTORE_INFO (
2372   VOID
2373   )
2374 {
2375   mVarStoreId      = EFI_VARSTORE_ID_INVALID;
2376   mInfo.mVarName   = EFI_STRING_ID_INVALID;
2377   mInfo.mVarOffset = EFI_VAROFFSET_INVALID;
2378   mVarType         = EFI_IFR_TYPE_OTHER;
2379   mVarTotalSize    = 0;
2380 }
2381
2382 EFI_VARSTORE_INFO::EFI_VARSTORE_INFO (
2383   IN EFI_VARSTORE_INFO &Info
2384   )
2385 {
2386   mVarStoreId      = Info.mVarStoreId;
2387   mInfo.mVarName   = Info.mInfo.mVarName;
2388   mInfo.mVarOffset = Info.mInfo.mVarOffset;
2389   mVarType         = Info.mVarType;
2390   mVarTotalSize    = Info.mVarTotalSize;
2391 }
2392
2393 EFI_VARSTORE_INFO&
2394 EFI_VARSTORE_INFO::operator= (
2395   IN CONST EFI_VARSTORE_INFO &Info
2396   )
2397 {
2398   if (this != &Info) {
2399     mVarStoreId      = Info.mVarStoreId;
2400     mInfo.mVarName   = Info.mInfo.mVarName;
2401     mInfo.mVarOffset = Info.mInfo.mVarOffset;
2402     mVarType         = Info.mVarType;
2403     mVarTotalSize    = Info.mVarTotalSize;
2404   }
2405
2406   return *this;
2407 }
2408
2409 BOOLEAN
2410 EFI_VARSTORE_INFO::operator == (
2411   IN EFI_VARSTORE_INFO  *Info
2412   )
2413 {
2414   if ((mVarStoreId == Info->mVarStoreId) &&
2415           (mInfo.mVarName == Info->mInfo.mVarName) &&
2416       (mInfo.mVarOffset == Info->mInfo.mVarOffset) &&
2417       (mVarType == Info->mVarType) &&
2418       (mVarTotalSize == Info->mVarTotalSize)) {
2419     return TRUE;
2420   }
2421
2422   return FALSE;
2423 }
2424
2425 BufferVarStoreFieldInfoNode::BufferVarStoreFieldInfoNode(
2426   IN EFI_VARSTORE_INFO  *Info
2427   )
2428 {
2429   mVarStoreInfo.mVarType               = Info->mVarType;
2430   mVarStoreInfo.mVarTotalSize          = Info->mVarTotalSize;
2431   mVarStoreInfo.mInfo.mVarOffset       = Info->mInfo.mVarOffset;
2432   mVarStoreInfo.mVarStoreId            = Info->mVarStoreId;
2433   mNext = NULL;
2434 }
2435
2436 BufferVarStoreFieldInfoNode::~BufferVarStoreFieldInfoNode ()
2437 {
2438   mVarStoreInfo.mVarType               = EFI_IFR_TYPE_OTHER;
2439   mVarStoreInfo.mVarTotalSize          = 0;
2440   mVarStoreInfo.mInfo.mVarOffset       = EFI_VAROFFSET_INVALID;
2441   mVarStoreInfo.mVarStoreId            = EFI_VARSTORE_ID_INVALID;
2442   mNext = NULL;
2443 }
2444
2445 static EFI_VARSTORE_INFO gEfiInvalidVarStoreInfo;
2446
2447 EFI_QUESTION_ID
2448 CVfrQuestionDB::GetFreeQuestionId (
2449   VOID
2450   )
2451 {
2452   UINT32  Index, Mask, Offset;
2453
2454   for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) {
2455     if (mFreeQIdBitMap[Index] != 0xFFFFFFFF) {
2456       break;
2457     }
2458   }
2459
2460   if (Index == EFI_FREE_QUESTION_ID_BITMAP_SIZE) {
2461     return EFI_QUESTION_ID_INVALID;
2462   }
2463
2464   for (Offset = 0, Mask = 0x80000000; Mask != 0; Mask >>= 1, Offset++) {
2465     if ((mFreeQIdBitMap[Index] & Mask) == 0) {
2466       mFreeQIdBitMap[Index] |= Mask;
2467       return (EFI_QUESTION_ID)((Index << EFI_BITS_SHIFT_PER_UINT32) + Offset);
2468     }
2469   }
2470
2471   return EFI_QUESTION_ID_INVALID;
2472 }
2473
2474 BOOLEAN
2475 CVfrQuestionDB::ChekQuestionIdFree (
2476   IN EFI_QUESTION_ID QId
2477   )
2478 {
2479   UINT32 Index  = (QId / EFI_BITS_PER_UINT32);
2480   UINT32 Offset = (QId % EFI_BITS_PER_UINT32);
2481
2482   return (mFreeQIdBitMap[Index] & (0x80000000 >> Offset)) == 0;
2483 }
2484
2485 VOID
2486 CVfrQuestionDB::MarkQuestionIdUsed (
2487   IN EFI_QUESTION_ID QId
2488   )
2489 {
2490   UINT32 Index  = (QId / EFI_BITS_PER_UINT32);
2491   UINT32 Offset = (QId % EFI_BITS_PER_UINT32);
2492
2493   mFreeQIdBitMap[Index] |= (0x80000000 >> Offset);
2494 }
2495
2496 VOID
2497 CVfrQuestionDB::MarkQuestionIdUnused (
2498   IN EFI_QUESTION_ID QId
2499   )
2500 {
2501   UINT32 Index  = (QId / EFI_BITS_PER_UINT32);
2502   UINT32 Offset = (QId % EFI_BITS_PER_UINT32);
2503
2504   mFreeQIdBitMap[Index] &= ~(0x80000000 >> Offset);
2505 }
2506
2507 SVfrQuestionNode::SVfrQuestionNode (
2508   IN CHAR8  *Name,
2509   IN CHAR8  *VarIdStr,
2510   IN UINT32 BitMask
2511   )
2512 {
2513   mName       = NULL;
2514   mVarIdStr   = NULL;
2515   mQuestionId = EFI_QUESTION_ID_INVALID;
2516   mBitMask    = BitMask;
2517   mNext       = NULL;
2518   mQtype      = QUESTION_NORMAL;
2519
2520   if (Name == NULL) {
2521     mName = new CHAR8[strlen ("$DEFAULT") + 1];
2522     strcpy (mName, "$DEFAULT");
2523   } else {
2524     mName = new CHAR8[strlen (Name) + 1];
2525     strcpy (mName, Name);
2526   }
2527
2528   if (VarIdStr != NULL) {
2529     mVarIdStr = new CHAR8[strlen (VarIdStr) + 1];
2530     strcpy (mVarIdStr, VarIdStr);
2531   } else {
2532     mVarIdStr = new CHAR8[strlen ("$") + 1];
2533     strcpy (mVarIdStr, "$");
2534   }
2535 }
2536
2537 SVfrQuestionNode::~SVfrQuestionNode (
2538   VOID
2539   )
2540 {
2541   if (mName != NULL) {
2542     delete[] mName;
2543   }
2544
2545   if (mVarIdStr != NULL) {
2546     delete[] mVarIdStr;
2547   }
2548 }
2549
2550 CVfrQuestionDB::CVfrQuestionDB ()
2551 {
2552   UINT32 Index;
2553
2554   for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) {
2555     mFreeQIdBitMap[Index] = 0;
2556   }
2557
2558   // Question ID 0 is reserved.
2559   mFreeQIdBitMap[0] = 0x80000000;
2560   mQuestionList     = NULL;
2561 }
2562
2563 CVfrQuestionDB::~CVfrQuestionDB ()
2564 {
2565   SVfrQuestionNode     *pNode;
2566
2567   while (mQuestionList != NULL) {
2568     pNode = mQuestionList;
2569     mQuestionList = mQuestionList->mNext;
2570     delete pNode;
2571   }
2572 }
2573
2574 //
2575 // Reset to init state
2576 //
2577 VOID
2578 CVfrQuestionDB::ResetInit(
2579   IN VOID
2580   )
2581 {
2582   UINT32               Index;
2583   SVfrQuestionNode     *pNode;
2584
2585   while (mQuestionList != NULL) {
2586     pNode = mQuestionList;
2587     mQuestionList = mQuestionList->mNext;
2588     delete pNode;
2589   }
2590
2591   for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) {
2592     mFreeQIdBitMap[Index] = 0;
2593   }
2594
2595   // Question ID 0 is reserved.
2596   mFreeQIdBitMap[0] = 0x80000000;
2597   mQuestionList     = NULL;
2598 }
2599
2600 VOID
2601 CVfrQuestionDB::PrintAllQuestion (
2602   VOID
2603   )
2604 {
2605   SVfrQuestionNode *pNode = NULL;
2606
2607   for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) {
2608     printf ("Question VarId is %s and QuesitonId is 0x%x\n", pNode->mVarIdStr, pNode->mQuestionId);
2609   }
2610 }
2611
2612 EFI_VFR_RETURN_CODE
2613 CVfrQuestionDB::RegisterQuestion (
2614   IN     CHAR8             *Name,
2615   IN     CHAR8             *VarIdStr,
2616   IN OUT EFI_QUESTION_ID   &QuestionId
2617   )
2618 {
2619   SVfrQuestionNode *pNode = NULL;
2620
2621   if ((Name != NULL) && (FindQuestion(Name) == VFR_RETURN_SUCCESS)) {
2622     return VFR_RETURN_REDEFINED;
2623   }
2624
2625   if ((pNode = new SVfrQuestionNode (Name, VarIdStr)) == NULL) {
2626     return VFR_RETURN_OUT_FOR_RESOURCES;
2627   }
2628
2629   if (QuestionId == EFI_QUESTION_ID_INVALID) {
2630     QuestionId = GetFreeQuestionId ();
2631   } else {
2632     //
2633     // For Framework Vfr, don't check question ID conflict.
2634     //
2635     if (!VfrCompatibleMode && ChekQuestionIdFree (QuestionId) == FALSE) {
2636       delete pNode;
2637       return VFR_RETURN_QUESTIONID_REDEFINED;
2638     }
2639     MarkQuestionIdUsed (QuestionId);
2640   }
2641   pNode->mQuestionId = QuestionId;
2642
2643   pNode->mNext       = mQuestionList;
2644   mQuestionList      = pNode;
2645
2646   gCFormPkg.DoPendingAssign (VarIdStr, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2647
2648   return VFR_RETURN_SUCCESS;
2649 }
2650
2651 VOID
2652 CVfrQuestionDB::RegisterOldDateQuestion (
2653   IN     CHAR8            *YearVarId,
2654   IN     CHAR8            *MonthVarId,
2655   IN     CHAR8            *DayVarId,
2656   IN OUT EFI_QUESTION_ID &QuestionId
2657   )
2658 {
2659   SVfrQuestionNode *pNode[3] = {NULL, };
2660   UINT32           Index;
2661
2662   if ((YearVarId == NULL) || (MonthVarId == NULL) || (DayVarId == NULL)) {
2663     return;
2664   }
2665
2666   if ((pNode[0] = new SVfrQuestionNode (NULL, YearVarId, DATE_YEAR_BITMASK)) == NULL) {
2667     goto Err;
2668   }
2669   if ((pNode[1] = new SVfrQuestionNode (NULL, MonthVarId, DATE_MONTH_BITMASK)) == NULL) {
2670     goto Err;
2671   }
2672   if ((pNode[2] = new SVfrQuestionNode (NULL, DayVarId, DATE_DAY_BITMASK)) == NULL) {
2673     goto Err;
2674   }
2675
2676   if (QuestionId == EFI_QUESTION_ID_INVALID) {
2677     QuestionId = GetFreeQuestionId ();
2678   } else {
2679     if (ChekQuestionIdFree (QuestionId) == FALSE) {
2680       goto Err;
2681     }
2682     MarkQuestionIdUsed (QuestionId);
2683   }
2684
2685   pNode[0]->mQuestionId = QuestionId;
2686   pNode[1]->mQuestionId = QuestionId;
2687   pNode[2]->mQuestionId = QuestionId;
2688   pNode[0]->mQtype      = QUESTION_DATE;
2689   pNode[1]->mQtype      = QUESTION_DATE;
2690   pNode[2]->mQtype      = QUESTION_DATE;
2691   pNode[0]->mNext       = pNode[1];
2692   pNode[1]->mNext       = pNode[2];
2693   pNode[2]->mNext       = mQuestionList;
2694   mQuestionList         = pNode[0];
2695
2696   gCFormPkg.DoPendingAssign (YearVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2697   gCFormPkg.DoPendingAssign (MonthVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2698   gCFormPkg.DoPendingAssign (DayVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2699
2700   return;
2701
2702 Err:
2703   for (Index = 0; Index < 3; Index++) {
2704     if (pNode[Index] != NULL) {
2705       delete pNode[Index];
2706     }
2707   }
2708   QuestionId = EFI_QUESTION_ID_INVALID;
2709 }
2710
2711 VOID
2712 CVfrQuestionDB::RegisterNewDateQuestion (
2713   IN     CHAR8            *Name,
2714   IN     CHAR8            *BaseVarId,
2715   IN OUT EFI_QUESTION_ID &QuestionId
2716   )
2717 {
2718   SVfrQuestionNode     *pNode[3] = {NULL, };
2719   UINT32               Len;
2720   CHAR8                *VarIdStr[3] = {NULL, };
2721   CHAR8                 Index;
2722
2723   if (BaseVarId == NULL && Name == NULL) {
2724     if (QuestionId == EFI_QUESTION_ID_INVALID) {
2725       QuestionId = GetFreeQuestionId ();
2726     } else {
2727       if (ChekQuestionIdFree (QuestionId) == FALSE) {
2728         goto Err;
2729       }
2730       MarkQuestionIdUsed (QuestionId);
2731     }
2732     return;
2733   }
2734
2735   if (BaseVarId != NULL) {
2736     Len = strlen (BaseVarId);
2737
2738     VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1];
2739     if (VarIdStr[0] != NULL) {
2740       strcpy (VarIdStr[0], BaseVarId);
2741       strcat (VarIdStr[0], ".Year");
2742     }
2743     VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1];
2744     if (VarIdStr[1] != NULL) {
2745       strcpy (VarIdStr[1], BaseVarId);
2746       strcat (VarIdStr[1], ".Month");
2747     }
2748     VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1];
2749     if (VarIdStr[2] != NULL) {
2750       strcpy (VarIdStr[2], BaseVarId);
2751       strcat (VarIdStr[2], ".Day");
2752     }
2753   } else {
2754     Len = strlen (Name);
2755
2756     VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1];
2757     if (VarIdStr[0] != NULL) {
2758       strcpy (VarIdStr[0], Name);
2759       strcat (VarIdStr[0], ".Year");
2760     }
2761     VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1];
2762     if (VarIdStr[1] != NULL) {
2763       strcpy (VarIdStr[1], Name);
2764       strcat (VarIdStr[1], ".Month");
2765     }
2766     VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1];
2767     if (VarIdStr[2] != NULL) {
2768       strcpy (VarIdStr[2], Name);
2769       strcat (VarIdStr[2], ".Day");
2770     }
2771   }
2772
2773   if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0], DATE_YEAR_BITMASK)) == NULL) {
2774     goto Err;
2775   }
2776   if ((pNode[1] = new SVfrQuestionNode (Name, VarIdStr[1], DATE_MONTH_BITMASK)) == NULL) {
2777     goto Err;
2778   }
2779   if ((pNode[2] = new SVfrQuestionNode (Name, VarIdStr[2], DATE_DAY_BITMASK)) == NULL) {
2780     goto Err;
2781   }
2782
2783   if (QuestionId == EFI_QUESTION_ID_INVALID) {
2784     QuestionId = GetFreeQuestionId ();
2785   } else {
2786     if (ChekQuestionIdFree (QuestionId) == FALSE) {
2787       goto Err;
2788     }
2789     MarkQuestionIdUsed (QuestionId);
2790   }
2791
2792   pNode[0]->mQuestionId = QuestionId;
2793   pNode[1]->mQuestionId = QuestionId;
2794   pNode[2]->mQuestionId = QuestionId;
2795   pNode[0]->mQtype      = QUESTION_DATE;
2796   pNode[1]->mQtype      = QUESTION_DATE;
2797   pNode[2]->mQtype      = QUESTION_DATE;
2798   pNode[0]->mNext       = pNode[1];
2799   pNode[1]->mNext       = pNode[2];
2800   pNode[2]->mNext       = mQuestionList;
2801   mQuestionList         = pNode[0];
2802
2803   for (Index = 0; Index < 3; Index++) {
2804     if (VarIdStr[Index] != NULL) {
2805       delete VarIdStr[Index];
2806     }
2807   }
2808
2809   gCFormPkg.DoPendingAssign (VarIdStr[0], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2810   gCFormPkg.DoPendingAssign (VarIdStr[1], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2811   gCFormPkg.DoPendingAssign (VarIdStr[2], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2812
2813   return;
2814
2815 Err:
2816   for (Index = 0; Index < 3; Index++) {
2817     if (pNode[Index] != NULL) {
2818       delete pNode[Index];
2819     }
2820
2821     if (VarIdStr[Index] != NULL) {
2822       delete VarIdStr[Index];
2823     }
2824   }
2825 }
2826
2827 VOID
2828 CVfrQuestionDB::RegisterOldTimeQuestion (
2829   IN     CHAR8            *HourVarId,
2830   IN     CHAR8            *MinuteVarId,
2831   IN     CHAR8            *SecondVarId,
2832   IN OUT EFI_QUESTION_ID &QuestionId
2833   )
2834 {
2835   SVfrQuestionNode *pNode[3] = {NULL, };
2836   UINT32           Index;
2837
2838   if ((HourVarId == NULL) || (MinuteVarId == NULL) || (SecondVarId == NULL)) {
2839     return;
2840   }
2841
2842   if ((pNode[0] = new SVfrQuestionNode (NULL, HourVarId, TIME_HOUR_BITMASK)) == NULL) {
2843     goto Err;
2844   }
2845   if ((pNode[1] = new SVfrQuestionNode (NULL, MinuteVarId, TIME_MINUTE_BITMASK)) == NULL) {
2846     goto Err;
2847   }
2848   if ((pNode[2] = new SVfrQuestionNode (NULL, SecondVarId, TIME_SECOND_BITMASK)) == NULL) {
2849     goto Err;
2850   }
2851
2852   if (QuestionId == EFI_QUESTION_ID_INVALID) {
2853     QuestionId = GetFreeQuestionId ();
2854   } else {
2855     if (ChekQuestionIdFree (QuestionId) == FALSE) {
2856       goto Err;
2857     }
2858     MarkQuestionIdUsed (QuestionId);
2859   }
2860
2861   pNode[0]->mQuestionId = QuestionId;
2862   pNode[1]->mQuestionId = QuestionId;
2863   pNode[2]->mQuestionId = QuestionId;
2864   pNode[0]->mQtype      = QUESTION_TIME;
2865   pNode[1]->mQtype      = QUESTION_TIME;
2866   pNode[2]->mQtype      = QUESTION_TIME;
2867   pNode[0]->mNext       = pNode[1];
2868   pNode[1]->mNext       = pNode[2];
2869   pNode[2]->mNext       = mQuestionList;
2870   mQuestionList         = pNode[0];
2871
2872   gCFormPkg.DoPendingAssign (HourVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2873   gCFormPkg.DoPendingAssign (MinuteVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2874   gCFormPkg.DoPendingAssign (SecondVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2875
2876   return;
2877
2878 Err:
2879   for (Index = 0; Index < 3; Index++) {
2880     if (pNode[Index] != NULL) {
2881       delete pNode[Index];
2882     }
2883   }
2884   QuestionId = EFI_QUESTION_ID_INVALID;
2885 }
2886
2887 VOID
2888 CVfrQuestionDB::RegisterNewTimeQuestion (
2889   IN     CHAR8           *Name,
2890   IN     CHAR8           *BaseVarId,
2891   IN OUT EFI_QUESTION_ID &QuestionId
2892   )
2893 {
2894   SVfrQuestionNode     *pNode[3] = {NULL, };
2895   UINT32               Len;
2896   CHAR8                *VarIdStr[3] = {NULL, };
2897   CHAR8                 Index;
2898
2899   if (BaseVarId == NULL && Name == NULL) {
2900     if (QuestionId == EFI_QUESTION_ID_INVALID) {
2901       QuestionId = GetFreeQuestionId ();
2902     } else {
2903       if (ChekQuestionIdFree (QuestionId) == FALSE) {
2904         goto Err;
2905       }
2906       MarkQuestionIdUsed (QuestionId);
2907     }
2908     return;
2909   }
2910
2911   if (BaseVarId != NULL) {
2912     Len = strlen (BaseVarId);
2913
2914     VarIdStr[0] = new CHAR8[Len + strlen (".Hour") + 1];
2915     if (VarIdStr[0] != NULL) {
2916       strcpy (VarIdStr[0], BaseVarId);
2917       strcat (VarIdStr[0], ".Hour");
2918     }
2919     VarIdStr[1] = new CHAR8[Len + strlen (".Minute") + 1];
2920     if (VarIdStr[1] != NULL) {
2921       strcpy (VarIdStr[1], BaseVarId);
2922       strcat (VarIdStr[1], ".Minute");
2923     }
2924     VarIdStr[2] = new CHAR8[Len + strlen (".Second") + 1];
2925     if (VarIdStr[2] != NULL) {
2926       strcpy (VarIdStr[2], BaseVarId);
2927       strcat (VarIdStr[2], ".Second");
2928     }
2929   } else {
2930     Len = strlen (Name);
2931
2932     VarIdStr[0] = new CHAR8[Len + strlen (".Hour") + 1];
2933     if (VarIdStr[0] != NULL) {
2934       strcpy (VarIdStr[0], Name);
2935       strcat (VarIdStr[0], ".Hour");
2936     }
2937     VarIdStr[1] = new CHAR8[Len + strlen (".Minute") + 1];
2938     if (VarIdStr[1] != NULL) {
2939       strcpy (VarIdStr[1], Name);
2940       strcat (VarIdStr[1], ".Minute");
2941     }
2942     VarIdStr[2] = new CHAR8[Len + strlen (".Second") + 1];
2943     if (VarIdStr[2] != NULL) {
2944       strcpy (VarIdStr[2], Name);
2945       strcat (VarIdStr[2], ".Second");
2946     }
2947   }
2948
2949   if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0], TIME_HOUR_BITMASK)) == NULL) {
2950     goto Err;
2951   }
2952   if ((pNode[1] = new SVfrQuestionNode (Name, VarIdStr[1], TIME_MINUTE_BITMASK)) == NULL) {
2953     goto Err;
2954   }
2955   if ((pNode[2] = new SVfrQuestionNode (Name, VarIdStr[2], TIME_SECOND_BITMASK)) == NULL) {
2956     goto Err;
2957   }
2958
2959   if (QuestionId == EFI_QUESTION_ID_INVALID) {
2960     QuestionId = GetFreeQuestionId ();
2961   } else {
2962     if (ChekQuestionIdFree (QuestionId) == FALSE) {
2963       goto Err;
2964     }
2965     MarkQuestionIdUsed (QuestionId);
2966   }
2967
2968   pNode[0]->mQuestionId = QuestionId;
2969   pNode[1]->mQuestionId = QuestionId;
2970   pNode[2]->mQuestionId = QuestionId;
2971   pNode[0]->mQtype      = QUESTION_TIME;
2972   pNode[1]->mQtype      = QUESTION_TIME;
2973   pNode[2]->mQtype      = QUESTION_TIME;
2974   pNode[0]->mNext       = pNode[1];
2975   pNode[1]->mNext       = pNode[2];
2976   pNode[2]->mNext       = mQuestionList;
2977   mQuestionList         = pNode[0];
2978
2979   for (Index = 0; Index < 3; Index++) {
2980     if (VarIdStr[Index] != NULL) {
2981       delete VarIdStr[Index];
2982     }
2983   }
2984
2985   gCFormPkg.DoPendingAssign (VarIdStr[0], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2986   gCFormPkg.DoPendingAssign (VarIdStr[1], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2987   gCFormPkg.DoPendingAssign (VarIdStr[2], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2988
2989   return;
2990
2991 Err:
2992   for (Index = 0; Index < 3; Index++) {
2993     if (pNode[Index] != NULL) {
2994       delete pNode[Index];
2995     }
2996
2997     if (VarIdStr[Index] != NULL) {
2998       delete VarIdStr[Index];
2999     }
3000   }
3001 }
3002
3003 VOID
3004 CVfrQuestionDB::RegisterRefQuestion (
3005   IN     CHAR8           *Name,
3006   IN     CHAR8           *BaseVarId,
3007   IN OUT EFI_QUESTION_ID &QuestionId
3008   )
3009 {
3010   SVfrQuestionNode     *pNode[4] = {NULL, };
3011   UINT32               Len;
3012   CHAR8                *VarIdStr[4] = {NULL, };
3013   CHAR8                 Index;
3014
3015   if (BaseVarId == NULL && Name == NULL) {
3016     return;
3017   }
3018
3019   if (BaseVarId != NULL) {
3020     Len = strlen (BaseVarId);
3021
3022     VarIdStr[0] = new CHAR8[Len + strlen (".QuestionId") + 1];
3023     if (VarIdStr[0] != NULL) {
3024       strcpy (VarIdStr[0], BaseVarId);
3025       strcat (VarIdStr[0], ".QuestionId");
3026     }
3027     VarIdStr[1] = new CHAR8[Len + strlen (".FormId") + 1];
3028     if (VarIdStr[1] != NULL) {
3029       strcpy (VarIdStr[1], BaseVarId);
3030       strcat (VarIdStr[1], ".FormId");
3031     }
3032     VarIdStr[2] = new CHAR8[Len + strlen (".FormSetGuid") + 1];
3033     if (VarIdStr[2] != NULL) {
3034       strcpy (VarIdStr[2], BaseVarId);
3035       strcat (VarIdStr[2], ".FormSetGuid");
3036     }
3037     VarIdStr[3] = new CHAR8[Len + strlen (".DevicePath") + 1];
3038     if (VarIdStr[3] != NULL) {
3039       strcpy (VarIdStr[3], BaseVarId);
3040       strcat (VarIdStr[3], ".DevicePath");
3041     }
3042   } else {
3043     Len = strlen (Name);
3044
3045     VarIdStr[0] = new CHAR8[Len + strlen (".QuestionId") + 1];
3046     if (VarIdStr[0] != NULL) {
3047       strcpy (VarIdStr[0], Name);
3048       strcat (VarIdStr[0], ".QuestionId");
3049     }
3050     VarIdStr[1] = new CHAR8[Len + strlen (".FormId") + 1];
3051     if (VarIdStr[1] != NULL) {
3052       strcpy (VarIdStr[1], Name);
3053       strcat (VarIdStr[1], ".FormId");
3054     }
3055     VarIdStr[2] = new CHAR8[Len + strlen (".FormSetGuid") + 1];
3056     if (VarIdStr[2] != NULL) {
3057       strcpy (VarIdStr[2], Name);
3058       strcat (VarIdStr[2], ".FormSetGuid");
3059     }
3060     VarIdStr[3] = new CHAR8[Len + strlen (".DevicePath") + 1];
3061     if (VarIdStr[3] != NULL) {
3062       strcpy (VarIdStr[3], Name);
3063       strcat (VarIdStr[3], ".DevicePath");
3064     }
3065   }
3066
3067   if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0])) == NULL) {
3068     goto Err;
3069   }
3070   if ((pNode[1] = new SVfrQuestionNode (Name, VarIdStr[1])) == NULL) {
3071     goto Err;
3072   }
3073   if ((pNode[2] = new SVfrQuestionNode (Name, VarIdStr[2])) == NULL) {
3074     goto Err;
3075   }
3076   if ((pNode[3] = new SVfrQuestionNode (Name, VarIdStr[3])) == NULL) {
3077     goto Err;
3078   }
3079
3080   if (QuestionId == EFI_QUESTION_ID_INVALID) {
3081     QuestionId = GetFreeQuestionId ();
3082   } else {
3083     if (ChekQuestionIdFree (QuestionId) == FALSE) {
3084       goto Err;
3085     }
3086     MarkQuestionIdUsed (QuestionId);
3087   }
3088
3089   pNode[0]->mQuestionId = QuestionId;
3090   pNode[1]->mQuestionId = QuestionId;
3091   pNode[2]->mQuestionId = QuestionId;
3092   pNode[3]->mQuestionId = QuestionId;
3093   pNode[0]->mQtype      = QUESTION_REF;
3094   pNode[1]->mQtype      = QUESTION_REF;
3095   pNode[2]->mQtype      = QUESTION_REF;
3096   pNode[3]->mQtype      = QUESTION_REF;
3097   pNode[0]->mNext       = pNode[1];
3098   pNode[1]->mNext       = pNode[2];
3099   pNode[2]->mNext       = pNode[3];
3100   pNode[3]->mNext       = mQuestionList;
3101   mQuestionList         = pNode[0];
3102
3103   gCFormPkg.DoPendingAssign (VarIdStr[0], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
3104   gCFormPkg.DoPendingAssign (VarIdStr[1], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
3105   gCFormPkg.DoPendingAssign (VarIdStr[2], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
3106   gCFormPkg.DoPendingAssign (VarIdStr[3], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
3107
3108   return;
3109
3110   Err:
3111   for (Index = 0; Index < 4; Index++) {
3112     if (pNode[Index] != NULL) {
3113       delete pNode[Index];
3114     }
3115
3116     if (VarIdStr[Index] != NULL) {
3117       delete VarIdStr[Index];
3118     }
3119   }
3120 }
3121
3122 EFI_VFR_RETURN_CODE
3123 CVfrQuestionDB::UpdateQuestionId (
3124   IN EFI_QUESTION_ID   QId,
3125   IN EFI_QUESTION_ID   NewQId
3126   )
3127 {
3128   SVfrQuestionNode *pNode = NULL;
3129
3130   if (QId == NewQId) {
3131     // don't update
3132     return VFR_RETURN_SUCCESS;
3133   }
3134
3135   //
3136   // For Framework Vfr, don't check question ID conflict.
3137   //
3138   if (!VfrCompatibleMode && ChekQuestionIdFree (NewQId) == FALSE) {
3139     return VFR_RETURN_REDEFINED;
3140   }
3141
3142   for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) {
3143     if (pNode->mQuestionId == QId) {
3144       break;
3145     }
3146   }
3147
3148   if (pNode == NULL) {
3149     return VFR_RETURN_UNDEFINED;
3150   }
3151
3152   MarkQuestionIdUnused (QId);
3153   pNode->mQuestionId = NewQId;
3154   MarkQuestionIdUsed (NewQId);
3155
3156   gCFormPkg.DoPendingAssign (pNode->mVarIdStr, (VOID *)&NewQId, sizeof(EFI_QUESTION_ID));
3157
3158   return VFR_RETURN_SUCCESS;
3159 }
3160
3161 VOID
3162 CVfrQuestionDB::GetQuestionId (
3163   IN  CHAR8             *Name,
3164   IN  CHAR8             *VarIdStr,
3165   OUT EFI_QUESTION_ID   &QuestionId,
3166   OUT UINT32            &BitMask,
3167   OUT EFI_QUESION_TYPE  *QType
3168   )
3169 {
3170   SVfrQuestionNode *pNode;
3171
3172   QuestionId = EFI_QUESTION_ID_INVALID;
3173   BitMask    = 0x00000000;
3174   if (QType != NULL) {
3175     *QType = QUESTION_NORMAL;
3176   }
3177
3178   if ((Name == NULL) && (VarIdStr == NULL)) {
3179     return ;
3180   }
3181
3182   for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) {
3183     if (Name != NULL) {
3184       if (strcmp (pNode->mName, Name) != 0) {
3185         continue;
3186       }
3187     }
3188
3189     if (VarIdStr != NULL) {
3190       if (strcmp (pNode->mVarIdStr, VarIdStr) != 0) {
3191         continue;
3192       }
3193         }
3194
3195     QuestionId = pNode->mQuestionId;
3196     BitMask    = pNode->mBitMask;
3197     if (QType != NULL) {
3198       *QType     = pNode->mQtype;
3199     }
3200     break;
3201   }
3202
3203   return ;
3204 }
3205
3206 EFI_VFR_RETURN_CODE
3207 CVfrQuestionDB::FindQuestion (
3208   IN EFI_QUESTION_ID QuestionId
3209   )
3210 {
3211   SVfrQuestionNode *pNode;
3212
3213   if (QuestionId == EFI_QUESTION_ID_INVALID) {
3214     return VFR_RETURN_INVALID_PARAMETER;
3215   }
3216
3217   for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) {
3218     if (pNode->mQuestionId == QuestionId) {
3219       return VFR_RETURN_SUCCESS;
3220     }
3221   }
3222
3223   return VFR_RETURN_UNDEFINED;
3224 }
3225
3226 EFI_VFR_RETURN_CODE
3227 CVfrQuestionDB::FindQuestion (
3228   IN CHAR8 *Name
3229   )
3230 {
3231   SVfrQuestionNode *pNode;
3232
3233   if (Name == NULL) {
3234     return VFR_RETURN_FATAL_ERROR;
3235   }
3236
3237   for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) {
3238     if (strcmp (pNode->mName, Name) == 0) {
3239       return VFR_RETURN_SUCCESS;
3240     }
3241   }
3242
3243   return VFR_RETURN_UNDEFINED;
3244 }
3245
3246 CVfrStringDB::CVfrStringDB ()
3247 {
3248   mStringFileName = NULL;
3249 }
3250
3251 CVfrStringDB::~CVfrStringDB ()
3252 {
3253   if (mStringFileName != NULL) {
3254     delete mStringFileName;
3255   }
3256   mStringFileName = NULL;
3257 }
3258
3259
3260 VOID
3261 CVfrStringDB::SetStringFileName(IN CHAR8 *StringFileName)
3262 {
3263   UINT32 FileLen = 0;
3264
3265   if (StringFileName == NULL) {
3266     return;
3267   }
3268
3269   FileLen = strlen (StringFileName) + 1;
3270   mStringFileName = new CHAR8[FileLen];
3271   if (mStringFileName == NULL) {
3272     return;
3273   }
3274
3275   strcpy (mStringFileName, StringFileName);
3276   mStringFileName[FileLen - 1] = '\0';
3277 }
3278
3279
3280 /**
3281   Returns TRUE or FALSE whether SupportedLanguages contains the best matching language
3282   from a set of supported languages.
3283
3284   @param[in]  SupportedLanguages  A pointer to a Null-terminated ASCII string that
3285                                   contains a set of language codes.
3286   @param[in]  Language            A variable that contains pointers to Null-terminated
3287                                   ASCII strings that contain one language codes.
3288
3289   @retval FALSE   The best matching language could not be found in SupportedLanguages.
3290   @retval TRUE    The best matching language could be found in SupportedLanguages.
3291
3292 **/
3293 BOOLEAN
3294 CVfrStringDB::GetBestLanguage (
3295   IN CONST CHAR8  *SupportedLanguages,
3296   IN CHAR8        *Language
3297   )
3298 {
3299   UINTN        CompareLength;
3300   UINTN        LanguageLength;
3301   CONST CHAR8  *Supported;
3302
3303   if (SupportedLanguages == NULL || Language == NULL){
3304     return FALSE;
3305   }
3306
3307   //
3308   // Determine the length of the first RFC 4646 language code in Language
3309   //
3310   for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++);
3311
3312   //
3313   // Trim back the length of Language used until it is empty
3314   //
3315   while (LanguageLength > 0) {
3316     //
3317     // Loop through all language codes in SupportedLanguages
3318     //
3319     for (Supported = SupportedLanguages; *Supported != '\0'; Supported += CompareLength) {
3320       //
3321       // Skip ';' characters in Supported
3322       //
3323       for (; *Supported != '\0' && *Supported == ';'; Supported++);
3324       //
3325       // Determine the length of the next language code in Supported
3326       //
3327       for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++);
3328       //
3329       // If Language is longer than the Supported, then skip to the next language
3330       //
3331       if (LanguageLength > CompareLength) {
3332         continue;
3333       }
3334
3335       //
3336       // See if the first LanguageLength characters in Supported match Language
3337       //
3338       if (strncmp (Supported, Language, LanguageLength) == 0) {
3339         return TRUE;
3340       }
3341     }
3342
3343     //
3344     // Trim Language from the right to the next '-' character
3345     //
3346     for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--);
3347   }
3348
3349   //
3350   // No matches were found
3351   //
3352   return FALSE;
3353 }
3354
3355
3356 CHAR8 *
3357 CVfrStringDB::GetVarStoreNameFormStringId (
3358   IN EFI_STRING_ID StringId
3359   )
3360 {
3361   FILE        *pInFile    = NULL;
3362   UINT32      NameOffset;
3363   UINT32      Length;
3364   UINT8       *StringPtr;
3365   CHAR8       *StringName;
3366   CHAR16      *UnicodeString;
3367   CHAR8       *VarStoreName = NULL;
3368   CHAR8       *DestTmp;
3369   UINT8       *Current;
3370   EFI_STATUS  Status;
3371   CHAR8       LineBuf[EFI_IFR_MAX_LENGTH];
3372   UINT8       BlockType;
3373   EFI_HII_STRING_PACKAGE_HDR *PkgHeader;
3374
3375   if (mStringFileName == '\0' ) {
3376     return NULL;
3377   }
3378
3379   if ((pInFile = fopen (LongFilePath (mStringFileName), "rb")) == NULL) {
3380     return NULL;
3381   }
3382
3383   //
3384   // Get file length.
3385   //
3386   fseek (pInFile, 0, SEEK_END);
3387   Length = ftell (pInFile);
3388   fseek (pInFile, 0, SEEK_SET);
3389
3390   //
3391   // Get file data.
3392   //
3393   StringPtr = new UINT8[Length];
3394   if (StringPtr == NULL) {
3395     fclose (pInFile);
3396     return NULL;
3397   }
3398   fread ((char *)StringPtr, sizeof (UINT8), Length, pInFile);
3399   fclose (pInFile);
3400
3401   PkgHeader = (EFI_HII_STRING_PACKAGE_HDR *) StringPtr;
3402   //
3403   // Check the String package.
3404   //
3405   if (PkgHeader->Header.Type != EFI_HII_PACKAGE_STRINGS) {
3406     delete[] StringPtr;
3407     return NULL;
3408   }
3409
3410   //
3411   // Search the language, get best language base on RFC 4647 matching algorithm.
3412   //
3413   Current = StringPtr;
3414   while (!GetBestLanguage ("en", PkgHeader->Language)) {
3415     Current += PkgHeader->Header.Length;
3416     PkgHeader = (EFI_HII_STRING_PACKAGE_HDR *) Current;
3417     //
3418     // If can't find string package base on language, just return the first string package.
3419     //
3420     if (Current - StringPtr >= Length) {
3421       Current = StringPtr;
3422       PkgHeader = (EFI_HII_STRING_PACKAGE_HDR *) StringPtr;
3423       break;
3424     }
3425   }
3426
3427   Current += PkgHeader->HdrSize;
3428   //
3429   // Find the string block according the stringId.
3430   //
3431   Status = FindStringBlock(Current, StringId, &NameOffset, &BlockType);
3432   if (Status != EFI_SUCCESS) {
3433     delete[] StringPtr;
3434     return NULL;
3435   }
3436
3437   //
3438   // Get varstore name according the string type.
3439   //
3440   switch (BlockType) {
3441   case EFI_HII_SIBT_STRING_SCSU:
3442   case EFI_HII_SIBT_STRING_SCSU_FONT:
3443   case EFI_HII_SIBT_STRINGS_SCSU:
3444   case EFI_HII_SIBT_STRINGS_SCSU_FONT:
3445     StringName = (CHAR8*)(Current + NameOffset);
3446     VarStoreName = new CHAR8[strlen(StringName) + 1];
3447     strcpy (VarStoreName, StringName);
3448     break;
3449   case EFI_HII_SIBT_STRING_UCS2:
3450   case EFI_HII_SIBT_STRING_UCS2_FONT:
3451   case EFI_HII_SIBT_STRINGS_UCS2:
3452   case EFI_HII_SIBT_STRINGS_UCS2_FONT:
3453     UnicodeString = (CHAR16*)(Current + NameOffset);
3454     Length = GetUnicodeStringTextSize ((UINT8*)UnicodeString) ;
3455     DestTmp = new CHAR8[Length / 2 + 1];
3456     VarStoreName = DestTmp;
3457     while (*UnicodeString != '\0') {
3458       *(DestTmp++) = (CHAR8) *(UnicodeString++);
3459     }
3460     *DestTmp = '\0';
3461     break;
3462   default:
3463     break;
3464   }
3465
3466   delete[] StringPtr;
3467
3468   return VarStoreName;
3469 }
3470
3471 EFI_STATUS
3472 CVfrStringDB::FindStringBlock (
3473   IN  UINT8                           *StringData,
3474   IN  EFI_STRING_ID                   StringId,
3475   OUT UINT32                          *StringTextOffset,
3476   OUT UINT8                           *BlockType
3477   )
3478 {
3479   UINT8                                *BlockHdr;
3480   EFI_STRING_ID                        CurrentStringId;
3481   UINT32                               BlockSize;
3482   UINT32                               Index;
3483   UINT8                                *StringTextPtr;
3484   UINT32                               Offset;
3485   UINT16                               StringCount;
3486   UINT16                               SkipCount;
3487   UINT8                                Length8;
3488   EFI_HII_SIBT_EXT2_BLOCK              Ext2;
3489   UINT32                               Length32;
3490   UINT32                               StringSize;
3491
3492   CurrentStringId = 1;
3493
3494   //
3495   // Parse the string blocks to get the string text and font.
3496   //
3497   BlockHdr  = StringData;
3498   BlockSize = 0;
3499   Offset    = 0;
3500   while (*BlockHdr != EFI_HII_SIBT_END) {
3501     switch (*BlockHdr) {
3502     case EFI_HII_SIBT_STRING_SCSU:
3503       Offset = sizeof (EFI_HII_STRING_BLOCK);
3504       StringTextPtr = BlockHdr + Offset;
3505       BlockSize += Offset + strlen ((CHAR8 *) StringTextPtr) + 1;
3506       CurrentStringId++;
3507       break;
3508
3509     case EFI_HII_SIBT_STRING_SCSU_FONT:
3510       Offset = sizeof (EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK) - sizeof (UINT8);
3511       StringTextPtr = BlockHdr + Offset;
3512       BlockSize += Offset + strlen ((CHAR8 *) StringTextPtr) + 1;
3513       CurrentStringId++;
3514       break;
3515
3516     case EFI_HII_SIBT_STRINGS_SCSU:
3517       memcpy (&StringCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16));
3518       StringTextPtr = BlockHdr + sizeof (EFI_HII_SIBT_STRINGS_SCSU_BLOCK) - sizeof (UINT8);
3519       BlockSize += StringTextPtr - BlockHdr;
3520
3521       for (Index = 0; Index < StringCount; Index++) {
3522         BlockSize += strlen ((CHAR8 *) StringTextPtr) + 1;
3523         if (CurrentStringId == StringId) {
3524           *BlockType        = *BlockHdr;
3525           *StringTextOffset = StringTextPtr - StringData;
3526           return EFI_SUCCESS;
3527         }
3528         StringTextPtr = StringTextPtr + strlen ((CHAR8 *) StringTextPtr) + 1;
3529         CurrentStringId++;
3530       }
3531       break;
3532
3533     case EFI_HII_SIBT_STRINGS_SCSU_FONT:
3534       memcpy (
3535         &StringCount,
3536         BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8),
3537         sizeof (UINT16)
3538         );
3539       StringTextPtr = BlockHdr + sizeof (EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK) - sizeof (UINT8);
3540       BlockSize += StringTextPtr - BlockHdr;
3541
3542       for (Index = 0; Index < StringCount; Index++) {
3543         BlockSize += strlen ((CHAR8 *) StringTextPtr) + 1;
3544         if (CurrentStringId == StringId) {
3545           *BlockType        = *BlockHdr;
3546           *StringTextOffset = StringTextPtr - StringData;
3547           return EFI_SUCCESS;
3548         }
3549         StringTextPtr = StringTextPtr + strlen ((CHAR8 *) StringTextPtr) + 1;
3550         CurrentStringId++;
3551       }
3552       break;
3553
3554     case EFI_HII_SIBT_STRING_UCS2:
3555       Offset        = sizeof (EFI_HII_STRING_BLOCK);
3556       StringTextPtr = BlockHdr + Offset;
3557       //
3558       // Use StringSize to store the size of the specified string, including the NULL
3559       // terminator.
3560       //
3561       StringSize = GetUnicodeStringTextSize (StringTextPtr);
3562       BlockSize += Offset + StringSize;
3563       CurrentStringId++;
3564       break;
3565
3566     case EFI_HII_SIBT_STRING_UCS2_FONT:
3567       Offset = sizeof (EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK)  - sizeof (CHAR16);
3568       StringTextPtr = BlockHdr + Offset;
3569       //
3570       // Use StrSize to store the size of the specified string, including the NULL
3571       // terminator.
3572       //
3573       StringSize = GetUnicodeStringTextSize (StringTextPtr);
3574       BlockSize += Offset + StringSize;
3575       CurrentStringId++;
3576       break;
3577
3578     case EFI_HII_SIBT_STRINGS_UCS2:
3579       Offset = sizeof (EFI_HII_SIBT_STRINGS_UCS2_BLOCK) - sizeof (CHAR16);
3580       StringTextPtr = BlockHdr + Offset;
3581       BlockSize += Offset;
3582       memcpy (&StringCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16));
3583       for (Index = 0; Index < StringCount; Index++) {
3584         StringSize = GetUnicodeStringTextSize (StringTextPtr);
3585         BlockSize += StringSize;
3586         if (CurrentStringId == StringId) {
3587           *BlockType        = *BlockHdr;
3588           *StringTextOffset = StringTextPtr - StringData;
3589           return EFI_SUCCESS;
3590         }
3591         StringTextPtr = StringTextPtr + StringSize;
3592         CurrentStringId++;
3593       }
3594       break;
3595
3596     case EFI_HII_SIBT_STRINGS_UCS2_FONT:
3597       Offset = sizeof (EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK) - sizeof (CHAR16);
3598       StringTextPtr = BlockHdr + Offset;
3599       BlockSize += Offset;
3600       memcpy (
3601         &StringCount,
3602         BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8),
3603         sizeof (UINT16)
3604         );
3605       for (Index = 0; Index < StringCount; Index++) {
3606         StringSize = GetUnicodeStringTextSize (StringTextPtr);
3607         BlockSize += StringSize;
3608         if (CurrentStringId == StringId) {
3609           *BlockType        = *BlockHdr;
3610           *StringTextOffset = StringTextPtr - StringData;
3611           return EFI_SUCCESS;
3612         }
3613         StringTextPtr = StringTextPtr + StringSize;
3614         CurrentStringId++;
3615       }
3616       break;
3617
3618     case EFI_HII_SIBT_DUPLICATE:
3619       if (CurrentStringId == StringId) {
3620         //
3621         // Incoming StringId is an id of a duplicate string block.
3622         // Update the StringId to be the previous string block.
3623         // Go back to the header of string block to search.
3624         //
3625         memcpy (
3626           &StringId,
3627           BlockHdr + sizeof (EFI_HII_STRING_BLOCK),
3628           sizeof (EFI_STRING_ID)
3629           );
3630         CurrentStringId = 1;
3631         BlockSize       = 0;
3632       } else {
3633         BlockSize       += sizeof (EFI_HII_SIBT_DUPLICATE_BLOCK);
3634         CurrentStringId++;
3635       }
3636       break;
3637
3638     case EFI_HII_SIBT_SKIP1:
3639       SkipCount = (UINT16) (*(BlockHdr + sizeof (EFI_HII_STRING_BLOCK)));
3640       CurrentStringId = (UINT16) (CurrentStringId + SkipCount);
3641       BlockSize       +=  sizeof (EFI_HII_SIBT_SKIP1_BLOCK);
3642       break;
3643
3644     case EFI_HII_SIBT_SKIP2:
3645       memcpy (&SkipCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16));
3646       CurrentStringId = (UINT16) (CurrentStringId + SkipCount);
3647       BlockSize       +=  sizeof (EFI_HII_SIBT_SKIP2_BLOCK);
3648       break;
3649
3650     case EFI_HII_SIBT_EXT1:
3651       memcpy (
3652         &Length8,
3653         BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8),
3654         sizeof (UINT8)
3655         );
3656       BlockSize += Length8;
3657       break;
3658
3659     case EFI_HII_SIBT_EXT2:
3660       memcpy (&Ext2, BlockHdr, sizeof (EFI_HII_SIBT_EXT2_BLOCK));
3661       BlockSize += Ext2.Length;
3662       break;
3663
3664     case EFI_HII_SIBT_EXT4:
3665       memcpy (
3666         &Length32,
3667         BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8),
3668         sizeof (UINT32)
3669         );
3670
3671       BlockSize += Length32;
3672       break;
3673
3674     default:
3675       break;
3676     }
3677
3678     if (StringId > 0 && StringId != (EFI_STRING_ID)(-1)) {
3679       *StringTextOffset = BlockHdr - StringData + Offset;
3680       *BlockType        = *BlockHdr;
3681
3682       if (StringId == CurrentStringId - 1) {
3683         //
3684         // if only one skip item, return EFI_NOT_FOUND.
3685         //
3686         if(*BlockType == EFI_HII_SIBT_SKIP2 || *BlockType == EFI_HII_SIBT_SKIP1) {
3687           return EFI_NOT_FOUND;
3688         } else {
3689           return EFI_SUCCESS;
3690         }
3691       }
3692
3693       if (StringId < CurrentStringId - 1) {
3694         return EFI_NOT_FOUND;
3695       }
3696     }
3697     BlockHdr  = StringData + BlockSize;
3698   }
3699
3700   return EFI_NOT_FOUND;
3701 }
3702
3703 UINT32
3704 CVfrStringDB::GetUnicodeStringTextSize (
3705   IN  UINT8            *StringSrc
3706   )
3707 {
3708   UINT32 StringSize;
3709   CHAR16 *StringPtr;
3710
3711   StringSize = sizeof (CHAR16);
3712   StringPtr  = (UINT16*)StringSrc;
3713   while (*StringPtr++ != L'\0') {
3714     StringSize += sizeof (CHAR16);
3715   }
3716
3717   return StringSize;
3718 }
3719
3720 BOOLEAN  VfrCompatibleMode = FALSE;
3721
3722 CVfrVarDataTypeDB gCVfrVarDataTypeDB;
3723 CVfrDefaultStore  gCVfrDefaultStore;
3724 CVfrDataStorage  gCVfrDataStorage;
3725
3726