BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp

   1 /** @file
   2
   3   The definition of CFormPkg's member function
   4
   5 Copyright (c) 2004 - 2013, 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 "VfrFormPkg.h"
  18
  19 /*
  20  * The definition of CFormPkg's member function
  21  */
  22
  23 SPendingAssign::SPendingAssign (
  24   IN CHAR8  *Key,
  25   IN VOID   *Addr,
  26   IN UINT32 Len,
  27   IN UINT32 LineNo,
  28   IN CONST CHAR8  *Msg
  29   )
  30 {
  31   mKey    = NULL;
  32   mAddr   = Addr;
  33   mLen    = Len;
  34   mFlag   = PENDING;
  35   mLineNo = LineNo;
  36   mMsg    = NULL;
  37   mNext   = NULL;
  38   if (Key != NULL) {
  39     mKey = new CHAR8[strlen (Key) + 1];
  40     if (mKey != NULL) {
  41       strcpy (mKey, Key);
  42     }
  43   }
  44
  45   if (Msg != NULL) {
  46     mMsg = new CHAR8[strlen (Msg) + 1];
  47     if (mMsg != NULL) {
  48       strcpy (mMsg, Msg);
  49     }
  50   }
  51 }
  52
  53 SPendingAssign::~SPendingAssign (
  54   VOID
  55   )
  56 {
  57   if (mKey != NULL) {
  58     delete mKey;
  59   }
  60   mAddr   = NULL;
  61   mLen    = 0;
  62   mLineNo = 0;
  63   if (mMsg != NULL) {
  64     delete mMsg;
  65   }
  66   mNext   = NULL;
  67 }
  68
  69 VOID
  70 SPendingAssign::SetAddrAndLen (
  71   IN VOID   *Addr,
  72   IN UINT32 LineNo
  73   )
  74 {
  75   mAddr   = Addr;
  76   mLineNo = LineNo;
  77 }
  78
  79 VOID
  80 SPendingAssign::AssignValue (
  81   IN VOID   *Addr,
  82   IN UINT32 Len
  83   )
  84 {
  85   memmove (mAddr, Addr, (mLen < Len ? mLen : Len));
  86   mFlag = ASSIGNED;
  87 }
  88
  89 CHAR8 *
  90 SPendingAssign::GetKey (
  91   VOID
  92   )
  93 {
  94   return mKey;
  95 }
  96
  97 CFormPkg::CFormPkg (
  98   IN UINT32 BufferSize
  99   )
 100 {
 101   CHAR8       *BufferStart;
 102   CHAR8       *BufferEnd;
 103   SBufferNode *Node;
 104
 105   mPkgLength           = 0;
 106   mBufferNodeQueueHead = NULL;
 107   mCurrBufferNode      = NULL;
 108
 109   Node = new SBufferNode;
 110   if (Node == NULL) {
 111     return ;
 112   }
 113   BufferStart = new CHAR8[BufferSize];
 114   if (BufferStart == NULL) {
 115     return;
 116   }
 117   BufferEnd   = BufferStart + BufferSize;
 118
 119   memset (BufferStart, 0, BufferSize);
 120   Node->mBufferStart   = BufferStart;
 121   Node->mBufferEnd     = BufferEnd;
 122   Node->mBufferFree    = BufferStart;
 123   Node->mNext          = NULL;
 124
 125   mBufferSize          = BufferSize;
 126   mBufferNodeQueueHead = Node;
 127   mBufferNodeQueueTail = Node;
 128   mCurrBufferNode      = Node;
 129 }
 130
 131 CFormPkg::~CFormPkg ()
 132 {
 133   SBufferNode    *pBNode;
 134   SPendingAssign *pPNode;
 135
 136   while (mBufferNodeQueueHead != NULL) {
 137     pBNode = mBufferNodeQueueHead;
 138     mBufferNodeQueueHead = mBufferNodeQueueHead->mNext;
 139     if (pBNode->mBufferStart != NULL) {
 140       delete pBNode->mBufferStart;
 141       delete pBNode;
 142     }
 143   }
 144   mBufferNodeQueueTail = NULL;
 145   mCurrBufferNode      = NULL;
 146
 147   while (PendingAssignList != NULL) {
 148     pPNode = PendingAssignList;
 149     PendingAssignList = PendingAssignList->mNext;
 150     delete pPNode;
 151   }
 152   PendingAssignList = NULL;
 153 }
 154
 155 SBufferNode *
 156 CFormPkg::CreateNewNode (
 157   VOID
 158   )
 159 {
 160   SBufferNode *Node;
 161
 162   Node = new SBufferNode;
 163   if (Node == NULL) {
 164     return NULL;
 165   }
 166
 167   Node->mBufferStart = new CHAR8[mBufferSize];
 168   if (Node->mBufferStart == NULL) {
 169     delete Node;
 170     return NULL;
 171   } else {
 172     memset (Node->mBufferStart, 0, mBufferSize);
 173     Node->mBufferEnd  = Node->mBufferStart + mBufferSize;
 174     Node->mBufferFree = Node->mBufferStart;
 175     Node->mNext       = NULL;
 176   }
 177
 178   return Node;
 179 }
 180
 181 CHAR8 *
 182 CFormPkg::IfrBinBufferGet (
 183   IN UINT32 Len
 184   )
 185 {
 186   CHAR8       *BinBuffer = NULL;
 187   SBufferNode *Node      = NULL;
 188
 189   if ((Len == 0) || (Len > mBufferSize)) {
 190     return NULL;
 191   }
 192
 193   if ((mCurrBufferNode->mBufferFree + Len) <= mCurrBufferNode->mBufferEnd) {
 194     BinBuffer = mCurrBufferNode->mBufferFree;
 195     mCurrBufferNode->mBufferFree += Len;
 196   } else {
 197     Node = CreateNewNode ();
 198     if (Node == NULL) {
 199       return NULL;
 200     }
 201
 202     if (mBufferNodeQueueTail == NULL) {
 203       mBufferNodeQueueHead = mBufferNodeQueueTail = Node;
 204     } else {
 205       mBufferNodeQueueTail->mNext = Node;
 206       mBufferNodeQueueTail = Node;
 207     }
 208     mCurrBufferNode = Node;
 209
 210     //
 211     // Now try again.
 212     //
 213     BinBuffer = mCurrBufferNode->mBufferFree;
 214     mCurrBufferNode->mBufferFree += Len;
 215   }
 216
 217   mPkgLength += Len;
 218
 219   return BinBuffer;
 220 }
 221
 222 inline
 223 UINT32
 224 CFormPkg::GetPkgLength (
 225   VOID
 226   )
 227 {
 228   return mPkgLength;
 229 }
 230
 231 VOID
 232 CFormPkg::Open (
 233   VOID
 234   )
 235 {
 236   mReadBufferNode   = mBufferNodeQueueHead;
 237   mReadBufferOffset = 0;
 238 }
 239
 240 VOID
 241 CFormPkg::Close (
 242   VOID
 243   )
 244 {
 245   mReadBufferNode   = NULL;
 246   mReadBufferOffset = 0;
 247 }
 248
 249 UINT32
 250 CFormPkg::Read (
 251   IN CHAR8     *Buffer,
 252   IN UINT32    Size
 253   )
 254 {
 255   UINT32       Index;
 256
 257   if ((Size == 0) || (Buffer == NULL)) {
 258     return 0;
 259   }
 260
 261   if (mReadBufferNode == NULL) {
 262     return 0;
 263   }
 264
 265   for (Index = 0; Index < Size; Index++) {
 266     if ((mReadBufferNode->mBufferStart + mReadBufferOffset) < mReadBufferNode->mBufferFree) {
 267       Buffer[Index] = mReadBufferNode->mBufferStart[mReadBufferOffset++];
 268     } else {
 269       if ((mReadBufferNode = mReadBufferNode->mNext) == NULL) {
 270         return Index;
 271       } else {
 272         mReadBufferOffset = 0;
 273         Index --;
 274       }
 275     }
 276   }
 277
 278   return Size;
 279 }
 280
 281 EFI_VFR_RETURN_CODE
 282 CFormPkg::BuildPkgHdr (
 283   OUT EFI_HII_PACKAGE_HEADER **PkgHdr
 284   )
 285 {
 286   if (PkgHdr == NULL) {
 287     return VFR_RETURN_FATAL_ERROR;
 288   }
 289
 290   if (((*PkgHdr) = new EFI_HII_PACKAGE_HEADER) == NULL) {
 291     return VFR_RETURN_OUT_FOR_RESOURCES;
 292   }
 293
 294   (*PkgHdr)->Type = EFI_HII_PACKAGE_FORM;
 295   (*PkgHdr)->Length = mPkgLength + sizeof (EFI_HII_PACKAGE_HEADER);
 296
 297   return VFR_RETURN_SUCCESS;
 298 }
 299
 300 EFI_VFR_RETURN_CODE
 301 CFormPkg::BuildPkg (
 302   OUT PACKAGE_DATA &TBuffer
 303   )
 304 {
 305
 306   CHAR8  *Temp;
 307   UINT32 Size;
 308   CHAR8  Buffer[1024];
 309
 310   if (TBuffer.Buffer != NULL) {
 311     delete TBuffer.Buffer;
 312   }
 313
 314   TBuffer.Size = mPkgLength;
 315   TBuffer.Buffer = NULL;
 316   if (TBuffer.Size != 0) {
 317     TBuffer.Buffer = new CHAR8[TBuffer.Size];
 318   } else {
 319     return VFR_RETURN_SUCCESS;
 320   }
 321
 322   Temp = TBuffer.Buffer;
 323   Open ();
 324   while ((Size = Read (Buffer, 1024)) != 0) {
 325     memcpy (Temp, Buffer, Size);
 326     Temp += Size;
 327   }
 328   Close ();
 329   return VFR_RETURN_SUCCESS;
 330 }
 331
 332
 333 EFI_VFR_RETURN_CODE
 334 CFormPkg::BuildPkg (
 335   IN FILE  *Output,
 336   IN PACKAGE_DATA *PkgData
 337   )
 338 {
 339   EFI_VFR_RETURN_CODE     Ret;
 340   CHAR8                   Buffer[1024];
 341   UINT32                  Size;
 342   EFI_HII_PACKAGE_HEADER  *PkgHdr;
 343
 344   if (Output == NULL) {
 345     return VFR_RETURN_FATAL_ERROR;
 346   }
 347
 348   if ((Ret = BuildPkgHdr(&PkgHdr)) != VFR_RETURN_SUCCESS) {
 349     return Ret;
 350   }
 351   fwrite (PkgHdr, sizeof (EFI_HII_PACKAGE_HEADER), 1, Output);
 352   delete PkgHdr;
 353
 354   if (PkgData == NULL) {
 355     Open ();
 356     while ((Size = Read (Buffer, 1024)) != 0) {
 357       fwrite (Buffer, Size, 1, Output);
 358     }
 359     Close ();
 360   } else {
 361     fwrite (PkgData->Buffer, PkgData->Size, 1, Output);
 362   }
 363
 364   return VFR_RETURN_SUCCESS;
 365 }
 366
 367 VOID
 368 CFormPkg::_WRITE_PKG_LINE (
 369   IN FILE         *pFile,
 370   IN UINT32       LineBytes,
 371   IN CONST CHAR8  *LineHeader,
 372   IN CHAR8        *BlkBuf,
 373   IN UINT32       BlkSize
 374   )
 375 {
 376   UINT32    Index;
 377
 378   if ((pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
 379     return;
 380   }
 381
 382   for (Index = 0; Index < BlkSize; Index++) {
 383     if ((Index % LineBytes) == 0) {
 384       fprintf (pFile, "\n%s", LineHeader);
 385     }
 386     fprintf (pFile, "0x%02X,  ", (UINT8)BlkBuf[Index]);
 387   }
 388 }
 389
 390 VOID
 391 CFormPkg::_WRITE_PKG_END (
 392   IN FILE         *pFile,
 393   IN UINT32       LineBytes,
 394   IN CONST CHAR8  *LineHeader,
 395   IN CHAR8        *BlkBuf,
 396   IN UINT32       BlkSize
 397   )
 398 {
 399   UINT32    Index;
 400
 401   if ((BlkSize == 0) || (pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
 402     return;
 403   }
 404
 405   for (Index = 0; Index < BlkSize - 1; Index++) {
 406     if ((Index % LineBytes) == 0) {
 407       fprintf (pFile, "\n%s", LineHeader);
 408     }
 409     fprintf (pFile, "0x%02X,  ", (UINT8)BlkBuf[Index]);
 410   }
 411
 412   if ((Index % LineBytes) == 0) {
 413     fprintf (pFile, "\n%s", LineHeader);
 414   }
 415   fprintf (pFile, "0x%02X\n", (UINT8)BlkBuf[Index]);
 416 }
 417
 418 #define BYTES_PRE_LINE 0x10
 419 UINT32   gAdjustOpcodeOffset = 0;
 420 BOOLEAN  gNeedAdjustOpcode   = FALSE;
 421 UINT32   gAdjustOpcodeLen    = 0;
 422
 423 EFI_VFR_RETURN_CODE
 424 CFormPkg::GenCFile (
 425   IN CHAR8 *BaseName,
 426   IN FILE *pFile,
 427   IN PACKAGE_DATA *PkgData
 428   )
 429 {
 430   EFI_VFR_RETURN_CODE          Ret;
 431   CHAR8                        Buffer[BYTES_PRE_LINE * 8];
 432   EFI_HII_PACKAGE_HEADER       *PkgHdr;
 433   UINT32                       PkgLength  = 0;
 434   UINT32                       ReadSize   = 0;
 435
 436   if ((BaseName == NULL) || (pFile == NULL)) {
 437     return VFR_RETURN_FATAL_ERROR;
 438   }
 439
 440   fprintf (pFile, "\nunsigned char %sBin[] = {\n", BaseName);
 441
 442   if ((Ret = BuildPkgHdr(&PkgHdr)) != VFR_RETURN_SUCCESS) {
 443     return Ret;
 444   }
 445
 446   //
 447   // For framework vfr file, the extension framework header will be added.
 448   //
 449   if (VfrCompatibleMode) {
 450           fprintf (pFile, "  // FRAMEWORK PACKAGE HEADER Length\n");
 451           PkgLength = PkgHdr->Length + sizeof (UINT32) + 2;
 452           _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&PkgLength, sizeof (UINT32));
 453           fprintf (pFile, "\n\n  // FRAMEWORK PACKAGE HEADER Type\n");
 454           PkgLength = 3;
 455           _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&PkgLength, sizeof (UINT16));
 456         } else {
 457           fprintf (pFile, "  // ARRAY LENGTH\n");
 458           PkgLength = PkgHdr->Length + sizeof (UINT32);
 459           _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)&PkgLength, sizeof (UINT32));
 460         }
 461
 462   fprintf (pFile, "\n\n  // PACKAGE HEADER\n");
 463   _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, "  ", (CHAR8 *)PkgHdr, sizeof (EFI_HII_PACKAGE_HEADER));
 464   PkgLength = sizeof (EFI_HII_PACKAGE_HEADER);
 465
 466   fprintf (pFile, "\n\n  // PACKAGE DATA\n");
 467
 468   if (PkgData == NULL) {
 469     Open ();
 470     while ((ReadSize = Read ((CHAR8 *)Buffer, BYTES_PRE_LINE * 8)) != 0) {
 471       PkgLength += ReadSize;
 472       if (PkgLength < PkgHdr->Length) {
 473         _WRITE_PKG_LINE (pFile, BYTES_PRE_LINE, "  ", Buffer, ReadSize);
 474       } else {
 475         _WRITE_PKG_END (pFile, BYTES_PRE_LINE, "  ", Buffer, ReadSize);
 476       }
 477     }
 478     Close ();
 479   } else {
 480     if (PkgData->Size % BYTES_PRE_LINE != 0) {
 481       PkgLength = PkgData->Size - (PkgData->Size % BYTES_PRE_LINE);
 482       _WRITE_PKG_LINE (pFile, BYTES_PRE_LINE, "  ", PkgData->Buffer, PkgLength);
 483       _WRITE_PKG_END (pFile, BYTES_PRE_LINE, "  ", PkgData->Buffer + PkgLength, PkgData->Size % BYTES_PRE_LINE);
 484     } else {
 485       PkgLength = PkgData->Size - BYTES_PRE_LINE;
 486       _WRITE_PKG_LINE (pFile, BYTES_PRE_LINE, "  ", PkgData->Buffer, PkgLength);
 487       _WRITE_PKG_END (pFile, BYTES_PRE_LINE, "  ", PkgData->Buffer + PkgLength, BYTES_PRE_LINE);
 488     }
 489   }
 490
 491   delete PkgHdr;
 492   fprintf (pFile, "\n};\n");
 493
 494   return VFR_RETURN_SUCCESS;
 495 }
 496
 497 EFI_VFR_RETURN_CODE
 498 CFormPkg::AssignPending (
 499   IN CHAR8  *Key,
 500   IN VOID   *ValAddr,
 501   IN UINT32 ValLen,
 502   IN UINT32 LineNo,
 503   IN CONST CHAR8  *Msg
 504   )
 505 {
 506   SPendingAssign *pNew;
 507
 508   pNew = new SPendingAssign (Key, ValAddr, ValLen, LineNo, Msg);
 509   if (pNew == NULL) {
 510     return VFR_RETURN_OUT_FOR_RESOURCES;
 511   }
 512
 513   pNew->mNext       = PendingAssignList;
 514   PendingAssignList = pNew;
 515   return VFR_RETURN_SUCCESS;
 516 }
 517
 518 VOID
 519 CFormPkg::DoPendingAssign (
 520   IN CHAR8  *Key,
 521   IN VOID   *ValAddr,
 522   IN UINT32 ValLen
 523   )
 524 {
 525   SPendingAssign *pNode;
 526
 527   if ((Key == NULL) || (ValAddr == NULL)) {
 528     return;
 529   }
 530
 531   for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
 532     if (strcmp (pNode->mKey, Key) == 0) {
 533       pNode->AssignValue (ValAddr, ValLen);
 534     }
 535   }
 536 }
 537
 538 bool
 539 CFormPkg::HavePendingUnassigned (
 540   VOID
 541   )
 542 {
 543   SPendingAssign *pNode;
 544
 545   for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
 546     if (pNode->mFlag == PENDING) {
 547       return TRUE;
 548     }
 549   }
 550
 551   return FALSE;
 552 }
 553
 554 VOID
 555 CFormPkg::PendingAssignPrintAll (
 556   VOID
 557   )
 558 {
 559   SPendingAssign *pNode;
 560
 561   for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
 562     if (pNode->mFlag == PENDING) {
 563       gCVfrErrorHandle.PrintMsg (pNode->mLineNo, pNode->mKey, "Error", pNode->mMsg);
 564     }
 565   }
 566 }
 567
 568 SBufferNode *
 569 CFormPkg::GetBinBufferNodeForAddr (
 570   IN CHAR8              *BinBuffAddr
 571   )
 572 {
 573   SBufferNode *TmpNode;
 574
 575   TmpNode = mBufferNodeQueueHead;
 576
 577   while (TmpNode != NULL) {
 578     if (TmpNode->mBufferStart <= BinBuffAddr && TmpNode->mBufferFree >= BinBuffAddr) {
 579       return TmpNode;
 580     }
 581
 582     TmpNode = TmpNode->mNext;
 583   }
 584
 585   return NULL;
 586 }
 587
 588 SBufferNode *
 589 CFormPkg::GetNodeBefore(
 590   IN SBufferNode *CurrentNode
 591   )
 592 {
 593   SBufferNode *FirstNode   = mBufferNodeQueueHead;
 594   SBufferNode *LastNode    = mBufferNodeQueueHead;
 595
 596   while (FirstNode != NULL) {
 597     if (FirstNode == CurrentNode) {
 598       break;
 599     }
 600
 601     LastNode    = FirstNode;
 602     FirstNode   = FirstNode->mNext;
 603   }
 604
 605   if (FirstNode == NULL) {
 606     LastNode = NULL;
 607   }
 608
 609   return LastNode;
 610 }
 611
 612 EFI_VFR_RETURN_CODE
 613 CFormPkg::InsertNodeBefore(
 614   IN SBufferNode *CurrentNode,
 615   IN SBufferNode *NewNode
 616   )
 617 {
 618   SBufferNode *LastNode = GetNodeBefore (CurrentNode);
 619
 620   if (LastNode == NULL) {
 621     return VFR_RETURN_MISMATCHED;
 622   }
 623
 624   NewNode->mNext = LastNode->mNext;
 625   LastNode->mNext = NewNode;
 626
 627   return VFR_RETURN_SUCCESS;
 628 }
 629
 630 CHAR8 *
 631 CFormPkg::GetBufAddrBaseOnOffset (
 632   IN UINT32      Offset
 633   )
 634 {
 635   SBufferNode *TmpNode;
 636   UINT32      TotalBufLen;
 637   UINT32      CurrentBufLen;
 638
 639   TotalBufLen = 0;
 640
 641   for (TmpNode = mBufferNodeQueueHead; TmpNode != NULL; TmpNode = TmpNode->mNext) {
 642     CurrentBufLen = TmpNode->mBufferFree - TmpNode->mBufferStart;
 643     if (Offset >= TotalBufLen && Offset < TotalBufLen + CurrentBufLen) {
 644       return TmpNode->mBufferStart + (Offset - TotalBufLen);
 645     }
 646
 647     TotalBufLen += CurrentBufLen;
 648   }
 649
 650   return NULL;
 651 }
 652
 653 EFI_VFR_RETURN_CODE
 654 CFormPkg::AdjustDynamicInsertOpcode (
 655   IN CHAR8              *LastFormEndAddr,
 656   IN CHAR8              *InsertOpcodeAddr
 657   )
 658 {
 659   SBufferNode *LastFormEndNode;
 660   SBufferNode *InsertOpcodeNode;
 661   SBufferNode *NewRestoreNodeBegin;
 662   SBufferNode *NewRestoreNodeEnd;
 663   SBufferNode *NewLastEndNode;
 664   SBufferNode *TmpNode;
 665   UINT32      NeedRestoreCodeLen;
 666
 667   NewRestoreNodeEnd = NULL;
 668
 669   LastFormEndNode  = GetBinBufferNodeForAddr(LastFormEndAddr);
 670   InsertOpcodeNode = GetBinBufferNodeForAddr(InsertOpcodeAddr);
 671
 672   if (LastFormEndNode == InsertOpcodeNode) {
 673     //
 674     // Create New Node to save the restore opcode.
 675     //
 676     NeedRestoreCodeLen = InsertOpcodeAddr - LastFormEndAddr;
 677     gAdjustOpcodeLen   = NeedRestoreCodeLen;
 678     NewRestoreNodeBegin = CreateNewNode ();
 679     if (NewRestoreNodeBegin == NULL) {
 680       return VFR_RETURN_OUT_FOR_RESOURCES;
 681     }
 682     memcpy (NewRestoreNodeBegin->mBufferFree, LastFormEndAddr, NeedRestoreCodeLen);
 683     NewRestoreNodeBegin->mBufferFree += NeedRestoreCodeLen;
 684
 685     //
 686     // Override the restore buffer data.
 687     //
 688     memmove (LastFormEndAddr, InsertOpcodeAddr, InsertOpcodeNode->mBufferFree - InsertOpcodeAddr);
 689     InsertOpcodeNode->mBufferFree -= NeedRestoreCodeLen;
 690     memset (InsertOpcodeNode->mBufferFree, 0, NeedRestoreCodeLen);
 691   } else {
 692     //
 693     // Create New Node to save the restore opcode.
 694     //
 695     NeedRestoreCodeLen = LastFormEndNode->mBufferFree - LastFormEndAddr;
 696     gAdjustOpcodeLen   = NeedRestoreCodeLen;
 697     NewRestoreNodeBegin = CreateNewNode ();
 698     if (NewRestoreNodeBegin == NULL) {
 699       return VFR_RETURN_OUT_FOR_RESOURCES;
 700     }
 701     memcpy (NewRestoreNodeBegin->mBufferFree, LastFormEndAddr, NeedRestoreCodeLen);
 702     NewRestoreNodeBegin->mBufferFree += NeedRestoreCodeLen;
 703     //
 704     // Override the restore buffer data.
 705     //
 706     LastFormEndNode->mBufferFree -= NeedRestoreCodeLen;
 707     //
 708     // Link the restore data to new node.
 709     //
 710     NewRestoreNodeBegin->mNext = LastFormEndNode->mNext;
 711
 712     //
 713     // Count the Adjust opcode len.
 714     //
 715     TmpNode = LastFormEndNode->mNext;
 716     while (TmpNode != InsertOpcodeNode) {
 717       gAdjustOpcodeLen += TmpNode->mBufferFree - TmpNode->mBufferStart;
 718       TmpNode = TmpNode->mNext;
 719     }
 720
 721     //
 722     // Create New Node to save the last node of restore opcode.
 723     //
 724     NeedRestoreCodeLen = InsertOpcodeAddr - InsertOpcodeNode->mBufferStart;
 725     gAdjustOpcodeLen  += NeedRestoreCodeLen;
 726     if (NeedRestoreCodeLen > 0) {
 727       NewRestoreNodeEnd = CreateNewNode ();
 728       if (NewRestoreNodeEnd == NULL) {
 729         return VFR_RETURN_OUT_FOR_RESOURCES;
 730       }
 731       memcpy (NewRestoreNodeEnd->mBufferFree, InsertOpcodeNode->mBufferStart, NeedRestoreCodeLen);
 732       NewRestoreNodeEnd->mBufferFree += NeedRestoreCodeLen;
 733       //
 734       // Override the restore buffer data.
 735       //
 736       memmove (InsertOpcodeNode->mBufferStart, InsertOpcodeAddr, InsertOpcodeNode->mBufferFree - InsertOpcodeAddr);
 737       InsertOpcodeNode->mBufferFree -= InsertOpcodeAddr - InsertOpcodeNode->mBufferStart;
 738
 739       //
 740       // Insert the last restore data node.
 741       //
 742       TmpNode = GetNodeBefore (InsertOpcodeNode);
 743       if (TmpNode == LastFormEndNode) {
 744         NewRestoreNodeBegin->mNext = NewRestoreNodeEnd;
 745       } else {
 746         TmpNode->mNext = NewRestoreNodeEnd;
 747       }
 748       //
 749       // Connect the dynamic opcode node to the node before last form end node.
 750       //
 751       LastFormEndNode->mNext = InsertOpcodeNode;
 752     }
 753   }
 754
 755   if (mBufferNodeQueueTail->mBufferFree - mBufferNodeQueueTail->mBufferStart > 2) {
 756     //
 757     // End form set opcode all in the mBufferNodeQueueTail node.
 758     //
 759     NewLastEndNode = CreateNewNode ();
 760     if (NewLastEndNode == NULL) {
 761       return VFR_RETURN_OUT_FOR_RESOURCES;
 762     }
 763     NewLastEndNode->mBufferStart[0] = 0x29;
 764     NewLastEndNode->mBufferStart[1] = 0x02;
 765     NewLastEndNode->mBufferFree += 2;
 766
 767     mBufferNodeQueueTail->mBufferFree -= 2;
 768
 769     mBufferNodeQueueTail->mNext = NewRestoreNodeBegin;
 770     if (NewRestoreNodeEnd != NULL) {
 771       NewRestoreNodeEnd->mNext = NewLastEndNode;
 772     } else {
 773       NewRestoreNodeBegin->mNext = NewLastEndNode;
 774     }
 775
 776     mBufferNodeQueueTail = NewLastEndNode;
 777   } else if (mBufferNodeQueueTail->mBufferFree - mBufferNodeQueueTail->mBufferStart == 2) {
 778     TmpNode = GetNodeBefore(mBufferNodeQueueTail);
 779     TmpNode->mNext = NewRestoreNodeBegin;
 780     if (NewRestoreNodeEnd != NULL) {
 781       NewRestoreNodeEnd->mNext = mBufferNodeQueueTail;
 782     } else {
 783       NewRestoreNodeBegin->mNext = mBufferNodeQueueTail;
 784     }
 785   }
 786
 787   return VFR_RETURN_SUCCESS;
 788 }
 789
 790 EFI_VFR_RETURN_CODE
 791 CFormPkg::DeclarePendingQuestion (
 792   IN CVfrVarDataTypeDB   &lCVfrVarDataTypeDB,
 793   IN CVfrDataStorage     &lCVfrDataStorage,
 794   IN CVfrQuestionDB      &lCVfrQuestionDB,
 795   IN EFI_GUID            *LocalFormSetGuid,
 796   IN UINT32              LineNo,
 797   OUT CHAR8              **InsertOpcodeAddr
 798   )
 799 {
 800   SPendingAssign *pNode;
 801   CHAR8          *VarStr;
 802   UINT32         ArrayIdx;
 803   CHAR8          FName[MAX_NAME_LEN];
 804   CHAR8          *SName;
 805   CHAR8          *NewStr;
 806   UINT32         ShrinkSize;
 807   EFI_VFR_RETURN_CODE  ReturnCode;
 808   EFI_VFR_VARSTORE_TYPE VarStoreType  = EFI_VFR_VARSTORE_INVALID;
 809   EFI_VARSTORE_ID       VarStoreId    = EFI_VARSTORE_ID_INVALID;
 810
 811   //
 812   // Declare all questions as Numeric in DisableIf True
 813   //
 814   // DisableIf
 815   CIfrDisableIf DIObj;
 816   DIObj.SetLineNo (LineNo);
 817   *InsertOpcodeAddr = DIObj.GetObjBinAddr ();
 818
 819   //TrueOpcode
 820   CIfrTrue TObj (LineNo);
 821
 822   // Declare Numeric qeustion for each undefined question.
 823   for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
 824     if (pNode->mFlag == PENDING) {
 825       CIfrNumeric CNObj;
 826       EFI_VARSTORE_INFO Info;
 827       EFI_QUESTION_ID   QId   = EFI_QUESTION_ID_INVALID;
 828
 829       CNObj.SetLineNo (LineNo);
 830       CNObj.SetPrompt (0x0);
 831       CNObj.SetHelp (0x0);
 832
 833       //
 834       // Register this question, assume it is normal question, not date or time question
 835       //
 836       VarStr = pNode->mKey;
 837       ReturnCode = lCVfrQuestionDB.RegisterQuestion (NULL, VarStr, QId);
 838       if (ReturnCode != VFR_RETURN_SUCCESS) {
 839         gCVfrErrorHandle.HandleError (ReturnCode, pNode->mLineNo, pNode->mKey);
 840         return ReturnCode;
 841       }
 842
 843 #ifdef VFREXP_DEBUG
 844       printf ("Undefined Question name is %s and Id is 0x%x\n", VarStr, QId);
 845 #endif
 846       //
 847       // Get Question Info, framework vfr VarName == StructName
 848       //
 849       ReturnCode = lCVfrVarDataTypeDB.ExtractFieldNameAndArrary (VarStr, FName, ArrayIdx);
 850       if (ReturnCode != VFR_RETURN_SUCCESS) {
 851         gCVfrErrorHandle.PrintMsg (pNode->mLineNo, pNode->mKey, "Error", "Var string is not the valid C variable");
 852         return ReturnCode;
 853       }
 854       //
 855       // Get VarStoreType
 856       //
 857       ReturnCode = lCVfrDataStorage.GetVarStoreId (FName, &Info.mVarStoreId);
 858       if (ReturnCode != VFR_RETURN_SUCCESS) {
 859         gCVfrErrorHandle.PrintMsg (pNode->mLineNo, FName, "Error", "Var Store Type is not defined");
 860         return ReturnCode;
 861       }
 862       VarStoreType = lCVfrDataStorage.GetVarStoreType (Info.mVarStoreId);
 863
 864       if (*VarStr == '\0' && ArrayIdx != INVALID_ARRAY_INDEX) {
 865         ReturnCode = lCVfrDataStorage.GetNameVarStoreInfo (&Info, ArrayIdx);
 866       } else {
 867         if (VarStoreType == EFI_VFR_VARSTORE_EFI) {
 868           ReturnCode = lCVfrDataStorage.GetEfiVarStoreInfo (&Info);
 869         } else if (VarStoreType == EFI_VFR_VARSTORE_BUFFER) {
 870           VarStr = pNode->mKey;
 871           //convert VarStr with store name to VarStr with structure name
 872           ReturnCode = lCVfrDataStorage.GetBufferVarStoreDataTypeName (Info.mVarStoreId, &SName);
 873           if (ReturnCode == VFR_RETURN_SUCCESS) {
 874             NewStr = new CHAR8[strlen (VarStr) + strlen (SName) + 1];
 875             NewStr[0] = '\0';
 876             strcpy (NewStr, SName);
 877             strcat (NewStr, VarStr + strlen (FName));
 878             ReturnCode = lCVfrVarDataTypeDB.GetDataFieldInfo (NewStr, Info.mInfo.mVarOffset, Info.mVarType, Info.mVarTotalSize);
 879             delete NewStr;
 880           }
 881         } else {
 882           ReturnCode = VFR_RETURN_UNSUPPORTED;
 883         }
 884       }
 885       if (ReturnCode != VFR_RETURN_SUCCESS) {
 886         gCVfrErrorHandle.HandleError (ReturnCode, pNode->mLineNo, pNode->mKey);
 887         return ReturnCode;
 888       }
 889
 890       CNObj.SetQuestionId (QId);
 891       CNObj.SetVarStoreInfo (&Info);
 892       //
 893       // Numeric doesn't support BOOLEAN data type.
 894       // BOOLEAN type has the same data size to UINT8.
 895       //
 896       if (Info.mVarType == EFI_IFR_TYPE_BOOLEAN) {
 897         Info.mVarType = EFI_IFR_TYPE_NUM_SIZE_8;
 898       }
 899       CNObj.SetFlags (0, Info.mVarType);
 900       //
 901       // Use maximum value not to limit the vaild value for the undefined question.
 902       //
 903       switch (Info.mVarType) {
 904       case EFI_IFR_TYPE_NUM_SIZE_64:
 905         CNObj.SetMinMaxStepData ((UINT64) 0, (UINT64) -1 , (UINT64) 0);
 906         ShrinkSize = 0;
 907         break;
 908       case EFI_IFR_TYPE_NUM_SIZE_32:
 909         CNObj.SetMinMaxStepData ((UINT32) 0, (UINT32) -1 , (UINT32) 0);
 910         ShrinkSize = 12;
 911         break;
 912       case EFI_IFR_TYPE_NUM_SIZE_16:
 913         CNObj.SetMinMaxStepData ((UINT16) 0, (UINT16) -1 , (UINT16) 0);
 914         ShrinkSize = 18;
 915         break;
 916       case EFI_IFR_TYPE_NUM_SIZE_8:
 917         CNObj.SetMinMaxStepData ((UINT8) 0, (UINT8) -1 , (UINT8) 0);
 918         ShrinkSize = 21;
 919         break;
 920       default:
 921         break;
 922       }
 923       CNObj.ShrinkBinSize (ShrinkSize);
 924
 925       //
 926       // For undefined Efi VarStore type question
 927       // Append the extended guided opcode to contain VarName
 928       //
 929       if (VarStoreType == EFI_VFR_VARSTORE_EFI || VfrCompatibleMode) {
 930         CIfrVarEqName CVNObj (QId, Info.mInfo.mVarName);
 931         CVNObj.SetLineNo (LineNo);
 932       }
 933
 934       //
 935       // End for Numeric
 936       //
 937       CIfrEnd CEObj;
 938       CEObj.SetLineNo (LineNo);
 939     }
 940   }
 941
 942   //
 943   // End for DisableIf
 944   //
 945   CIfrEnd SEObj;
 946   SEObj.SetLineNo (LineNo);
 947
 948   return VFR_RETURN_SUCCESS;
 949 }
 950
 951 CFormPkg gCFormPkg;
 952
 953 SIfrRecord::SIfrRecord (
 954   VOID
 955   )
 956 {
 957   mIfrBinBuf = NULL;
 958   mBinBufLen = 0;
 959   mLineNo    = 0xFFFFFFFF;
 960   mOffset    = 0xFFFFFFFF;
 961   mNext      = NULL;
 962 }
 963
 964 SIfrRecord::~SIfrRecord (
 965   VOID
 966   )
 967 {
 968   if (mIfrBinBuf != NULL) {
 969     //delete mIfrBinBuf;
 970     mIfrBinBuf = NULL;
 971   }
 972   mLineNo      = 0xFFFFFFFF;
 973   mOffset      = 0xFFFFFFFF;
 974   mBinBufLen   = 0;
 975   mNext        = NULL;
 976 }
 977
 978 CIfrRecordInfoDB::CIfrRecordInfoDB (
 979   VOID
 980   )
 981 {
 982   mSwitch            = TRUE;
 983   mRecordCount       = EFI_IFR_RECORDINFO_IDX_START;
 984   mIfrRecordListHead = NULL;
 985   mIfrRecordListTail = NULL;
 986 }
 987
 988 CIfrRecordInfoDB::~CIfrRecordInfoDB (
 989   VOID
 990   )
 991 {
 992   SIfrRecord *pNode;
 993
 994   while (mIfrRecordListHead != NULL) {
 995     pNode = mIfrRecordListHead;
 996     mIfrRecordListHead = mIfrRecordListHead->mNext;
 997     delete pNode;
 998   }
 999 }
