MdePkg/Library/BasePrintLib/PrintLibInternal.c

   1 /** @file
   2   Print Library worker functions.
   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:  PrintLibInternal.c
  14
  15 **/
  16
  17 #include "PrintLibInternal.h"
  18
  19 static CONST CHAR8 mHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  20
  21
  22 /**
  23   Internal function that places the character into the Buffer.
  24
  25   Internal function that places ASCII or Unicode character into the Buffer.
  26
  27   @param  Buffer      Buffer to place the Unicode or ASCII string.
  28   @param  EndBuffer   The end of the input Buffer. No characters will be
  29                       placed after that.
  30   @param  Length      Count of character to be placed into Buffer.
  31   @param  Character   Character to be placed into Buffer.
  32   @param  Increment   Character increment in Buffer.
  33
  34   @return Number of characters printed.
  35
  36 **/
  37 CHAR8 *
  38 BasePrintLibFillBuffer (
  39   CHAR8   *Buffer,
  40   CHAR8   *EndBuffer,
  41   INTN    Length,
  42   UINTN   Character,
  43   INTN    Increment
  44   )
  45 {
  46   INTN  Index;
  47
  48   for (Index = 0; Index < Length && Buffer < EndBuffer; Index++) {
  49     *Buffer       =  (CHAR8) Character;
  50     *(Buffer + 1) =  (CHAR8) (Character >> 8);
  51     Buffer        += Increment;
  52   }
  53   return Buffer;
  54 }
  55
  56 /**
  57   Internal function that convert a decimal number to a string in Buffer.
  58
  59   Print worker function that convert a decimal number to a string in Buffer.
  60
  61   @param  Buffer    Location to place the Unicode or ASCII string of Value.
  62   @param  Value     Value to convert to a Decimal or Hexidecimal string in Buffer.
  63   @param  Radix     Radix of the value
  64
  65   @return Number of characters printed.
  66
  67 **/
  68 UINTN
  69 EFIAPI
  70 BasePrintLibValueToString (
  71   IN OUT CHAR8  *Buffer,
  72   IN INT64      Value,
  73   IN UINTN      Radix
  74   )
  75 {
  76   UINTN   Digits;
  77   UINT32  Remainder;
  78
  79   //
  80   // Loop to convert one digit at a time in reverse order
  81   //
  82   *(Buffer++) = 0;
  83   Digits = 0;
  84   do {
  85     Value = (INT64)DivU64x32Remainder ((UINT64)Value, (UINT32)Radix, &Remainder);
  86     *(Buffer++) = mHexStr[Remainder];
  87     Digits++;
  88   } while (Value != 0);
  89   return Digits;
  90 }
  91
  92 /**
  93   Internal function that converts a decimal value to a Null-terminated string.
  94
  95   Converts the decimal number specified by Value to a Null-terminated
  96   string specified by Buffer containing at most Width characters.
  97   If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
  98   The number of characters in Buffer is returned not including the Null-terminator.
  99   If the conversion contains more than Width characters, then only the first
 100   Width characters are returned, and the total number of characters
 101   required to perform the conversion is returned.
 102   Additional conversion parameters are specified in Flags.
 103   The Flags bit LEFT_JUSTIFY is always ignored.
 104   All conversions are left justified in Buffer.
 105   If Width is 0, PREFIX_ZERO is ignored in Flags.
 106   If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
 107   are inserted every 3rd digit starting from the right.
 108   If Value is < 0, then the fist character in Buffer is a '-'.
 109   If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
 110   then Buffer is padded with '0' characters so the combination of the optional '-'
 111   sign character, '0' characters, digit characters for Value, and the Null-terminator
 112   add up to Width characters.
 113
 114   If Buffer is NULL, then ASSERT().
 115   If unsupported bits are set in Flags, then ASSERT().
 116   If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
 117
 118   @param  Buffer    Pointer to the output buffer for the produced Null-terminated
 119                     string.
 120   @param  Flags     The bitmask of flags that specify left justification, zero pad,
 121                     and commas.
 122   @param  Value     The 64-bit signed value to convert to a string.
 123   @param  Width     The maximum number of characters to place in Buffer, not including
 124                     the Null-terminator.
 125   @param  Increment Character increment in Buffer.
 126
 127   @return The number of characters in Buffer not including the Null-terminator.
 128
 129 **/
 130 UINTN
 131 BasePrintLibConvertValueToString (
 132   IN OUT CHAR8   *Buffer,
 133   IN UINTN       Flags,
 134   IN INT64       Value,
 135   IN UINTN       Width,
 136   IN UINTN       Increment
 137   )
 138 {
 139   CHAR8  *OriginalBuffer;
 140   CHAR8  *EndBuffer;
 141   CHAR8  ValueBuffer[MAXIMUM_VALUE_CHARACTERS];
 142   UINTN  Count;
 143   UINTN  Digits;
 144   UINTN  Index;
 145
 146   ASSERT (Buffer != NULL);
 147   ASSERT (Width < MAXIMUM_VALUE_CHARACTERS);
 148   //
 149   // Make sure Flags can only contain supported bits.
 150   //
 151   ASSERT ((Flags & ~(LEFT_JUSTIFY | COMMA_TYPE | PREFIX_ZERO)) == 0);
 152
 153   OriginalBuffer = Buffer;
 154
 155   if (Width == 0 || (Flags & COMMA_TYPE) != 0) {
 156     Flags &= (~PREFIX_ZERO);
 157   }
 158
 159   if (Width == 0) {
 160     Width = MAXIMUM_VALUE_CHARACTERS - 1;
 161   }
 162   //
 163   // Set the tag for the end of the input Buffer.
 164   //
 165   EndBuffer = Buffer + Width * Increment;
 166
 167   if (Value < 0) {
 168     Value = -Value;
 169     Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, '-', Increment);
 170     Width--;
 171   }
 172
 173   Count = BasePrintLibValueToString (ValueBuffer, Value, 10);
 174
 175   if ((Flags & PREFIX_ZERO) != 0) {
 176     Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Count, '0', Increment);
 177   }
 178
 179   Digits = Count % 3;
 180   if (Digits != 0) {
 181     Digits = 3 - Digits;
 182   }
 183   for (Index = 0; Index < Count; Index++) {
 184     Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ValueBuffer[Count - Index], Increment);
 185     if ((Flags & COMMA_TYPE) != 0) {
 186       Digits++;
 187       if (Digits == 3) {
 188         Digits = 0;
 189         if ((Index + 1) < Count) {
 190           Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', Increment);
 191         }
 192       }
 193     }
 194   }
 195
 196   BasePrintLibFillBuffer (Buffer, EndBuffer + Increment, 1, 0, Increment);
 197
 198   return ((Buffer - OriginalBuffer) / Increment);
 199 }