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   if (FormSet->OriginalDefaultVarStoreName != NULL) {
 408     FreePool (FormSet->OriginalDefaultVarStoreName);
 409   }
 410
 411   FreePool (FormSet);
 412 }
 413
 414
 415 /**
 416   Tell whether this Operand is an Expression OpCode or not
 417
 418   @param  Operand                Operand of an IFR OpCode.
 419
 420   @retval TRUE                   This is an Expression OpCode.
 421   @retval FALSE                  Not an Expression OpCode.
 422
 423 **/
 424 BOOLEAN
 425 IsExpressionOpCode (
 426   IN UINT8              Operand
 427   )
 428 {
 429   if (((Operand >= EFI_IFR_EQ_ID_VAL_OP) && (Operand <= EFI_IFR_NOT_OP)) ||
 430       ((Operand >= EFI_IFR_MATCH_OP) && (Operand <= EFI_IFR_SPAN_OP)) ||
 431       (Operand == EFI_IFR_CATENATE_OP)
 432      ) {
 433     return TRUE;
 434   } else {
 435     return FALSE;
 436   }
 437 }
 438
 439
 440 /**
 441   Calculate number of Statemens(Questions) and Expression OpCodes.
 442
 443   @param  FormSet                The FormSet to be counted.
 444   @param  NumberOfStatement      Number of Statemens(Questions)
 445   @param  NumberOfExpression     Number of Expression OpCodes
 446
 447   @return None.
 448
 449 **/
 450 VOID
 451 CountOpCodes (
 452   IN  FORM_BROWSER_FORMSET  *FormSet,
 453   IN OUT  UINT16            *NumberOfStatement,
 454   IN OUT  UINT16            *NumberOfExpression
 455   )
 456 {
 457   UINT16  StatementCount;
 458   UINT16  ExpressionCount;
 459   UINT8   *OpCodeData;
 460   UINTN   Offset;
 461   UINTN   OpCodeLen;
 462
 463   Offset = 0;
 464   StatementCount = 0;
 465   ExpressionCount = 0;
 466
 467   while (Offset < FormSet->IfrBinaryLength) {
 468     OpCodeData = FormSet->IfrBinaryData + Offset;
 469     OpCodeLen = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
 470     Offset += OpCodeLen;
 471
 472     if (IsExpressionOpCode (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode)) {
 473       ExpressionCount++;
 474     } else {
 475       StatementCount++;
 476     }
 477   }
 478
 479   *NumberOfStatement = StatementCount;
 480   *NumberOfExpression = ExpressionCount;
 481 }
 482
 483
 484 /**
 485   Parse opcodes in the formset IFR binary.
 486
 487   @param  FormSet                Pointer of the FormSet data structure.
 488
 489   @retval EFI_SUCCESS            Opcode parse success.
 490   @retval Other                  Opcode parse fail.
 491
 492 **/
 493 EFI_STATUS
 494 ParseOpCodes (
 495   IN FORM_BROWSER_FORMSET              *FormSet
 496   )
 497 {
 498   EFI_STATUS              Status;
 499   UINT16                  Index;
 500   FORM_BROWSER_FORM       *CurrentForm;
 501   FORM_BROWSER_STATEMENT  *CurrentStatement;
 502   UINT8                   Operand;
 503   UINT8                   Scope;
 504   UINTN                   OpCodeOffset;
 505   UINTN                   OpCodeLength;
 506   UINT8                   *OpCodeData;
 507   UINT8                   ScopeOpCode;
 508   FORMSET_STORAGE         *Storage;
 509   FORMSET_DEFAULTSTORE    *DefaultStore;
 510   QUESTION_DEFAULT        *CurrentDefault;
 511   QUESTION_OPTION         *CurrentOption;
 512   CHAR8                   *AsciiString;
 513   UINT16                  NumberOfStatement;
 514   UINT16                  NumberOfExpression;
 515   EFI_IMAGE_ID            *ImageId;
 516   EFI_HII_VALUE           *Value;
 517   LIST_ENTRY              *OneOfOptinMapEntryListHead;
 518   EFI_IFR_GUID_OPTIONKEY  *OptionMap;
 519   ONE_OF_OPTION_MAP       *OneOfOptionMap;
 520   ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry;
 521   UINT8                   OneOfType;
 522   EFI_IFR_ONE_OF          *OneOfOpcode;
 523
 524   mInScopeSubtitle         = FALSE;
 525   mInScopeSuppress         = FALSE;
 526   mInScopeGrayOut          = FALSE;
 527   CurrentDefault           = NULL;
 528   CurrentOption            = NULL;
 529
 530   //
 531   // Set to a invalid value.
 532   //
 533   OneOfType = (UINT8) -1;
 534
 535   //
 536   // Get the number of Statements and Expressions
 537   //
 538   CountOpCodes (FormSet, &NumberOfStatement, &NumberOfExpression);
 539   FormSet->NumberOfStatement = NumberOfStatement;
 540
 541   mStatementIndex = 0;
 542   FormSet->StatementBuffer = AllocateZeroPool (NumberOfStatement * sizeof (FORM_BROWSER_STATEMENT));
 543   if (FormSet->StatementBuffer == NULL) {
 544     return EFI_OUT_OF_RESOURCES;
 545   }
 546
 547   InitializeListHead (&FormSet->StorageListHead);
 548   InitializeListHead (&FormSet->DefaultStoreListHead);
 549   InitializeListHead (&FormSet->FormListHead);
 550   InitializeListHead (&FormSet->OneOfOptionMapListHead);
 551
 552   CurrentForm = NULL;
 553   CurrentStatement = NULL;
 554
 555   ResetScopeStack ();
 556
 557   OpCodeOffset = 0;
 558   while (OpCodeOffset < FormSet->IfrBinaryLength) {
 559     OpCodeData = FormSet->IfrBinaryData + OpCodeOffset;
 560
 561     OpCodeLength = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
 562     OpCodeOffset += OpCodeLength;
 563     Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
 564     Scope = ((EFI_IFR_OP_HEADER *) OpCodeData)->Scope;
 565
 566     //
 567     // If scope bit set, push onto scope stack
 568     //
 569     if (Scope) {
 570       PushScope (Operand);
 571     }
 572
 573     if (IsExpressionOpCode (Operand)) {
 574       continue;
 575     }
 576
 577     //
 578     // Parse the Opcode
 579     //
 580     switch (Operand) {
 581
 582     case EFI_IFR_FORM_SET_OP:
 583       //
 584       // check the formset GUID
 585       //
 586       if (!CompareGuid ((EFI_GUID *)(VOID *)&FormSet->Guid, (EFI_GUID *)(VOID *)&((EFI_IFR_FORM_SET *) OpCodeData)->Guid)) {
 587         return EFI_INVALID_PARAMETER;
 588       }
 589
 590       CopyMem (&FormSet->FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
 591       CopyMem (&FormSet->Help,         &((EFI_IFR_FORM_SET *) OpCodeData)->Help,         sizeof (EFI_STRING_ID));
 592       break;
 593
 594     case EFI_IFR_FORM_OP:
 595       //
 596       // Create a new Form for this FormSet
 597       //
 598       CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM));
 599       CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE;
 600
 601       InitializeListHead (&CurrentForm->StatementListHead);
 602
 603       CopyMem (&CurrentForm->FormId,    &((EFI_IFR_FORM *) OpCodeData)->FormId,    sizeof (UINT16));
 604       CopyMem (&CurrentForm->FormTitle, &((EFI_IFR_FORM *) OpCodeData)->FormTitle, sizeof (EFI_STRING_ID));
 605
 606       //
 607       // Insert into Form list of this FormSet
 608       //
 609       InsertTailList (&FormSet->FormListHead, &CurrentForm->Link);
 610       break;
 611
 612     //
 613     // Storage
 614     //
 615     case EFI_IFR_VARSTORE_OP:
 616       //
 617       // Create a buffer Storage for this FormSet
 618       //
 619       Storage = CreateStorage (FormSet);
 620       Storage->Type = EFI_HII_VARSTORE_BUFFER;
 621
 622       CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
 623       CopyMem (&Storage->Guid,       &((EFI_IFR_VARSTORE *) OpCodeData)->Guid,       sizeof (EFI_GUID));
 624       CopyMem (&Storage->Size,       &((EFI_IFR_VARSTORE *) OpCodeData)->Size,       sizeof (UINT16));
 625
 626       AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name;
 627       Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2);
 628       ASSERT (Storage->Name != NULL);
 629       for (Index = 0; AsciiString[Index] != 0; Index++) {
 630         Storage->Name[Index] = (CHAR16) AsciiString[Index];
 631       }
 632
 633       break;
 634
 635     case EFI_IFR_VARSTORE_NAME_VALUE_OP:
 636       ASSERT (FALSE);
 637
 638       break;
 639
 640     case EFI_IFR_VARSTORE_EFI_OP:
 641       //
 642       // Create a EFI variable Storage for this FormSet
 643       //
 644       Storage = CreateStorage (FormSet);
 645       Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE;
 646
 647       CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
 648       CopyMem (&Storage->Guid,       &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid,       sizeof (EFI_GUID));
 649       CopyMem (&Storage->Attributes, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Attributes, sizeof (UINT32));
 650       break;
 651
 652     //
 653     // DefaultStore
 654     //
 655     case EFI_IFR_DEFAULTSTORE_OP:
 656       DefaultStore = AllocateZeroPool (sizeof (FORMSET_DEFAULTSTORE));
 657       DefaultStore->Signature = FORMSET_DEFAULTSTORE_SIGNATURE;
 658
 659       CopyMem (&DefaultStore->DefaultId,   &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultId,   sizeof (UINT16));
 660       CopyMem (&DefaultStore->DefaultName, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultName, sizeof (EFI_STRING_ID));
 661
 662       //
 663       // Insert to DefaultStore list of this Formset
 664       //
 665       InsertTailList (&FormSet->DefaultStoreListHead, &DefaultStore->Link);
 666       break;
 667
 668     //
 669     // Statements
 670     //
 671     case EFI_IFR_SUBTITLE_OP:
 672       CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
 673       CurrentStatement->Flags = ((EFI_IFR_SUBTITLE *) OpCodeData)->Flags;
 674
 675       if (Scope) {
 676         mInScopeSubtitle = TRUE;
 677       }
 678       break;
 679
 680     case EFI_IFR_TEXT_OP:
 681       CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
 682
 683       CopyMem (&CurrentStatement->TextTwo, &((EFI_IFR_TEXT *) OpCodeData)->TextTwo, sizeof (EFI_STRING_ID));
 684       break;
 685
 686     //
 687     // Questions
 688     //
 689     case EFI_IFR_ACTION_OP:
 690       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 691
 692       if (OpCodeLength == sizeof (EFI_IFR_ACTION_1)) {
 693         //
 694         // No QuestionConfig present, so no configuration string will be processed
 695         //
 696         CurrentStatement->QuestionConfig = 0;
 697       } else {
 698         CopyMem (&CurrentStatement->QuestionConfig, &((EFI_IFR_ACTION *) OpCodeData)->QuestionConfig, sizeof (EFI_STRING_ID));
 699       }
 700       break;
 701
 702     case EFI_IFR_RESET_BUTTON_OP:
 703       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 704
 705       CopyMem (&CurrentStatement->DefaultId, &((EFI_IFR_RESET_BUTTON *) OpCodeData)->DefaultId, sizeof (EFI_DEFAULT_ID));
 706       break;
 707
 708     case EFI_IFR_REF_OP:
 709       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 710
 711       CopyMem (&CurrentStatement->RefFormId, &((EFI_IFR_REF *) OpCodeData)->FormId, sizeof (EFI_FORM_ID));
 712       if (OpCodeLength >= sizeof (EFI_IFR_REF2)) {
 713         CopyMem (&CurrentStatement->RefQuestionId, &((EFI_IFR_REF2 *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
 714
 715         if (OpCodeLength >= sizeof (EFI_IFR_REF3)) {
 716           CopyMem (&CurrentStatement->RefFormSetId, &((EFI_IFR_REF3 *) OpCodeData)->FormSetId, sizeof (EFI_GUID));
 717
 718           if (OpCodeLength >= sizeof (EFI_IFR_REF4)) {
 719             CopyMem (&CurrentStatement->RefDevicePath, &((EFI_IFR_REF4 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID));
 720           }
 721         }
 722       }
 723       break;
 724
 725     case EFI_IFR_ONE_OF_OP:
 726     case EFI_IFR_NUMERIC_OP:
 727       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 728
 729       CurrentStatement->Flags = ((EFI_IFR_ONE_OF *) OpCodeData)->Flags;
 730       Value = &CurrentStatement->HiiValue;
 731
 732       switch (CurrentStatement->Flags & EFI_IFR_NUMERIC_SIZE) {
 733       case EFI_IFR_NUMERIC_SIZE_1:
 734         CurrentStatement->Minimum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MinValue;
 735         CurrentStatement->Maximum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MaxValue;
 736         CurrentStatement->Step    = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.Step;
 737         CurrentStatement->StorageWidth = sizeof (UINT8);
 738         Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
 739         break;
 740
 741       case EFI_IFR_NUMERIC_SIZE_2:
 742         CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MinValue, sizeof (UINT16));
 743         CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MaxValue, sizeof (UINT16));
 744         CopyMem (&CurrentStatement->Step,    &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.Step,     sizeof (UINT16));
 745         CurrentStatement->StorageWidth = sizeof (UINT16);
 746         Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
 747         break;
 748
 749       case EFI_IFR_NUMERIC_SIZE_4:
 750         CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MinValue, sizeof (UINT32));
 751         CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MaxValue, sizeof (UINT32));
 752         CopyMem (&CurrentStatement->Step,    &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.Step,     sizeof (UINT32));
 753         CurrentStatement->StorageWidth = sizeof (UINT32);
 754         Value->Type = EFI_IFR_TYPE_NUM_SIZE_32;
 755         break;
 756
 757       case EFI_IFR_NUMERIC_SIZE_8:
 758         CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MinValue, sizeof (UINT64));
 759         CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MaxValue, sizeof (UINT64));
 760         CopyMem (&CurrentStatement->Step,    &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.Step,     sizeof (UINT64));
 761         CurrentStatement->StorageWidth = sizeof (UINT64);
 762         Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
 763         break;
 764
 765       default:
 766         break;
 767       }
 768
 769       if (Operand == EFI_IFR_ONE_OF_OP) {
 770         OneOfOpcode = (EFI_IFR_ONE_OF *) OpCodeData;
 771         OneOfType   = (UINT8) (OneOfOpcode->Flags & EFI_IFR_NUMERIC_SIZE);
 772       }
 773       break;
 774
 775     case EFI_IFR_ORDERED_LIST_OP:
 776       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 777
 778       CurrentStatement->Flags = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->Flags;
 779       CurrentStatement->MaxContainers = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->MaxContainers;
 780       CurrentStatement->StorageWidth = (UINT16)(CurrentStatement->MaxContainers * sizeof (UINT8));
 781
 782       //
 783       // No buffer type is defined in EFI_IFR_TYPE_VALUE, so a Configuration Driver
 784       // has to use FormBrowser2.Callback() to retrieve the uncommited data for
 785       // an interactive orderedlist (i.e. with EFI_IFR_FLAG_CALLBACK flag set).
 786       //
 787       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_OTHER;
 788       CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
 789
 790       break;
 791
 792     case EFI_IFR_CHECKBOX_OP:
 793       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 794
 795       CurrentStatement->Flags = ((EFI_IFR_CHECKBOX *) OpCodeData)->Flags;
 796       CurrentStatement->StorageWidth = sizeof (BOOLEAN);
 797       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BOOLEAN;
 798
 799       break;
 800
 801     case EFI_IFR_STRING_OP:
 802       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 803
 804       //
 805       // MinSize is the minimum number of characters that can be accepted for this opcode,
 806       // MaxSize is the maximum number of characters that can be accepted for this opcode.
 807       // The characters are stored as Unicode, so the storage width should multiply 2.
 808       //
 809       CurrentStatement->Minimum = ((EFI_IFR_STRING *) OpCodeData)->MinSize;
 810       CurrentStatement->Maximum = ((EFI_IFR_STRING *) OpCodeData)->MaxSize;
 811       CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16));
 812       CurrentStatement->Flags = ((EFI_IFR_STRING *) OpCodeData)->Flags;
 813
 814       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
 815       CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
 816
 817       break;
 818
 819     case EFI_IFR_PASSWORD_OP:
 820       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 821
 822       //
 823       // MinSize is the minimum number of characters that can be accepted for this opcode,
 824       // MaxSize is the maximum number of characters that can be accepted for this opcode.
 825       // The characters are stored as Unicode, so the storage width should multiply 2.
 826       //
 827       CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_PASSWORD *) OpCodeData)->MinSize, sizeof (UINT16));
 828       CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_PASSWORD *) OpCodeData)->MaxSize, sizeof (UINT16));
 829       CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16));
 830
 831       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
 832       CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
 833
 834       break;
 835
 836     case EFI_IFR_DATE_OP:
 837       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 838
 839       CurrentStatement->Flags = ((EFI_IFR_DATE *) OpCodeData)->Flags;
 840       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_DATE;
 841
 842       break;
 843
 844     case EFI_IFR_TIME_OP:
 845       CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
 846
 847       CurrentStatement->Flags = ((EFI_IFR_TIME *) OpCodeData)->Flags;
 848       CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_TIME;
 849
 850       break;
 851
 852     //
 853     // Default
 854     //
 855     case EFI_IFR_DEFAULT_OP:
 856       //
 857       // EFI_IFR_DEFAULT appear in scope of a Question,
 858       // It creates a default value for the current question.
 859       // A Question may have more than one Default value which have different default types.
 860       //
 861       CurrentDefault = AllocateZeroPool (sizeof (QUESTION_DEFAULT));
 862       CurrentDefault->Signature = QUESTION_DEFAULT_SIGNATURE;
 863
 864       CurrentDefault->Value.Type = ((EFI_IFR_DEFAULT *) OpCodeData)->Type;
 865       CopyMem (&CurrentDefault->DefaultId, &((EFI_IFR_DEFAULT *) OpCodeData)->DefaultId, sizeof (UINT16));
 866       CopyMem (&CurrentDefault->Value.Value, &((EFI_IFR_DEFAULT *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
 867       ExtendValueToU64 (&CurrentDefault->Value);
 868
 869       //
 870       // Insert to Default Value list of current Question
 871       //
 872       InsertTailList (&CurrentStatement->DefaultListHead, &CurrentDefault->Link);
 873
 874       break;
 875
 876     //
 877     // Option
 878     //
 879     case EFI_IFR_ONE_OF_OPTION_OP:
 880       //
 881       // EFI_IFR_ONE_OF_OPTION appear in scope of a Question.
 882       // It create a selection for use in current Question.
 883       //
 884       CurrentOption = AllocateZeroPool (sizeof (QUESTION_OPTION));
 885       CurrentOption->Signature = QUESTION_OPTION_SIGNATURE;
 886
 887       CurrentOption->Flags = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Flags;
 888       CurrentOption->Value.Type = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Type;
 889       CopyMem (&CurrentOption->Text, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Option, sizeof (EFI_STRING_ID));
 890       CopyMem (&CurrentOption->Value.Value, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
 891       ExtendValueToU64 (&CurrentOption->Value);
 892
 893       //
 894       // Insert to Option list of current Question
 895       //
 896       InsertTailList (&CurrentStatement->OptionListHead, &CurrentOption->Link);
 897       break;
 898
 899     //
 900     // Conditional
 901     //
 902     case EFI_IFR_NO_SUBMIT_IF_OP:
 903     case EFI_IFR_INCONSISTENT_IF_OP:
 904       break;
 905
 906     case EFI_IFR_SUPPRESS_IF_OP:
 907       break;
 908
 909     case EFI_IFR_GRAY_OUT_IF_OP:
 910       break;
 911
 912     case EFI_IFR_DISABLE_IF_OP:
 913       ASSERT (FALSE);
 914
 915
 916     //
 917     // Expression
 918     //
 919     case EFI_IFR_VALUE_OP:
 920       break;
 921
 922     case EFI_IFR_RULE_OP:
 923       break;
 924
 925     //
 926     // Image
 927     //
 928     case EFI_IFR_IMAGE_OP:
 929       //
 930       // Get ScopeOpcode from top of stack
 931       //
 932       PopScope (&ScopeOpCode);
 933       PushScope (ScopeOpCode);
 934
 935       switch (ScopeOpCode) {
 936       case EFI_IFR_FORM_SET_OP:
 937         ImageId = &FormSet->ImageId;
 938         break;
 939
 940       case EFI_IFR_FORM_OP:
 941         ImageId = &CurrentForm->ImageId;
 942         break;
 943
 944       case EFI_IFR_ONE_OF_OPTION_OP:
 945         ImageId = &CurrentOption->ImageId;
 946         break;
 947
 948       default:
 949         ImageId = &CurrentStatement->ImageId;
 950         break;
 951       }
 952
 953       CopyMem (ImageId, &((EFI_IFR_IMAGE *) OpCodeData)->Id, sizeof (EFI_IMAGE_ID));
 954       break;
 955
 956     //
 957     // Refresh
 958     //
 959     case EFI_IFR_REFRESH_OP:
 960       CurrentStatement->RefreshInterval = ((EFI_IFR_REFRESH *) OpCodeData)->RefreshInterval;
 961       break;
 962
 963     //
 964     // Vendor specific
 965     //
 966     case EFI_IFR_GUID_OP:
 967       OptionMap = (EFI_IFR_GUID_OPTIONKEY *) OpCodeData;
 968
 969       if (CompareGuid (&mTianoHiiIfrGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
 970         //
 971         // Tiano specific GUIDed opcodes
 972         //
 973         switch (((EFI_IFR_GUID_LABEL *) OpCodeData)->ExtendOpCode) {
 974         case EFI_IFR_EXTEND_OP_LABEL:
 975           //
 976           // just ignore label
 977           //
 978           break;
 979
 980
 981         case EFI_IFR_EXTEND_OP_CLASS:
 982           CopyMem (&FormSet->Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16));
 983           break;
 984
 985         case EFI_IFR_EXTEND_OP_SUBCLASS:
 986           CopyMem (&FormSet->SubClass, &((EFI_IFR_GUID_SUBCLASS *) OpCodeData)->SubClass, sizeof (UINT16));
 987           break;
 988
 989         default:
 990           break;
 991         }
 992       }
 993       else if (CompareGuid ((EFI_GUID *)(VOID *)&OptionMap->Guid, &mFrameworkHiiCompatibilityGuid)) {
 994         if (OptionMap->ExtendOpCode == EFI_IFR_EXTEND_OP_OPTIONKEY) {
 995           OneOfOptinMapEntryListHead = GetOneOfOptionMapEntryListHead (FormSet, OptionMap->QuestionId);
 996           if (OneOfOptinMapEntryListHead == NULL) {
 997             OneOfOptionMap = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP));
 998             ASSERT (OneOfOptionMap != NULL);
 999
1000             OneOfOptionMap->Signature = ONE_OF_OPTION_MAP_SIGNATURE;
1001             OneOfOptionMap->QuestionId = OptionMap->QuestionId;
1002
1003             //
1004             // Make sure OneOfType is initialized.
1005             //
1006             ASSERT (OneOfType != (UINT8) -1);
1007             OneOfOptionMap->ValueType = OneOfType;
1008             InitializeListHead (&OneOfOptionMap->OneOfOptionMapEntryListHead);
1009             OneOfOptinMapEntryListHead = &OneOfOptionMap->OneOfOptionMapEntryListHead;
1010             InsertTailList (&FormSet->OneOfOptionMapListHead, &OneOfOptionMap->Link);
1011           }
1012           OneOfOptionMapEntry = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP_ENTRY));
1013           ASSERT (OneOfOptionMapEntry != NULL);
1014
1015           OneOfOptionMapEntry->Signature = ONE_OF_OPTION_MAP_ENTRY_SIGNATURE;
1016           OneOfOptionMapEntry->FwKey = OptionMap->KeyValue;
1017           CopyMem (&OneOfOptionMapEntry->Value, &OptionMap->OptionValue, sizeof (EFI_IFR_TYPE_VALUE));
1018
1019           InsertTailList (OneOfOptinMapEntryListHead, &OneOfOptionMapEntry->Link);
1020         }
1021      }
1022       break;
1023
1024     //
1025     // Scope End
1026     //
1027     case EFI_IFR_END_OP:
1028       Status = PopScope (&ScopeOpCode);
1029       if (EFI_ERROR (Status)) {
1030         ResetScopeStack ();
1031         return Status;
1032       }
1033
1034       switch (ScopeOpCode) {
1035       case EFI_IFR_FORM_SET_OP:
1036         //
1037         // End of FormSet, update FormSet IFR binary length
1038         // to stop parsing substantial OpCodes
1039         //
1040         FormSet->IfrBinaryLength = OpCodeOffset;
1041         break;
1042
1043       case EFI_IFR_FORM_OP:
1044         //
1045         // End of Form
1046         //
1047         CurrentForm = NULL;
1048         break;
1049
1050       case EFI_IFR_ONE_OF_OPTION_OP:
1051         //
1052         // End of Option
1053         //
1054         CurrentOption = NULL;
1055         break;
1056
1057       case EFI_IFR_SUBTITLE_OP:
1058         mInScopeSubtitle = FALSE;
1059         break;
1060
1061       case EFI_IFR_NO_SUBMIT_IF_OP:
1062       case EFI_IFR_INCONSISTENT_IF_OP:
1063         //
1064         // Ignore end of EFI_IFR_NO_SUBMIT_IF and EFI_IFR_INCONSISTENT_IF
1065         //
1066         break;
1067
1068       case EFI_IFR_GRAY_OUT_IF_OP:
1069         mInScopeGrayOut = FALSE;
1070         break;
1071
1072       default:
1073         if (IsExpressionOpCode (ScopeOpCode)) {
1074         }
1075         break;
1076       }
1077       break;
1078
1079     default:
1080       break;
1081     }
1082   }
1083
1084   return EFI_SUCCESS;
1085 }
1086
1087
1088
1089