EdkCompatibilityPkg/Compatibility/FrameworkHiiOnUefiHiiThunk/Strings.c

   1 /**@file
   2   This file implements the protocol functions related to string package.
   3
   4 Copyright (c) 2006 - 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
  16 #include "HiiDatabase.h"
  17
  18 typedef struct {
  19   CHAR8 *Iso639;
  20   CHAR8 *Rfc3066;
  21 } ISO639TORFC3066MAP;
  22
  23 ISO639TORFC3066MAP Iso639ToRfc3066Map [] = {
  24     {"eng", "en-US"},
  25     {"fra", "fr-FR"},
  26 };
  27
  28 //
  29 // Lookup table of ISO639-2 3 character language codes to ISO 639-1 2 character language codes
  30 // Each entry is 5 CHAR8 values long.  The first 3 CHAR8 values are the ISO 639-2 code.
  31 // The last 2 CHAR8 values are the ISO 639-1 code.
  32 //
  33 GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 Iso639ToRfc3066ConversionTable[] =
  34 "\
  35 aaraa\
  36 abkab\
  37 afraf\
  38 amham\
  39 araar\
  40 asmas\
  41 aymay\
  42 azeaz\
  43 bakba\
  44 belbe\
  45 benbn\
  46 bihbh\
  47 bisbi\
  48 bodbo\
  49 brebr\
  50 bulbg\
  51 catca\
  52 cescs\
  53 corkw\
  54 cosco\
  55 cymcy\
  56 danda\
  57 deude\
  58 dzodz\
  59 ellel\
  60 engen\
  61 epoeo\
  62 estet\
  63 euseu\
  64 faofo\
  65 fasfa\
  66 fijfj\
  67 finfi\
  68 frafr\
  69 fryfy\
  70 gaiga\
  71 gdhgd\
  72 glggl\
  73 grngn\
  74 gujgu\
  75 hauha\
  76 hebhe\
  77 hinhi\
  78 hrvhr\
  79 hunhu\
  80 hyehy\
  81 ikuiu\
  82 ileie\
  83 inaia\
  84 indid\
  85 ipkik\
  86 islis\
  87 itait\
  88 jawjw\
  89 jpnja\
  90 kalkl\
  91 kankn\
  92 kasks\
  93 katka\
  94 kazkk\
  95 khmkm\
  96 kinrw\
  97 kirky\
  98 korko\
  99 kurku\
 100 laolo\
 101 latla\
 102 lavlv\
 103 linln\
 104 litlt\
 105 ltzlb\
 106 malml\
 107 marmr\
 108 mkdmk\
 109 mlgmg\
 110 mltmt\
 111 molmo\
 112 monmn\
 113 mrimi\
 114 msams\
 115 myamy\
 116 nauna\
 117 nepne\
 118 nldnl\
 119 norno\
 120 ocioc\
 121 ormom\
 122 panpa\
 123 polpl\
 124 porpt\
 125 pusps\
 126 quequ\
 127 rohrm\
 128 ronro\
 129 runrn\
 130 rusru\
 131 sagsg\
 132 sansa\
 133 sinsi\
 134 slksk\
 135 slvsl\
 136 smise\
 137 smosm\
 138 snasn\
 139 sndsd\
 140 somso\
 141 sotst\
 142 spaes\
 143 sqisq\
 144 srpsr\
 145 sswss\
 146 sunsu\
 147 swasw\
 148 swesv\
 149 tamta\
 150 tattt\
 151 telte\
 152 tgktg\
 153 tgltl\
 154 thath\
 155 tsnts\
 156 tuktk\
 157 twitw\
 158 uigug\
 159 ukruk\
 160 urdur\
 161 uzbuz\
 162 vievi\
 163 volvo\
 164 wolwo\
 165 xhoxh\
 166 yidyi\
 167 zhaza\
 168 zhozh\
 169 zulzu\
 170 ";
 171
 172 CHAR8 *
 173 ConvertIso639ToRfc3066 (
 174   CHAR8 *Iso638Lang
 175   )
 176 {
 177   UINTN Index;
 178   CHAR8 AsciiLanguage[ISO_639_2_ENTRY_SIZE + 1];
 179
 180   AsciiStrnCpy (AsciiLanguage, Iso638Lang, sizeof (AsciiLanguage));
 181   for (Index = 0; Index < ISO_639_2_ENTRY_SIZE + 1; Index ++) {
 182         if (AsciiLanguage [Index] == 0) {
 183                 break;
 184         } else if (AsciiLanguage [Index] >= 'A' && AsciiLanguage [Index] <= 'Z') {
 185                 AsciiLanguage [Index] = (CHAR8) (AsciiLanguage [Index] - 'A' + 'a');
 186         }
 187   }
 188
 189   for (Index = 0; Index < sizeof (Iso639ToRfc3066Map) / sizeof (Iso639ToRfc3066Map[0]); Index++) {
 190     if (AsciiStrnCmp (AsciiLanguage, Iso639ToRfc3066Map[Index].Iso639, AsciiStrSize (AsciiLanguage)) == 0) {
 191       return Iso639ToRfc3066Map[Index].Rfc3066;
 192     }
 193   }
 194
 195   return (CHAR8 *) NULL;
 196 }
 197
 198 /**
 199   Convert language code from RFC3066 to ISO639-2.
 200
 201   @param  LanguageRfc3066        RFC3066 language code.
 202   @param  LanguageIso639         ISO639-2 language code.
 203
 204   @retval EFI_SUCCESS            Language code converted.
 205   @retval EFI_NOT_FOUND          Language code not found.
 206
 207 **/
 208 EFI_STATUS
 209 EFIAPI
 210 ConvertRfc3066LanguageToIso639Language (
 211   IN  CHAR8   *LanguageRfc3066,
 212   OUT CHAR8   *LanguageIso639
 213   )
 214 {
 215   UINTN  Index;
 216
 217   if ((LanguageRfc3066[2] != '-') && (LanguageRfc3066[2] != 0)) {
 218     CopyMem (LanguageIso639, LanguageRfc3066, 3);
 219     return EFI_SUCCESS;
 220   }
 221
 222   for (Index = 0; Iso639ToRfc3066ConversionTable[Index] != 0; Index += 5) {
 223     if (CompareMem (LanguageRfc3066, &Iso639ToRfc3066ConversionTable[Index + 3], 2) == 0) {
 224       CopyMem (LanguageIso639, &Iso639ToRfc3066ConversionTable[Index], 3);
 225       return EFI_SUCCESS;
 226     }
 227   }
 228
 229   return EFI_NOT_FOUND;
 230 }
 231
 232
 233 /**
 234   Convert language code from ISO639-2 to RFC3066 and return the converted language.
 235   Caller is responsible for freeing the allocated buffer.
 236
 237   LanguageIso639 contain a single ISO639-2 code such as
 238   "eng" or "fra".
 239
 240   If LanguageIso639 is NULL, then ASSERT.
 241   If LanguageRfc3066 is NULL, then ASSERT.
 242
 243   @param  LanguageIso639         ISO639-2 language code.
 244
 245   @return the allocated buffer or NULL, if the language is not found.
 246
 247 **/
 248 CHAR8*
 249 EFIAPI
 250 ConvertIso639LanguageToRfc3066Language (
 251   IN  CONST CHAR8   *LanguageIso639
 252   )
 253 {
 254   UINTN Index;
 255   CHAR8 *Rfc3066Language;
 256
 257   for (Index = 0; Iso639ToRfc3066ConversionTable[Index] != 0; Index += 5) {
 258     if (CompareMem (LanguageIso639, &Iso639ToRfc3066ConversionTable[Index], 3) == 0) {
 259       Rfc3066Language = AllocateZeroPool (3);
 260       if (Rfc3066Language != NULL) {
 261         Rfc3066Language = CopyMem (Rfc3066Language, &Iso639ToRfc3066ConversionTable[Index + 3], 2);
 262       }
 263       return Rfc3066Language;
 264     }
 265   }
 266
 267   return NULL;
 268 }
 269
 270 /**
 271   Get next language from language code list (with separator ';').
 272
 273   If LangCode is NULL, then ASSERT.
 274   If Lang is NULL, then ASSERT.
 275
 276   @param  LangCode    On input: point to first language in the list. On
 277                                  output: point to next language in the list, or
 278                                  NULL if no more language in the list.
 279   @param  Lang           The first language in the list.
 280
 281 **/
 282 VOID
 283 EFIAPI
 284 GetNextLanguage (
 285   IN OUT CHAR8      **LangCode,
 286   OUT CHAR8         *Lang
 287   )
 288 {
 289   UINTN  Index;
 290   CHAR8  *StringPtr;
 291
 292   ASSERT (LangCode != NULL);
 293   ASSERT (*LangCode != NULL);
 294   ASSERT (Lang != NULL);
 295
 296   Index = 0;
 297   StringPtr = *LangCode;
 298   while (StringPtr[Index] != 0 && StringPtr[Index] != ';') {
 299     Index++;
 300   }
 301
 302   CopyMem (Lang, StringPtr, Index);
 303   Lang[Index] = 0;
 304
 305   if (StringPtr[Index] == ';') {
 306     Index++;
 307   }
 308   *LangCode = StringPtr + Index;
 309 }
 310
 311 /**
 312   Test if all of the characters in a string have corresponding font characters.
 313
 314   This is a deprecated API. No Framework HII module is calling it. This function will ASSERT and
 315   return EFI_UNSUPPORTED.
 316
 317   @param This            A pointer to the EFI_HII_PROTOCOL instance.
 318   @param StringToTest    A pointer to a Unicode string.
 319   @param FirstMissing    A pointer to an index into the string. On input, the index of
 320                          the first character in the StringToTest to examine. On exit, the index
 321                          of the first character encountered for which a glyph is unavailable.
 322                          If all glyphs in the string are available, the index is the index of the terminator
 323                          of the string.
 324   @param GlyphBufferSize A pointer to a value. On output, if the function returns EFI_SUCCESS,
 325                          it contains the amount of memory that is required to store the string? glyph equivalent.
 326
 327   @retval EFI_UNSUPPORTED  The function performs nothing and return EFI_UNSUPPORTED.
 328 **/
 329 EFI_STATUS
 330 EFIAPI
 331 HiiTestString (
 332   IN     EFI_HII_PROTOCOL   *This,
 333   IN     CHAR16             *StringToTest,
 334   IN OUT UINT32             *FirstMissing,
 335   OUT    UINT32             *GlyphBufferSize
 336   )
 337 {
 338   ASSERT (FALSE);
 339
 340   return EFI_UNSUPPORTED;
 341 }
 342
 343
 344 /**
 345   Find the corressponding TAG GUID from a Framework HII Handle given.
 346
 347   @param Private      The HII Thunk Module Private context.
 348   @param FwHiiHandle  The Framemwork HII Handle.
 349   @param TagGuid      The output of TAG GUID found.
 350
 351   @return NULL        If Framework HII Handle is invalid.
 352   @return The corresponding HII Thunk Context.
 353 **/
 354 EFI_STATUS
 355 GetTagGuidByFwHiiHandle (
 356   IN  CONST HII_THUNK_PRIVATE_DATA      *Private,
 357   IN        FRAMEWORK_EFI_HII_HANDLE    FwHiiHandle,
 358   OUT       EFI_GUID                    *TagGuid
 359   )
 360 {
 361   LIST_ENTRY                                *Link;
 362   HII_THUNK_CONTEXT                          *ThunkContext;
 363
 364   ASSERT (TagGuid != NULL);
 365
 366   Link = GetFirstNode (&Private->ThunkContextListHead);
 367   while (!IsNull (&Private->ThunkContextListHead, Link)) {
 368
 369     ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
 370
 371     if (FwHiiHandle == ThunkContext->FwHiiHandle) {
 372       CopyGuid (TagGuid, &ThunkContext->TagGuid);
 373       return EFI_SUCCESS;
 374     }
 375
 376     Link = GetNextNode (&Private->ThunkContextListHead, Link);
 377   }
 378
 379   return EFI_NOT_FOUND;
 380 }
 381
 382 /**
 383   Create or update the String given a new string and String ID.
 384
 385   @param ThunkContext           The Thunk Context.
 386   @param Rfc3066AsciiLanguage   The RFC 3066 Language code in ASCII string format.
 387   @param NewString              The new string.
 388   @param StringId               The String ID. If StringId is 0, a new String Token
 389                                 is created. Otherwise, the String Token StringId is
 390                                 updated.
 391
 392
 393   @retval EFI_SUCCESS           The new string is created or updated successfully.
 394                                 The new String Token ID is returned in StringId if
 395                                 *StringId is 0 on input.
 396   @return Others                The update of string failed.
 397
 398 **/
 399 EFI_STATUS
 400 UpdateString (
 401   IN CONST HII_THUNK_CONTEXT        *ThunkContext,
 402   IN CONST CHAR8                    *Rfc3066AsciiLanguage,
 403   IN       CHAR16                   *NewString,
 404   IN OUT STRING_REF                 *StringId
 405   )
 406 {
 407   EFI_STRING_ID                             NewStringId;
 408
 409   NewStringId = HiiSetString (ThunkContext->UefiHiiHandle, *StringId, NewString, Rfc3066AsciiLanguage);
 410   *StringId = NewStringId;
 411   if (NewStringId == 0) {
 412     //
 413     // Only EFI_INVALID_PARAMETER is defined in HII 0.92 specification.
 414     //
 415     return EFI_INVALID_PARAMETER;
 416   } else {
 417     return EFI_SUCCESS;
 418   }
 419 }
 420
 421 /**
 422   Create or update a String Token in a String Package.
 423
 424   If *Reference == 0, a new String Token is created.
 425
 426   @param This            A pointer to the EFI_HII_PROTOCOL instance.
 427   @param Language        Pointer to a NULL-terminated string containing a single ISO 639-2 language
 428                          identifier, indicating the language to print. A string consisting of
 429                          all spaces indicates that the string is applicable to all languages.
 430   @param Handle          The handle of the language pack to which the string is to be added.
 431   @param Token           The string token assigned to the string.
 432   @param NewString       The string to be added.
 433
 434
 435   @retval EFI_SUCCESS             The string was effectively registered.
 436   @retval EFI_INVALID_PARAMETER   The Handle was unknown. The string is not created or updated in the
 437                                   the string package.
 438 **/
 439
 440 EFI_STATUS
 441 EFIAPI
 442 HiiNewString (
 443   IN     EFI_HII_PROTOCOL           *This,
 444   IN     CHAR16                     *Language,
 445   IN     FRAMEWORK_EFI_HII_HANDLE   Handle,
 446   IN OUT STRING_REF                 *Reference,
 447   IN     CHAR16                     *NewString
 448   )
 449 {
 450   EFI_STATUS                                Status;
 451   HII_THUNK_PRIVATE_DATA                    *Private;
 452   EFI_GUID                                  TagGuid;
 453   LIST_ENTRY                                *Link;
 454   HII_THUNK_CONTEXT                          *ThunkContext;
 455   HII_THUNK_CONTEXT                          *StringPackThunkContext;
 456   EFI_STRING_ID                             StringId;
 457   EFI_STRING_ID                             LastStringId;
 458   CHAR8                                     AsciiLanguage[ISO_639_2_ENTRY_SIZE + 1];
 459   CHAR16                                    LanguageCopy[ISO_639_2_ENTRY_SIZE + 1];
 460   CHAR8                                     *Rfc3066AsciiLanguage;
 461
 462   LastStringId      = (EFI_STRING_ID) 0;
 463   StringId          = (EFI_STRING_ID) 0;
 464   Rfc3066AsciiLanguage = NULL;
 465
 466   if (Language != NULL) {
 467     ZeroMem (AsciiLanguage, sizeof (AsciiLanguage));;
 468     ZeroMem (LanguageCopy, sizeof (LanguageCopy));
 469     CopyMem (LanguageCopy, Language, ISO_639_2_ENTRY_SIZE * sizeof (CHAR16));
 470     UnicodeStrToAsciiStr (LanguageCopy, AsciiLanguage);
 471     Rfc3066AsciiLanguage = ConvertIso639ToRfc3066 (AsciiLanguage);
 472     ASSERT (Rfc3066AsciiLanguage != NULL);
 473   }
 474
 475   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 476
 477   StringPackThunkContext = FwHiiHandleToThunkContext (Private, Handle);
 478   if (StringPackThunkContext == NULL) {
 479     return EFI_INVALID_PARAMETER;
 480   }
 481
 482   if (StringPackThunkContext->SharingStringPack) {
 483     Status = GetTagGuidByFwHiiHandle (Private, Handle, &TagGuid);
 484     ASSERT_EFI_ERROR (Status);
 485
 486     Link = GetFirstNode (&Private->ThunkContextListHead);
 487     while (!IsNull (&Private->ThunkContextListHead, Link)) {
 488       ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
 489
 490       if (CompareGuid (&TagGuid, &ThunkContext->TagGuid)) {
 491         if (ThunkContext->SharingStringPack) {
 492           StringId = *Reference;
 493           Status = UpdateString (ThunkContext, Rfc3066AsciiLanguage, NewString, &StringId);
 494           if (EFI_ERROR (Status)) {
 495             break;
 496           }
 497
 498           DEBUG_CODE_BEGIN ();
 499           if (*Reference == 0) {
 500             //
 501             // When creating new string token, make sure all created token is the same
 502             // for all string packages registered using FW HII interface.
 503             //
 504             if (LastStringId == (EFI_STRING_ID) 0) {
 505               LastStringId = StringId;
 506             } else {
 507               if (LastStringId != StringId) {
 508                 ASSERT(FALSE);
 509               }
 510             }
 511           }
 512           DEBUG_CODE_END ();
 513
 514         }
 515       }
 516
 517       Link = GetNextNode (&Private->ThunkContextListHead, Link);
 518     }
 519   } else {
 520     StringId = *Reference;
 521     Status = UpdateString (StringPackThunkContext, Rfc3066AsciiLanguage, NewString, &StringId);
 522   }
 523
 524   if (!EFI_ERROR (Status)) {
 525     if (*Reference == 0) {
 526       *Reference = StringId;
 527     }
 528   } else {
 529     //
 530     // Only EFI_INVALID_PARAMETER is defined in HII 0.92 specification.
 531     //
 532     Status = EFI_INVALID_PARAMETER;
 533   }
 534
 535   return Status;
 536 }
 537
 538 /**
 539   This function removes any new strings that were added after the initial string export for this handle.
 540   UEFI HII String Protocol does not have Reset String function. This function perform nothing.
 541
 542   @param This            A pointer to the EFI_HII_PROTOCOL instance.
 543   @param Handle          The HII handle on which the string resides.
 544
 545   @retval EFI_SUCCESS    This function is a NOP and always return EFI_SUCCESS.
 546
 547 **/
 548 EFI_STATUS
 549 EFIAPI
 550 HiiResetStrings (
 551   IN     EFI_HII_PROTOCOL   *This,
 552   IN     FRAMEWORK_EFI_HII_HANDLE      Handle
 553   )
 554 {
 555   return EFI_SUCCESS;
 556 }
 557
 558 /**
 559  This function extracts a string from a package already registered with the EFI HII database.
 560
 561   @param This            A pointer to the EFI_HII_PROTOCOL instance.
 562   @param Handle          The HII handle on which the string resides.
 563   @param Token           The string token assigned to the string.
 564   @param Raw             If TRUE, the string is returned unedited in the internal storage format described
 565                          above. If false, the string returned is edited by replacing <cr> with <space>
 566                          and by removing special characters such as the <wide> prefix.
 567   @param LanguageString  Pointer to a NULL-terminated string containing a single ISO 639-2 language
 568                          identifier, indicating the language to print. If the LanguageString is empty (starts
 569                          with a NULL), the default system language will be used to determine the language.
 570   @param BufferLength    Length of the StringBuffer. If the status reports that the buffer width is too
 571                          small, this parameter is filled with the length of the buffer needed.
 572   @param StringBuffer    The buffer designed to receive the characters in the string. Type EFI_STRING is
 573                          defined in String.
 574
 575   @retval EFI_INVALID_PARAMETER If input parameter is invalid.
 576   @retval EFI_BUFFER_TOO_SMALL  If the *BufferLength is too small.
 577   @retval EFI_SUCCESS           Operation is successful.
 578
 579 **/
 580 EFI_STATUS
 581 EFIAPI
 582 HiiThunkGetString (
 583   IN     EFI_HII_PROTOCOL           *This,
 584   IN     FRAMEWORK_EFI_HII_HANDLE   Handle,
 585   IN     STRING_REF                 Token,
 586   IN     BOOLEAN                    Raw,
 587   IN     CHAR16                     *LanguageString,
 588   IN OUT UINTN                      *BufferLengthTemp,
 589   OUT    EFI_STRING                 StringBuffer
 590   )
 591 {
 592   HII_THUNK_PRIVATE_DATA                *Private;
 593   CHAR8                                 *Iso639AsciiLanguage;
 594   CHAR8                                 *Rfc3066AsciiLanguage;
 595   CHAR8                                 *SupportedLanguages;
 596   CHAR8                                 *PlatformLanguage;
 597   CHAR8                                 *BestLanguage;
 598   EFI_HII_HANDLE                        UefiHiiHandle;
 599   EFI_STATUS                            Status;
 600
 601   Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
 602
 603   Iso639AsciiLanguage = NULL;
 604   Rfc3066AsciiLanguage = NULL;
 605
 606   if (LanguageString != NULL) {
 607     Iso639AsciiLanguage = AllocateZeroPool (StrLen (LanguageString) + 1);
 608     if (Iso639AsciiLanguage == NULL) {
 609       return EFI_OUT_OF_RESOURCES;
 610     }
 611     UnicodeStrToAsciiStr  (LanguageString, Iso639AsciiLanguage);
 612
 613     //
 614     // Caller of Framework HII Interface uses the Language Identification String defined
 615     // in Iso639. So map it to the Language Identifier defined in RFC3066.
 616     //
 617     Rfc3066AsciiLanguage = ConvertIso639ToRfc3066 (Iso639AsciiLanguage);
 618
 619     //
 620     // If Rfc3066AsciiLanguage is NULL, more language mapping must be added to
 621     // Iso639ToRfc3066Map.
 622     //
 623     ASSERT (Rfc3066AsciiLanguage != NULL);
 624
 625   }
 626
 627   UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
 628   if (UefiHiiHandle == NULL) {
 629     Status = EFI_NOT_FOUND;
 630     goto Done;
 631   }
 632
 633   if (Rfc3066AsciiLanguage == NULL) {
 634     //
 635     // Get the languages that the package specified by HiiHandle supports
 636     //
 637     SupportedLanguages = HiiGetSupportedLanguages (UefiHiiHandle);
 638     if (SupportedLanguages == NULL) {
 639       goto Error2;
 640     }
 641
 642     //
 643     // Get the current platform language setting
 644     //
 645     PlatformLanguage = GetEfiGlobalVariable (L"PlatformLang");
 646     if (PlatformLanguage == NULL) {
 647       goto Error1;
 648     }
 649
 650     //
 651     // Get the best matching language from SupportedLanguages
 652     //
 653     BestLanguage = GetBestLanguage (
 654                      SupportedLanguages,
 655                      FALSE,                // RFC 4646 mode
 656                      PlatformLanguage,     // Next highest priority
 657                      SupportedLanguages,   // Lowest priority
 658                      NULL
 659                      );
 660     if (BestLanguage == NULL) {
 661       FreePool (PlatformLanguage);
 662 Error1:
 663       FreePool (SupportedLanguages);
 664 Error2:
 665       Status = EFI_INVALID_PARAMETER;
 666       goto Done;
 667     }
 668
 669     Status = mHiiStringProtocol->GetString (
 670                                  mHiiStringProtocol,
 671                                  BestLanguage,
 672                                  UefiHiiHandle,
 673                                  Token,
 674                                  StringBuffer,
 675                                  BufferLengthTemp,
 676                                  NULL
 677                                  );
 678     FreePool (BestLanguage);
 679   } else {
 680     Status = mHiiStringProtocol->GetString (
 681                                  mHiiStringProtocol,
 682                                  Rfc3066AsciiLanguage,
 683                                  UefiHiiHandle,
 684                                  Token,
 685                                  StringBuffer,
 686                                  BufferLengthTemp,
 687                                  NULL
 688                                  );
 689   }
 690
 691 Done:
 692         if (Iso639AsciiLanguage != NULL) {
 693     FreePool (Iso639AsciiLanguage);
 694   }
 695
 696   return Status;
 697 }
 698
 699 /**
 700
 701   This function allows a program to extract a part of a string of not more than a given width.
 702   With repeated calls, this allows a calling program to extract "lines" of text that fit inside
 703   columns.  The effort of measuring the fit of strings inside columns is localized to this call.
 704
 705   This is a deprecated API. No Framework HII module is calling it. This function will ASSERT and
 706   return EFI_UNSUPPORTED.
 707
 708   @param This            A pointer to the EFI_HII_PROTOCOL instance.
 709   @param Handle          The HII handle on which the string resides.
 710   @param Token           The string token assigned to the string.
 711   @param Raw             If TRUE, the string is returned unedited in the internal storage format described
 712                          above. If false, the string returned is edited by replacing <cr> with <space>
 713                          and by removing special characters such as the <wide> prefix.
 714   @param LanguageString  Pointer to a NULL-terminated string containing a single ISO 639-2 language
 715                          identifier, indicating the language to print. If the LanguageString is empty (starts
 716                          with a NULL), the default system language will be used to determine the language.
 717   @param BufferLength    Length of the StringBuffer. If the status reports that the buffer width is too
 718                          small, this parameter is filled with the length of the buffer needed.
 719   @param StringBuffer    The buffer designed to receive the characters in the string. Type EFI_STRING is
 720                          defined in String.
 721
 722   @retval EFI_UNSUPPORTED.
 723 **/
 724 EFI_STATUS
 725 EFIAPI
 726 HiiGetLine (
 727   IN     EFI_HII_PROTOCOL           *This,
 728   IN     FRAMEWORK_EFI_HII_HANDLE   Handle,
 729   IN     STRING_REF                 Token,
 730   IN OUT UINT16                     *Index,
 731   IN     UINT16                     LineWidth,
 732   IN     CHAR16                     *LanguageString,
 733   IN OUT UINT16                     *BufferLength,
 734   OUT    EFI_STRING                 StringBuffer
 735   )
 736 {
 737   ASSERT (FALSE);
 738   return EFI_UNSUPPORTED;
 739 }
 740
 741