/EdkCompatibilityPkg/Sample/Tools/Source/HiiPack/IfrParse.c

Large files files are truncated, but you can click here to view the full file

/*++



Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>

This program and the accompanying materials

are licensed and made available under the terms and conditions of the BSD License

which accompanies this distribution.  The full text of the license may be found at

http://opensource.org/licenses/bsd-license.php



THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.



Module Name:



  IfrParse.c  



Abstract:



  Routines for parsing and managing HII IFR packs.



--*/



#include <stdio.h>

#include <string.h>

#include <stdlib.h>



#include "Tiano.h"

#include "EfiUtilityMsgs.h"

#include "EfiInternalFormRepresentation.h"

#include "Hii.h"

#include "IfrParse.h"

#include "HiiPack.h"



typedef struct _VARIABLE_STORE_ENTRY {

  struct _VARIABLE_STORE_ENTRY  *Next;

  CHAR8                         VarName[MAX_VARIABLE_NAME];

  char                          *VarBuffer;

  int                           VarBufferSize;

  EFI_HII_VARIABLE_PACK         *VarPack;

  int                           VarPackSize;

} VARIABLE_STORE_ENTRY;



typedef STATUS (*IFR_PARSE_FUNCTION) (IFR_PARSE_CONTEXT * Context);



typedef struct {

  INT8                *Name;

  INT32               Size;

  IFR_PARSE_FUNCTION  Parse;

} IFR_PARSE_TABLE_ENTRY;



static

STATUS

