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