1000
1001 SIfrRecord *
1002 CIfrRecordInfoDB::GetRecordInfoFromIdx (
1003   IN UINT32 RecordIdx
1004   )
1005 {
1006   UINT32     Idx;
1007   SIfrRecord *pNode = NULL;
1008
1009   if (RecordIdx == EFI_IFR_RECORDINFO_IDX_INVALUD) {
1010     return NULL;
1011   }
1012
1013   for (Idx = (EFI_IFR_RECORDINFO_IDX_START + 1), pNode = mIfrRecordListHead;
1014        (Idx != RecordIdx) && (pNode != NULL);
1015        Idx++, pNode = pNode->mNext)
1016   ;
1017
1018   return pNode;
1019 }
1020
1021 UINT32
1022 CIfrRecordInfoDB::IfrRecordRegister (
1023   IN UINT32 LineNo,
1024   IN CHAR8  *IfrBinBuf,
1025   IN UINT8  BinBufLen,
1026   IN UINT32 Offset
1027   )
1028 {
1029   SIfrRecord *pNew;
1030
1031   if (mSwitch == FALSE) {
1032     return EFI_IFR_RECORDINFO_IDX_INVALUD;
1033   }
1034
1035   if ((pNew = new SIfrRecord) == NULL) {
1036     return EFI_IFR_RECORDINFO_IDX_INVALUD;
1037   }
1038
1039   if (mIfrRecordListHead == NULL) {
1040     mIfrRecordListHead = pNew;
1041     mIfrRecordListTail = pNew;
1042   } else {
1043     mIfrRecordListTail->mNext = pNew;
1044     mIfrRecordListTail = pNew;
1045   }
1046   mRecordCount++;
1047
1048   return mRecordCount;
1049 }
1050
1051 VOID
1052 CIfrRecordInfoDB::IfrRecordInfoUpdate (
1053   IN UINT32 RecordIdx,
1054   IN UINT32 LineNo,
1055   IN CHAR8  *BinBuf,
1056   IN UINT8  BinBufLen,
1057   IN UINT32 Offset
1058   )
1059 {
1060   SIfrRecord *pNode;
1061   SIfrRecord *Prev;
1062
1063   if ((pNode = GetRecordInfoFromIdx (RecordIdx)) == NULL) {
1064     return;
1065   }
1066
1067   if (LineNo == 0) {
1068     //
1069     // Line number is not specified explicitly, try to use line number of previous opcode
1070     //
1071     Prev = GetRecordInfoFromIdx (RecordIdx - 1);
1072     if (Prev != NULL) {
1073       LineNo = Prev->mLineNo;
1074     }
1075   }
1076
1077   pNode->mLineNo    = LineNo;
1078   pNode->mOffset    = Offset;
1079   pNode->mBinBufLen = BinBufLen;
1080   pNode->mIfrBinBuf = BinBuf;
1081
1082 }
1083
1084 VOID
1085 CIfrRecordInfoDB::IfrRecordOutput (
1086   OUT PACKAGE_DATA &TBuffer
1087   )
1088 {
1089   CHAR8      *Temp;
1090   SIfrRecord *pNode;
1091
1092   if (TBuffer.Buffer != NULL) {
1093     delete TBuffer.Buffer;
1094   }
1095
1096   TBuffer.Size = 0;
1097   TBuffer.Buffer = NULL;
1098
1099
1100   if (mSwitch == FALSE) {
1101     return;
1102   }
1103
1104   for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1105     TBuffer.Size += pNode->mBinBufLen;
1106   }
1107
1108   if (TBuffer.Size != 0) {
1109     TBuffer.Buffer = new CHAR8[TBuffer.Size];
1110   } else {
1111     return;
1112   }
1113
1114   Temp = TBuffer.Buffer;
1115
1116   for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1117     if (pNode->mIfrBinBuf != NULL) {
1118       memcpy (Temp, pNode->mIfrBinBuf, pNode->mBinBufLen);
1119       Temp += pNode->mBinBufLen;
1120     }
1121   }
1122
1123   return;
1124 }
1125
1126 VOID
1127 CIfrRecordInfoDB::IfrRecordOutput (
1128   IN FILE   *File,
1129   IN UINT32 LineNo
1130   )
1131 {
1132   SIfrRecord *pNode;
1133   UINT8      Index;
1134   UINT32     TotalSize;
1135
1136   if (mSwitch == FALSE) {
1137     return;
1138   }
1139
1140   if (File == NULL) {
1141     return;
1142   }
1143
1144   TotalSize = 0;
1145
1146   for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1147     if (pNode->mLineNo == LineNo || LineNo == 0) {
1148       fprintf (File, ">%08X: ", pNode->mOffset);
1149       TotalSize += pNode->mBinBufLen;
1150       if (pNode->mIfrBinBuf != NULL) {
1151         for (Index = 0; Index < pNode->mBinBufLen; Index++) {
1152           fprintf (File, "%02X ", (UINT8)(pNode->mIfrBinBuf[Index]));
1153         }
1154       }
1155       fprintf (File, "\n");
1156     }
1157   }
1158
1159   if (LineNo == 0) {
1160     fprintf (File, "\nTotal Size of all record is 0x%08X\n", TotalSize);
1161   }
1162 }
1163
1164 //
1165 // for framework vfr file
1166 // adjust opcode sequence for uefi IFR format
1167 // adjust inconsistent and varstore into the right position.
1168 //
1169 BOOLEAN
1170 CIfrRecordInfoDB::CheckQuestionOpCode (
1171   IN UINT8 OpCode
1172   )
1173 {
1174   switch (OpCode) {
1175   case EFI_IFR_CHECKBOX_OP:
1176   case EFI_IFR_NUMERIC_OP:
1177   case EFI_IFR_PASSWORD_OP:
1178   case EFI_IFR_ONE_OF_OP:
1179   case EFI_IFR_ACTION_OP:
1180   case EFI_IFR_STRING_OP:
1181   case EFI_IFR_DATE_OP:
1182   case EFI_IFR_TIME_OP:
1183   case EFI_IFR_ORDERED_LIST_OP:
1184     return TRUE;
1185   default:
1186     return FALSE;
1187   }
1188 }
1189
1190 BOOLEAN
1191 CIfrRecordInfoDB::CheckIdOpCode (
1192   IN UINT8 OpCode
1193   )
1194 {
1195   switch (OpCode) {
1196   case EFI_IFR_EQ_ID_VAL_OP:
1197   case EFI_IFR_EQ_ID_ID_OP:
1198   case EFI_IFR_EQ_ID_VAL_LIST_OP:
1199   case EFI_IFR_QUESTION_REF1_OP:
1200     return TRUE;
1201   default:
1202     return FALSE;
1203   }
1204 }
1205
1206 EFI_QUESTION_ID
1207 CIfrRecordInfoDB::GetOpcodeQuestionId (
1208   IN EFI_IFR_OP_HEADER *OpHead
1209   )
1210 {
1211   EFI_IFR_QUESTION_HEADER *QuestionHead;
1212
1213   QuestionHead = (EFI_IFR_QUESTION_HEADER *) (OpHead + 1);
1214
1215   return QuestionHead->QuestionId;
1216 }
1217
1218 SIfrRecord *
1219 CIfrRecordInfoDB::GetRecordInfoFromOffset (
1220   IN UINT32 Offset
1221   )
1222 {
1223   SIfrRecord *pNode = NULL;
1224
1225   for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1226     if (pNode->mOffset == Offset) {
1227       return pNode;
1228     }
1229   }
1230
1231   return pNode;
1232 }
1233
1234 /*
1235   Add just the op code position.
1236
1237   From
1238
1239   | form end opcode + end of if opcode for form ... + Dynamic opcode + form set end opcode |
1240
1241   To
1242
1243   | Dynamic opcode + form end opcode + end of if opcode for form ... + form set end opcode |
1244
1245 */
1246 BOOLEAN
1247 CIfrRecordInfoDB::IfrAdjustDynamicOpcodeInRecords (
1248   VOID
1249   )
1250 {
1251   UINT32             OpcodeOffset;
1252   SIfrRecord         *pNode, *pPreNode;
1253   SIfrRecord         *pStartNode, *pNodeBeforeStart;
1254   SIfrRecord         *pEndNode;
1255
1256   pStartNode = NULL;
1257   pEndNode   = NULL;
1258   OpcodeOffset = 0;
1259
1260   //
1261   // Base on the offset info to get the node.
1262   //
1263   for (pNode = mIfrRecordListHead; pNode->mNext != NULL; pPreNode = pNode,pNode = pNode->mNext) {
1264     if (OpcodeOffset == gAdjustOpcodeOffset) {
1265       pStartNode       = pNode;
1266       pNodeBeforeStart = pPreNode;
1267     } else if (OpcodeOffset == gAdjustOpcodeOffset + gAdjustOpcodeLen) {
1268       pEndNode = pPreNode;
1269     }
1270
1271     OpcodeOffset += pNode->mBinBufLen;
1272   }
1273
1274   //
1275   // Check the value.
1276   //
1277   if (pEndNode == NULL || pStartNode == NULL) {
1278     return FALSE;
1279   }
1280
1281   //
1282   // Adjust the node. pPreNode save the Node before mIfrRecordListTail
1283   //
1284   pNodeBeforeStart->mNext = pEndNode->mNext;
1285   pPreNode->mNext = pStartNode;
1286   pEndNode->mNext = mIfrRecordListTail;
1287
1288   return TRUE;
1289 }
1290
1291 VOID
1292 CIfrRecordInfoDB::IfrAdjustOffsetForRecord (
1293   VOID
1294   )
1295 {
1296   UINT32             OpcodeOffset;
1297   SIfrRecord         *pNode;
1298
1299   OpcodeOffset = 0;
1300   for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1301     pNode->mOffset = OpcodeOffset;
1302     OpcodeOffset += pNode->mBinBufLen;
1303   }
1304 }
1305
1306 EFI_VFR_RETURN_CODE
1307 CIfrRecordInfoDB::IfrRecordAdjust (
1308   VOID
1309   )
1310 {
1311   SIfrRecord *pNode, *preNode;
1312   SIfrRecord *uNode, *tNode;
1313   EFI_IFR_OP_HEADER  *OpHead, *tOpHead;
1314   EFI_QUESTION_ID    QuestionId;
1315   UINT32             StackCount;
1316   UINT32             QuestionScope;
1317   UINT32             OpcodeOffset;
1318   CHAR8              ErrorMsg[MAX_STRING_LEN] = {0, };
1319   EFI_VFR_RETURN_CODE  Status;
1320
1321   //
1322   // Init local variable
1323   //
1324   Status = VFR_RETURN_SUCCESS;
1325   pNode = mIfrRecordListHead;
1326   preNode = pNode;
1327   QuestionScope = 0;
1328   while (pNode != NULL) {
1329     OpHead = (EFI_IFR_OP_HEADER *) pNode->mIfrBinBuf;
1330
1331     //
1332     // make sure the inconsistent opcode in question scope
1333     //
1334     if (QuestionScope > 0) {
1335       QuestionScope += OpHead->Scope;
1336       if (OpHead->OpCode == EFI_IFR_END_OP) {
1337         QuestionScope --;
1338       }
1339     }
1340
1341     if (CheckQuestionOpCode (OpHead->OpCode)) {
1342       QuestionScope = 1;
1343     }
1344     //
1345     // for the inconsistent opcode not in question scope, adjust it
1346     //
1347     if (OpHead->OpCode == EFI_IFR_INCONSISTENT_IF_OP && QuestionScope == 0) {
1348       //
1349       // for inconsistent opcode not in question scope
1350       //
1351
1352       //
1353       // Count inconsistent opcode Scope
1354       //
1355       StackCount = OpHead->Scope;
1356       QuestionId = EFI_QUESTION_ID_INVALID;
1357       tNode = pNode;
1358       while (tNode != NULL && StackCount > 0) {
1359         tNode = tNode->mNext;
1360         tOpHead = (EFI_IFR_OP_HEADER *) tNode->mIfrBinBuf;
1361         //
1362         // Calculate Scope Number
1363         //
1364         StackCount += tOpHead->Scope;
1365         if (tOpHead->OpCode == EFI_IFR_END_OP) {
1366           StackCount --;
1367         }
1368         //
1369         // by IdEqual opcode to get QuestionId
1370         //
1371         if (QuestionId == EFI_QUESTION_ID_INVALID &&
1372             CheckIdOpCode (tOpHead->OpCode)) {
1373           QuestionId = *(EFI_QUESTION_ID *) (tOpHead + 1);
1374         }
1375       }
1376       if (tNode == NULL || QuestionId == EFI_QUESTION_ID_INVALID) {
1377         //
1378         // report error; not found
1379         //
1380         sprintf (ErrorMsg, "Inconsistent OpCode Record list invalid QuestionId is 0x%X", QuestionId);
1381         gCVfrErrorHandle.PrintMsg (0, NULL, "Error", ErrorMsg);
1382         Status = VFR_RETURN_MISMATCHED;
1383         break;
1384       }
1385       //
1386       // extract inconsistent opcode list
1387       // pNode is Incosistent opcode, tNode is End Opcode
1388       //
1389
1390       //
1391       // insert inconsistent opcode list into the right question scope by questionid
1392       //
1393       for (uNode = mIfrRecordListHead; uNode != NULL; uNode = uNode->mNext) {
1394         tOpHead = (EFI_IFR_OP_HEADER *) uNode->mIfrBinBuf;
1395         if (CheckQuestionOpCode (tOpHead->OpCode) &&
1396             (QuestionId == GetOpcodeQuestionId (tOpHead))) {
1397           break;
1398         }
1399       }
1400       //
1401       // insert inconsistent opcode list and check LATE_CHECK flag
1402       //
1403       if (uNode != NULL) {
1404         if ((((EFI_IFR_QUESTION_HEADER *)(tOpHead + 1))->Flags & 0x20) != 0) {
1405           //
1406           // if LATE_CHECK flag is set, change inconsistent to nosumbit
1407           //
1408           OpHead->OpCode = EFI_IFR_NO_SUBMIT_IF_OP;
1409         }
1410
1411         //
1412         // skip the default storage for Date and Time
1413         //
1414         if ((uNode->mNext != NULL) && (*uNode->mNext->mIfrBinBuf == EFI_IFR_DEFAULT_OP)) {
1415           uNode = uNode->mNext;
1416         }
1417
1418         preNode->mNext = tNode->mNext;
1419         tNode->mNext = uNode->mNext;
1420         uNode->mNext = pNode;
1421         //
1422         // reset pNode to head list, scan the whole list again.
1423         //
1424         pNode = mIfrRecordListHead;
1425         preNode = pNode;
1426         QuestionScope = 0;
1427         continue;
1428       } else {
1429         //
1430         // not found matched question id, report error
1431         //
1432         sprintf (ErrorMsg, "QuestionId required by Inconsistent OpCode is not found. QuestionId is 0x%X", QuestionId);
1433         gCVfrErrorHandle.PrintMsg (0, NULL, "Error", ErrorMsg);
1434         Status = VFR_RETURN_MISMATCHED;
1435         break;
1436       }
1437     } else if (OpHead->OpCode == EFI_IFR_VARSTORE_OP ||
1438                OpHead->OpCode == EFI_IFR_VARSTORE_EFI_OP) {
1439       //
1440       // for new added group of varstore opcode
1441       //
1442       tNode = pNode;
1443       while (tNode->mNext != NULL) {
1444         tOpHead = (EFI_IFR_OP_HEADER *) tNode->mNext->mIfrBinBuf;
1445         if (tOpHead->OpCode != EFI_IFR_VARSTORE_OP &&
1446             tOpHead->OpCode != EFI_IFR_VARSTORE_EFI_OP) {
1447           break;
1448         }
1449         tNode = tNode->mNext;
1450       }
1451
1452       if (tNode->mNext == NULL) {
1453         //
1454         // invalid IfrCode, IfrCode end by EndOpCode
1455         //
1456         gCVfrErrorHandle.PrintMsg (0, NULL, "Error", "No found End Opcode in the end");
1457         Status = VFR_RETURN_MISMATCHED;
1458         break;
1459       }
1460
1461       if (tOpHead->OpCode != EFI_IFR_END_OP) {
1462           //
1463           // not new added varstore, which are not needed to be adjust.
1464           //
1465           preNode = tNode;
1466           pNode   = tNode->mNext;
1467           continue;
1468       } else {
1469         //
1470         // move new added varstore opcode to the position befor form opcode
1471         // varstore opcode between pNode and tNode
1472         //
1473
1474         //
1475         // search form opcode from begin
1476         //
1477         for (uNode = mIfrRecordListHead; uNode->mNext != NULL; uNode = uNode->mNext) {
1478           tOpHead = (EFI_IFR_OP_HEADER *) uNode->mNext->mIfrBinBuf;
1479           if (tOpHead->OpCode == EFI_IFR_FORM_OP) {
1480             break;
1481           }
1482         }
1483         //
1484         // Insert varstore opcode beform form opcode if form opcode is found
1485         //
1486         if (uNode->mNext != NULL) {
1487           preNode->mNext = tNode->mNext;
1488           tNode->mNext = uNode->mNext;
1489           uNode->mNext = pNode;
1490           //
1491           // reset pNode to head list, scan the whole list again.
1492           //
1493           pNode = mIfrRecordListHead;
1494           preNode = pNode;
1495           QuestionScope = 0;
1496           continue;
1497         } else {
1498           //
1499           // not found form, continue scan IfrRecord list
1500           //
1501           preNode = tNode;
1502           pNode   = tNode->mNext;
1503           continue;
1504         }
1505       }
1506     }
1507     //
1508     // next node
1509     //
1510     preNode = pNode;
1511     pNode = pNode->mNext;
1512   }
1513
1514   //
1515   // Update Ifr Opcode Offset
1516   //
1517   if (Status == VFR_RETURN_SUCCESS) {
1518     IfrAdjustOffsetForRecord ();
1519   }
1520   return Status;
1521 }
1522
1523 CIfrRecordInfoDB gCIfrRecordInfoDB;
1524
1525 VOID
1526 CIfrObj::_EMIT_PENDING_OBJ (
1527   VOID
1528   )
1529 {
1530   CHAR8  *ObjBinBuf = NULL;
1531
1532   //
1533   // do nothing
1534   //
1535   if (!mDelayEmit || !gCreateOp) {
1536     return;
1537   }
1538
1539   mPkgOffset = gCFormPkg.GetPkgLength ();
1540   //
1541   // update data buffer to package data
1542   //
1543   ObjBinBuf  = gCFormPkg.IfrBinBufferGet (mObjBinLen);
1544   if (ObjBinBuf != NULL) {
1545     memmove (ObjBinBuf, mObjBinBuf, mObjBinLen);
1546   }
1547
1548   //
1549   // update bin buffer to package data buffer
1550   //
1551   if (mObjBinBuf != NULL) {
1552     delete mObjBinBuf;
1553     mObjBinBuf = ObjBinBuf;
1554   }
1555
1556   mDelayEmit = FALSE;
1557 }
1558
1559 /*
1560  * The definition of CIfrObj's member function
1561  */
1562 static struct {
1563   UINT8  mSize;
1564   UINT8  mScope;
1565 } gOpcodeSizesScopeTable[] = {
1566   { 0, 0 },                                    // EFI_IFR_INVALID - 0x00
1567   { sizeof (EFI_IFR_FORM), 1 },                // EFI_IFR_FORM_OP
1568   { sizeof (EFI_IFR_SUBTITLE), 1 },            // EFI_IFR_SUBTITLE_OP
1569   { sizeof (EFI_IFR_TEXT), 0 },                // EFI_IFR_TEXT_OP
1570   { sizeof (EFI_IFR_IMAGE), 0 },               // EFI_IFR_IMAGE_OP
1571   { sizeof (EFI_IFR_ONE_OF), 1 },              // EFI_IFR_ONE_OF_OP - 0x05
1572   { sizeof (EFI_IFR_CHECKBOX), 1},             // EFI_IFR_CHECKBOX_OP
1573   { sizeof (EFI_IFR_NUMERIC), 1 },             // EFI_IFR_NUMERIC_OP
1574   { sizeof (EFI_IFR_PASSWORD), 1 },            // EFI_IFR_PASSWORD_OP
1575   { sizeof (EFI_IFR_ONE_OF_OPTION), 0 },       // EFI_IFR_ONE_OF_OPTION_OP
1576   { sizeof (EFI_IFR_SUPPRESS_IF), 1 },         // EFI_IFR_SUPPRESS_IF - 0x0A
1577   { sizeof (EFI_IFR_LOCKED), 0 },              // EFI_IFR_LOCKED_OP
1578   { sizeof (EFI_IFR_ACTION), 1 },              // EFI_IFR_ACTION_OP
1579   { sizeof (EFI_IFR_RESET_BUTTON), 1 },        // EFI_IFR_RESET_BUTTON_OP
1580   { sizeof (EFI_IFR_FORM_SET), 1 },            // EFI_IFR_FORM_SET_OP -0xE
1581   { sizeof (EFI_IFR_REF), 0 },                 // EFI_IFR_REF_OP
1582   { sizeof (EFI_IFR_NO_SUBMIT_IF), 1},         // EFI_IFR_NO_SUBMIT_IF_OP -0x10
1583   { sizeof (EFI_IFR_INCONSISTENT_IF), 1 },     // EFI_IFR_INCONSISTENT_IF_OP
1584   { sizeof (EFI_IFR_EQ_ID_VAL), 0 },           // EFI_IFR_EQ_ID_VAL_OP
1585   { sizeof (EFI_IFR_EQ_ID_ID), 0 },            // EFI_IFR_EQ_ID_ID_OP
1586   { sizeof (EFI_IFR_EQ_ID_VAL_LIST), 0 },      // EFI_IFR_EQ_ID_LIST_OP - 0x14
1587   { sizeof (EFI_IFR_AND), 0 },                 // EFI_IFR_AND_OP
1588   { sizeof (EFI_IFR_OR), 0 },                  // EFI_IFR_OR_OP
1589   { sizeof (EFI_IFR_NOT), 0 },                 // EFI_IFR_NOT_OP
1590   { sizeof (EFI_IFR_RULE), 1 },                // EFI_IFR_RULE_OP
1591   { sizeof (EFI_IFR_GRAY_OUT_IF), 1 },         // EFI_IFR_GRAYOUT_IF_OP - 0x19
1592   { sizeof (EFI_IFR_DATE), 1 },                // EFI_IFR_DATE_OP
1593   { sizeof (EFI_IFR_TIME), 1 },                // EFI_IFR_TIME_OP
1594   { sizeof (EFI_IFR_STRING), 1 },              // EFI_IFR_STRING_OP
1595   { sizeof (EFI_IFR_REFRESH), 0 },             // EFI_IFR_REFRESH_OP
1596   { sizeof (EFI_IFR_DISABLE_IF), 1 },          // EFI_IFR_DISABLE_IF_OP - 0x1E
1597   { 0, 0 },                                    // 0x1F
1598   { sizeof (EFI_IFR_TO_LOWER), 0 },            // EFI_IFR_TO_LOWER_OP - 0x20
1599   { sizeof (EFI_IFR_TO_UPPER), 0 },            // EFI_IFR_TO_UPPER_OP - 0x21
1600   { sizeof (EFI_IFR_MAP), 1 },                 // EFI_IFR_MAP - 0x22
1601   { sizeof (EFI_IFR_ORDERED_LIST), 1 },        // EFI_IFR_ORDERED_LIST_OP - 0x23
1602   { sizeof (EFI_IFR_VARSTORE), 0 },            // EFI_IFR_VARSTORE_OP
1603   { sizeof (EFI_IFR_VARSTORE_NAME_VALUE), 0 }, // EFI_IFR_VARSTORE_NAME_VALUE_OP
1604   { sizeof (EFI_IFR_VARSTORE_EFI), 0 },        // EFI_IFR_VARSTORE_EFI_OP
1605   { sizeof (EFI_IFR_VARSTORE_DEVICE), 1 },     // EFI_IFR_VARSTORE_DEVICE_OP
1606   { sizeof (EFI_IFR_VERSION), 0 },             // EFI_IFR_VERSION_OP - 0x28
1607   { sizeof (EFI_IFR_END), 0 },                 // EFI_IFR_END_OP
1608   { sizeof (EFI_IFR_MATCH), 0 },               // EFI_IFR_MATCH_OP - 0x2A
1609   { sizeof (EFI_IFR_GET), 0 },                 // EFI_IFR_GET - 0x2B
1610   { sizeof (EFI_IFR_SET), 0 },                 // EFI_IFR_SET - 0x2C
1611   { sizeof (EFI_IFR_READ), 0 },                // EFI_IFR_READ - 0x2D
1612   { sizeof (EFI_IFR_WRITE), 0 },               // EFI_IFR_WRITE - 0x2E
1613   { sizeof (EFI_IFR_EQUAL), 0 },               // EFI_IFR_EQUAL_OP - 0x2F
1614   { sizeof (EFI_IFR_NOT_EQUAL), 0 },           // EFI_IFR_NOT_EQUAL_OP
1615   { sizeof (EFI_IFR_GREATER_THAN), 0 },        // EFI_IFR_GREATER_THAN_OP
1616   { sizeof (EFI_IFR_GREATER_EQUAL), 0 },       // EFI_IFR_GREATER_EQUAL_OP
1617   { sizeof (EFI_IFR_LESS_THAN), 0 },           // EFI_IFR_LESS_THAN_OP
1618   { sizeof (EFI_IFR_LESS_EQUAL), 0 },          // EFI_IFR_LESS_EQUAL_OP - 0x34
1619   { sizeof (EFI_IFR_BITWISE_AND), 0 },         // EFI_IFR_BITWISE_AND_OP
1620   { sizeof (EFI_IFR_BITWISE_OR), 0 },          // EFI_IFR_BITWISE_OR_OP
1621   { sizeof (EFI_IFR_BITWISE_NOT), 0 },         // EFI_IFR_BITWISE_NOT_OP
1622   { sizeof (EFI_IFR_SHIFT_LEFT), 0 },          // EFI_IFR_SHIFT_LEFT_OP
1623   { sizeof (EFI_IFR_SHIFT_RIGHT), 0 },         // EFI_IFR_SHIFT_RIGHT_OP
1624   { sizeof (EFI_IFR_ADD), 0 },                 // EFI_IFR_ADD_OP - 0x3A
1625   { sizeof (EFI_IFR_SUBTRACT), 0 },            // EFI_IFR_SUBTRACT_OP
1626   { sizeof (EFI_IFR_MULTIPLY), 0 },            // EFI_IFR_MULTIPLY_OP
1627   { sizeof (EFI_IFR_DIVIDE), 0 },              // EFI_IFR_DIVIDE_OP
1628   { sizeof (EFI_IFR_MODULO), 0 },              // EFI_IFR_MODULO_OP - 0x3E
1629   { sizeof (EFI_IFR_RULE_REF), 0 },            // EFI_IFR_RULE_REF_OP
1630   { sizeof (EFI_IFR_QUESTION_REF1), 0 },       // EFI_IFR_QUESTION_REF1_OP
1631   { sizeof (EFI_IFR_QUESTION_REF2), 0 },       // EFI_IFR_QUESTION_REF2_OP - 0x41
1632   { sizeof (EFI_IFR_UINT8), 0},                // EFI_IFR_UINT8
1633   { sizeof (EFI_IFR_UINT16), 0},               // EFI_IFR_UINT16
1634   { sizeof (EFI_IFR_UINT32), 0},               // EFI_IFR_UINT32
1635   { sizeof (EFI_IFR_UINT64), 0},               // EFI_IFR_UTNT64
1636   { sizeof (EFI_IFR_TRUE), 0 },                // EFI_IFR_TRUE_OP - 0x46
1637   { sizeof (EFI_IFR_FALSE), 0 },               // EFI_IFR_FALSE_OP
1638   { sizeof (EFI_IFR_TO_UINT), 0 },             // EFI_IFR_TO_UINT_OP
1639   { sizeof (EFI_IFR_TO_STRING), 0 },           // EFI_IFR_TO_STRING_OP
1640   { sizeof (EFI_IFR_TO_BOOLEAN), 0 },          // EFI_IFR_TO_BOOLEAN_OP
1641   { sizeof (EFI_IFR_MID), 0 },                 // EFI_IFR_MID_OP
1642   { sizeof (EFI_IFR_FIND), 0 },                // EFI_IFR_FIND_OP
1643   { sizeof (EFI_IFR_TOKEN), 0 },               // EFI_IFR_TOKEN_OP
1644   { sizeof (EFI_IFR_STRING_REF1), 0 },         // EFI_IFR_STRING_REF1_OP - 0x4E
1645   { sizeof (EFI_IFR_STRING_REF2), 0 },         // EFI_IFR_STRING_REF2_OP
1646   { sizeof (EFI_IFR_CONDITIONAL), 0 },         // EFI_IFR_CONDITIONAL_OP
1647   { sizeof (EFI_IFR_QUESTION_REF3), 0 },       // EFI_IFR_QUESTION_REF3_OP
1648   { sizeof (EFI_IFR_ZERO), 0 },                // EFI_IFR_ZERO_OP
1649   { sizeof (EFI_IFR_ONE), 0 },                 // EFI_IFR_ONE_OP
1650   { sizeof (EFI_IFR_ONES), 0 },                // EFI_IFR_ONES_OP
1651   { sizeof (EFI_IFR_UNDEFINED), 0 },           // EFI_IFR_UNDEFINED_OP
1652   { sizeof (EFI_IFR_LENGTH), 0 },              // EFI_IFR_LENGTH_OP
1653   { sizeof (EFI_IFR_DUP), 0 },                 // EFI_IFR_DUP_OP - 0x57
1654   { sizeof (EFI_IFR_THIS), 0 },                // EFI_IFR_THIS_OP
1655   { sizeof (EFI_IFR_SPAN), 0 },                // EFI_IFR_SPAN_OP
1656   { sizeof (EFI_IFR_VALUE), 1 },               // EFI_IFR_VALUE_OP
1657   { sizeof (EFI_IFR_DEFAULT), 0 },             // EFI_IFR_DEFAULT_OP
1658   { sizeof (EFI_IFR_DEFAULTSTORE), 0 },        // EFI_IFR_DEFAULTSTORE_OP - 0x5C
1659   { sizeof (EFI_IFR_FORM_MAP), 1},             // EFI_IFR_FORM_MAP_OP - 0x5D
1660   { sizeof (EFI_IFR_CATENATE), 0 },            // EFI_IFR_CATENATE_OP
1661   { sizeof (EFI_IFR_GUID), 0 },                // EFI_IFR_GUID_OP
1662   { sizeof (EFI_IFR_SECURITY), 0 },            // EFI_IFR_SECURITY_OP - 0x60
1663   { sizeof (EFI_IFR_MODAL_TAG), 0},            // EFI_IFR_MODAL_TAG_OP - 0x61
1664   { sizeof (EFI_IFR_REFRESH_ID), 0},           // EFI_IFR_REFRESH_ID_OP - 0x62
1665   { sizeof (EFI_IFR_WARNING_IF), 1},           // EFI_IFR_WARNING_IF_OP - 0x63
1666   { sizeof (EFI_IFR_MATCH2), 0 },              // EFI_IFR_MATCH2_OP - 0x64
1667 };
1668
1669 #ifdef CIFROBJ_DEUBG
1670 static struct {
1671   CHAR8 *mIfrName;
1672 } gIfrObjPrintDebugTable[] = {
1673   "EFI_IFR_INVALID",    "EFI_IFR_FORM",                 "EFI_IFR_SUBTITLE",      "EFI_IFR_TEXT",            "EFI_IFR_IMAGE",         "EFI_IFR_ONE_OF",
1674   "EFI_IFR_CHECKBOX",   "EFI_IFR_NUMERIC",              "EFI_IFR_PASSWORD",      "EFI_IFR_ONE_OF_OPTION",   "EFI_IFR_SUPPRESS_IF",   "EFI_IFR_LOCKED",
1675   "EFI_IFR_ACTION",     "EFI_IFR_RESET_BUTTON",         "EFI_IFR_FORM_SET",      "EFI_IFR_REF",             "EFI_IFR_NO_SUBMIT_IF",  "EFI_IFR_INCONSISTENT_IF",
1676   "EFI_IFR_EQ_ID_VAL",  "EFI_IFR_EQ_ID_ID",             "EFI_IFR_EQ_ID_LIST",    "EFI_IFR_AND",             "EFI_IFR_OR",            "EFI_IFR_NOT",
1677   "EFI_IFR_RULE",       "EFI_IFR_GRAY_OUT_IF",          "EFI_IFR_DATE",          "EFI_IFR_TIME",            "EFI_IFR_STRING",        "EFI_IFR_REFRESH",
1678   "EFI_IFR_DISABLE_IF", "EFI_IFR_INVALID",              "EFI_IFR_TO_LOWER",      "EFI_IFR_TO_UPPER",        "EFI_IFR_MAP",           "EFI_IFR_ORDERED_LIST",
1679   "EFI_IFR_VARSTORE",   "EFI_IFR_VARSTORE_NAME_VALUE",  "EFI_IFR_VARSTORE_EFI",  "EFI_IFR_VARSTORE_DEVICE", "EFI_IFR_VERSION",       "EFI_IFR_END",
1680   "EFI_IFR_MATCH",      "EFI_IFR_GET",                  "EFI_IFR_SET",           "EFI_IFR_READ",            "EFI_IFR_WRITE",         "EFI_IFR_EQUAL",
1681   "EFI_IFR_NOT_EQUAL",  "EFI_IFR_GREATER_THAN",         "EFI_IFR_GREATER_EQUAL", "EFI_IFR_LESS_THAN",       "EFI_IFR_LESS_EQUAL",    "EFI_IFR_BITWISE_AND",
1682   "EFI_IFR_BITWISE_OR", "EFI_IFR_BITWISE_NOT",          "EFI_IFR_SHIFT_LEFT",    "EFI_IFR_SHIFT_RIGHT",     "EFI_IFR_ADD",           "EFI_IFR_SUBTRACT",
1683   "EFI_IFR_MULTIPLY",   "EFI_IFR_DIVIDE",               "EFI_IFR_MODULO",        "EFI_IFR_RULE_REF",        "EFI_IFR_QUESTION_REF1", "EFI_IFR_QUESTION_REF2",
1684   "EFI_IFR_UINT8",      "EFI_IFR_UINT16",               "EFI_IFR_UINT32",        "EFI_IFR_UINT64",          "EFI_IFR_TRUE",          "EFI_IFR_FALSE",
1685   "EFI_IFR_TO_UINT",    "EFI_IFR_TO_STRING",            "EFI_IFR_TO_BOOLEAN",    "EFI_IFR_MID",             "EFI_IFR_FIND",          "EFI_IFR_TOKEN",
1686   "EFI_IFR_STRING_REF1","EFI_IFR_STRING_REF2",          "EFI_IFR_CONDITIONAL",   "EFI_IFR_QUESTION_REF3",   "EFI_IFR_ZERO",          "EFI_IFR_ONE",
1687   "EFI_IFR_ONES",       "EFI_IFR_UNDEFINED",            "EFI_IFR_LENGTH",        "EFI_IFR_DUP",             "EFI_IFR_THIS",          "EFI_IFR_SPAN",
1688   "EFI_IFR_VALUE",      "EFI_IFR_DEFAULT",              "EFI_IFR_DEFAULTSTORE",  "EFI_IFR_FORM_MAP",        "EFI_IFR_CATENATE",      "EFI_IFR_GUID",
1689   "EFI_IFR_SECURITY",   "EFI_IFR_MODAL_TAG",            "EFI_IFR_REFRESH_ID",    "EFI_IFR_WARNING_IF",      "EFI_IFR_MATCH2",
1690 };
1691
1692 VOID
1693 CIFROBJ_DEBUG_PRINT (
1694   IN UINT8 OpCode
1695   )
1696 {
1697   printf ("======Create IFR [%s]\n", gIfrObjPrintDebugTable[OpCode].mIfrName);
1698 }
1699 #else
1700
1701 #define CIFROBJ_DEBUG_PRINT(OpCode)
1702
1703 #endif
1704
1705 BOOLEAN gCreateOp = TRUE;
1706
1707 CIfrObj::CIfrObj (
1708   IN  UINT8   OpCode,
1709   OUT CHAR8   **IfrObj,
1710   IN  UINT8   ObjBinLen,
1711   IN  BOOLEAN DelayEmit
1712   )
1713 {
1714   mDelayEmit   = DelayEmit;
1715   mPkgOffset   = gCFormPkg.GetPkgLength ();
1716   mObjBinLen   = (ObjBinLen == 0) ? gOpcodeSizesScopeTable[OpCode].mSize : ObjBinLen;
1717   mObjBinBuf   = ((DelayEmit == FALSE) && (gCreateOp == TRUE)) ? gCFormPkg.IfrBinBufferGet (mObjBinLen) : new CHAR8[EFI_IFR_MAX_LENGTH];
1718   mRecordIdx   = (gCreateOp == TRUE) ? gCIfrRecordInfoDB.IfrRecordRegister (0xFFFFFFFF, mObjBinBuf, mObjBinLen, mPkgOffset) : EFI_IFR_RECORDINFO_IDX_INVALUD;
1719
1720   if (IfrObj != NULL) {
1721     *IfrObj    = mObjBinBuf;
1722   }
1723
1724   CIFROBJ_DEBUG_PRINT (OpCode);
1725 }
1726
1727 CIfrObj::~CIfrObj (
1728   VOID
1729   )
1730 {
1731   if ((mDelayEmit == TRUE) && ((gCreateOp == TRUE))) {
1732     _EMIT_PENDING_OBJ ();
1733   }
1734
1735   gCIfrRecordInfoDB.IfrRecordInfoUpdate (mRecordIdx, mLineNo, mObjBinBuf, mObjBinLen, mPkgOffset);
1736 }
1737
1738 /*
1739  * The definition of CIfrObj's member function
1740  */
1741 UINT8 gScopeCount = 0;
1742
1743 CIfrOpHeader::CIfrOpHeader (
1744   IN UINT8 OpCode,
1745   IN VOID *StartAddr,
1746   IN UINT8 Length
1747   ) : mHeader ((EFI_IFR_OP_HEADER *)StartAddr)
1748 {
1749   mHeader->OpCode = OpCode;
1750   mHeader->Length = (Length == 0) ? gOpcodeSizesScopeTable[OpCode].mSize : Length;
1751   mHeader->Scope  = (gOpcodeSizesScopeTable[OpCode].mScope + gScopeCount > 0) ? 1 : 0;
1752 }
1753
1754 CIfrOpHeader::CIfrOpHeader (
1755   IN CIfrOpHeader &OpHdr
1756   )
1757 {
1758   mHeader = OpHdr.mHeader;
1759 }
1760
1761 UINT32 CIfrFormId::FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE] = {0, };