EdkCompatibilityPkg/Compatibility/FrameworkHiiOnUefiHiiThunk/UefiIfrParser.c

   1 /** @file
   2 Parser for IFR binary encoding.
   3
   4 Copyright (c) 2008, Intel Corporation
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <PiDxe.h>
  16
  17 #include <Protocol/HiiConfigAccess.h>
  18 #include <Protocol/HiiConfigRouting.h>
  19 #include <Protocol/HiiDatabase.h>
  20 #include <Protocol/HiiString.h>
  21
  22 #include <Library/BaseLib.h>
  23 #include <Library/BaseMemoryLib.h>
  24 #include <Library/DebugLib.h>
  25 #include <Library/HiiLib.h>
  26 #include <Library/IfrSupportLib.h>
  27 #include <Library/MemoryAllocationLib.h>
  28 #include <Library/PrintLib.h>
  29 #include <Library/UefiBootServicesTableLib.h>
  30
  31 #include <Guid/MdeModuleHii.h>
  32
  33 #include "UefiIfrParser.h"
  34
  35 #include "UefiIfrParserExpression.h"
  36
  37 UINT16           mStatementIndex;
  38
  39 BOOLEAN          mInScopeSubtitle;
  40 BOOLEAN          mInScopeSuppress;
  41 BOOLEAN          mInScopeGrayOut;
  42
  43 EFI_GUID  mFrameworkHiiCompatibilityGuid = EFI_IFR_FRAMEWORK_GUID;
  44 extern EFI_GUID mTianoHiiIfrGuid;
  45
  46 LIST_ENTRY *
  47 GetOneOfOptionMapEntryListHead (
  48   IN CONST FORM_BROWSER_FORMSET  *FormSet,
  49   IN       UINT16                 QuestionId
  50   )
  51 {
  52   LIST_ENTRY            *Link;
  53   ONE_OF_OPTION_MAP     *Map;
  54
  55   Link = GetFirstNode (&FormSet->OneOfOptionMapListHead);
  56
  57   while (!IsNull (&FormSet->OneOfOptionMapListHead, Link)) {
  58     Map = ONE_OF_OPTION_MAP_FROM_LINK (Link);
  59     if (QuestionId == Map->QuestionId) {
  60       return &Map->OneOfOptionMapEntryListHead;
  61     }
  62     Link = GetNextNode (&FormSet->OneOfOptionMapListHead, Link);
  63   }
  64
  65   return NULL;
  66 }
  67
  68 VOID
  69 DestoryOneOfOptionMap (
  70   IN LIST_ENTRY     *OneOfOptionMapListHead
  71   )
  72 {
  73   ONE_OF_OPTION_MAP         *Map;
  74   ONE_OF_OPTION_MAP_ENTRY   *MapEntry;
  75   LIST_ENTRY                *Link;
  76   LIST_ENTRY                *Link2;
  77
  78   while (!IsListEmpty (OneOfOptionMapListHead)) {
  79     Link = GetFirstNode (OneOfOptionMapListHead);
  80
  81     Map = ONE_OF_OPTION_MAP_FROM_LINK (Link);
  82
  83     while (!IsListEmpty (&Map->OneOfOptionMapEntryListHead)) {
  84       Link2 = GetFirstNode (&Map->OneOfOptionMapEntryListHead);
  85
  86       MapEntry = ONE_OF_OPTION_MAP_ENTRY_FROM_LINK (Link2);
  87
  88       RemoveEntryList (Link2);
  89
  90       FreePool (MapEntry);
  91     }
  92
  93     RemoveEntryList (Link);
  94     FreePool (Map);
  95   }
  96 }
  97
  98
  99 /**
 100   Initialize Statement header members.
 101
 102   @param  OpCodeData             Pointer of the raw OpCode data.
 103   @param  FormSet                Pointer of the current FormSe.
 104   @param  Form                   Pointer of the current Form.
 105
 106   @return The Statement.
 107
 108 **/
 109 FORM_BROWSER_STATEMENT *
 110 CreateStatement (
 111   IN UINT8                        *OpCodeData,
 112   IN OUT FORM_BROWSER_FORMSET     *FormSet,
 113   IN OUT FORM_BROWSER_FORM        *Form
 114   )
 115 {
 116   FORM_BROWSER_STATEMENT    *Statement;
 117   EFI_IFR_STATEMENT_HEADER  *StatementHdr;
 118
 119   if (Form == NULL) {
 120     //
 121     // We are currently not in a Form Scope, so just skip this Statement
 122     //
 123     return NULL;
 124   }
 125
 126   Statement = &FormSet->StatementBuffer[mStatementIndex];
 127   mStatementIndex++;
 128
 129   InitializeListHead (&Statement->DefaultListHead);
 130   InitializeListHead (&Statement->OptionListHead);
 131
 132   Statement->Signature = FORM_BROWSER_STATEMENT_SIGNATURE;
 133
 134   Statement->Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
 135
 136   StatementHdr = (EFI_IFR_STATEMENT_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
 137   CopyMem (&Statement->Prompt, &StatementHdr->Prompt, sizeof (EFI_STRING_ID));
 138   CopyMem (&Statement->Help, &StatementHdr->Help, sizeof (EFI_STRING_ID));
 139
 140   Statement->InSubtitle = mInScopeSubtitle;
 141
 142   //
 143   // Insert this Statement into current Form
 144   //
 145   InsertTailList (&Form->StatementListHead, &Statement->Link);
 146
 147   return Statement;
 148 }
 149
 150 /**
 151   Initialize Question's members.
 152
 153   @param  OpCodeData             Pointer of the raw OpCode data.
 154   @param  FormSet                Pointer of the current FormSet.
 155   @param  Form                   Pointer of the current Form.
 156
 157   @return The Question.
 158
 159 **/
 160 FORM_BROWSER_STATEMENT *
 161 CreateQuestion (
 162   IN UINT8                        *OpCodeData,
 163   IN OUT FORM_BROWSER_FORMSET     *FormSet,
 164   IN OUT FORM_BROWSER_FORM        *Form
 165   )
 166 {
 167   FORM_BROWSER_STATEMENT   *Statement;
 168   EFI_IFR_QUESTION_HEADER  *QuestionHdr;
 169   LIST_ENTRY               *Link;
 170   FORMSET_STORAGE          *Storage;
 171
 172   Statement = CreateStatement (OpCodeData, FormSet, Form);
 173   if (Statement == NULL) {
 174     return NULL;
 175   }
 176
 177   QuestionHdr = (EFI_IFR_QUESTION_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
 178   CopyMem (&Statement->QuestionId, &QuestionHdr->QuestionId, sizeof (EFI_QUESTION_ID));
 179   CopyMem (&Statement->VarStoreId, &QuestionHdr->VarStoreId, sizeof (EFI_VARSTORE_ID));
 180   CopyMem (&Statement->VarStoreInfo.VarOffset, &QuestionHdr->VarStoreInfo.VarOffset, sizeof (UINT16));
 181
 182   if (FormSet->MaxQuestionId < QuestionHdr->QuestionId) {
 183     FormSet->MaxQuestionId = QuestionHdr->QuestionId;
 184   }
 185
 186   Statement->QuestionFlags = QuestionHdr->Flags;
 187
 188   if (Statement->VarStoreId == 0) {
 189     //
 190     // VarStoreId of zero indicates no variable storage
 191     //
 192     return Statement;
 193   }
 194
 195   //
 196   // Find Storage for this Question
 197   //
 198   Link = GetFirstNode (&FormSet->StorageListHead);
 199   while (!IsNull (&FormSet->StorageListHead, Link)) {
 200     Storage = FORMSET_STORAGE_FROM_LINK (Link);
 201
 202     if (Storage->VarStoreId == Statement->VarStoreId) {
 203       Statement->Storage = Storage;
 204       break;
 205     }
 206
 207     Link = GetNextNode (&FormSet->StorageListHead, Link);
 208   }
 209   ASSERT (Statement->Storage != NULL);
 210
 211   return Statement;
 212 }
 213
 214 /**
 215   Allocate a FORMSET_STORAGE data structure and insert to FormSet Storage List.
 216
 217   @param  FormSet                Pointer of the current FormSet
 218
 219   @return Pointer to a FORMSET_STORAGE data structure.
 220
 221 **/
 222 FORMSET_STORAGE *
 223 CreateStorage (
 224   IN FORM_BROWSER_FORMSET  *FormSet
 225   )
 226 {
 227   FORMSET_STORAGE  *Storage;
 228
 229   Storage = AllocateZeroPool (sizeof (FORMSET_STORAGE));
 230   Storage->Signature = FORMSET_STORAGE_SIGNATURE;
 231   InsertTailList (&FormSet->StorageListHead, &Storage->Link);
 232
 233   return Storage;
 234 }
 235
 236 /**
 237   Free resources of a storage
 238
 239   @param  Storage                Pointer of the storage
 240
 241   @return None.
 242
 243 **/
 244 VOID
 245 DestroyStorage (
 246   IN FORMSET_STORAGE   *Storage
 247   )
 248 {
 249   if (Storage == NULL) {
 250     return;
 251   }
 252
 253   if (Storage->Name!= NULL) {
 254     FreePool (Storage->Name);
 255   }
 256
 257   FreePool (Storage);
 258 }
 259
 260
 261 /**
 262   Free resources of a Statement
 263
 264   @param  Statement              Pointer of the Statement
 265
 266   @return None.
 267
 268 **/
 269 VOID
 270 DestroyStatement (
 271   IN OUT FORM_BROWSER_STATEMENT  *Statement
 272   )
 273 {
 274   LIST_ENTRY        *Link;
 275   QUESTION_DEFAULT  *Default;
 276   QUESTION_OPTION   *Option;
 277
 278   //
 279   // Free Default value List
 280   //
 281   while (!IsListEmpty (&Statement->DefaultListHead)) {
 282     Link = GetFirstNode (&Statement->DefaultListHead);
 283     Default = QUESTION_DEFAULT_FROM_LINK (Link);
 284     RemoveEntryList (&Default->Link);
 285
 286     gBS->FreePool (Default);
 287   }
 288
 289   //
 290   // Free Options List
 291   //
 292   while (!IsListEmpty (&Statement->OptionListHead)) {
 293     Link = GetFirstNode (&Statement->OptionListHead);
 294     Option = QUESTION_OPTION_FROM_LINK (Link);
 295     RemoveEntryList (&Option->Link);
 296
 297     gBS->FreePool (Option);
 298   }
 299
 300 }
 301
 302
 303
 304 /**
 305   Free resources of a Form
 306
 307   @param  Form                   Pointer of the Form
 308
 309   @return None.
 310
 311 **/
 312 VOID
 313 DestroyForm (
 314   IN OUT FORM_BROWSER_FORM  *Form
 315   )
 316 {
 317   LIST_ENTRY              *Link;
 318   FORM_BROWSER_STATEMENT  *Statement;
 319
 320   //
 321   // Free Statements/Questions
 322   //
 323   while (!IsListEmpty (&Form->StatementListHead)) {
 324     Link = GetFirstNode (&Form->StatementListHead);
 325     Statement = FORM_BROWSER_STATEMENT_FROM_LINK (Link);
 326     RemoveEntryList (&Statement->Link);
 327
 328     DestroyStatement (Statement);
 329   }
 330
 331   //
 332   // Free this Form
 333   //
 334   gBS->FreePool (Form);
 335 }
 336
 337
 338 /**
 339   Free resources allocated for a FormSet
 340
 341   @param  FormSet                Pointer of the FormSet
 342
 343   @return None.
 344
 345 **/
 346 VOID
 347 DestroyFormSet (
 348   IN OUT FORM_BROWSER_FORMSET  *FormSet
 349   )
 350 {
 351   LIST_ENTRY            *Link;
 352   FORMSET_STORAGE       *Storage;
 353   FORMSET_DEFAULTSTORE  *DefaultStore;
 354   FORM_BROWSER_FORM     *Form;
 355
 356   //
 357   // Free IFR binary buffer
 358   //
 359   FreePool (FormSet->IfrBinaryData);
 360
 361   //
 362   // Free FormSet Storage
 363   //
 364   if (FormSet->StorageListHead.ForwardLink != NULL) {
 365     while (!IsListEmpty (&FormSet->StorageListHead)) {
 366       Link = GetFirstNode (&FormSet->StorageListHead);
 367       Storage = FORMSET_STORAGE_FROM_LINK (Link);
 368       RemoveEntryList (&Storage->Link);
 369
 370       DestroyStorage (Storage);
 371     }
 372   }
 373
 374   //
 375   // Free FormSet Default Store
 376   //
 377   if (FormSet->DefaultStoreListHead.ForwardLink != NULL) {
 378     while (!IsListEmpty (&FormSet->DefaultStoreListHead)) {
 379       Link = GetFirstNode (&FormSet->DefaultStoreListHead);
 380       DefaultStore = FORMSET_DEFAULTSTORE_FROM_LINK (Link);
 381       RemoveEntryList (&DefaultStore->Link);
 382
 383       gBS->FreePool (DefaultStore);
 384     }
 385   }
 386
 387   //
 388   // Free Forms
 389   //
 390   if (FormSet->FormListHead.ForwardLink != NULL) {
 391     while (!IsListEmpty (&FormSet->FormListHead)) {
 392       Link = GetFirstNode (&FormSet->FormListHead);
 393       Form = FORM_BROWSER_FORM_FROM_LINK (Link);
 394       RemoveEntryList (&Form->Link);
 395
 396       DestroyForm (Form);
 397     }
 398   }
 399
 400   if (FormSet->StatementBuffer != NULL) {
 401     FreePool (FormSet->StatementBuffer);
 402   }
 403
 404   DestoryOneOfOptionMap (&FormSet->OneOfOptionMapListHead);
 405
 406   if (FormSet->OriginalDefaultVarStoreName != NULL) {
 407     FreePool (FormSet->OriginalDefaultVarStoreName);
 408   }
 409
 410   FreePool (FormSet);
 411 }
 412
 413
 414 /**
 415   Tell whether this Operand is an Expression OpCode or not
 416
 417   @param  Operand                Operand of an IFR OpCode.
 418
 419   @retval TRUE                   This is an Expression OpCode.
 420   @retval FALSE                  Not an Expression OpCode.
 421
 422 **/
 423 BOOLEAN
 424 IsExpressionOpCode (
 425   IN UINT8              Operand
 426   )
 427 {
 428   if (((Operand >= EFI_IFR_EQ_ID_VAL_OP) && (Operand <= EFI_IFR_NOT_OP)) ||
 429       ((Operand >= EFI_IFR_MATCH_OP) && (Operand <= EFI_IFR_SPAN_OP)) ||
 430       (Operand == EFI_IFR_CATENATE_OP)
 431      ) {
 432     return TRUE;
 433   } else {
 434     return FALSE;
 435   }
 436 }
 437
 438
 439 /**
 440   Calculate number of Statemens(Questions) and Expression OpCodes.
 441
 442   @param  FormSet                The FormSet to be counted.
 443   @param  NumberOfStatement      Number of Statemens(Questions)
 444   @param  NumberOfExpression     Number of Expression OpCodes
 445
 446   @return None.
 447
 448 **/
 449 VOID
 450 CountOpCodes (
 451   IN  FORM_BROWSER_FORMSET  *FormSet,
 452   IN OUT  UINT16            *NumberOfStatement,
 453   IN OUT  UINT16            *NumberOfExpression
 454   )
 455 {
 456   UINT16  StatementCount;
 457   UINT16  ExpressionCount;
 458   UINT8   *OpCodeData;
 459   UINTN   Offset;
 460   UINTN   OpCodeLen;
 461
 462   Offset = 0;
 463   StatementCount = 0;
 464   ExpressionCount = 0;
 465
 466   while (Offset < FormSet->IfrBinaryLength) {
 467     OpCodeData = FormSet->IfrBinaryData + Offset;
 468     OpCodeLen = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
 469     Offset += OpCodeLen;
 470
 471     if (IsExpressionOpCode (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode)) {
 472       ExpressionCount++;
 473     } else {
 474       StatementCount++;
 475     }
 476   }
 477
 478   *NumberOfStatement = StatementCount;
 479   *NumberOfExpression = ExpressionCount;
 480 }
 481
 482
 483 /**
 484   Parse opcodes in the formset IFR binary.
 485
 486   @param  FormSet                Pointer of the FormSet data structure.
 487
 488   @retval EFI_SUCCESS            Opcode parse success.
 489   @retval Other                  Opcode parse fail.
 490
 491 **/
 492 EFI_STATUS
 493 ParseOpCodes (
 494   IN FORM_BROWSER_FORMSET              *FormSet
 495   )
 496 {
 497   EFI_STATUS              Status;
 498   UINT16                  Index;
 499   FORM_BROWSER_FORM       *CurrentForm;
 500   FORM_BROWSER_STATEMENT  *CurrentStatement;
 501   UINT8                   Operand;
 502   UINT8                   Scope;
 503   UINTN                   OpCodeOffset;
 504   UINTN                   OpCodeLength;
 505   UINT8                   *OpCodeData;
 506   UINT8                   ScopeOpCode;
 507   FORMSET_STORAGE         *Storage;
 508   FORMSET_DEFAULTSTORE    *DefaultStore;
 509   QUESTION_DEFAULT        *CurrentDefault;
 510   QUESTION_OPTION         *CurrentOption;
 511   CHAR8                   *AsciiString;
 512   UINT16                  NumberOfStatement;
 513   UINT16                  NumberOfExpression;
 514   EFI_IMAGE_ID            *ImageId;
 515   EFI_HII_VALUE           *Value;
 516   LIST_ENTRY              *OneOfOptinMapEntryListHead;
 517   EFI_IFR_GUID_OPTIONKEY  *OptionMap;
 518   ONE_OF_OPTION_MAP       *OneOfOptionMap;
 519   ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry;
 520   UINT8                   OneOfType;
 521   EFI_IFR_ONE_OF          *OneOfOpcode;
 522
 523   mInScopeSubtitle         = FALSE;
 524   mInScopeSuppress         = FALSE;
 525   mInScopeGrayOut          = FALSE;
 526   CurrentDefault           = NULL;
 527   CurrentOption            = NULL;
 528
 529   //
 530   // Set to a invalid value.
 531   //
 532   OneOfType = (UINT8) -1;
 533
 534   //
 535   // Get the number of Statements and Expressions
 536   //
 537   CountOpCodes (FormSet, &NumberOfStatement, &NumberOfExpression);
 538   FormSet->NumberOfStatement = NumberOfStatement;
 539
 540   mStatementIndex = 0;
 541   FormSet->StatementBuffer = AllocateZeroPool (NumberOfStatement * sizeof (FORM_BROWSER_STATEMENT));
 542   if (FormSet->StatementBuffer == NULL) {
 543     return EFI_OUT_OF_RESOURCES;
 544   }
 545
 546   InitializeListHead (&FormSet->StorageListHead);
 547   InitializeListHead (&FormSet->DefaultStoreListHead);
 548   InitializeListHead (&FormSet->FormListHead);
 549   InitializeListHead (&FormSet->OneOfOptionMapListHead);
 550
 551   CurrentForm = NULL;
 552   CurrentStatement = NULL;
 553
 554   ResetScopeStack ();
 555
 556   OpCodeOffset = 0;
 557   while (OpCodeOffset < FormSet->IfrBinaryLength) {
 558     OpCodeData = FormSet->IfrBinaryData + OpCodeOffset;
 559
 560     OpCodeLength = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
 561     OpCodeOffset += OpCodeLength;
 562     Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
 563     Scope = ((EFI_IFR_OP_HEADER *) OpCodeData)->Scope;
 564
 565     //
 566     // If scope bit set, push onto scope stack
 567     //
 568     if (Scope) {
 569       PushScope (Operand);
 570     }
 571
 572     if (IsExpressionOpCode (Operand)) {
 573       continue;
 574     }
 575
 576     //
 577     // Parse the Opcode
 578     //
 579     switch (Operand) {
 580
 581     case EFI_IFR_FORM_SET_OP:
 582       //
 583       // check the formset GUID
 584       //
 585       if (!CompareGuid ((EFI_GUID *)(VOID *)&FormSet->Guid, (EFI_GUID *)(VOID *)&((EFI_IFR_FORM_SET *) OpCodeData)->Guid)) {
 586         return EFI_INVALID_PARAMETER;
 587       }
 588
 589       CopyMem (&FormSet->FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
 590       CopyMem (&FormSet->Help,         &((EFI_IFR_FORM_SET *) OpCodeData)->Help,         sizeof (EFI_STRING_ID));
 591       break;
 592
 593     case EFI_IFR_FORM_OP:
 594       //
 595       // Create a new Form for this FormSet
 596       //
 597       CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM));
 598       CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE;
 599
 600       InitializeListHead (&CurrentForm->StatementListHead);
 601
 602       CopyMem (&CurrentForm->FormId,    &((EFI_IFR_FORM *) OpCodeData)->FormId,    sizeof (UINT16));
 603       CopyMem (&CurrentForm->FormTitle, &((EFI_IFR_FORM *) OpCodeData)->FormTitle, sizeof (EFI_STRING_ID));
 604
 605       //
 606       // Insert into Form list of this FormSet
 607       //
 608       InsertTailList (&FormSet->FormListHead, &CurrentForm->Link);
 609       break;
 610
 611     //
 612     // Storage
 613     //
 614     case EFI_IFR_VARSTORE_OP:
 615       //
 616       // Create a buffer Storage for this FormSet
 617       //
 618       Storage = CreateStorage (FormSet);
 619       Storage->Type = EFI_HII_VARSTORE_BUFFER;
 620
 621       CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
 622       CopyMem (&Storage->Guid,       &((EFI_IFR_VARSTORE *) OpCodeData)->Guid,       sizeof (EFI_GUID));
 623       CopyMem (&Storage->Size,       &((EFI_IFR_VARSTORE *) OpCodeData)->Size,       sizeof (UINT16));
 624
 625       AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name;
 626       Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2);
 627       ASSERT (Storage->Name != NULL);
 628       for (Index = 0; AsciiString[Index] != 0; Index++) {
 629         Storage->Name[Index] = (CHAR16) AsciiString[Index];
 630       }
 631
 632       break;
 633
 634     case EFI_IFR_VARSTORE_NAME_VALUE_OP:
 635       ASSERT (FALSE);
 636
 637       break;
 638
 639     case EFI_IFR_VARSTORE_EFI_OP:
 640       //
 641       // Create a EFI variable Storage for this FormSet
 642       //
 643       Storage = CreateStorage (FormSet);
 644       Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE;
 645
 646       CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
 647       CopyMem (&Storage->Guid,       &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid,       sizeof (EFI_GUID));
 648       CopyMem (&Storage->Attributes, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Attributes, sizeof (UINT32));
 649       break;
 650
 651     //
 652     // DefaultStore
 653     //
 654     case EFI_IFR_DEFAULTSTORE_OP:
 655       DefaultStore = AllocateZeroPool (sizeof (FORMSET_DEFAULTSTORE));
 656       DefaultStore->Signature = FORMSET_DEFAULTSTORE_SIGNATURE;
 657
 658       CopyMem (&DefaultStore->DefaultId,   &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultId,   sizeof (UINT16));
 659       CopyMem (&DefaultStore->DefaultName, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultName, sizeof (EFI_STRING_ID));
 660
 661       //
 662       // Insert to DefaultStore list of this Formset
 663       //
 664       InsertTailList (&FormSet->DefaultStoreListHead, &DefaultStore->Link);
 665       break;
 666
 667     //
 668     // Statements
 669     //
 670     case EFI_IFR_SUBTITLE_OP:
 671       CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
 672       CurrentStatement->Flags = ((EFI_IFR_SUBTITLE *) OpCodeData)->Flags;
 673
 674       if (Scope) {
 675         mInScopeSubtitle = TRUE;
 676       }
 677       break;
 678
 679     case EFI_IFR_TEXT_OP:
 680       CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
 681
 682       CopyMem (&CurrentStatement->TextTwo, &((EFI_IFR_TEXT *) OpCodeData)->TextTwo, sizeof (EFI_STRING_ID));
 683       break;
 684
 685     //
 686     // Questions
 687     //
 688     case EFI_IFR_ACTION_OP:
 689       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 690
 691       if (OpCodeLength == sizeof (EFI_IFR_ACTION_1)) {
 692         //
 693         // No QuestionConfig present, so no configuration string will be processed
 694         //
 695         CurrentStatement->QuestionConfig = 0;
 696       } else {
 697         CopyMem (&CurrentStatement->QuestionConfig, &((EFI_IFR_ACTION *) OpCodeData)->QuestionConfig, sizeof (EFI_STRING_ID));
 698       }
 699       break;
 700
 701     case EFI_IFR_RESET_BUTTON_OP:
 702       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 703
 704       CopyMem (&CurrentStatement->DefaultId, &((EFI_IFR_RESET_BUTTON *) OpCodeData)->DefaultId, sizeof (EFI_DEFAULT_ID));
 705       break;
 706
 707     case EFI_IFR_REF_OP:
 708       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 709
 710       CopyMem (&CurrentStatement->RefFormId, &((EFI_IFR_REF *) OpCodeData)->FormId, sizeof (EFI_FORM_ID));
 711       if (OpCodeLength >= sizeof (EFI_IFR_REF2)) {
 712         CopyMem (&CurrentStatement->RefQuestionId, &((EFI_IFR_REF2 *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
 713
 714         if (OpCodeLength >= sizeof (EFI_IFR_REF3)) {
 715           CopyMem (&CurrentStatement->RefFormSetId, &((EFI_IFR_REF3 *) OpCodeData)->FormSetId, sizeof (EFI_GUID));
 716
 717           if (OpCodeLength >= sizeof (EFI_IFR_REF4)) {
 718             CopyMem (&CurrentStatement->RefDevicePath, &((EFI_IFR_REF4 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID));
 719           }
 720         }
 721       }
 722       break;
 723
 724     case EFI_IFR_ONE_OF_OP:
 725     case EFI_IFR_NUMERIC_OP:
 726       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 727
 728       CurrentStatement->Flags = ((EFI_IFR_ONE_OF *) OpCodeData)->Flags;
 729       Value = &CurrentStatement->HiiValue;
 730
 731       switch (CurrentStatement->Flags & EFI_IFR_NUMERIC_SIZE) {
 732       case EFI_IFR_NUMERIC_SIZE_1:
 733         CurrentStatement->Minimum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MinValue;
 734         CurrentStatement->Maximum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MaxValue;
 735         CurrentStatement->Step    = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.Step;
 736         CurrentStatement->StorageWidth = sizeof (UINT8);
 737         Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
 738         break;
 739
 740       case EFI_IFR_NUMERIC_SIZE_2:
 741         CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MinValue, sizeof (UINT16));
 742         CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MaxValue, sizeof (UINT16));
 743         CopyMem (&CurrentStatement->Step,    &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.Step,     sizeof (UINT16));
 744         CurrentStatement->StorageWidth = sizeof (UINT16);
 745         Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
 746         break;
 747
 748       case EFI_IFR_NUMERIC_SIZE_4:
 749         CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MinValue, sizeof (UINT32));
 750         CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MaxValue, sizeof (UINT32));
 751         CopyMem (&CurrentStatement->Step,    &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.Step,     sizeof (UINT32));
 752         CurrentStatement->StorageWidth = sizeof (UINT32);
 753         Value->Type = EFI_IFR_TYPE_NUM_SIZE_32;
 754         break;
 755
 756       case EFI_IFR_NUMERIC_SIZE_8:
 757         CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MinValue, sizeof (UINT64));
 758         CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MaxValue, sizeof (UINT64));
 759         CopyMem (&CurrentStatement->Step,    &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.Step,     sizeof (UINT64));
 760         CurrentStatement->StorageWidth = sizeof (UINT64);
 761         Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
 762         break;
 763
 764       default:
 765         break;
 766       }
 767
 768       if (Operand == EFI_IFR_ONE_OF_OP) {
 769         OneOfOpcode = (EFI_IFR_ONE_OF *) OpCodeData;
 770         OneOfType   = (UINT8) (OneOfOpcode->Flags & EFI_IFR_NUMERIC_SIZE);
 771       }
 772       break;
 773
 774     case EFI_IFR_ORDERED_LIST_OP:
 775       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 776
 777       CurrentStatement->Flags = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->Flags;
 778       CurrentStatement->MaxContainers = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->MaxContainers;
 779       CurrentStatement->StorageWidth = (UINT16)(CurrentStatement->MaxContainers * sizeof (UINT8));
 780
 781       //
 782       // No buffer type is defined in EFI_IFR_TYPE_VALUE, so a Configuration Driver
 783       // has to use FormBrowser2.Callback() to retrieve the uncommited data for
 784       // an interactive orderedlist (i.e. with EFI_IFR_FLAG_CALLBACK flag set).
 785       //
 786       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_OTHER;
 787       CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
 788
 789       break;
 790
 791     case EFI_IFR_CHECKBOX_OP:
 792       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 793
 794       CurrentStatement->Flags = ((EFI_IFR_CHECKBOX *) OpCodeData)->Flags;
 795       CurrentStatement->StorageWidth = sizeof (BOOLEAN);
 796       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BOOLEAN;
 797
 798       break;
 799
 800     case EFI_IFR_STRING_OP:
 801       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 802
 803       //
 804       // MinSize is the minimum number of characters that can be accepted for this opcode,
 805       // MaxSize is the maximum number of characters that can be accepted for this opcode.
 806       // The characters are stored as Unicode, so the storage width should multiply 2.
 807       //
 808       CurrentStatement->Minimum = ((EFI_IFR_STRING *) OpCodeData)->MinSize;
 809       CurrentStatement->Maximum = ((EFI_IFR_STRING *) OpCodeData)->MaxSize;
 810       CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16));
 811       CurrentStatement->Flags = ((EFI_IFR_STRING *) OpCodeData)->Flags;
 812
 813       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
 814       CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
 815
 816       break;
 817
 818     case EFI_IFR_PASSWORD_OP:
 819       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 820
 821       //
 822       // MinSize is the minimum number of characters that can be accepted for this opcode,
 823       // MaxSize is the maximum number of characters that can be accepted for this opcode.
 824       // The characters are stored as Unicode, so the storage width should multiply 2.
 825       //
 826       CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_PASSWORD *) OpCodeData)->MinSize, sizeof (UINT16));
 827       CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_PASSWORD *) OpCodeData)->MaxSize, sizeof (UINT16));
 828       CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16));
 829
 830       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
 831       CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
 832
 833       break;
 834
 835     case EFI_IFR_DATE_OP:
 836       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 837
 838       CurrentStatement->Flags = ((EFI_IFR_DATE *) OpCodeData)->Flags;
 839       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_DATE;
 840
 841       break;
 842
 843     case EFI_IFR_TIME_OP:
 844       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 845
 846       CurrentStatement->Flags = ((EFI_IFR_TIME *) OpCodeData)->Flags;
 847       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_TIME;
 848
 849       break;
 850
 851     //
 852     // Default
 853     //
 854     case EFI_IFR_DEFAULT_OP:
 855       //
 856       // EFI_IFR_DEFAULT appear in scope of a Question,
 857       // It creates a default value for the current question.
 858       // A Question may have more than one Default value which have different default types.
 859       //
 860       CurrentDefault = AllocateZeroPool (sizeof (QUESTION_DEFAULT));
 861       CurrentDefault->Signature = QUESTION_DEFAULT_SIGNATURE;
 862
 863       CurrentDefault->Value.Type = ((EFI_IFR_DEFAULT *) OpCodeData)->Type;
 864       CopyMem (&CurrentDefault->DefaultId, &((EFI_IFR_DEFAULT *) OpCodeData)->DefaultId, sizeof (UINT16));
 865       CopyMem (&CurrentDefault->Value.Value, &((EFI_IFR_DEFAULT *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
 866       ExtendValueToU64 (&CurrentDefault->Value);
 867
 868       //
 869       // Insert to Default Value list of current Question
 870       //
 871       InsertTailList (&CurrentStatement->DefaultListHead, &CurrentDefault->Link);
 872
 873       break;
 874
 875     //
 876     // Option
 877     //
 878     case EFI_IFR_ONE_OF_OPTION_OP:
 879       //
 880       // EFI_IFR_ONE_OF_OPTION appear in scope of a Question.
 881       // It create a selection for use in current Question.
 882       //
 883       CurrentOption = AllocateZeroPool (sizeof (QUESTION_OPTION));
 884       CurrentOption->Signature = QUESTION_OPTION_SIGNATURE;
 885
 886       CurrentOption->Flags = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Flags;
 887       CurrentOption->Value.Type = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Type;
 888       CopyMem (&CurrentOption->Text, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Option, sizeof (EFI_STRING_ID));
 889       CopyMem (&CurrentOption->Value.Value, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
 890       ExtendValueToU64 (&CurrentOption->Value);
 891
 892       //
 893       // Insert to Option list of current Question
 894       //
 895       InsertTailList (&CurrentStatement->OptionListHead, &CurrentOption->Link);
 896       break;
 897
 898     //
 899     // Conditional
 900     //
 901     case EFI_IFR_NO_SUBMIT_IF_OP:
 902     case EFI_IFR_INCONSISTENT_IF_OP:
 903       break;
 904
 905     case EFI_IFR_SUPPRESS_IF_OP:
 906       break;
 907
 908     case EFI_IFR_GRAY_OUT_IF_OP:
 909       break;
 910
 911     case EFI_IFR_DISABLE_IF_OP:
 912       ASSERT (FALSE);
 913
 914
 915     //
 916     // Expression
 917     //
 918     case EFI_IFR_VALUE_OP:
 919       break;
 920
 921     case EFI_IFR_RULE_OP:
 922       break;
 923
 924     //
 925     // Image
 926     //
 927     case EFI_IFR_IMAGE_OP:
 928       //
 929       // Get ScopeOpcode from top of stack
 930       //
 931       PopScope (&ScopeOpCode);
 932       PushScope (ScopeOpCode);
 933
 934       switch (ScopeOpCode) {
 935       case EFI_IFR_FORM_SET_OP:
 936         ImageId = &FormSet->ImageId;
 937         break;
 938
 939       case EFI_IFR_FORM_OP:
 940         ImageId = &CurrentForm->ImageId;
 941         break;
 942
 943       case EFI_IFR_ONE_OF_OPTION_OP:
 944         ImageId = &CurrentOption->ImageId;
 945         break;
 946
 947       default:
 948         ImageId = &CurrentStatement->ImageId;
 949         break;
 950       }
 951
 952       CopyMem (ImageId, &((EFI_IFR_IMAGE *) OpCodeData)->Id, sizeof (EFI_IMAGE_ID));
 953       break;
 954
 955     //
 956     // Refresh
 957     //
 958     case EFI_IFR_REFRESH_OP:
 959       CurrentStatement->RefreshInterval = ((EFI_IFR_REFRESH *) OpCodeData)->RefreshInterval;
 960       break;
 961
 962     //
 963     // Vendor specific
 964     //
 965     case EFI_IFR_GUID_OP:
 966       OptionMap = (EFI_IFR_GUID_OPTIONKEY *) OpCodeData;
 967
 968       if (CompareGuid (&mTianoHiiIfrGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
 969         //
 970         // Tiano specific GUIDed opcodes
 971         //
 972         switch (((EFI_IFR_GUID_LABEL *) OpCodeData)->ExtendOpCode) {
 973         case EFI_IFR_EXTEND_OP_LABEL:
 974           //
 975           // just ignore label
 976           //
 977           break;
 978
 979
 980         case EFI_IFR_EXTEND_OP_CLASS:
 981           CopyMem (&FormSet->Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16));
 982           break;
 983
 984         case EFI_IFR_EXTEND_OP_SUBCLASS:
 985           CopyMem (&FormSet->SubClass, &((EFI_IFR_GUID_SUBCLASS *) OpCodeData)->SubClass, sizeof (UINT16));
 986           break;
 987
 988         default:
 989           break;
 990         }
 991       }
 992       else if (CompareGuid ((EFI_GUID *)(VOID *)&OptionMap->Guid, &mFrameworkHiiCompatibilityGuid)) {
 993         if (OptionMap->ExtendOpCode == EFI_IFR_EXTEND_OP_OPTIONKEY) {
 994           OneOfOptinMapEntryListHead = GetOneOfOptionMapEntryListHead (FormSet, OptionMap->QuestionId);
 995           if (OneOfOptinMapEntryListHead == NULL) {
 996             OneOfOptionMap = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP));
 997             ASSERT (OneOfOptionMap != NULL);
 998
 999             OneOfOptionMap->Signature = ONE_OF_OPTION_MAP_SIGNATURE;
1000             OneOfOptionMap->QuestionId = OptionMap->QuestionId;
1001
1002             //
1003             // Make sure OneOfType is initialized.
1004             //
1005             ASSERT (OneOfType != (UINT8) -1);
1006             OneOfOptionMap->ValueType = OneOfType;
1007             InitializeListHead (&OneOfOptionMap->OneOfOptionMapEntryListHead);
1008             OneOfOptinMapEntryListHead = &OneOfOptionMap->OneOfOptionMapEntryListHead;
1009             InsertTailList (&FormSet->OneOfOptionMapListHead, &OneOfOptionMap->Link);
1010           }
1011           OneOfOptionMapEntry = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP_ENTRY));
1012           ASSERT (OneOfOptionMapEntry != NULL);
1013
1014           OneOfOptionMapEntry->Signature = ONE_OF_OPTION_MAP_ENTRY_SIGNATURE;
1015           OneOfOptionMapEntry->FwKey = OptionMap->KeyValue;
1016           CopyMem (&OneOfOptionMapEntry->Value, &OptionMap->OptionValue, sizeof (EFI_IFR_TYPE_VALUE));
1017
1018           InsertTailList (OneOfOptinMapEntryListHead, &OneOfOptionMapEntry->Link);
1019         }
1020      }
1021       break;
1022
1023     //
1024     // Scope End
1025     //
1026     case EFI_IFR_END_OP:
1027       Status = PopScope (&ScopeOpCode);
1028       if (EFI_ERROR (Status)) {
1029         ResetScopeStack ();
1030         return Status;
1031       }
1032
1033       switch (ScopeOpCode) {
1034       case EFI_IFR_FORM_SET_OP:
1035         //
1036         // End of FormSet, update FormSet IFR binary length
1037         // to stop parsing substantial OpCodes
1038         //
1039         FormSet->IfrBinaryLength = OpCodeOffset;
1040         break;
1041
1042       case EFI_IFR_FORM_OP:
1043         //
1044         // End of Form
1045         //
1046         CurrentForm = NULL;
1047         break;
1048
1049       case EFI_IFR_ONE_OF_OPTION_OP:
1050         //
1051         // End of Option
1052         //
1053         CurrentOption = NULL;
1054         break;
1055
1056       case EFI_IFR_SUBTITLE_OP:
1057         mInScopeSubtitle = FALSE;
1058         break;
1059
1060       case EFI_IFR_NO_SUBMIT_IF_OP:
1061       case EFI_IFR_INCONSISTENT_IF_OP:
1062         //
1063         // Ignore end of EFI_IFR_NO_SUBMIT_IF and EFI_IFR_INCONSISTENT_IF
1064         //
1065         break;
1066
1067       case EFI_IFR_GRAY_OUT_IF_OP:
1068         mInScopeGrayOut = FALSE;
1069         break;
1070
1071       default:
1072         if (IsExpressionOpCode (ScopeOpCode)) {
1073         }
1074         break;
1075       }
1076       break;
1077
1078     default:
1079       break;
1080     }
1081   }
1082
1083   return EFI_SUCCESS;
1084 }
1085
1086
1087
1088