EdkCompatibilityPkg/Compatibility/FrameworkHiiOnUefiHiiThunk/Strings.c - third_party/edk2 - Git at Google

 /**@file
   This file implements the protocol functions related to string package.

 Copyright (c) 2006 - 2008, Intel Corporation
 All rights reserved. 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.

 **/


 #include "HiiDatabase.h"

 /**
   Test if all of the characters in a string have corresponding font characters.

   This is a deprecated API. No Framework HII module is calling it. This function will ASSERT and
   return EFI_UNSUPPORTED.

   @param This            A pointer to the EFI_HII_PROTOCOL instance.
   @param StringToTest    A pointer to a Unicode string.
   @param FirstMissing    A pointer to an index into the string. On input, the index of
                          the first character in the StringToTest to examine. On exit, the index
                          of the first character encountered for which a glyph is unavailable.
                          If all glyphs in the string are available, the index is the index of the terminator
                          of the string.
   @param GlyphBufferSize A pointer to a value. On output, if the function returns EFI_SUCCESS,
                          it contains the amount of memory that is required to store the string? glyph equivalent.

   @retval EFI_UNSUPPORTED  The function performs nothing and return EFI_UNSUPPORTED.
 **/
 EFI_STATUS
 EFIAPI
 HiiTestString (
   IN     EFI_HII_PROTOCOL   *This,
   IN     CHAR16             *StringToTest,
   IN OUT UINT32             *FirstMissing,
   OUT    UINT32             *GlyphBufferSize
   )
 {
   ASSERT (FALSE);

   return EFI_UNSUPPORTED;
 }


 /**
   Find the corressponding TAG GUID from a Framework HII Handle given.

   @param Private      The HII Thunk Module Private context.
   @param FwHiiHandle  The Framemwork HII Handle.
   @param TagGuid      The output of TAG GUID found.

   @return NULL        If Framework HII Handle is invalid.
   @return The corresponding HII Thunk Context.
 **/
 EFI_STATUS
 GetTagGuidByFwHiiHandle (
   IN  CONST HII_THUNK_PRIVATE_DATA      *Private,
   IN        FRAMEWORK_EFI_HII_HANDLE    FwHiiHandle,
   OUT       EFI_GUID                    *TagGuid
   )
 {
   LIST_ENTRY                                *Link;
   HII_THUNK_CONTEXT                          *ThunkContext;

   ASSERT (TagGuid != NULL);

   Link = GetFirstNode (&Private->ThunkContextListHead);
   while (!IsNull (&Private->ThunkContextListHead, Link)) {

     ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);

     if (FwHiiHandle == ThunkContext->FwHiiHandle) {
       CopyGuid (TagGuid, &ThunkContext->TagGuid);
       return EFI_SUCCESS;
     }

     Link = GetNextNode (&Private->ThunkContextListHead, Link);
   }

   return EFI_NOT_FOUND;
 }

 /**
   Create or update the String given a new string and String ID.

   @param ThunkContext           The Thunk Context.
   @param Rfc4646AsciiLanguage   The RFC 4646 Language code in ASCII string format.
   @param NewString              The new string.
   @param StringId               The String ID. If StringId is 0, a new String Token
                                 is created. Otherwise, the String Token StringId is
                                 updated.


   @retval EFI_SUCCESS           The new string is created or updated successfully.
                                 The new String Token ID is returned in StringId if
                                 *StringId is 0 on input.
   @return Others                The update of string failed.

 **/
 EFI_STATUS
 UpdateString (
   IN CONST HII_THUNK_CONTEXT        *ThunkContext,
   IN CONST CHAR8                    *Rfc4646AsciiLanguage,
   IN       CHAR16                   *NewString,
   IN OUT STRING_REF                 *StringId
   )
 {
   EFI_STRING_ID                             NewStringId;

   NewStringId = HiiSetString (ThunkContext->UefiHiiHandle, *StringId, NewString, Rfc4646AsciiLanguage);
   *StringId = NewStringId;
   if (NewStringId == 0) {
     //
     // Only EFI_INVALID_PARAMETER is defined in HII 0.92 specification.
     //
     return EFI_INVALID_PARAMETER;
   } else {
     return EFI_SUCCESS;
   }
 }

 /**
   Create or update a String Token in a String Package.

   If *Reference == 0, a new String Token is created.

   @param This            A pointer to the EFI_HII_PROTOCOL instance.
   @param Language        Pointer to a NULL-terminated string containing a single ISO 639-2 language
                          identifier, indicating the language to print. A string consisting of
                          all spaces indicates that the string is applicable to all languages.
   @param Handle          The handle of the language pack to which the string is to be added.
   @param Token           The string token assigned to the string.
   @param NewString       The string to be added.


   @retval EFI_SUCCESS             The string was effectively registered.
   @retval EFI_INVALID_PARAMETER   The Handle was unknown. The string is not created or updated in the
                                   the string package.
 **/

 EFI_STATUS
 EFIAPI
 HiiNewString (
   IN     EFI_HII_PROTOCOL           *This,
   IN     CHAR16                     *Language,
   IN     FRAMEWORK_EFI_HII_HANDLE   Handle,
   IN OUT STRING_REF                 *Reference,
   IN     CHAR16                     *NewString
   )
 {
   EFI_STATUS                                Status;
   HII_THUNK_PRIVATE_DATA                    *Private;
   EFI_GUID                                  TagGuid;
   LIST_ENTRY                                *Link;
   HII_THUNK_CONTEXT                          *ThunkContext;
   HII_THUNK_CONTEXT                          *StringPackThunkContext;
   EFI_STRING_ID                             StringId;
   EFI_STRING_ID                             LastStringId;
   CHAR8                                     AsciiLanguage[ISO_639_2_ENTRY_SIZE + 1];
   CHAR16                                    LanguageCopy[ISO_639_2_ENTRY_SIZE + 1];
   CHAR8                                     *Rfc4646AsciiLanguage;

   LastStringId      = (EFI_STRING_ID) 0;
   StringId          = (EFI_STRING_ID) 0;
   Rfc4646AsciiLanguage = NULL;

   if (Language != NULL) {
     ZeroMem (AsciiLanguage, sizeof (AsciiLanguage));;
     ZeroMem (LanguageCopy, sizeof (LanguageCopy));
     CopyMem (LanguageCopy, Language, ISO_639_2_ENTRY_SIZE * sizeof (CHAR16));
     UnicodeStrToAsciiStr (LanguageCopy, AsciiLanguage);
     Rfc4646AsciiLanguage = ConvertLanguagesIso639ToRfc4646 (AsciiLanguage);
     ASSERT (Rfc4646AsciiLanguage != NULL);
   }

   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);

   StringPackThunkContext = FwHiiHandleToThunkContext (Private, Handle);
   if (StringPackThunkContext == NULL) {
     return EFI_INVALID_PARAMETER;
   }

   if (StringPackThunkContext->SharingStringPack) {
     Status = GetTagGuidByFwHiiHandle (Private, Handle, &TagGuid);
     ASSERT_EFI_ERROR (Status);

     Link = GetFirstNode (&Private->ThunkContextListHead);
     while (!IsNull (&Private->ThunkContextListHead, Link)) {
       ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);

       if (CompareGuid (&TagGuid, &ThunkContext->TagGuid)) {
         if (ThunkContext->SharingStringPack) {
           StringId = *Reference;
           Status = UpdateString (ThunkContext, Rfc4646AsciiLanguage, NewString, &StringId);
           if (EFI_ERROR (Status)) {
             break;
           }

           DEBUG_CODE_BEGIN ();
           if (*Reference == 0) {
             //
             // When creating new string token, make sure all created token is the same
             // for all string packages registered using FW HII interface.
             //
             if (LastStringId == (EFI_STRING_ID) 0) {
               LastStringId = StringId;
             } else {
               if (LastStringId != StringId) {
                 ASSERT(FALSE);
               }
             }
           }
           DEBUG_CODE_END ();

         }
       }

       Link = GetNextNode (&Private->ThunkContextListHead, Link);
     }
   } else {
     StringId = *Reference;
     Status = UpdateString (StringPackThunkContext, Rfc4646AsciiLanguage, NewString, &StringId);
   }

   if (!EFI_ERROR (Status)) {
     if (*Reference == 0) {
       *Reference = StringId;
     }
   } else {
     //
     // Only EFI_INVALID_PARAMETER is defined in HII 0.92 specification.
     //
     Status = EFI_INVALID_PARAMETER;
   }

   return Status;
 }

 /**
   This function removes any new strings that were added after the initial string export for this handle.
   UEFI HII String Protocol does not have Reset String function. This function perform nothing.

   @param This            A pointer to the EFI_HII_PROTOCOL instance.
   @param Handle          The HII handle on which the string resides.

   @retval EFI_SUCCESS    This function is a NOP and always return EFI_SUCCESS.

 **/
 EFI_STATUS
 EFIAPI
 HiiResetStrings (
   IN     EFI_HII_PROTOCOL   *This,
   IN     FRAMEWORK_EFI_HII_HANDLE      Handle
   )
 {
   return EFI_SUCCESS;
 }

 /**
  This function extracts a string from a package already registered with the EFI HII database.

   @param This            A pointer to the EFI_HII_PROTOCOL instance.
   @param Handle          The HII handle on which the string resides.
   @param Token           The string token assigned to the string.
   @param Raw             If TRUE, the string is returned unedited in the internal storage format described
                          above. If false, the string returned is edited by replacing <cr> with <space>
                          and by removing special characters such as the <wide> prefix.
   @param LanguageString  Pointer to a NULL-terminated string containing a single ISO 639-2 language
                          identifier, indicating the language to print. If the LanguageString is empty (starts
                          with a NULL), the default system language will be used to determine the language.
   @param BufferLength    Length of the StringBuffer. If the status reports that the buffer width is too
                          small, this parameter is filled with the length of the buffer needed.
   @param StringBuffer    The buffer designed to receive the characters in the string. Type EFI_STRING is
                          defined in String.

   @retval EFI_INVALID_PARAMETER If input parameter is invalid.
   @retval EFI_BUFFER_TOO_SMALL  If the *BufferLength is too small.
   @retval EFI_SUCCESS           Operation is successful.

 **/
 EFI_STATUS
 EFIAPI
 HiiThunkGetString (
   IN     EFI_HII_PROTOCOL           *This,
   IN     FRAMEWORK_EFI_HII_HANDLE   Handle,
   IN     STRING_REF                 Token,
   IN     BOOLEAN                    Raw,
   IN     CHAR16                     *LanguageString,
   IN OUT UINTN                      *BufferLengthTemp,
   OUT    EFI_STRING                 StringBuffer
   )
 {
   HII_THUNK_PRIVATE_DATA                *Private;
   CHAR8                                 *Iso639AsciiLanguage;
   CHAR8                                 *Rfc4646AsciiLanguage;
   CHAR8                                 *SupportedLanguages;
   CHAR8                                 *PlatformLanguage;
   CHAR8                                 *BestLanguage;
   EFI_HII_HANDLE                        UefiHiiHandle;
   EFI_STATUS                            Status;

   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);

   Rfc4646AsciiLanguage = NULL;
   SupportedLanguages   = NULL;
   PlatformLanguage     = NULL;
   Status               = EFI_SUCCESS;

   if (LanguageString != NULL) {
     Iso639AsciiLanguage = AllocateZeroPool (StrLen (LanguageString) + 1);
     if (Iso639AsciiLanguage == NULL) {
       return EFI_OUT_OF_RESOURCES;
     }
     UnicodeStrToAsciiStr  (LanguageString, Iso639AsciiLanguage);

     //
     // Caller of Framework HII Interface uses the Language Identification String defined
     // in Iso639. So map it to the Language Identifier defined in RFC4646.
     //
     Rfc4646AsciiLanguage = ConvertLanguagesIso639ToRfc4646 (Iso639AsciiLanguage);
     FreePool (Iso639AsciiLanguage);

     //
     // If Rfc4646AsciiLanguage is NULL, more language mapping must be added to
     // Iso639ToRfc4646Map.
     //
     ASSERT (Rfc4646AsciiLanguage != NULL);
   }

   UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
   if (UefiHiiHandle == NULL) {
     Status = EFI_NOT_FOUND;
     goto Done;
   }

   //
   // Get the languages that the package specified by HiiHandle supports
   //
   SupportedLanguages = HiiGetSupportedLanguages (UefiHiiHandle);
   if (SupportedLanguages == NULL) {
     goto Done;
   }

   //
   // Get the current platform language setting
   //
   PlatformLanguage = GetEfiGlobalVariable (L"PlatformLang");

   //
   // Get the best matching language from SupportedLanguages
   //
   BestLanguage = GetBestLanguage (
                    SupportedLanguages,
                    FALSE,                // RFC 4646 mode
                    (Rfc4646AsciiLanguage != NULL) ? Rfc4646AsciiLanguage : "", // Highest priority
                    (PlatformLanguage != NULL) ? PlatformLanguage : "",         // Next highest priority
                    SupportedLanguages,   // Lowest priority
                    NULL
                    );
   if (BestLanguage != NULL) {
     Status = mHiiStringProtocol->GetString (
                                  mHiiStringProtocol,
                                  BestLanguage,
                                  UefiHiiHandle,
                                  Token,
                                  StringBuffer,
                                  BufferLengthTemp,
                                  NULL
                                  );
     FreePool (BestLanguage);
   } else {
     Status = EFI_INVALID_PARAMETER;
   }

 Done:
 	if (Rfc4646AsciiLanguage != NULL) {
     FreePool (Rfc4646AsciiLanguage);
   }

   if (SupportedLanguages != NULL) {
     FreePool (SupportedLanguages);
   }

   if (PlatformLanguage != NULL) {
     FreePool (PlatformLanguage);
   }
   return Status;
 }

 /**

   This function allows a program to extract a part of a string of not more than a given width.
   With repeated calls, this allows a calling program to extract "lines" of text that fit inside
   columns.  The effort of measuring the fit of strings inside columns is localized to this call.

   This is a deprecated API. No Framework HII module is calling it. This function will ASSERT and
   return EFI_UNSUPPORTED.

   @param This            A pointer to the EFI_HII_PROTOCOL instance.
   @param Handle          The HII handle on which the string resides.
   @param Token           The string token assigned to the string.
   @param Raw             If TRUE, the string is returned unedited in the internal storage format described
                          above. If false, the string returned is edited by replacing <cr> with <space>
                          and by removing special characters such as the <wide> prefix.
   @param LanguageString  Pointer to a NULL-terminated string containing a single ISO 639-2 language
                          identifier, indicating the language to print. If the LanguageString is empty (starts
                          with a NULL), the default system language will be used to determine the language.
   @param BufferLength    Length of the StringBuffer. If the status reports that the buffer width is too
                          small, this parameter is filled with the length of the buffer needed.
   @param StringBuffer    The buffer designed to receive the characters in the string. Type EFI_STRING is
                          defined in String.

   @retval EFI_UNSUPPORTED.
 **/
 EFI_STATUS
 EFIAPI
 HiiGetLine (
   IN     EFI_HII_PROTOCOL           *This,
   IN     FRAMEWORK_EFI_HII_HANDLE   Handle,
   IN     STRING_REF                 Token,
   IN OUT UINT16                     *Index,
   IN     UINT16                     LineWidth,
   IN     CHAR16                     *LanguageString,
   IN OUT UINT16                     *BufferLength,
   OUT    EFI_STRING                 StringBuffer
   )
 {
   ASSERT (FALSE);
   return EFI_UNSUPPORTED;
 }
	/**@file
	This file implements the protocol functions related to string package.

	Copyright (c) 2006 - 2008, Intel Corporation
	All rights reserved. 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.

	**/


	#include "HiiDatabase.h"

	/**
	Test if all of the characters in a string have corresponding font characters.

	This is a deprecated API. No Framework HII module is calling it. This function will ASSERT and
	return EFI_UNSUPPORTED.

	@param This A pointer to the EFI_HII_PROTOCOL instance.
	@param StringToTest A pointer to a Unicode string.
	@param FirstMissing A pointer to an index into the string. On input, the index of
	the first character in the StringToTest to examine. On exit, the index
	of the first character encountered for which a glyph is unavailable.
	If all glyphs in the string are available, the index is the index of the terminator
	of the string.
	@param GlyphBufferSize A pointer to a value. On output, if the function returns EFI_SUCCESS,
	it contains the amount of memory that is required to store the string? glyph equivalent.

	@retval EFI_UNSUPPORTED The function performs nothing and return EFI_UNSUPPORTED.
	**/
	EFI_STATUS
	EFIAPI
	HiiTestString (
	IN EFI_HII_PROTOCOL *This,
	IN CHAR16 *StringToTest,
	IN OUT UINT32 *FirstMissing,
	OUT UINT32 *GlyphBufferSize
	)
	{
	ASSERT (FALSE);

	return EFI_UNSUPPORTED;
	}


	/**
	Find the corressponding TAG GUID from a Framework HII Handle given.

	@param Private The HII Thunk Module Private context.
	@param FwHiiHandle The Framemwork HII Handle.
	@param TagGuid The output of TAG GUID found.

	@return NULL If Framework HII Handle is invalid.
	@return The corresponding HII Thunk Context.
	**/
	EFI_STATUS
	GetTagGuidByFwHiiHandle (
	IN CONST HII_THUNK_PRIVATE_DATA *Private,
	IN FRAMEWORK_EFI_HII_HANDLE FwHiiHandle,
	OUT EFI_GUID *TagGuid
	)
	{
	LIST_ENTRY *Link;
	HII_THUNK_CONTEXT *ThunkContext;

	ASSERT (TagGuid != NULL);

	Link = GetFirstNode (&Private->ThunkContextListHead);
	while (!IsNull (&Private->ThunkContextListHead, Link)) {

	ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);

	if (FwHiiHandle == ThunkContext->FwHiiHandle) {
	CopyGuid (TagGuid, &ThunkContext->TagGuid);
	return EFI_SUCCESS;
	}

	Link = GetNextNode (&Private->ThunkContextListHead, Link);
	}

	return EFI_NOT_FOUND;
	}

	/**
	Create or update the String given a new string and String ID.

	@param ThunkContext The Thunk Context.
	@param Rfc4646AsciiLanguage The RFC 4646 Language code in ASCII string format.
	@param NewString The new string.
	@param StringId The String ID. If StringId is 0, a new String Token
	is created. Otherwise, the String Token StringId is
	updated.


	@retval EFI_SUCCESS The new string is created or updated successfully.
	The new String Token ID is returned in StringId if
	*StringId is 0 on input.
	@return Others The update of string failed.

	**/
	EFI_STATUS
	UpdateString (
	IN CONST HII_THUNK_CONTEXT *ThunkContext,
	IN CONST CHAR8 *Rfc4646AsciiLanguage,
	IN CHAR16 *NewString,
	IN OUT STRING_REF *StringId
	)
	{
	EFI_STRING_ID NewStringId;

	NewStringId = HiiSetString (ThunkContext->UefiHiiHandle, *StringId, NewString, Rfc4646AsciiLanguage);
	*StringId = NewStringId;
	if (NewStringId == 0) {
	//
	// Only EFI_INVALID_PARAMETER is defined in HII 0.92 specification.
	//
	return EFI_INVALID_PARAMETER;
	} else {
	return EFI_SUCCESS;
	}
	}

	/**
	Create or update a String Token in a String Package.

	If *Reference == 0, a new String Token is created.

	@param This A pointer to the EFI_HII_PROTOCOL instance.
	@param Language Pointer to a NULL-terminated string containing a single ISO 639-2 language
	identifier, indicating the language to print. A string consisting of
	all spaces indicates that the string is applicable to all languages.
	@param Handle The handle of the language pack to which the string is to be added.
	@param Token The string token assigned to the string.
	@param NewString The string to be added.


	@retval EFI_SUCCESS The string was effectively registered.
	@retval EFI_INVALID_PARAMETER The Handle was unknown. The string is not created or updated in the
	the string package.
	**/

	EFI_STATUS
	EFIAPI
	HiiNewString (
	IN EFI_HII_PROTOCOL *This,
	IN CHAR16 *Language,
	IN FRAMEWORK_EFI_HII_HANDLE Handle,
	IN OUT STRING_REF *Reference,
	IN CHAR16 *NewString
	)
	{
	EFI_STATUS Status;
	HII_THUNK_PRIVATE_DATA *Private;
	EFI_GUID TagGuid;
	LIST_ENTRY *Link;
	HII_THUNK_CONTEXT *ThunkContext;
	HII_THUNK_CONTEXT *StringPackThunkContext;
	EFI_STRING_ID StringId;
	EFI_STRING_ID LastStringId;
	CHAR8 AsciiLanguage[ISO_639_2_ENTRY_SIZE + 1];
	CHAR16 LanguageCopy[ISO_639_2_ENTRY_SIZE + 1];
	CHAR8 *Rfc4646AsciiLanguage;

	LastStringId = (EFI_STRING_ID) 0;
	StringId = (EFI_STRING_ID) 0;
	Rfc4646AsciiLanguage = NULL;

	if (Language != NULL) {
	ZeroMem (AsciiLanguage, sizeof (AsciiLanguage));;
	ZeroMem (LanguageCopy, sizeof (LanguageCopy));
	CopyMem (LanguageCopy, Language, ISO_639_2_ENTRY_SIZE * sizeof (CHAR16));
	UnicodeStrToAsciiStr (LanguageCopy, AsciiLanguage);
	Rfc4646AsciiLanguage = ConvertLanguagesIso639ToRfc4646 (AsciiLanguage);
	ASSERT (Rfc4646AsciiLanguage != NULL);
	}

	Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);

	StringPackThunkContext = FwHiiHandleToThunkContext (Private, Handle);
	if (StringPackThunkContext == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	if (StringPackThunkContext->SharingStringPack) {
	Status = GetTagGuidByFwHiiHandle (Private, Handle, &TagGuid);
	ASSERT_EFI_ERROR (Status);

	Link = GetFirstNode (&Private->ThunkContextListHead);
	while (!IsNull (&Private->ThunkContextListHead, Link)) {
	ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);

	if (CompareGuid (&TagGuid, &ThunkContext->TagGuid)) {
	if (ThunkContext->SharingStringPack) {
	StringId = *Reference;
	Status = UpdateString (ThunkContext, Rfc4646AsciiLanguage, NewString, &StringId);
	if (EFI_ERROR (Status)) {
	break;
	}

	DEBUG_CODE_BEGIN ();
	if (*Reference == 0) {
	//
	// When creating new string token, make sure all created token is the same
	// for all string packages registered using FW HII interface.
	//
	if (LastStringId == (EFI_STRING_ID) 0) {
	LastStringId = StringId;
	} else {
	if (LastStringId != StringId) {
	ASSERT(FALSE);
	}
	}
	}
	DEBUG_CODE_END ();

	}
	}

	Link = GetNextNode (&Private->ThunkContextListHead, Link);
	}
	} else {
	StringId = *Reference;
	Status = UpdateString (StringPackThunkContext, Rfc4646AsciiLanguage, NewString, &StringId);
	}

	if (!EFI_ERROR (Status)) {
	if (*Reference == 0) {
	*Reference = StringId;
	}
	} else {
	//
	// Only EFI_INVALID_PARAMETER is defined in HII 0.92 specification.
	//
	Status = EFI_INVALID_PARAMETER;
	}

	return Status;
	}

	/**
	This function removes any new strings that were added after the initial string export for this handle.
	UEFI HII String Protocol does not have Reset String function. This function perform nothing.

	@param This A pointer to the EFI_HII_PROTOCOL instance.
	@param Handle The HII handle on which the string resides.

	@retval EFI_SUCCESS This function is a NOP and always return EFI_SUCCESS.

	**/
	EFI_STATUS
	EFIAPI
	HiiResetStrings (
	IN EFI_HII_PROTOCOL *This,
	IN FRAMEWORK_EFI_HII_HANDLE Handle
	)
	{
	return EFI_SUCCESS;
	}

	/**
	This function extracts a string from a package already registered with the EFI HII database.

	@param This A pointer to the EFI_HII_PROTOCOL instance.
	@param Handle The HII handle on which the string resides.
	@param Token The string token assigned to the string.
	@param Raw If TRUE, the string is returned unedited in the internal storage format described
	above. If false, the string returned is edited by replacing <cr> with <space>
	and by removing special characters such as the <wide> prefix.
	@param LanguageString Pointer to a NULL-terminated string containing a single ISO 639-2 language
	identifier, indicating the language to print. If the LanguageString is empty (starts
	with a NULL), the default system language will be used to determine the language.
	@param BufferLength Length of the StringBuffer. If the status reports that the buffer width is too
	small, this parameter is filled with the length of the buffer needed.
	@param StringBuffer The buffer designed to receive the characters in the string. Type EFI_STRING is
	defined in String.

	@retval EFI_INVALID_PARAMETER If input parameter is invalid.
	@retval EFI_BUFFER_TOO_SMALL If the *BufferLength is too small.
	@retval EFI_SUCCESS Operation is successful.

	**/
	EFI_STATUS
	EFIAPI
	HiiThunkGetString (
	IN EFI_HII_PROTOCOL *This,
	IN FRAMEWORK_EFI_HII_HANDLE Handle,
	IN STRING_REF Token,
	IN BOOLEAN Raw,
	IN CHAR16 *LanguageString,
	IN OUT UINTN *BufferLengthTemp,
	OUT EFI_STRING StringBuffer
	)
	{
	HII_THUNK_PRIVATE_DATA *Private;
	CHAR8 *Iso639AsciiLanguage;
	CHAR8 *Rfc4646AsciiLanguage;
	CHAR8 *SupportedLanguages;
	CHAR8 *PlatformLanguage;
	CHAR8 *BestLanguage;
	EFI_HII_HANDLE UefiHiiHandle;
	EFI_STATUS Status;

	Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);

	Rfc4646AsciiLanguage = NULL;
	SupportedLanguages = NULL;
	PlatformLanguage = NULL;
	Status = EFI_SUCCESS;

	if (LanguageString != NULL) {
	Iso639AsciiLanguage = AllocateZeroPool (StrLen (LanguageString) + 1);
	if (Iso639AsciiLanguage == NULL) {
	return EFI_OUT_OF_RESOURCES;
	}
	UnicodeStrToAsciiStr (LanguageString, Iso639AsciiLanguage);

	//
	// Caller of Framework HII Interface uses the Language Identification String defined
	// in Iso639. So map it to the Language Identifier defined in RFC4646.
	//
	Rfc4646AsciiLanguage = ConvertLanguagesIso639ToRfc4646 (Iso639AsciiLanguage);
	FreePool (Iso639AsciiLanguage);

	//
	// If Rfc4646AsciiLanguage is NULL, more language mapping must be added to
	// Iso639ToRfc4646Map.
	//
	ASSERT (Rfc4646AsciiLanguage != NULL);
	}

	UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
	if (UefiHiiHandle == NULL) {
	Status = EFI_NOT_FOUND;
	goto Done;
	}

	//
	// Get the languages that the package specified by HiiHandle supports
	//
	SupportedLanguages = HiiGetSupportedLanguages (UefiHiiHandle);
	if (SupportedLanguages == NULL) {
	goto Done;
	}

	//
	// Get the current platform language setting
	//
	PlatformLanguage = GetEfiGlobalVariable (L"PlatformLang");

	//
	// Get the best matching language from SupportedLanguages
	//
	BestLanguage = GetBestLanguage (
	SupportedLanguages,
	FALSE, // RFC 4646 mode
	(Rfc4646AsciiLanguage != NULL) ? Rfc4646AsciiLanguage : "", // Highest priority
	(PlatformLanguage != NULL) ? PlatformLanguage : "", // Next highest priority
	SupportedLanguages, // Lowest priority
	NULL
	);
	if (BestLanguage != NULL) {
	Status = mHiiStringProtocol->GetString (
	mHiiStringProtocol,
	BestLanguage,
	UefiHiiHandle,
	Token,
	StringBuffer,
	BufferLengthTemp,
	NULL
	);
	FreePool (BestLanguage);
	} else {
	Status = EFI_INVALID_PARAMETER;
	}

	Done:
	if (Rfc4646AsciiLanguage != NULL) {
	FreePool (Rfc4646AsciiLanguage);
	}

	if (SupportedLanguages != NULL) {
	FreePool (SupportedLanguages);
	}

	if (PlatformLanguage != NULL) {
	FreePool (PlatformLanguage);
	}
	return Status;
	}

	/**

	This function allows a program to extract a part of a string of not more than a given width.
	With repeated calls, this allows a calling program to extract "lines" of text that fit inside
	columns. The effort of measuring the fit of strings inside columns is localized to this call.

	This is a deprecated API. No Framework HII module is calling it. This function will ASSERT and
	return EFI_UNSUPPORTED.

	@param This A pointer to the EFI_HII_PROTOCOL instance.
	@param Handle The HII handle on which the string resides.
	@param Token The string token assigned to the string.
	@param Raw If TRUE, the string is returned unedited in the internal storage format described
	above. If false, the string returned is edited by replacing <cr> with <space>
	and by removing special characters such as the <wide> prefix.
	@param LanguageString Pointer to a NULL-terminated string containing a single ISO 639-2 language
	identifier, indicating the language to print. If the LanguageString is empty (starts
	with a NULL), the default system language will be used to determine the language.
	@param BufferLength Length of the StringBuffer. If the status reports that the buffer width is too
	small, this parameter is filled with the length of the buffer needed.
	@param StringBuffer The buffer designed to receive the characters in the string. Type EFI_STRING is
	defined in String.

	@retval EFI_UNSUPPORTED.
	**/
	EFI_STATUS
	EFIAPI
	HiiGetLine (
	IN EFI_HII_PROTOCOL *This,
	IN FRAMEWORK_EFI_HII_HANDLE Handle,
	IN STRING_REF Token,
	IN OUT UINT16 *Index,
	IN UINT16 LineWidth,
	IN CHAR16 *LanguageString,
	IN OUT UINT16 *BufferLength,
	OUT EFI_STRING StringBuffer
	)
	{
	ASSERT (FALSE);
	return EFI_UNSUPPORTED;
	}