IfrParse01 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse02 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse03 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse05 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse06 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse07 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse08 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse09 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse0A (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse0B (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse0C (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse0D (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse0E (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse0F (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse10 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse11 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse12 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse13 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse14 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse15 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse16 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse17 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse18 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse19 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse1A (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse1B (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse1C (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse1D (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse1E (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse1F (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse20 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse21 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse22 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse23 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse24 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse25 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse26 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse27 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse28 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse29 (

  IFR_PARSE_CONTEXT *Context

  );

static

STATUS

IfrParse2A (

  IFR_PARSE_CONTEXT *Context

  );



static const IFR_PARSE_TABLE_ENTRY  mIfrParseTable[] = {

  {

    0,

    0,

    NULL

  },  // invalid

  {

    "EFI_IFR_FORM",

    sizeof (EFI_IFR_FORM),

    IfrParse01

  },

  {

    "EFI_IFR_SUBTITLE",

    sizeof (EFI_IFR_SUBTITLE),

    IfrParse02

  },

  {

    "EFI_IFR_TEXT",

    -6,

    IfrParse03

  },  // sizeof (EFI_IFR_TEXT) },

  {

    "unused 0x04 opcode",

    0,

    NULL

  },  // EFI_IFR_GRAPHIC_OP

  {

    "EFI_IFR_ONE_OF",

    sizeof (EFI_IFR_ONE_OF),

    IfrParse05

  },

  {

    "EFI_IFR_CHECK_BOX",

    sizeof (EFI_IFR_CHECK_BOX),

    IfrParse06

  },

  {

    "EFI_IFR_NUMERIC",

    sizeof (EFI_IFR_NUMERIC),

    IfrParse07

  },

  {

    "EFI_IFR_PASSWORD",

    sizeof (EFI_IFR_PASSWORD),

    IfrParse08

  },

  {

    "EFI_IFR_ONE_OF_OPTION",

    sizeof (EFI_IFR_ONE_OF_OPTION),

    IfrParse09

  },

  {

    "EFI_IFR_SUPPRESS",

    sizeof (EFI_IFR_SUPPRESS),

    IfrParse0A

  },

  {

    "EFI_IFR_END_FORM",

    sizeof (EFI_IFR_END_FORM),

    IfrParse0B

  },

  {

    "EFI_IFR_HIDDEN",

    sizeof (EFI_IFR_HIDDEN),

    IfrParse0C

  },

  {

    "EFI_IFR_END_FORM_SET",

    sizeof (EFI_IFR_END_FORM_SET),

    IfrParse0D

  },

  {

    "EFI_IFR_FORM_SET",

    sizeof (EFI_IFR_FORM_SET),

    IfrParse0E

  },

  {

    "EFI_IFR_REF",

    sizeof (EFI_IFR_REF),

    IfrParse0F

  },

  {

    "EFI_IFR_END_ONE_OF",

    sizeof (EFI_IFR_END_ONE_OF),

    IfrParse10

  },

  {

    "EFI_IFR_INCONSISTENT",

    sizeof (EFI_IFR_INCONSISTENT),

    IfrParse11

  },

  {

    "EFI_IFR_EQ_ID_VAL",

    sizeof (EFI_IFR_EQ_ID_VAL),

    IfrParse12

  },

  {

    "EFI_IFR_EQ_ID_ID",

    sizeof (EFI_IFR_EQ_ID_ID),

    IfrParse13

  },

  {

    "EFI_IFR_EQ_ID_LIST",

    -(int) (sizeof (EFI_IFR_EQ_ID_LIST)),

    IfrParse14

  },

  {

    "EFI_IFR_AND",

    sizeof (EFI_IFR_AND),

    IfrParse15

  },

  {

    "EFI_IFR_OR",

    sizeof (EFI_IFR_OR),

    IfrParse16

  },

  {

    "EFI_IFR_NOT",

    sizeof (EFI_IFR_NOT),

    IfrParse17

  },

  {

    "EFI_IFR_END_IF",

    sizeof (EFI_IFR_END_IF),

    IfrParse18

  },

  {

    "EFI_IFR_GRAYOUT",

    sizeof (EFI_IFR_GRAYOUT),

    IfrParse19

  },

  {

    "EFI_IFR_DATE",

    sizeof (EFI_IFR_DATE) / 3,

    IfrParse1A

  },

  {

    "EFI_IFR_TIME",

    sizeof (EFI_IFR_TIME) / 3,

    IfrParse1B

  },

  {

    "EFI_IFR_STRING",

    sizeof (EFI_IFR_STRING),

    IfrParse1C

  },

  {

    "EFI_IFR_LABEL",

    sizeof (EFI_IFR_LABEL),

    IfrParse1D

  },

  {

    "EFI_IFR_SAVE_DEFAULTS",

    sizeof (EFI_IFR_SAVE_DEFAULTS),

    IfrParse1E

  },

  {

    "EFI_IFR_RESTORE_DEFAULTS",

    sizeof (EFI_IFR_RESTORE_DEFAULTS),

    IfrParse1F

  },

  {

    "EFI_IFR_BANNER",

    sizeof (EFI_IFR_BANNER),

    IfrParse20

  },

  {

    "EFI_IFR_INVENTORY",

    sizeof (EFI_IFR_INVENTORY),

    IfrParse21

  },

  {

    "EFI_IFR_EQ_VAR_VAL_OP",

    sizeof (EFI_IFR_EQ_VAR_VAL),

    IfrParse22

  },

  {

    "EFI_IFR_ORDERED_LIST_OP",

    sizeof (EFI_IFR_ORDERED_LIST),

    IfrParse23

  },

  {

    "EFI_IFR_VARSTORE_OP",

    -(int) (sizeof (EFI_IFR_VARSTORE)),

    IfrParse24

  },

  {

    "EFI_IFR_VARSTORE_SELECT_OP",

    sizeof (EFI_IFR_VARSTORE_SELECT),

    IfrParse25

  },

  {

    "EFI_IFR_VARSTORE_SELECT_PAIR_OP",

    sizeof (EFI_IFR_VARSTORE_SELECT_PAIR),

    IfrParse26

  },

  {

    "EFI_IFR_TRUE",

    sizeof (EFI_IFR_TRUE),

    IfrParse27

  },

  {

    "EFI_IFR_FALSE",

    sizeof (EFI_IFR_FALSE),

    IfrParse28

  },

  {

    "EFI_IFR_GT",

    sizeof (EFI_IFR_GT),

    IfrParse29

  },

  {

    "EFI_IFR_GE",

    sizeof (EFI_IFR_GE),

    IfrParse2A

  },

};

#define PARSE_TABLE_ENTRIES (sizeof (mIfrParseTable) / sizeof (mIfrParseTable[0]))



static

STATUS

GetVarStoreInfo (

  IFR_PARSE_CONTEXT   *Context,

  UINT16              VarId,

  EFI_GUID            **VarStoreGuid,

  char                **VarStoreName

  );



static

void

FreeVarStores (

  VOID

  );



static

STATUS

CreateVarStore (

  EFI_GUID *VarGuid,

  CHAR8    *VarName,

  int      VarStoreSize

  );



static

STATUS

SetDefaults (

  IFR_PARSE_CONTEXT *Context,

  UINT32            MfgDefaults

  );



//

// Globals

//

static IFR_PARSE_CONTEXT            *mParseContext    = NULL;

static VARIABLE_STORE_ENTRY         *mVariableStores  = NULL;

static int                          BreakOnOpcodeTag  = 0;

static int                          OpcodeTag         = 1;



/*****************************************************************************/

STATUS

IfrParseCheck (

  char    *Buffer,

  long    BufferSize

  )

/*++



Routine Description:



  Check a buffer to ensure that is is parseable IFR

  

Arguments:



  Buffer      - pointer to raw IFR bytes

  BufferSize  - size of IFR pointed to by Buffer



Returns:



  STATUS_SUCCESS      if successful

  STATUS_ERROR        otherwise

  

--*/

{

  char              *Start;



  char              *End;



  char              *Pos;

  EFI_IFR_OP_HEADER *OpHeader;

  char              *FileName;

  FileName = "";

  //

  // Walk the list of IFR statements in the IFR pack

  //

  Start = Buffer;

  Pos   = Buffer;

  End   = Start + BufferSize;

  while ((Pos >= Start) && (Pos < End)) {

    OpHeader = (EFI_IFR_OP_HEADER *) Pos;

    //

    // Check range on size

    //

    if (Pos + OpHeader->Length > End) {

      Error (NULL, 0, 0, FileName, "invalid IFR opcode size at offset 0x%X", (int) Pos - (int) Start);

      return STATUS_ERROR;

    }



    if (OpHeader->Length == 0) {

      Error (NULL, 0, 0, FileName, "IFR opcode size=0 at offset 0x%X", (int) Pos - (int) Start);

      return STATUS_ERROR;

    }

    //

    // See if it's the END_FORMSET opcode

    //

    if (OpHeader->OpCode == EFI_IFR_END_FORM_SET_OP) {

      break;

    }

    //

    // Advance to next IFR statement/opcode

    //

    Pos += OpHeader->Length;

  }



  return STATUS_SUCCESS;

}



STATUS

IfrParseInit (

  VOID

  )

/*++



Routine Description:



  Initialize this module for IFR pack parsing

  

Arguments:



Returns:



  STATUS_SUCCESS      always

  

--*/

{

  return STATUS_SUCCESS;

}



STATUS

IfrParseEnd (

  VOID

  )

/*++



Routine Description:



  Free up memory allocated during IFR pack parsing done by this module

  

Arguments:

  None



Returns:



  STATUS_SUCCESS      always

  

--*/

{

  IFR_PARSE_CONTEXT *NextContext;

  IFR_PARSE_ENTRY   *NextEntry;

  //

  // Free up the memory from our parse contexts

  //

  while (mParseContext != NULL) {

    while (mParseContext->Ifr != NULL) {

      NextEntry = mParseContext->Ifr->Next;

      //

      // We pointed directly into the user buffer, rather than make

      // a copy, so don't free up the bytes.

      //

      free (mParseContext->Ifr);

      mParseContext->Ifr = NextEntry;

    }



    NextContext = mParseContext->Next;

    free (mParseContext->PackHeader);

    free (mParseContext);

    mParseContext = NextContext;

  }



  return STATUS_SUCCESS;

}



static

void

FreeVarStores (

  VOID

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  None



Returns:



  GC_TODO: add return values



--*/

{

  VARIABLE_STORE_ENTRY  *NextVarStore;

  //

  // Free up memory from our variable stores

  //

  while (mVariableStores != NULL) {

    if (mVariableStores->VarPack != NULL) {

      free (mVariableStores->VarPack);

    }



    NextVarStore = mVariableStores->Next;

    free (mVariableStores);

    mVariableStores = NextVarStore;

  }

}



/******************************************************************************

  FUNCTION: IfrParsePack() 

   

  DESCRIPTION:  Given a pointer to an IFR pack, parse it to create a linked

    list of opcodes and relevant data required for later dumping.





*******************************************************************************/

STATUS

IfrParsePack (

  int               Handle,

  EFI_HII_IFR_PACK  *PackHeader,

  EFI_GUID          *PackageGuid

  )

/*++



Routine Description:



  Given a pointer to an IFR pack, parse it to create a linked

  list of opcodes and relevant data required for later dumping.

  

Arguments:



  Handle          - the handle number associated with this IFR pack. It

                    can be used later to retrieve more info on the particular

                    pack

  PackHeader      - pointer to IFR pack to parse

  PackageGuid     - on input, it comes from the HII data table entry for this pack. 

                    On output, we'll return the IFR formset GUID.



Returns:



  STATUS_SUCCESS      always



--*/

{

  EFI_IFR_OP_HEADER *OpHeader;

  IFR_PARSE_CONTEXT *Context;

  IFR_PARSE_CONTEXT *TempContext;

  IFR_PARSE_ENTRY   *IfrEntry;

  //

  // Initialize our context

  //

  Context = (IFR_PARSE_CONTEXT *) malloc (sizeof (IFR_PARSE_CONTEXT));

  if (Context == NULL) {

    Error (NULL, 0, 0, "memory allocation failure", NULL);

    return STATUS_ERROR;

  }



  memset ((void *) Context, 0, sizeof (IFR_PARSE_CONTEXT));

  //

  // Cache a copy of the input pack so the caller can free their copy

  //

  Context->PackHeader = (EFI_HII_IFR_PACK *) malloc (PackHeader->Header.Length);

  if (Context->PackHeader == NULL) {

    Error (NULL, 0, 0, "memory allocation failure", NULL);

    free (Context);

    return STATUS_ERROR;

  }



  memcpy (Context->PackHeader, PackHeader, PackHeader->Header.Length);

  Context->IfrBufferStart = (char *) (Context->PackHeader + 1);

  Context->CurrentPos     = Context->IfrBufferStart;

  Context->IfrBufferLen   = PackHeader->Header.Length - sizeof (EFI_HII_IFR_PACK);

  Context->Handle         = Handle;

  Context->FormsetGuid    = &Context->NullGuid;

  Context->PackageGuid    = *PackageGuid;

  //

  // Add it to the end of our list

  //

  if (mParseContext == NULL) {

    mParseContext = Context;

  } else {

    TempContext = mParseContext;

    while (TempContext->Next != NULL) {

      TempContext = TempContext->Next;

    }



    TempContext->Next = Context;

  }

  //

  // Walk the opcodes in the pack

  //

  while

  (

    (Context->CurrentPos >= Context->IfrBufferStart) &&

    (Context->CurrentPos < Context->IfrBufferStart + Context->IfrBufferLen)

  ) {

    OpHeader = (EFI_IFR_OP_HEADER *) Context->CurrentPos;

    //

    // Allocate a new IFR entry to put in our linked list, then

    // point directly to the caller's raw data.

    //

    IfrEntry = (IFR_PARSE_ENTRY *) malloc (sizeof (IFR_PARSE_ENTRY));

    if (IfrEntry == NULL) {

      Error (NULL, 0, 0, "memory allocation failure", NULL);

      free (Context->PackHeader);

      free (Context);

      return STATUS_ERROR;

    }



    memset ((void *) IfrEntry, 0, sizeof (IFR_PARSE_ENTRY));

    IfrEntry->Tag = ++OpcodeTag;

    if (OpcodeTag == BreakOnOpcodeTag) {

      EFI_BREAKPOINT ();

    }



    IfrEntry->RawIfrHeader = (EFI_IFR_OP_HEADER *) (Context->CurrentPos);

    //

    // Add this entry to our linked list. If it's not the first, then

    // forward the variable store settings from the previous entry.

    //

    if (Context->LastIfr != NULL) {

      IfrEntry->VarStoreGuid1 = Context->LastIfr->VarStoreGuid1;

      IfrEntry->VarStoreName1 = Context->LastIfr->VarStoreName1;

      IfrEntry->VarStoreGuid2 = Context->LastIfr->VarStoreGuid2;

      IfrEntry->VarStoreName2 = Context->LastIfr->VarStoreName2;

      Context->LastIfr->Next  = IfrEntry;

    } else {

      Context->Ifr = IfrEntry;

    }



    Context->LastIfr = IfrEntry;

    //

    // Switch on the opcode to parse it

    //

    if (OpHeader->OpCode < PARSE_TABLE_ENTRIES) {

      if (mIfrParseTable[OpHeader->OpCode].Parse != NULL) {

        mIfrParseTable[OpHeader->OpCode].Parse (Context);

      }

    } else {

      Error (

        NULL,

        0,

        0,

        "invalid opcode found in IFR",

        "offset=0x%X opcode=0x%02X",

        (int) OpHeader - (int) Context->PackHeader,

        (int) OpHeader->OpCode

        );

      free (IfrEntry);

      free (Context->PackHeader);

      free (Context);

      return STATUS_ERROR;

    }

    //

    // If it's the END_FORMSET opcode, then we're done

    //

    if (OpHeader->OpCode == EFI_IFR_END_FORM_SET_OP) {

      break;

    }

    //

    // Advance to next IFR statement/opcode

    //

    if (OpHeader->Length == 0) {

      Error (NULL, 0, 0, "0-length IFR opcode encountered", NULL);

      free (IfrEntry);

      free (Context->PackHeader);

      free (Context);

      return STATUS_ERROR;

    }



    Context->CurrentPos += OpHeader->Length;

  }

  //

  // Return the form GUID.

  //

  *PackageGuid = *Context->FormsetGuid;  

  return STATUS_SUCCESS;

}



/******************************************************************************

  FUNCTION:  GetVarStoreInfo()

   

  DESCRIPTION:  IFR contains VARSTORE opcodes to specify where variable data 

    for following opcodes is supposed to be stored. One VARSTORE statement

    allows you to specify the variable store GUID and a key, and another

    VARSTORE (select) allows you to specify the key of a VARSTORE statement. 

    Given the key from a VARSTORE_SELECT statement, go find the corresponding

    VARSTORE statement with a matching key and return the varstore GUID and 

    name. If key == 0, then the variable store is FormsetGuid."Setup"

*******************************************************************************/

static

STATUS

GetVarStoreInfo (

  IFR_PARSE_CONTEXT     *Context,

  UINT16                VarId,

  EFI_GUID              **VarStoreGuid,

  char                  **VarStoreName

  )

/*++



Routine Description:



  Get variable store information from an IFR pack for a given variable store ID.

  

Arguments:



  Context       - pointer to IFR parse context

  VarId         - variable store ID referenced by IFR being parsed

  VarStoreGuid  - outgoing GUID of the variable store corresponding to VarId

  VarStoreName  - outgoing variable name of variable store corresponding to VarId



Returns:



  STATUS_SUCCESS      - variable store with matching VarId found, and outoing GUID/Name are valid

  STATUS_ERROR        - otherwise



--*/

{

  IFR_PARSE_ENTRY   *Ptr;

  EFI_IFR_VARSTORE  *VarStore;

  if (Context == NULL) {

    return STATUS_ERROR;

  }



  //

  // Walk the entire IFR form and find a variable store opcode that

  // has a matching variable store ID.

  //

  for (Ptr = Context->Ifr; Ptr != NULL; Ptr = Ptr->Next) {

    if (Ptr->RawIfrHeader->OpCode == EFI_IFR_FORM_SET_OP) {

      if (VarId == 0) {

        *VarStoreGuid = &((EFI_IFR_FORM_SET *) (Ptr->RawIfrHeader))->Guid;

        *VarStoreName = DEFAULT_VARIABLE_NAME;

        return STATUS_SUCCESS;

      }

    } else if (Ptr->RawIfrHeader->OpCode == EFI_IFR_VARSTORE_OP) {

      //

      // See if it's a variable ID match

      //

      VarStore = (EFI_IFR_VARSTORE *) Ptr->RawIfrHeader;

      if (VarStore->VarId == VarId) {

        *VarStoreGuid = &VarStore->Guid;

        *VarStoreName = (char *) (VarStore + 1);

        return STATUS_SUCCESS;

      }

    }

  }



  return STATUS_ERROR;

}



STATUS

IfrSetDefaults (

  int MfgDefaults

  )

/*++



Routine Description:



  Go through all the IFR forms we've parsed so far and create and set variable

  defaults.

  

Arguments:



  MfgDefaults   - non-zero if manufacturing defaults are desired



Returns:



  STATUS_SUCCESS      - always



--*/

{

  IFR_PARSE_CONTEXT *Context;

  //

  // First free up any variable stores we've created so far.

  //

  FreeVarStores ();

  for (Context = mParseContext; Context != NULL; Context = Context->Next) {

    //

    // Call our internal function to handle it

    //

    SetDefaults (Context, MfgDefaults);

  }



  return STATUS_SUCCESS;



}



/******************************************************************************/

STATUS

IfrGetIfrPack (

  int               Handle,

  EFI_HII_IFR_PACK  **PackHeader,

  EFI_GUID          *FormsetGuid

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Handle      - GC_TODO: add argument description

  PackHeader  - GC_TODO: add argument description

  FormsetGuid - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  IFR_PARSE_CONTEXT *Context;



  for (Context = mParseContext; Context != NULL; Context = Context->Next) {

    if (Context->Handle == Handle) {

      *PackHeader = Context->PackHeader;

      memcpy (FormsetGuid, Context->FormsetGuid, sizeof (EFI_GUID));

      return STATUS_SUCCESS;

    }

  }



  return STATUS_ERROR;

}



STATUS

IfrReferencesVarPack (

  int                   IfrHandle,

  EFI_HII_VARIABLE_PACK *VarPack

  )

/*++



Routine Description:



  Given an HII handle number (which corrresponds to a handle number passed 

  in to IfrParsePack()), see if the IFR references the specified variable

  pack.

  

Arguments:



  IfrHandle   - handle number for the IFR pack to check (passed to IfrParsePack())

  VarPack     - variable pack to check to see if the IFR references



Returns:



  STATUS_SUCCESS      if the IFR on the given handle references the variable pack

  STATUS_WARNING      the IFR does not reference the variable pack

  STATUS_ERROR        invalid IFR handle

  

--*/

{

  IFR_PARSE_CONTEXT *Context;

  char              VarName[MAX_VARIABLE_NAME];

  IFR_PARSE_ENTRY   *ParseEntry;



  for (Context = mParseContext; Context != NULL; Context = Context->Next) {

    if (Context->Handle == IfrHandle) {

      //

      // Create an ASCII version of the variable name, since that's what is

      // referenced in IFR.

      //

      sprintf (VarName, "%S", (CHAR16 *) (VarPack + 1));

      //

      // Walk all the opcodes and see if the IFR references this variable pack

      //

      for (ParseEntry = Context->Ifr; ParseEntry != NULL; ParseEntry = ParseEntry->Next) {

        //

        // Check for Name.Guid match for primary IFR variable store

        //

        if ((strcmp (VarName, ParseEntry->VarStoreName1) == 0) &&

            (memcmp (&VarPack->VariableGuid, ParseEntry->VarStoreGuid1, sizeof (EFI_GUID)) == 0)

            ) {

          return STATUS_SUCCESS;

        }

        //

        // Check for Name.Guid match for secondary IFR variable store

        //

        if ((ParseEntry->VarStoreName2 != NULL) &&

            (strcmp (VarName, ParseEntry->VarStoreName2) == 0) &&

            (memcmp (&VarPack->VariableGuid, ParseEntry->VarStoreGuid2, sizeof (EFI_GUID)) == 0)

            ) {

          return STATUS_SUCCESS;

        }

      }



      return STATUS_WARNING;

    }

  }



  return STATUS_ERROR;

}



STATUS

IfrGetVarPack (

  int                     VarIndex,

  EFI_HII_VARIABLE_PACK   **VarPack

  )

/*++



Routine Description:



  Get the variable defaults. It is expected that the caller

  called IfrSetDefaults() previously to walk all the IFR forms we know about

  and create and initialize default values.

  

Arguments:



  VarIndex - a 0-based index into all the variable stores we know about

  VarPack  - outgoing pointer to a variable pack



Returns:



  STATUS_ERROR    - VarIndex exceeds the number of variable packs we know of

  STATUS_SUCCESS  - otherwise

  

--*/

{

  VARIABLE_STORE_ENTRY  *Entry;

  //

  // Initialize outgoing parameters

  //

  *VarPack = NULL;

  for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {

    if (VarIndex == 0) {

      *VarPack = Entry->VarPack;

      return STATUS_SUCCESS;

    }



    VarIndex--;

  }



  return STATUS_ERROR;

}



static

STATUS

SetVariableValue (

  EFI_GUID    *VarGuid,

  char        *VarName,

  int         VarOffset,

  int         VarSize,

  void        *VarValue

  )

/*++



Routine Description:



  Given a variable GUID.Name, offset, size, and value, set the bytes in

  the variable to the provided value.

  

Arguments:

  VarGuid           - GUID of variable to set

  VarName           - name of variable to set

  VarOffset         - byte offset into the variable store 

  VarSize           - size of the value in the variable store (in bytes)

  VarValue          - pointer to buffer containing the value to set



Returns:



  

--*/

{

  VARIABLE_STORE_ENTRY  *Entry;

  char                  *Src;

  char                  *Dest;

  //

  // Go through our list of variable stores to find the match

  //

  for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {

    if (memcmp (VarGuid, &Entry->VarPack->VariableGuid, sizeof (EFI_GUID)) == 0) {

      if (strcmp (VarName, Entry->VarName) == 0) {

        //

        // Found match -- check offset. If it's beyond the size of the variable store

        // buffer, then return a warning. Note that date-time can be beyond the

        // end of the varstore, which is ok.

        //

        if (VarOffset + VarSize <= Entry->VarBufferSize) {

          //

          // Stuff the data

          //

          Dest  = Entry->VarBuffer + VarOffset;

          Src   = (char *) VarValue;

          while (VarSize > 0) {

            *Dest = *Src;

            Src++;

            Dest++;

            VarSize--;

          }



          return STATUS_SUCCESS;

        }



        return STATUS_WARNING;

      }

    }

  }



  return STATUS_ERROR;

}



static

STATUS

SetDefaults (

  IFR_PARSE_CONTEXT *Context,

  UINT32            MfgDefaults

  )

/*++



Routine Description:



  Set variable defaults by walking a single IFR form.

  

Arguments:

  

  Context     - Pointer to the IFR context.

  MfgDefaults - Number of Mfg defaults



Returns:



  EFI_INVALID_PARAMETER - arguments to function are invalid

  STATUS_SUCCESS        - function executed successfully

  

--*/

{

  int                   Size;

  int                   CachedVarOffset;

  int                   CachedVarSize;

  int                   OrderedList;

  IFR_PARSE_ENTRY       *SavedParseEntry;

  EFI_IFR_CHECK_BOX     *IfrCheckBox;

  EFI_IFR_ONE_OF_OPTION *IfrOneOfOption;

  EFI_IFR_NUMERIC       *IfrNumeric;

  STATUS                Status;

  char                  ZeroByte;



  //

  // Walk the opcodes to set default values and stuff them into the variable stores

  //



  if (Context == NULL) {

    return EFI_INVALID_PARAMETER;

  }

  Status              = STATUS_SUCCESS;

  Context->CurrentIfr = Context->Ifr;

  SavedParseEntry     = NULL;

  OrderedList         = 0;

  CachedVarOffset     = 0;

  CachedVarSize       = 0;

  ZeroByte            = 0;



  while (Context->CurrentIfr != NULL) {

    if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_FORM_SET_OP) {

      //

      // Formset opcode -- create a variable pack

      //

      Status = CreateVarStore (

                &((EFI_IFR_FORM_SET *) (Context->CurrentIfr->RawIfrHeader))->Guid,

                DEFAULT_VARIABLE_NAME,

                ((EFI_IFR_FORM_SET *) (Context->CurrentIfr->RawIfrHeader))->NvDataSize

                );

    } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_VARSTORE_OP) {

      //

      // Variable store opcode -- create a variable pack

      //

      Status = CreateVarStore (

                &((EFI_IFR_VARSTORE *) (Context->CurrentIfr->RawIfrHeader))->Guid,

                (char *) Context->CurrentIfr->RawIfrHeader + sizeof (EFI_IFR_VARSTORE),

                ((EFI_IFR_VARSTORE *) (Context->CurrentIfr->RawIfrHeader))->Size

                );

    } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ONE_OF_OP) {

      //

      // Need this parse context later when we find the default ONE_OF_OPTION.

      // Clear out the variable store first, so that we're covered if someone

      // has two one-of opcode that operate on the same data.

      // So "last one wins" is the behavior.

      //

      OrderedList     = 0;

      SavedParseEntry = Context->CurrentIfr;

      CachedVarOffset = ((EFI_IFR_ONE_OF *) Context->CurrentIfr->RawIfrHeader)->QuestionId;

      CachedVarSize   = ((EFI_IFR_ONE_OF *) Context->CurrentIfr->RawIfrHeader)->Width;

    } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ORDERED_LIST_OP) {

      //

      // Need this parse context later as we parse the ONE_OF_OP's in the ordered list

      //

      OrderedList     = 1;

      SavedParseEntry = Context->CurrentIfr;

      CachedVarOffset = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->QuestionId;

      CachedVarSize   = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->MaxEntries;



      while (CachedVarSize > 0) {

        Status = SetVariableValue (

                  SavedParseEntry->VarStoreGuid1, // GUID of variable store to write

                  SavedParseEntry->VarStoreName1, // name of variable store to write

                  CachedVarOffset,                // offset into variable store

                  1,                              // variable data size

                  (void *) &ZeroByte

                  );

        //

        // variable value

        //

        CachedVarSize--;

        CachedVarOffset++;

      }



      CachedVarOffset = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->QuestionId;

      CachedVarSize   = 1;

      //

      // ((EFI_IFR_ORDERED_LIST *)Context->CurrentIfr->RawIfrHeader)->Width;

      //

    } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ONE_OF_OPTION_OP) {

      IfrOneOfOption = (EFI_IFR_ONE_OF_OPTION *) Context->CurrentIfr->RawIfrHeader;

      //

      // If we're in an ordered list, then copy the value to the data store

      //

      if (OrderedList) {

        Status = SetVariableValue (

                  SavedParseEntry->VarStoreGuid1, // GUID of variable store to write

                  SavedParseEntry->VarStoreName1, // name of variable store to write

                  CachedVarOffset,                // offset into variable store

                  1,                              // variable data size

                  (void *) &IfrOneOfOption->Value

                  );

        //

        // variable value

        //

        // Advance the offset for the next ordered list item

        //

        CachedVarOffset += CachedVarSize;

      } else {

        //

        // ONE-OF list. See if the default flag is set (provided we're not doing mfg defaults)

        //

        if (!MfgDefaults) {

          if (IfrOneOfOption->Flags & EFI_IFR_FLAG_DEFAULT) {

            Status = SetVariableValue (

                      SavedParseEntry->VarStoreGuid1, // GUID of variable store to write

                      SavedParseEntry->VarStoreName1, // name of variable store to write

                      CachedVarOffset,                // offset into variable store

                      CachedVarSize,                  // variable data size

                      &IfrOneOfOption->Value

                      );

            //

            // variable value

            //

          }

        } else {

          if (IfrOneOfOption->Flags & EFI_IFR_FLAG_MANUFACTURING) {

            Status = SetVariableValue (

                      SavedParseEntry->VarStoreGuid1, // GUID of variable store to write

                      SavedParseEntry->VarStoreName1, // name of variable store to write

                      CachedVarOffset,                // offset into variable store

                      CachedVarSize,                  // variable data size

                      &IfrOneOfOption->Value

                      );

            //

            // variable value

            //

          }

        }

      }

    } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_CHECKBOX_OP) {

      //

      // If we're saving defaults, and the default flag is set, or we're saving

      // manufacturing defaults and the manufacturing flag is set, then save a 1.

      // By default the varstore buffer is cleared, so we don't need to save a 0 ever.

      //

      IfrCheckBox = (EFI_IFR_CHECK_BOX *) Context->CurrentIfr->RawIfrHeader;

      if (((MfgDefaults == 0) && (IfrCheckBox->Flags & EFI_IFR_FLAG_DEFAULT)) ||

          ((MfgDefaults != 0) && (IfrCheckBox->Flags & EFI_IFR_FLAG_MANUFACTURING))

          ) {

        Size = 1;

        Status = SetVariableValue (

                  Context->CurrentIfr->VarStoreGuid1, // GUID of variable store to write

                  Context->CurrentIfr->VarStoreName1, // name of variable store to write

                  IfrCheckBox->QuestionId,            // offset into variable store

                  IfrCheckBox->Width,                 // variable data size

                  (void *) &Size

                  );

        //

        // variable value

        //

      }

    } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_NUMERIC_OP) {

      IfrNumeric = (EFI_IFR_NUMERIC *) Context->CurrentIfr->RawIfrHeader;

      Status = SetVariableValue (

                Context->CurrentIfr->VarStoreGuid1, // GUID of variable store to write

                Context->CurrentIfr->VarStoreName1, // name of variable store to write

                IfrNumeric->QuestionId,             // offset into variable store

                IfrNumeric->Width,                  // variable data size

                (void *) &IfrNumeric->Default

                );

      //

      // variable value

      //

    }



    Context->CurrentIfr = Context->CurrentIfr->Next;

  }



  return STATUS_SUCCESS;

}



static

STATUS

CreateVarStore (

  EFI_GUID  *VarGuid,

  CHAR8     *VarName,

  int       VarStoreSize

  )

/*++



Routine Description:



  Given a variable GUID.Name and the size of the variable store, allocate

  storage for maintaining the variable value.

  

Arguments:



  VarGuid - GUID for a variable

  VarName - Name of the variable

  VarStoreSize - size of the variable store



Returns:



  STATUS_ERROR   - problem with storage allocation 

  STATUS_SUCCESS - function executed successfully

 

--*/

{

  VARIABLE_STORE_ENTRY  *Entry;



  VARIABLE_STORE_ENTRY  *TempEntry;

  int                   PackSize;

  int                   VarNameLen;

  //

  // If the variable store size is zero, then do nothing. This could be valid

  // if variable steering is used in the IFR such that FormsetGUID."Setup" variable

  // store is never used.

  //

  // OPEN: What about a form that only has a time/date question? Then if some other

  // function called SetDefaults(), attempting to set time/date would result in an

  // error in the SetVarValue() function.

  //

   if (VarStoreSize == 0) {

    return STATUS_SUCCESS;

   }

  //

  // Go through our list of variable stores and see if we've already created one

  // for this Guid.Name. If so, check the size and return. Otherwise create

  // one and add it to the list.

  //

  for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {

    if (memcmp (VarGuid, &Entry->VarPack->VariableGuid, sizeof (EFI_GUID)) == 0) {

      if (strcmp (VarName, Entry->VarName) == 0) {

        //

        // Already have one. Check size.

        //

        if (Entry->VarBufferSize != VarStoreSize) {

          Error (NULL, 0, 0, "mismatched variable store size between two formsets", VarName);

          return STATUS_ERROR;

        }



        return STATUS_SUCCESS;

      }

    }

  }

  //

  // Create a new one.

  //

  Entry = (VARIABLE_STORE_ENTRY *) malloc (sizeof (VARIABLE_STORE_ENTRY));

  if (Entry == NULL) {

    Error (NULL, 0, 0, "memory allocation failure", NULL);

    return STATUS_ERROR;

  }



  memset ((void *) Entry, 0, sizeof (VARIABLE_STORE_ENTRY));

  //

  // Compute size of the varpack

  //

  VarNameLen      = strlen (VarName) + 1;

  PackSize        = sizeof (EFI_HII_VARIABLE_PACK) + VarNameLen * sizeof (CHAR16) + VarStoreSize;

  Entry->VarPack  = (EFI_HII_VARIABLE_PACK *) malloc (PackSize);

  if (Entry->VarPack == NULL) {

    Error (NULL, 0, 0, "memory allocation failure", NULL);

    free (Entry);

    return STATUS_ERROR;

  }



  Entry->VarPack->Header.Length       = PackSize;

  Entry->VarPack->Header.Type         = EFI_HII_VARIABLE;

  Entry->VarPack->VariableNameLength  = VarNameLen * sizeof (CHAR16);

  Entry->VarName[MAX_VARIABLE_NAME - 1] = 0;

  strncpy (Entry->VarName, VarName, MAX_VARIABLE_NAME - 1);

#ifdef USE_VC8

  swprintf ((CHAR16 *) (Entry->VarPack + 1), (strlen (VarName) + 1) * sizeof (CHAR16), L"%S", VarName);

#else

  swprintf ((CHAR16 *) (Entry->VarPack + 1), L"%S", VarName);

#endif

  memcpy (&Entry->VarPack->VariableGuid, VarGuid, sizeof (EFI_GUID));

  //

  // Point VarBuffer into the allocated buffer (for convenience)

  //

  Entry->VarBuffer = (char *) Entry->VarPack + sizeof (EFI_HII_VARIABLE_PACK) + VarNameLen * sizeof (CHAR16);

  memset ((void *) Entry->VarBuffer, 0, VarStoreSize);

  Entry->VarBufferSize = VarStoreSize;

  //

  // Add this new varstore to our list

  //

  if (mVariableStores == NULL) {

    mVariableStores = Entry;

  } else {

    for (TempEntry = mVariableStores; TempEntry->Next != NULL; TempEntry = TempEntry->Next)

      ;

    TempEntry->Next = Entry;

  }

  return STATUS_SUCCESS;

}



/******************************************************************************/



/*++



Routine Description:



  The following IfrParseXX() functions are used to parse an IFR opcode numbered

  XX via a dispatch table. 

  

Arguments:



  Context - IFR parsing context into which pertinent data for the 

            current opcode can be saved. Context->LastIfr->RawIfrHeader points to 

            the raw IFR bytes currently being parsed.



Returns:



  STATUS_SUCCESS  - always

  

--*/



/*******************************************************************************/

static

STATUS

IfrParse01 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse02 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse03 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}

//

// Parse the IFR EFI_IFR_ONE_OF opcode.

//

static

STATUS

IfrParse05 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse06 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse07 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse08 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse09 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse0A (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse0B (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse0C (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse0D (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse0E (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  EFI_IFR_FORM_SET  *Op;

  Op  = (EFI_IFR_FORM_SET *) Context->LastIfr->RawIfrHeader;

  Context->LastIfr->VarStoreGuid1 = &Op->Guid;

  Context->LastIfr->VarStoreName1 = "Setup";

  Context->FormsetGuid            = &Op->Guid;

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse0F (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse10 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse11 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse12 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse13 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse14 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse15 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse16 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse17 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse18 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse19 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse1A (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse1B (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse1C (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse1D (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse1E (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse1F (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse20 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse21 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse22 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}



static

STATUS

IfrParse23 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  return STATUS_SUCCESS;

}

//

// EFI_IFR_VARSTORE

//

static

STATUS

IfrParse24 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  EFI_IFR_VARSTORE  *Op;

  Op = (EFI_IFR_VARSTORE *) Context->LastIfr->RawIfrHeader;

  return STATUS_SUCCESS;

}

//

// VARSTORE_SELECT

//

static

STATUS

IfrParse25 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  STATUS                  Status;

  EFI_IFR_VARSTORE_SELECT *Op;

  Op      = (EFI_IFR_VARSTORE_SELECT *) Context->LastIfr->RawIfrHeader;

  Status  = GetVarStoreInfo (Context, Op->VarId, &Context->LastIfr->VarStoreGuid1, &Context->LastIfr->VarStoreName1);

  //

  // VARSTORE_SELECT sets both

  //

  Context->LastIfr->VarStoreGuid2 = Context->LastIfr->VarStoreGuid1;

  Context->LastIfr->VarStoreName2 = Context->LastIfr->VarStoreName1;

  return Status;

}

//

// VARSTORE_SELECT_PAIR

//

static

STATUS

IfrParse26 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function description



Arguments:



  Context - GC_TODO: add argument description



Returns:



  GC_TODO: add return values



--*/

{

  STATUS                        Status;

  EFI_IFR_VARSTORE_SELECT_PAIR  *Op;



  Op      = (EFI_IFR_VARSTORE_SELECT_PAIR *) Context->LastIfr->RawIfrHeader;

  Status  = GetVarStoreInfo (Context, Op->VarId, &Context->LastIfr->VarStoreGuid1, &Context->LastIfr->VarStoreName1);

  Status = GetVarStoreInfo (

            Context,

            Op->SecondaryVarId,

            &Context->LastIfr->VarStoreGuid2,

            &Context->LastIfr->VarStoreName2

            );

  return Status;

}

//

// TRUE

//

static

STATUS

IfrParse27 (

  IFR_PARSE_CONTEXT *Context

  )

/*++



Routine Description:



  GC_TODO: Add function descriptio…