MdePkg/Library/HiiLib/HiiString.c

   1 /** @file
   2   HII Library implementation that uses DXE protocols and services.
   3
   4   Copyright (c) 2006, Intel Corporation<BR>
   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 "InternalHiiLib.h"
  17 EFI_STATUS
  18 EFIAPI
  19 HiiLibNewString (
  20   IN  EFI_HII_HANDLE                  PackageList,
  21   OUT EFI_STRING_ID                   *StringId,
  22   IN  CONST EFI_STRING                String
  23   )
  24 {
  25   EFI_STATUS  Status;
  26   CHAR8       *Languages;
  27   CHAR8       *LangStrings;
  28   CHAR8       Lang[RFC_3066_ENTRY_SIZE];
  29
  30   ASSERT (String != NULL);
  31   ASSERT (StringId != NULL);
  32
  33   Status = EFI_SUCCESS;
  34
  35   Languages = HiiLibGetSupportedLanguages (PackageList);
  36
  37   LangStrings = Languages;
  38   while (*LangStrings != 0) {
  39     HiiLibGetNextLanguage (&LangStrings, Lang);
  40
  41     Status = mHiiStringProt->NewString (
  42                                  mHiiStringProt,
  43                                  PackageList,
  44                                  StringId,
  45                                  Lang,
  46                                  NULL,
  47                                  String,
  48                                  NULL
  49                                  );
  50     if (EFI_ERROR (Status)) {
  51       break;
  52     }
  53   }
  54
  55   FreePool (Languages);
  56
  57   return Status;
  58
  59 }
  60
  61 EFI_STATUS
  62 EFIAPI
  63 HiiLibSetString (
  64   IN  EFI_HII_HANDLE                  PackageList,
  65   IN  EFI_STRING_ID                   StringId,
  66   IN  CONST EFI_STRING                String
  67   )
  68 {
  69   EFI_STATUS  Status;
  70   CHAR8       *Languages;
  71   CHAR8       *LangStrings;
  72   CHAR8       Lang[RFC_3066_ENTRY_SIZE];
  73
  74   ASSERT (IsHiiHandleRegistered (PackageList));
  75
  76   Status = EFI_SUCCESS;
  77
  78   Languages = HiiLibGetSupportedLanguages (PackageList);
  79   ASSERT (Languages != NULL);
  80
  81   LangStrings = Languages;
  82   while (*LangStrings != 0) {
  83     HiiLibGetNextLanguage (&LangStrings, Lang);
  84
  85     Status = mHiiStringProt->SetString (
  86                                  mHiiStringProt,
  87                                  PackageList,
  88                                  StringId,
  89                                  Lang,
  90                                  String,
  91                                  NULL
  92                                  );
  93     if (EFI_ERROR (Status)) {
  94       break;
  95     }
  96   }
  97
  98   FreePool (Languages);
  99
 100   return Status;
 101 }
 102
 103
 104 EFI_STATUS
 105 EFIAPI
 106 HiiLibGetStringFromToken (
 107   IN  EFI_GUID                        *ProducerGuid,
 108   IN  EFI_STRING_ID                   StringId,
 109   OUT EFI_STRING                      *String
 110   )
 111 {
 112   EFI_STATUS      Status;
 113   UINTN           Index;
 114   UINTN           HandleBufferLen;
 115   EFI_HII_HANDLE  *HiiHandleBuffer;
 116   EFI_GUID        Guid;
 117
 118   Status = HiiLibGetHiiHandles (&HandleBufferLen, &HiiHandleBuffer);
 119   if (EFI_ERROR(Status)) {
 120     return Status;
 121   }
 122   for (Index = 0; Index < (HandleBufferLen / sizeof (EFI_HII_HANDLE)); Index++) {
 123     Status = HiiLibExtractGuidFromHiiHandle (HiiHandleBuffer[Index], &Guid);
 124     if (EFI_ERROR(Status)) {
 125       return Status;
 126     }
 127     if (CompareGuid (&Guid, ProducerGuid) == TRUE) {
 128       break;
 129     }
 130   }
 131
 132   if (Index >= (HandleBufferLen / sizeof (EFI_HII_HANDLE))) {
 133     //
 134     // If PackageList with the matching ProducerGuid is not found, then ASSERT.
 135     //
 136     ASSERT (FALSE);
 137     Status = EFI_NOT_FOUND;
 138     goto Out;
 139   }
 140
 141   Status = HiiLibGetStringFromHandle (HiiHandleBuffer[Index], StringId, String);
 142
 143 Out:
 144   if (HiiHandleBuffer != NULL) {
 145     gBS->FreePool (HiiHandleBuffer);
 146   }
 147   return Status;
 148 }
 149
 150 EFI_STATUS
 151 EFIAPI
 152 HiiLibGetString (
 153   IN  EFI_HII_HANDLE                  PackageList,
 154   IN  EFI_STRING_ID                   StringId,
 155   OUT EFI_STRING                      String,
 156   IN  OUT UINTN                       *StringSize
 157   )
 158 {
 159   EFI_STATUS  Status;
 160   CHAR8       *Languages;
 161   CHAR8       *LangStrings;
 162   CHAR8       Lang[RFC_3066_ENTRY_SIZE];
 163   CHAR8       CurrentLang[RFC_3066_ENTRY_SIZE];
 164
 165   ASSERT (String != NULL);
 166   ASSERT (StringSize != NULL);
 167   ASSERT (IsHiiHandleRegistered (PackageList));
 168
 169   HiiLibGetCurrentLanguage (CurrentLang);
 170
 171   Status = mHiiStringProt->GetString (
 172                                mHiiStringProt,
 173                                CurrentLang,
 174                                PackageList,
 175                                StringId,
 176                                String,
 177                                StringSize,
 178                                NULL
 179                                );
 180
 181   if (EFI_ERROR (Status) && (Status != EFI_BUFFER_TOO_SMALL)) {
 182     Languages = HiiLibGetSupportedLanguages (PackageList);
 183     ASSERT (Languages != NULL);
 184
 185     LangStrings = Languages;
 186     HiiLibGetNextLanguage (&LangStrings, Lang);
 187     gBS->FreePool (Languages);
 188
 189     Status = mHiiStringProt->GetString (
 190                                  mHiiStringProt,
 191                                  Lang,
 192                                  PackageList,
 193                                  StringId,
 194                                  String,
 195                                  StringSize,
 196                                  NULL
 197                                  );
 198   }
 199
 200   return Status;
 201 }
 202
 203
 204 EFI_STATUS
 205 EFIAPI
 206 HiiLibGetStringFromHandle (
 207   IN  EFI_HII_HANDLE                  HiiHandle,
 208   IN  EFI_STRING_ID                   StringId,
 209   OUT EFI_STRING                      *String
 210   )
 211 {
 212   EFI_STATUS                          Status;
 213   UINTN                               StringSize;
 214
 215   ASSERT (String != NULL);
 216
 217   StringSize = HII_LIB_DEFAULT_STRING_SIZE;
 218   *String    = AllocateZeroPool (StringSize);
 219   if (*String == NULL) {
 220     return EFI_OUT_OF_RESOURCES;
 221   }
 222
 223   Status = HiiLibGetString (HiiHandle, StringId, *String, &StringSize);
 224   if (Status == EFI_BUFFER_TOO_SMALL) {
 225     gBS->FreePool (*String);
 226     *String = AllocateZeroPool (StringSize);
 227     if (*String == NULL) {
 228       return EFI_OUT_OF_RESOURCES;
 229     }
 230     Status = HiiLibGetString (HiiHandle, StringId, *String, &StringSize);
 231   }
 232
 233   return Status;
 234 }
 235
 236
 237
 238 //
 239 // Lookup table of ISO639-2 3 character language codes to ISO 639-1 2 character language codes
 240 // Each entry is 5 CHAR8 values long.  The first 3 CHAR8 values are the ISO 639-2 code.
 241 // The last 2 CHAR8 values are the ISO 639-1 code.
 242 //
 243 CHAR8 Iso639ToRfc3066ConversionTable[] =
 244 "\
 245 aaraa\
 246 abkab\
 247 afraf\
 248 amham\
 249 araar\
 250 asmas\
 251 aymay\
 252 azeaz\
 253 bakba\
 254 belbe\
 255 benbn\
 256 bihbh\
 257 bisbi\
 258 bodbo\
 259 brebr\
 260 bulbg\
 261 catca\
 262 cescs\
 263 corkw\
 264 cosco\
 265 cymcy\
 266 danda\
 267 deude\
 268 dzodz\
 269 ellel\
 270 engen\
 271 epoeo\
 272 estet\
 273 euseu\
 274 faofo\
 275 fasfa\
 276 fijfj\
 277 finfi\
 278 frafr\
 279 fryfy\
 280 gaiga\
 281 gdhgd\
 282 glggl\
 283 grngn\
 284 gujgu\
 285 hauha\
 286 hebhe\
 287 hinhi\
 288 hrvhr\
 289 hunhu\
 290 hyehy\
 291 ikuiu\
 292 ileie\
 293 inaia\
 294 indid\
 295 ipkik\
 296 islis\
 297 itait\
 298 jawjw\
 299 jpnja\
 300 kalkl\
 301 kankn\
 302 kasks\
 303 katka\
 304 kazkk\
 305 khmkm\
 306 kinrw\
 307 kirky\
 308 korko\
 309 kurku\
 310 laolo\
 311 latla\
 312 lavlv\
 313 linln\
 314 litlt\
 315 ltzlb\
 316 malml\
 317 marmr\
 318 mkdmk\
 319 mlgmg\
 320 mltmt\
 321 molmo\
 322 monmn\
 323 mrimi\
 324 msams\
 325 myamy\
 326 nauna\
 327 nepne\
 328 nldnl\
 329 norno\
 330 ocioc\
 331 ormom\
 332 panpa\
 333 polpl\
 334 porpt\
 335 pusps\
 336 quequ\
 337 rohrm\
 338 ronro\
 339 runrn\
 340 rusru\
 341 sagsg\
 342 sansa\
 343 sinsi\
 344 slksk\
 345 slvsl\
 346 smise\
 347 smosm\
 348 snasn\
 349 sndsd\
 350 somso\
 351 sotst\
 352 spaes\
 353 sqisq\
 354 srpsr\
 355 sswss\
 356 sunsu\
 357 swasw\
 358 swesv\
 359 tamta\
 360 tattt\
 361 telte\
 362 tgktg\
 363 tgltl\
 364 thath\
 365 tsnts\
 366 tuktk\
 367 twitw\
 368 uigug\
 369 ukruk\
 370 urdur\
 371 uzbuz\
 372 vievi\
 373 volvo\
 374 wolwo\
 375 xhoxh\
 376 yidyi\
 377 zhaza\
 378 zhozh\
 379 zulzu\
 380 ";
 381
 382
 383 /**
 384   Convert language code from RFC3066 to ISO639-2.
 385
 386   @param  LanguageRfc3066        RFC3066 language code.
 387   @param  LanguageIso639         ISO639-2 language code.
 388
 389   @retval EFI_SUCCESS            Language code converted.
 390   @retval EFI_NOT_FOUND          Language code not found.
 391
 392 **/
 393 EFI_STATUS
 394 EFIAPI
 395 ConvertRfc3066LanguageToIso639Language (
 396   CHAR8   *LanguageRfc3066,
 397   CHAR8   *LanguageIso639
 398   )
 399 {
 400   UINTN  Index;
 401
 402   if ((LanguageRfc3066[2] != '-') && (LanguageRfc3066[2] != 0)) {
 403     CopyMem (LanguageIso639, LanguageRfc3066, 3);
 404     return EFI_SUCCESS;
 405   }
 406
 407   for (Index = 0; Iso639ToRfc3066ConversionTable[Index] != 0; Index += 5) {
 408     if (CompareMem (LanguageRfc3066, &Iso639ToRfc3066ConversionTable[Index + 3], 2) == 0) {
 409       CopyMem (LanguageIso639, &Iso639ToRfc3066ConversionTable[Index], 3);
 410       return EFI_SUCCESS;
 411     }
 412   }
 413
 414   return EFI_NOT_FOUND;
 415 }
 416
 417
 418 /**
 419   Convert language code list from RFC3066 to ISO639-2, e.g. "en-US;fr-FR" will
 420   be converted to "engfra".
 421
 422   @param  SupportedLanguages     The RFC3066 language list.
 423
 424   @return The ISO639-2 language list.
 425
 426 **/
 427 CHAR8 *
 428 EFIAPI
 429 Rfc3066ToIso639 (
 430   CHAR8  *SupportedLanguages
 431   )
 432 {
 433   CHAR8       *Languages;
 434   CHAR8       *ReturnValue;
 435   CHAR8       *LangCodes;
 436   CHAR8       LangRfc3066[RFC_3066_ENTRY_SIZE];
 437   CHAR8       LangIso639[ISO_639_2_ENTRY_SIZE];
 438   EFI_STATUS  Status;
 439
 440   ReturnValue = AllocateZeroPool (AsciiStrSize (SupportedLanguages));
 441   if (ReturnValue == NULL) {
 442     return ReturnValue;
 443   }
 444
 445   Languages = ReturnValue;
 446   LangCodes = SupportedLanguages;
 447   while (*LangCodes != 0) {
 448     HiiLibGetNextLanguage (&LangCodes, LangRfc3066);
 449
 450     Status = ConvertRfc3066LanguageToIso639Language (LangRfc3066, LangIso639);
 451     if (!EFI_ERROR (Status)) {
 452       CopyMem (Languages, LangIso639, 3);
 453       Languages = Languages + 3;
 454     }
 455   }
 456
 457   return ReturnValue;
 458 }
 459
 460