MdePkg/Library/BasePrintLib/PrintLib.c

   1 /** @file
   2   Print Library.
   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   Module Name:  PrintLib.c
  14
  15 **/
  16
  17 #include "PrintLibInternal.h"
  18
  19 #define WARNING_STATUS_NUMBER          4
  20 #define ERROR_STATUS_NUMBER            24
  21
  22 STATIC CONST CHAR8 *StatusString [] = {
  23   "Success",                      //  RETURN_SUCCESS                = 0
  24   "Warning Unknown Glyph",        //  RETURN_WARN_UNKNOWN_GLYPH     = 1
  25   "Warning Delete Failure",       //  RETURN_WARN_DELETE_FAILURE    = 2
  26   "Warning Write Failure",        //  RETURN_WARN_WRITE_FAILURE     = 3
  27   "Warning Buffer Too Small",     //  RETURN_WARN_BUFFER_TOO_SMALL  = 4
  28   "Load Error",                   //  RETURN_LOAD_ERROR             = 1  | MAX_BIT
  29   "Invalid Parameter",            //  RETURN_INVALID_PARAMETER      = 2  | MAX_BIT
  30   "Unsupported",                  //  RETURN_UNSUPPORTED            = 3  | MAX_BIT
  31   "Bad Buffer Size",              //  RETURN_BAD_BUFFER_SIZE        = 4  | MAX_BIT
  32   "Buffer Too Small",             //  RETURN_BUFFER_TOO_SMALL,      = 5  | MAX_BIT
  33   "Not Ready",                    //  RETURN_NOT_READY              = 6  | MAX_BIT
  34   "Device Error",                 //  RETURN_DEVICE_ERROR           = 7  | MAX_BIT
  35   "Write Protected",              //  RETURN_WRITE_PROTECTED        = 8  | MAX_BIT
  36   "Out of Resources",             //  RETURN_OUT_OF_RESOURCES       = 9  | MAX_BIT
  37   "Volume Corrupt",               //  RETURN_VOLUME_CORRUPTED       = 10 | MAX_BIT
  38   "Volume Full",                  //  RETURN_VOLUME_FULL            = 11 | MAX_BIT
  39   "No Media",                     //  RETURN_NO_MEDIA               = 12 | MAX_BIT
  40   "Media changed",                //  RETURN_MEDIA_CHANGED          = 13 | MAX_BIT
  41   "Not Found",                    //  RETURN_NOT_FOUND              = 14 | MAX_BIT
  42   "Access Denied",                //  RETURN_ACCESS_DENIED          = 15 | MAX_BIT
  43   "No Response",                  //  RETURN_NO_RESPONSE            = 16 | MAX_BIT
  44   "No mapping",                   //  RETURN_NO_MAPPING             = 17 | MAX_BIT
  45   "Time out",                     //  RETURN_TIMEOUT                = 18 | MAX_BIT
  46   "Not started",                  //  RETURN_NOT_STARTED            = 19 | MAX_BIT
  47   "Already started",              //  RETURN_ALREADY_STARTED        = 20 | MAX_BIT
  48   "Aborted",                      //  RETURN_ABORTED                = 21 | MAX_BIT
  49   "ICMP Error",                   //  RETURN_ICMP_ERROR             = 22 | MAX_BIT
  50   "TFTP Error",                   //  RETURN_TFTP_ERROR             = 23 | MAX_BIT
  51   "Protocol Error"                //  RETURN_PROTOCOL_ERROR         = 24 | MAX_BIT
  52 };
  53
  54 /**
  55   Worker function that produces a Null-terminated string in an output buffer
  56   based on a Null-terminated format string and a VA_LIST argument list.
  57
  58   VSPrint function to process format and place the results in Buffer. Since a
  59   VA_LIST is used this rountine allows the nesting of Vararg routines. Thus
  60   this is the main print working routine
  61
  62   @param  Buffer      Character buffer to print the results of the parsing
  63                       of Format into.
  64   @param  BufferSize  Maximum number of characters to put into buffer.
  65   @param  Flags       Intial flags value.
  66                       Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
  67   @param  Format      Null-terminated format string.
  68   @param  Marker      Vararg list consumed by processing Format.
  69
  70   @return Number of characters printed.
  71
  72 **/
  73 UINTN
  74 BasePrintLibVSPrint (
  75   OUT CHAR8        *Buffer,
  76   IN  UINTN        BufferSize,
  77   IN  UINTN        Flags,
  78   IN  CONST CHAR8  *Format,
  79   IN  VA_LIST      Marker
  80   )
  81 {
  82   CHAR8           *OriginalBuffer;
  83   CHAR8           ValueBuffer[MAXIMUM_VALUE_CHARACTERS];
  84   UINTN           BytesPerOutputCharacter;
  85   UINTN           BytesPerFormatCharacter;
  86   UINTN           FormatMask;
  87   UINTN           FormatCharacter;
  88   UINTN           Width;
  89   UINTN           Precision;
  90   INT64           Value;
  91   CONST CHAR8     *ArgumentString;
  92   UINTN           Character;
  93   GUID            *TmpGuid;
  94   TIME            *TmpTime;
  95   UINTN           Count;
  96   UINTN           ArgumentMask;
  97   INTN            BytesPerArgumentCharacter;
  98   UINTN           ArgumentCharacter;
  99   BOOLEAN         Done;
 100   UINTN           Index;
 101   CHAR8           Prefix;
 102   BOOLEAN         ZeroPad;
 103   BOOLEAN         Comma;
 104   UINTN           Digits;
 105   UINTN           Radix;
 106   RETURN_STATUS   Status;
 107
 108   if (BufferSize == 0) {
 109     return 0;
 110   }
 111   ASSERT (Buffer != NULL);
 112
 113   OriginalBuffer = Buffer;
 114
 115   if ((Flags & OUTPUT_UNICODE) != 0) {
 116     BytesPerOutputCharacter = 2;
 117   } else {
 118     BytesPerOutputCharacter = 1;
 119   }
 120   if ((Flags & FORMAT_UNICODE) != 0) {
 121     //
 122     // Make sure format string cannot contain more than PcdMaximumUnicodeStringLength
 123     // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
 124     //
 125     ASSERT (StrSize ((CHAR16 *) Format) != 0);
 126     BytesPerFormatCharacter = 2;
 127     FormatMask = 0xffff;
 128   } else {
 129     //
 130     // Make sure format string cannot contain more than PcdMaximumUnicodeStringLength
 131     // Ascii characters if PcdMaximumUnicodeStringLength is not zero.
 132     //
 133     ASSERT (AsciiStrSize (Format) != 0);
 134     BytesPerFormatCharacter = 1;
 135     FormatMask = 0xff;
 136   }
 137
 138   //
 139   // Reserve space for the Null terminator.
 140   //
 141   BufferSize--;
 142
 143   //
 144   // Get the first character from the format string
 145   //
 146   FormatCharacter = (*Format | (*(Format + 1) << 8)) & FormatMask;
 147
 148   //
 149   // Loop until the end of the format string is reached or the output buffer is full
 150   //
 151   while (FormatCharacter != 0 && BufferSize > 0) {
 152     //
 153     // Clear all the flag bits except those that may have been passed in
 154     //
 155     Flags &= (OUTPUT_UNICODE | FORMAT_UNICODE);
 156
 157     //
 158     // Set the default width to zero, and the default precision to 1
 159     //
 160     Width     = 0;
 161     Precision = 1;
 162     Prefix    = 0;
 163     Comma     = FALSE;
 164     ZeroPad   = FALSE;
 165     Count     = 0;
 166     Digits    = 0;
 167
 168     switch (FormatCharacter) {
 169     case '%':
 170       //
 171       // Parse Flags and Width
 172       //
 173       for (Done = FALSE; !Done; ) {
 174         Format += BytesPerFormatCharacter;
 175         FormatCharacter = (*Format | (*(Format + 1) << 8)) & FormatMask;
 176         switch (FormatCharacter) {
 177         case '.':
 178           Flags |= PRECISION;
 179           break;
 180         case '-':
 181           Flags |= LEFT_JUSTIFY;
 182           break;
 183         case '+':
 184           Flags |= PREFIX_SIGN;
 185           break;
 186         case ' ':
 187           Flags |= PREFIX_BLANK;
 188           break;
 189         case ',':
 190           Flags |= COMMA_TYPE;
 191           break;
 192         case 'L':
 193         case 'l':
 194           Flags |= LONG_TYPE;
 195           break;
 196         case '*':
 197           if ((Flags & PRECISION) == 0) {
 198             Flags |= PAD_TO_WIDTH;
 199             Width = VA_ARG (Marker, UINTN);
 200           } else {
 201             Precision = VA_ARG (Marker, UINTN);
 202           }
 203           break;
 204         case '0':
 205           if ((Flags & PRECISION) == 0) {
 206             Flags |= PREFIX_ZERO;
 207           }
 208         case '1':
 209         case '2':
 210         case '3':
 211         case '4':
 212         case '5':
 213         case '6':
 214         case '7':
 215         case '8':
 216         case '9':
 217           for (Count = 0; ((FormatCharacter >= '0') &&  (FormatCharacter <= '9')); ){
 218             Count = (Count * 10) + FormatCharacter - '0';
 219             Format += BytesPerFormatCharacter;
 220             FormatCharacter = (*Format | (*(Format + 1) << 8)) & FormatMask;
 221           }
 222           Format -= BytesPerFormatCharacter;
 223           if ((Flags & PRECISION) == 0) {
 224             Flags |= PAD_TO_WIDTH;
 225             Width = Count;
 226           } else {
 227             Precision = Count;
 228           }
 229           break;
 230
 231         case '\0':
 232           //
 233           // Make no output if Format string terminates unexpectedly when
 234           // looking up for flag, width, precision and type.
 235           //
 236           Format   -= BytesPerFormatCharacter;
 237           Precision = 0;
 238           //
 239           // break skiped on purpose.
 240           //
 241         default:
 242           Done = TRUE;
 243           break;
 244         }
 245       }
 246
 247       //
 248       // Limit the maximum field width to the remaining characters in the output buffer
 249       //
 250       if (Width > BufferSize) {
 251         Width = BufferSize;
 252       }
 253
 254       //
 255       // Handle each argument type
 256       //
 257       switch (FormatCharacter) {
 258       case 'p':
 259         if (sizeof (VOID *) > 4) {
 260           Flags |= LONG_TYPE;
 261         }
 262       case 'X':
 263         Flags |= PREFIX_ZERO;
 264         //
 265         // break skiped on purpose
 266         //
 267       case 'x':
 268         Flags |= RADIX_HEX;
 269         //
 270         // break skiped on purpose
 271         //
 272       case 'd':
 273         if ((Flags & LONG_TYPE) == 0) {
 274           Value = (VA_ARG (Marker, int));
 275         } else {
 276           Value = VA_ARG (Marker, INT64);
 277         }
 278         if ((Flags & PREFIX_BLANK) != 0) {
 279           Prefix = ' ';
 280         }
 281         if ((Flags & PREFIX_SIGN) != 0) {
 282           Prefix = '+';
 283         }
 284         if ((Flags & COMMA_TYPE) != 0) {
 285           Comma = TRUE;
 286         }
 287         if ((Flags & RADIX_HEX) == 0) {
 288           Radix = 10;
 289           if (Comma) {
 290             Flags &= (~PREFIX_ZERO);
 291             Precision = 1;
 292           }
 293           if (Value < 0) {
 294             Flags |= PREFIX_SIGN;
 295             Prefix = '-';
 296             Value = -Value;
 297           }
 298         } else {
 299           Radix = 16;
 300           Comma = FALSE;
 301           if ((Flags & LONG_TYPE) == 0 && Value < 0) {
 302             Value = (unsigned int)Value;
 303           }
 304         }
 305         //
 306         // Convert Value to a reversed string
 307         //
 308         Count = BasePrintLibValueToString (ValueBuffer, Value, Radix);
 309         if (Value == 0 && Precision == 0) {
 310           Count = 0;
 311         }
 312         ArgumentString = (CHAR8 *)ValueBuffer + Count;
 313
 314         Digits = Count % 3;
 315         if (Digits != 0) {
 316           Digits = 3 - Digits;
 317         }
 318         if (Comma && Count != 0) {
 319           Count += ((Count - 1) / 3);
 320         }
 321         if (Prefix != 0) {
 322           Count++;
 323           Precision++;
 324         }
 325         Flags |= ARGUMENT_REVERSED;
 326         ZeroPad = TRUE;
 327         if ((Flags & PREFIX_ZERO) != 0) {
 328           if ((Flags & LEFT_JUSTIFY) == 0) {
 329             if ((Flags & PAD_TO_WIDTH) != 0) {
 330               if ((Flags & PRECISION) == 0) {
 331                 Precision = Width;
 332               }
 333             }
 334           }
 335         }
 336         break;
 337
 338       case 's':
 339       case 'S':
 340         Flags |= ARGUMENT_UNICODE;
 341         //
 342         // break skipped on purpose
 343         //
 344       case 'a':
 345         ArgumentString = (CHAR8 *)VA_ARG (Marker, CHAR8 *);
 346         if (ArgumentString == NULL) {
 347           Flags &= (~ARGUMENT_UNICODE);
 348           ArgumentString = "<null string>";
 349         }
 350         break;
 351
 352       case 'c':
 353         Character = VA_ARG (Marker, UINTN) & 0xffff;
 354         ArgumentString = (CHAR8 *)&Character;
 355         Flags |= ARGUMENT_UNICODE;
 356         break;
 357
 358       case 'g':
 359         TmpGuid = VA_ARG (Marker, GUID *);
 360         if (TmpGuid == NULL) {
 361           ArgumentString = "<null guid>";
 362         } else {
 363           BasePrintLibSPrint (
 364             ValueBuffer,
 365             MAXIMUM_VALUE_CHARACTERS,
 366             0,
 367             "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 368             TmpGuid->Data1,
 369             TmpGuid->Data2,
 370             TmpGuid->Data3,
 371             TmpGuid->Data4[0],
 372             TmpGuid->Data4[1],
 373             TmpGuid->Data4[2],
 374             TmpGuid->Data4[3],
 375             TmpGuid->Data4[4],
 376             TmpGuid->Data4[5],
 377             TmpGuid->Data4[6],
 378             TmpGuid->Data4[7]
 379             );
 380           ArgumentString = ValueBuffer;
 381         }
 382         break;
 383
 384       case 't':
 385         TmpTime = VA_ARG (Marker, TIME *);
 386         if (TmpTime == NULL) {
 387           ArgumentString = "<null time>";
 388         } else {
 389           BasePrintLibSPrint (
 390             ValueBuffer,
 391             MAXIMUM_VALUE_CHARACTERS,
 392             0,
 393             "%02d/%02d/%04d  %02d:%02d",
 394             TmpTime->Month,
 395             TmpTime->Day,
 396             TmpTime->Year,
 397             TmpTime->Hour,
 398             TmpTime->Minute
 399             );
 400           ArgumentString = ValueBuffer;
 401         }
 402         break;
 403
 404       case 'r':
 405         Status = VA_ARG (Marker, RETURN_STATUS);
 406         ArgumentString = ValueBuffer;
 407         if (RETURN_ERROR (Status)) {
 408           //
 409           // Clear error bit
 410           //
 411           Index = Status & ~MAX_BIT;
 412           if (Index > 0 && Index <= ERROR_STATUS_NUMBER) {
 413             ArgumentString = StatusString [Index + WARNING_STATUS_NUMBER];
 414           }
 415         } else {
 416           Index = Status;
 417           if (Index <= WARNING_STATUS_NUMBER) {
 418             ArgumentString = StatusString [Index];
 419           }
 420         }
 421         if (ArgumentString == ValueBuffer) {
 422           BasePrintLibSPrint ((CHAR8 *) ValueBuffer, MAXIMUM_VALUE_CHARACTERS, 0, "%08X", Status);
 423         }
 424         break;
 425
 426       case '\n':
 427         ArgumentString = "\n\r";
 428         break;
 429
 430       case '%':
 431       default:
 432         //
 433         // if the type is '%' or unknown, then print it to the screen
 434         //
 435         ArgumentString = (CHAR8 *)&FormatCharacter;
 436         Flags |= ARGUMENT_UNICODE;
 437         break;
 438       }
 439       break;
 440
 441     case '\n':
 442       ArgumentString = "\n\r";
 443       break;
 444
 445     default:
 446       ArgumentString = (CHAR8 *)&FormatCharacter;
 447       Flags |= ARGUMENT_UNICODE;
 448       break;
 449     }
 450
 451     //
 452     // Retrieve the ArgumentString attriubutes
 453     //
 454     if ((Flags & ARGUMENT_UNICODE) != 0) {
 455       ArgumentMask = 0xffff;
 456       BytesPerArgumentCharacter = 2;
 457     } else {
 458       ArgumentMask = 0xff;
 459       BytesPerArgumentCharacter = 1;
 460     }
 461     if ((Flags & ARGUMENT_REVERSED) != 0) {
 462       BytesPerArgumentCharacter = -BytesPerArgumentCharacter;
 463     } else {
 464       //
 465       // Compute the number of characters in ArgumentString and store it in Count
 466       // ArgumentString is either null-terminated, or it contains Precision characters
 467       //
 468       for (Count = 0; Count < Precision || ((Flags & PRECISION) == 0); Count++) {
 469         ArgumentCharacter = ((ArgumentString[Count * BytesPerArgumentCharacter] & 0xff) | ((ArgumentString[Count * BytesPerArgumentCharacter + 1]) << 8)) & ArgumentMask;
 470         if (ArgumentCharacter == 0) {
 471           break;
 472         }
 473       }
 474     }
 475
 476     //
 477     // Limit the length of the string to append to the remaining characters in the output buffer
 478     //
 479     if (Count > BufferSize) {
 480       Count = BufferSize;
 481     }
 482     if (Precision < Count) {
 483       Precision = Count;
 484     }
 485
 486     //
 487     // Pad before the string
 488     //
 489     if ((Flags & (PAD_TO_WIDTH | LEFT_JUSTIFY)) == (PAD_TO_WIDTH)) {
 490       Buffer = BasePrintLibFillBuffer (Buffer, Width - Precision, ' ', BytesPerOutputCharacter);
 491     }
 492
 493     if (ZeroPad) {
 494       if (Prefix != 0) {
 495         Buffer = BasePrintLibFillBuffer (Buffer, 1, Prefix, BytesPerOutputCharacter);
 496       }
 497       Buffer = BasePrintLibFillBuffer (Buffer, Precision - Count, '0', BytesPerOutputCharacter);
 498     } else {
 499       Buffer = BasePrintLibFillBuffer (Buffer, Precision - Count, ' ', BytesPerOutputCharacter);
 500       if (Prefix != 0) {
 501         Buffer = BasePrintLibFillBuffer (Buffer, 1, Prefix, BytesPerOutputCharacter);
 502       }
 503     }
 504
 505     //
 506     // Output the Prefix character if it is present
 507     //
 508     Index = 0;
 509     if (Prefix) {
 510       Index++;
 511     }
 512
 513     //
 514     // Copy the string into the output buffer performing the required type conversions
 515     //
 516     while (Index < Count) {
 517       ArgumentCharacter = ((*ArgumentString & 0xff) | (*(ArgumentString + 1) << 8)) & ArgumentMask;
 518
 519       Buffer = BasePrintLibFillBuffer (Buffer, 1, ArgumentCharacter, BytesPerOutputCharacter);
 520       ArgumentString    += BytesPerArgumentCharacter;
 521       Index++;
 522       if (Comma) {
 523         Digits++;
 524         if (Digits == 3) {
 525           Digits = 0;
 526           Index++;
 527           if (Index < Count) {
 528             Buffer = BasePrintLibFillBuffer (Buffer, 1, ',', BytesPerOutputCharacter);
 529           }
 530         }
 531       }
 532     }
 533
 534     //
 535     // Pad after the string
 536     //
 537     if ((Flags & (PAD_TO_WIDTH | LEFT_JUSTIFY)) == (PAD_TO_WIDTH | LEFT_JUSTIFY)) {
 538       Buffer = BasePrintLibFillBuffer (Buffer, Width - Precision, ' ', BytesPerOutputCharacter);
 539     }
 540
 541     //
 542     // Reduce the number of characters
 543     //
 544     BufferSize -= Count;
 545
 546     //
 547     // Get the next character from the format string
 548     //
 549     Format += BytesPerFormatCharacter;
 550
 551     //
 552     // Get the next character from the format string
 553     //
 554     FormatCharacter = (*Format | (*(Format + 1) << 8)) & FormatMask;
 555   }
 556
 557   //
 558   // Null terminate the Unicode or ASCII string
 559   //
 560   Buffer = BasePrintLibFillBuffer (Buffer, 1, 0, BytesPerOutputCharacter);
 561   //
 562   // Make sure output buffer cannot contain more than PcdMaximumUnicodeStringLength
 563   // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
 564   //
 565   ASSERT ((((Flags & OUTPUT_UNICODE) == 0)) || (StrSize ((CHAR16 *) OriginalBuffer) != 0));
 566   //
 567   // Make sure output buffer cannot contain more than PcdMaximumUnicodeStringLength
 568   // Ascii characters if PcdMaximumUnicodeStringLength is not zero.
 569   //
 570   ASSERT ((((Flags & OUTPUT_UNICODE) != 0)) || (AsciiStrSize (OriginalBuffer) != 0));
 571
 572
 573   return ((Buffer - OriginalBuffer) / BytesPerOutputCharacter);
 574 }
 575
 576 /**
 577   Worker function that produces a Null-terminated string in an output buffer
 578   based on a Null-terminated format string and variable argument list.
 579
 580   VSPrint function to process format and place the results in Buffer. Since a
 581   VA_LIST is used this rountine allows the nesting of Vararg routines. Thus
 582   this is the main print working routine
 583
 584   @param  Buffer        Character buffer to print the results of the parsing
 585                         of Format into.
 586   @param  BufferSize    Maximum number of characters to put into buffer.
 587                         Zero means no limit.
 588   @param  Flags         Intial flags value.
 589                         Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
 590   @param  FormatString  Null-terminated format string.
 591
 592   @return Number of characters printed.
 593
 594 **/
 595 UINTN
 596 BasePrintLibSPrint (
 597   OUT CHAR8        *StartOfBuffer,
 598   IN  UINTN        BufferSize,
 599   IN  UINTN        Flags,
 600   IN  CONST CHAR8  *FormatString,
 601   ...
 602   )
 603 {
 604   VA_LIST  Marker;
 605
 606   VA_START (Marker, FormatString);
 607   return BasePrintLibVSPrint (StartOfBuffer, BufferSize, Flags, FormatString, Marker);
 608 }
 609
 610 /**
 611   Produces a Null-terminated Unicode string in an output buffer based on
 612   a Null-terminated Unicode format string and a VA_LIST argument list
 613
 614   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
 615   and BufferSize.
 616   The Unicode string is produced by parsing the format string specified by FormatString.
 617   Arguments are pulled from the variable argument list specified by Marker based on the
 618   contents of the format string.
 619   The length of the produced output buffer is returned.
 620   If BufferSize is 0, then no output buffer is produced and 0 is returned.
 621
 622   If BufferSize is not 0 and StartOfBuffer is NULL, then ASSERT().
 623   If BufferSize is not 0 and FormatString is NULL, then ASSERT().
 624   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
 625   PcdMaximumUnicodeStringLength Unicode characters, then ASSERT().
 626   If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string
 627   contains more than PcdMaximumUnicodeStringLength Unicode characters, then ASSERT().
 628
 629   @param  StartOfBuffer   APointer to the output buffer for the produced Null-terminated
 630                           Unicode string.
 631   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
 632   @param  FormatString    Null-terminated Unicode format string.
 633   @param  Marker          VA_LIST marker for the variable argument list.
 634
 635   @return return Length of the produced output buffer.
 636
 637 **/
 638 UINTN
 639 EFIAPI
 640 UnicodeVSPrint (
 641   OUT CHAR16        *StartOfBuffer,
 642   IN  UINTN         BufferSize,
 643   IN  CONST CHAR16  *FormatString,
 644   IN  VA_LIST       Marker
 645   )
 646 {
 647   return BasePrintLibVSPrint ((CHAR8 *)StartOfBuffer, BufferSize >> 1, FORMAT_UNICODE | OUTPUT_UNICODE, (CHAR8 *)FormatString, Marker);
 648 }
 649
 650 /**
 651   Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
 652   Unicode format string and variable argument list.
 653
 654   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
 655   and BufferSize.
 656   The Unicode string is produced by parsing the format string specified by FormatString.
 657   Arguments are pulled from the variable argument list based on the contents of the format string.
 658   The length of the produced output buffer is returned.
 659   If BufferSize is 0, then no output buffer is produced and 0 is returned.
 660
 661   If BufferSize is not 0 and StartOfBuffer is NULL, then ASSERT().
 662   If BufferSize is not 0 and FormatString is NULL, then ASSERT().
 663   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
 664   PcdMaximumUnicodeStringLength Unicode characters, then ASSERT().
 665   If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string
 666   contains more than PcdMaximumUnicodeStringLength Unicode characters, then ASSERT().
 667
 668   @param  StartOfBuffer   APointer to the output buffer for the produced Null-terminated
 669                           Unicode string.
 670   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
 671   @param  FormatString    Null-terminated Unicode format string.
 672
 673   @return Length of the produced output buffer.
 674
 675 **/
 676 UINTN
 677 EFIAPI
 678 UnicodeSPrint (
 679   OUT CHAR16        *StartOfBuffer,
 680   IN  UINTN         BufferSize,
 681   IN  CONST CHAR16  *FormatString,
 682   ...
 683   )
 684 {
 685   VA_LIST Marker;
 686
 687   VA_START (Marker, FormatString);
 688   return UnicodeVSPrint (StartOfBuffer, BufferSize, FormatString, Marker);
 689 }
 690
 691 /**
 692   Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
 693   ASCII format string and a VA_LIST argument list
 694
 695   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
 696   and BufferSize.
 697   The Unicode string is produced by parsing the format string specified by FormatString.
 698   Arguments are pulled from the variable argument list specified by Marker based on the
 699   contents of the format string.
 700   The length of the produced output buffer is returned.
 701   If BufferSize is 0, then no output buffer is produced and 0 is returned.
 702
 703   If BufferSize is not 0 and StartOfBuffer is NULL, then ASSERT().
 704   If BufferSize is not 0 and FormatString is NULL, then ASSERT().
 705   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
 706   PcdMaximumUnicodeStringLength Unicode characters, then ASSERT().
 707   If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string
 708   contains more than PcdMaximumUnicodeStringLength Unicode characters, then ASSERT().
 709
 710   @param  StartOfBuffer   APointer to the output buffer for the produced Null-terminated
 711                           Unicode string.
 712   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
 713   @param  FormatString    Null-terminated Unicode format string.
 714   @param  Marker          VA_LIST marker for the variable argument list.
 715
 716   @return Length of the produced output buffer.
 717
 718 **/
 719 UINTN
 720 EFIAPI
 721 UnicodeVSPrintAsciiFormat (
 722   OUT CHAR16       *StartOfBuffer,
 723   IN  UINTN        BufferSize,
 724   IN  CONST CHAR8  *FormatString,
 725   IN  VA_LIST      Marker
 726   )
 727 {
 728   return BasePrintLibVSPrint ((CHAR8 *)StartOfBuffer, BufferSize >> 1, OUTPUT_UNICODE,FormatString, Marker);
 729 }
 730
 731 /**
 732   Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
 733   ASCII format string and  variable argument list.
 734
 735   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
 736   and BufferSize.
 737   The Unicode string is produced by parsing the format string specified by FormatString.
 738   Arguments are pulled from the variable argument list based on the contents of the
 739   format string.
 740   The length of the produced output buffer is returned.
 741   If BufferSize is 0, then no output buffer is produced and 0 is returned.
 742
 743   If BufferSize is not 0 and StartOfBuffer is NULL, then ASSERT().
 744   If BufferSize is not 0 and FormatString is NULL, then ASSERT().
 745   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
 746   PcdMaximumUnicodeStringLength Unicode characters, then ASSERT().
 747   If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string
 748   contains more than PcdMaximumUnicodeStringLength Unicode characters, then ASSERT().
 749
 750   @param  StartOfBuffer   APointer to the output buffer for the produced Null-terminated
 751                           Unicode string.
 752   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
 753   @param  FormatString    Null-terminated Unicode format string.
 754
 755   @return Length of the produced output buffer.
 756
 757 **/
 758 UINTN
 759 EFIAPI
 760 UnicodeSPrintAsciiFormat (
 761   OUT CHAR16       *StartOfBuffer,
 762   IN  UINTN        BufferSize,
 763   IN  CONST CHAR8  *FormatString,
 764   ...
 765   )
 766 {
 767   VA_LIST Marker;
 768
 769   VA_START (Marker, FormatString);
 770   return UnicodeVSPrintAsciiFormat (StartOfBuffer, BufferSize, FormatString, Marker);
 771 }
 772
 773 /**
 774   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
 775   ASCII format string and a VA_LIST argument list.
 776
 777   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
 778   and BufferSize.
 779   The ASCII string is produced by parsing the format string specified by FormatString.
 780   Arguments are pulled from the variable argument list specified by Marker based on
 781   the contents of the format string.
 782   The length of the produced output buffer is returned.
 783   If BufferSize is 0, then no output buffer is produced and 0 is returned.
 784
 785   If BufferSize is not 0 and StartOfBuffer is NULL, then ASSERT().
 786   If BufferSize is not 0 and FormatString is NULL, then ASSERT().
 787   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
 788   PcdMaximumUnicodeStringLength ASCII characters, then ASSERT().
 789   If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string
 790   contains more than PcdMaximumUnicodeStringLength ASCII characters, then ASSERT().
 791
 792   @param  StartOfBuffer   APointer to the output buffer for the produced Null-terminated
 793                           ASCII string.
 794   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
 795   @param  FormatString    Null-terminated Unicode format string.
 796   @param  Marker          VA_LIST marker for the variable argument list.
 797
 798   @return Length of the produced output buffer.
 799
 800 **/
 801 UINTN
 802 EFIAPI
 803 AsciiVSPrint (
 804   OUT CHAR8         *StartOfBuffer,
 805   IN  UINTN         BufferSize,
 806   IN  CONST CHAR8   *FormatString,
 807   IN  VA_LIST       Marker
 808   )
 809 {
 810   return BasePrintLibVSPrint (StartOfBuffer, BufferSize, 0, FormatString, Marker);
 811 }
 812
 813 /**
 814   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
 815   ASCII format string and  variable argument list.
 816
 817   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
 818   and BufferSize.
 819   The ASCII string is produced by parsing the format string specified by FormatString.
 820   Arguments are pulled from the variable argument list based on the contents of the
 821   format string.
 822   The length of the produced output buffer is returned.
 823   If BufferSize is 0, then no output buffer is produced and 0 is returned.
 824
 825   If BufferSize is not 0 and StartOfBuffer is NULL, then ASSERT().
 826   If BufferSize is not 0 and FormatString is NULL, then ASSERT().
 827   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
 828   PcdMaximumUnicodeStringLength ASCII characters, then ASSERT().
 829   If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string
 830   contains more than PcdMaximumUnicodeStringLength ASCII characters, then ASSERT().
 831
 832   @param  StartOfBuffer   APointer to the output buffer for the produced Null-terminated
 833                           ASCII string.
 834   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
 835   @param  FormatString    Null-terminated Unicode format string.
 836
 837   @return Length of the produced output buffer.
 838
 839 **/
 840 UINTN
 841 EFIAPI
 842 AsciiSPrint (
 843   OUT CHAR8        *StartOfBuffer,
 844   IN  UINTN        BufferSize,
 845   IN  CONST CHAR8  *FormatString,
 846   ...
 847   )
 848 {
 849   VA_LIST Marker;
 850
 851   VA_START (Marker, FormatString);
 852   return AsciiVSPrint (StartOfBuffer, BufferSize, FormatString, Marker);
 853 }
 854
 855 /**
 856   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
 857   ASCII format string and a VA_LIST argument list.
 858
 859   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
 860   and BufferSize.
 861   The ASCII string is produced by parsing the format string specified by FormatString.
 862   Arguments are pulled from the variable argument list specified by Marker based on
 863   the contents of the format string.
 864   The length of the produced output buffer is returned.
 865   If BufferSize is 0, then no output buffer is produced and 0 is returned.
 866
 867   If BufferSize is not 0 and StartOfBuffer is NULL, then ASSERT().
 868   If BufferSize is not 0 and FormatString is NULL, then ASSERT().
 869   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
 870   PcdMaximumUnicodeStringLength ASCII characters, then ASSERT().
 871   If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string
 872   contains more than PcdMaximumUnicodeStringLength ASCII characters, then ASSERT().
 873
 874   @param  StartOfBuffer   APointer to the output buffer for the produced Null-terminated
 875                           ASCII string.
 876   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
 877   @param  FormatString    Null-terminated Unicode format string.
 878   @param  Marker          VA_LIST marker for the variable argument list.
 879
 880   @return Length of the produced output buffer.
 881
 882 **/
 883 UINTN
 884 EFIAPI
 885 AsciiVSPrintUnicodeFormat (
 886   OUT CHAR8         *StartOfBuffer,
 887   IN  UINTN         BufferSize,
 888   IN  CONST CHAR16  *FormatString,
 889   IN  VA_LIST       Marker
 890   )
 891 {
 892   return BasePrintLibVSPrint (StartOfBuffer, BufferSize, FORMAT_UNICODE, (CHAR8 *)FormatString, Marker);
 893 }
 894
 895 /**
 896   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
 897   ASCII format string and  variable argument list.
 898
 899   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
 900   and BufferSize.
 901   The ASCII string is produced by parsing the format string specified by FormatString.
 902   Arguments are pulled from the variable argument list based on the contents of the
 903   format string.
 904   The length of the produced output buffer is returned.
 905   If BufferSize is 0, then no output buffer is produced and 0 is returned.
 906
 907   If BufferSize is not 0 and StartOfBuffer is NULL, then ASSERT().
 908   If BufferSize is not 0 and FormatString is NULL, then ASSERT().
 909   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
 910   PcdMaximumUnicodeStringLength ASCII characters, then ASSERT().
 911   If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string
 912   contains more than PcdMaximumUnicodeStringLength ASCII characters, then ASSERT().
 913
 914   @param  StartOfBuffer   APointer to the output buffer for the produced Null-terminated
 915                           ASCII string.
 916   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
 917   @param  FormatString    Null-terminated Unicode format string.
 918
 919   @return Length of the produced output buffer.
 920
 921 **/
 922 UINTN
 923 EFIAPI
 924 AsciiSPrintUnicodeFormat (
 925   OUT CHAR8         *StartOfBuffer,
 926   IN  UINTN         BufferSize,
 927   IN  CONST CHAR16  *FormatString,
 928   ...
 929   )
 930 {
 931   VA_LIST Marker;
 932
 933   VA_START (Marker, FormatString);
 934   return AsciiVSPrintUnicodeFormat (StartOfBuffer, BufferSize, FormatString, Marker);
 935 }
 936
 937 /**
 938   Converts a decimal value to a Null-terminated Unicode string.
 939
 940   Converts the decimal number specified by Value to a Null-terminated Unicode
 941   string specified by Buffer containing at most Width characters.
 942   If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
 943   The total number of characters placed in Buffer is returned.
 944   If the conversion contains more than Width characters, then only the first
 945   Width characters are returned, and the total number of characters
 946   required to perform the conversion is returned.
 947   Additional conversion parameters are specified in Flags.
 948   The Flags bit LEFT_JUSTIFY is always ignored.
 949   All conversions are left justified in Buffer.
 950   If Width is 0, PREFIX_ZERO is ignored in Flags.
 951   If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
 952   are inserted every 3rd digit starting from the right.
 953   If Value is < 0, then the fist character in Buffer is a '-'.
 954   If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
 955   then Buffer is padded with '0' characters so the combination of the optional '-'
 956   sign character, '0' characters, digit characters for Value, and the Null-terminator
 957   add up to Width characters.
 958
 959   If Buffer is NULL, then ASSERT().
 960   If unsupported bits are set in Flags, then ASSERT().
 961   If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
 962
 963   @param  Buffer  Pointer to the output buffer for the produced Null-terminated
 964                   Unicode string.
 965   @param  Flags   The bitmask of flags that specify left justification, zero pad, and commas.
 966   @param  Value   The 64-bit signed value to convert to a string.
 967   @param  Width    The maximum number of Unicode characters to place in Buffer.
 968
 969   @return Total number of characters required to perform the conversion.
 970
 971 **/
 972 UINTN
 973 EFIAPI
 974 UnicodeValueToString (
 975   IN OUT CHAR16  *Buffer,
 976   IN UINTN       Flags,
 977   IN INT64       Value,
 978   IN UINTN       Width
 979   )
 980 {
 981   return BasePrintLibConvertValueToString ((CHAR8 *)Buffer, Flags, Value, Width, 2);
 982 }
 983
 984 /**
 985   Converts a decimal value to a Null-terminated ASCII string.
 986
 987   Converts the decimal number specified by Value to a Null-terminated ASCII string
 988   specified by Buffer containing at most Width characters.
 989   If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
 990   The total number of characters placed in Buffer is returned.
 991   If the conversion contains more than Width characters, then only the first Width
 992   characters are returned, and the total number of characters required to perform
 993   the conversion is returned.
 994   Additional conversion parameters are specified in Flags.
 995   The Flags bit LEFT_JUSTIFY is always ignored.
 996   All conversions are left justified in Buffer.
 997   If Width is 0, PREFIX_ZERO is ignored in Flags.
 998   If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
 999   are inserted every 3rd digit starting from the right.
1000   If Value is < 0, then the fist character in Buffer is a '-'.
1001   If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, then Buffer
1002   is padded with '0' characters so the combination of the optional '-'
1003   sign character, '0' characters, digit characters for Value, and the
1004   Null-terminator add up to Width characters.
1005
1006   If Buffer is NULL, then ASSERT().
1007   If unsupported bits are set in Flags, then ASSERT().
1008   If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
1009
1010   @param  Buffer  Pointer to the output buffer for the produced Null-terminated
1011                   ASCII string.
1012   @param  Flags   The bitmask of flags that specify left justification, zero pad, and commas.
1013   @param  Value   The 64-bit signed value to convert to a string.
1014   @param  Width    The maximum number of ASCII characters to place in Buffer.
1015
1016   @return Total number of characters required to perform the conversion.
1017
1018 **/
1019 UINTN
1020 EFIAPI
1021 AsciiValueToString (
1022   IN OUT CHAR8  *Buffer,
1023   IN UINTN      Flags,
1024   IN INT64      Value,
1025   IN UINTN      Width
1026   )
1027 {
1028   return BasePrintLibConvertValueToString ((CHAR8 *)Buffer, Flags, Value, Width, 1);
1029 }