MdePkg/Library/BasePrintLib/PrintLibInternal.h

   1 /** @file
   2   Base Print Library instance Internal Functions definition.
   3
   4   Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
   5   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 #ifndef __PRINT_LIB_INTERNAL_H__
  16 #define __PRINT_LIB_INTERNAL_H__
  17
  18 #include <Base.h>
  19 #include <Library/PrintLib.h>
  20 #include <Library/BaseLib.h>
  21 #include <Library/DebugLib.h>
  22
  23
  24 //
  25 // Print primitives
  26 //
  27 #define PREFIX_SIGN           BIT1
  28 #define PREFIX_BLANK          BIT2
  29 #define LONG_TYPE             BIT4
  30 #define OUTPUT_UNICODE        BIT6
  31 #define FORMAT_UNICODE        BIT8
  32 #define PAD_TO_WIDTH          BIT9
  33 #define ARGUMENT_UNICODE      BIT10
  34 #define PRECISION             BIT11
  35 #define ARGUMENT_REVERSED     BIT12
  36 #define COUNT_ONLY_NO_PRINT   BIT13
  37 #define UNSIGNED_TYPE         BIT14
  38
  39 //
  40 // Record date and time information
  41 //
  42 typedef struct {
  43   UINT16  Year;
  44   UINT8   Month;
  45   UINT8   Day;
  46   UINT8   Hour;
  47   UINT8   Minute;
  48   UINT8   Second;
  49   UINT8   Pad1;
  50   UINT32  Nanosecond;
  51   INT16   TimeZone;
  52   UINT8   Daylight;
  53   UINT8   Pad2;
  54 } TIME;
  55
  56 /**
  57   Worker function that produces a Null-terminated string in an output buffer
  58   based on a Null-terminated format string and a VA_LIST argument list.
  59
  60   VSPrint function to process format and place the results in Buffer. Since a
  61   VA_LIST is used this routine allows the nesting of Vararg routines. Thus
  62   this is the main print working routine.
  63
  64   If COUNT_ONLY_NO_PRINT is set in Flags, Buffer will not be modified at all.
  65
  66   @param[out] Buffer          The character buffer to print the results of the
  67                               parsing of Format into.
  68   @param[in]  BufferSize      The maximum number of characters to put into
  69                               buffer.
  70   @param[in]  Flags           Initial flags value.
  71                               Can only have FORMAT_UNICODE, OUTPUT_UNICODE,
  72                               and COUNT_ONLY_NO_PRINT set.
  73   @param[in]  Format          A Null-terminated format string.
  74   @param[in]  VaListMarker    VA_LIST style variable argument list consumed by
  75                               processing Format.
  76   @param[in]  BaseListMarker  BASE_LIST style variable argument list consumed
  77                               by processing Format.
  78
  79   @return The number of characters printed not including the Null-terminator.
  80           If COUNT_ONLY_NO_PRINT was set returns the same, but without any
  81           modification to Buffer.
  82
  83 **/
  84 UINTN
  85 BasePrintLibSPrintMarker (
  86   OUT CHAR8        *Buffer,
  87   IN  UINTN        BufferSize,
  88   IN  UINTN        Flags,
  89   IN  CONST CHAR8  *Format,
  90   IN  VA_LIST      VaListMarker,   OPTIONAL
  91   IN  BASE_LIST    BaseListMarker  OPTIONAL
  92   );
  93
  94 /**
  95   Worker function that produces a Null-terminated string in an output buffer
  96   based on a Null-terminated format string and variable argument list.
  97
  98   VSPrint function to process format and place the results in Buffer. Since a
  99   VA_LIST is used this routine allows the nesting of Vararg routines. Thus
 100   this is the main print working routine
 101
 102   @param  StartOfBuffer The character buffer to print the results of the parsing
 103                         of Format into.
 104   @param  BufferSize    The maximum number of characters to put into buffer.
 105                         Zero means no limit.
 106   @param  Flags         Initial flags value.
 107                         Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
 108   @param  FormatString  Null-terminated format string.
 109   @param  ...           The variable argument list.
 110
 111   @return The number of characters printed.
 112
 113 **/
 114 UINTN
 115 EFIAPI
 116 BasePrintLibSPrint (
 117   OUT CHAR8        *StartOfBuffer,
 118   IN  UINTN        BufferSize,
 119   IN  UINTN        Flags,
 120   IN  CONST CHAR8  *FormatString,
 121   ...
 122   );
 123
 124 /**
 125   Internal function that places the character into the Buffer.
 126
 127   Internal function that places ASCII or Unicode character into the Buffer.
 128
 129   @param  Buffer      Buffer to place the Unicode or ASCII string.
 130   @param  EndBuffer   The end of the input Buffer. No characters will be
 131                       placed after that.
 132   @param  Length      The count of character to be placed into Buffer.
 133                       (Negative value indicates no buffer fill.)
 134   @param  Character   The character to be placed into Buffer.
 135   @param  Increment   The character increment in Buffer.
 136
 137   @return Buffer      Buffer filled with the input Character.
 138
 139 **/
 140 CHAR8 *
 141 BasePrintLibFillBuffer (
 142   OUT CHAR8   *Buffer,
 143   IN  CHAR8   *EndBuffer,
 144   IN  INTN    Length,
 145   IN  UINTN   Character,
 146   IN  INTN    Increment
 147   );
 148
 149 /**
 150   Internal function that convert a number to a string in Buffer.
 151
 152   Print worker function that converts a decimal or hexadecimal number to an ASCII string in Buffer.
 153
 154   @param  Buffer    Location to place the ASCII string of Value.
 155   @param  Value     The value to convert to a Decimal or Hexadecimal string in Buffer.
 156   @param  Radix     Radix of the value
 157
 158   @return A pointer to the end of buffer filled with ASCII string.
 159
 160 **/
 161 CHAR8 *
 162 BasePrintLibValueToString (
 163   IN OUT CHAR8  *Buffer,
 164   IN INT64      Value,
 165   IN UINTN      Radix
 166   );
 167
 168 /**
 169   Internal function that converts a decimal value to a Null-terminated string.
 170
 171   Converts the decimal number specified by Value to a Null-terminated
 172   string specified by Buffer containing at most Width characters.
 173   If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
 174   The total number of characters placed in Buffer is returned.
 175   If the conversion contains more than Width characters, then only the first
 176   Width characters are returned, and the total number of characters
 177   required to perform the conversion is returned.
 178   Additional conversion parameters are specified in Flags.
 179   The Flags bit LEFT_JUSTIFY is always ignored.
 180   All conversions are left justified in Buffer.
 181   If Width is 0, PREFIX_ZERO is ignored in Flags.
 182   If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
 183   are inserted every 3rd digit starting from the right.
 184   If Value is < 0, then the fist character in Buffer is a '-'.
 185   If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
 186   then Buffer is padded with '0' characters so the combination of the optional '-'
 187   sign character, '0' characters, digit characters for Value, and the Null-terminator
 188   add up to Width characters.
 189
 190   If Buffer is NULL, then ASSERT().
 191   If unsupported bits are set in Flags, then ASSERT().
 192   If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
 193
 194   @param  Buffer    The pointer to the output buffer for the produced Null-terminated
 195                     string.
 196   @param  Flags     The bitmask of flags that specify left justification, zero pad,
 197                     and commas.
 198   @param  Value     The 64-bit signed value to convert to a string.
 199   @param  Width     The maximum number of characters to place in Buffer, not including
 200                     the Null-terminator.
 201   @param  Increment Character increment in Buffer.
 202
 203   @return Total number of characters required to perform the conversion.
 204
 205 **/
 206 UINTN
 207 BasePrintLibConvertValueToString (
 208   IN OUT CHAR8   *Buffer,
 209   IN UINTN       Flags,
 210   IN INT64       Value,
 211   IN UINTN       Width,
 212   IN UINTN       Increment
 213   );
 214
 215 #endif