More moves for Tool Packages

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@1676 6f19259b-4bc3-4df7-8a09-765794883524

5 files changed, 1745 insertions, 0 deletions

diff --git a/Tools/CCode/Source/String/PrintLib.c b/Tools/CCode/Source/String/PrintLib.c
new file mode 100644
index 0000000..eef3f4d
--- /dev/null
+++ b/Tools/CCode/Source/String/PrintLib.c
@@ -0,0 +1,674 @@
+/*++

+

+Copyright (c)  2004-2006 Intel Corporation. All rights reserved

+This program and the accompanying materials are licensed and made available

+under the terms and conditions of the BSD License which accompanies this

+distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+

+Module Name:

+

+  PrintLib.c

+

+Abstract:

+

+  Print Library.

+

+--*/

+

+#include <Common/UefiBaseTypes.h>

+#include <Library/PrintLib.h>

+

+#include "CommonLib.h"

+#include "PrintLibInternal.h"

+

+typedef struct {

+  RETURN_STATUS  Status;

+  CHAR8          *String;

+} STATUS_LOOKUP_TABLE_ENTRY;

+

+static CONST STATUS_LOOKUP_TABLE_ENTRY  StatusString[] = {

+  { RETURN_SUCCESS,               "Success" },

+  { RETURN_LOAD_ERROR,            "Load Error" },

+  { RETURN_INVALID_PARAMETER,     "Invalid Parameter" },

+  { RETURN_UNSUPPORTED,           "Unsupported" },

+  { RETURN_BAD_BUFFER_SIZE,       "Bad Buffer Size" },

+  { RETURN_BUFFER_TOO_SMALL,      "Buffer Too Small" },

+  { RETURN_NOT_READY,             "Not Ready" },

+  { RETURN_DEVICE_ERROR,          "Device Error" },

+  { RETURN_WRITE_PROTECTED,       "Write Protected" },

+  { RETURN_OUT_OF_RESOURCES,      "Out of Resources" },

+  { RETURN_VOLUME_CORRUPTED,      "Volume Corrupt" },

+  { RETURN_VOLUME_FULL,           "Volume Full" },

+  { RETURN_NO_MEDIA,              "No Media" },

+  { RETURN_MEDIA_CHANGED,         "Media changed" },

+  { RETURN_NOT_FOUND,             "Not Found" },

+  { RETURN_ACCESS_DENIED,         "Access Denied" },

+  { RETURN_NO_RESPONSE,           "No Response" },

+  { RETURN_NO_MAPPING,            "No mapping" },

+  { RETURN_TIMEOUT,               "Time out" },

+  { RETURN_NOT_STARTED,           "Not started" },

+  { RETURN_ALREADY_STARTED,       "Already started" },

+  { RETURN_ABORTED,               "Aborted" },

+  { RETURN_ICMP_ERROR,            "ICMP Error" },

+  { RETURN_TFTP_ERROR,            "TFTP Error" },

+  { RETURN_PROTOCOL_ERROR,        "Protocol Error" },

+  { RETURN_WARN_UNKNOWN_GLYPH,    "Warning Unknown Glyph" },

+  { RETURN_WARN_DELETE_FAILURE,   "Warning Delete Failure" },

+  { RETURN_WARN_WRITE_FAILURE,    "Warning Write Failure" },

+  { RETURN_WARN_BUFFER_TOO_SMALL, "Warning Buffer Too Small" },

+  { 0,                              NULL                     }

+};

+

+

+/**

+  VSPrint function to process format and place the results in Buffer. Since a

+  VA_LIST is used this rountine allows the nesting of Vararg routines. Thus

+  this is the main print working routine

+

+  @param  StartOfBuffer Unicode buffer to print the results of the parsing of Format into.

+

+  @param  BufferSize Maximum number of characters to put into buffer. Zero means

+  no limit.

+

+  @param  Flags Intial flags value.  Can only have FORMAT_UNICODE and OUTPUT_UNICODE set

+

+  @param  FormatString Unicode format string see file header for more details.

+

+  @param  Marker Vararg list consumed by processing Format.

+

+  @return Number of characters printed.

+

+**/

+UINTN

+BasePrintLibVSPrint (

+  OUT CHAR8        *Buffer,

+  IN  UINTN        BufferSize,

+  IN  UINTN        Flags,

+  IN  CONST CHAR8  *Format,

+  IN  VA_LIST      Marker

+  )

+{

+  CHAR8           *OriginalBuffer;

+  CHAR8           ValueBuffer[MAXIMUM_VALUE_CHARACTERS];

+  UINTN           BytesPerOutputCharacter;

+  UINTN           BytesPerFormatCharacter;

+  UINTN           FormatMask;

+  UINTN           FormatCharacter;

+  UINTN           Width;

+  UINTN           Precision;

+  INT64           Value;

+  CHAR8           *ArgumentString;

+  UINTN           Character;

+  GUID            *TmpGuid;

+  TIME            *TmpTime;

+  UINTN           Count;

+  UINTN           ArgumentMask;

+  INTN            BytesPerArgumentCharacter;

+  UINTN           ArgumentCharacter;

+  BOOLEAN         Done;

+  UINTN           Index;

+  CHAR8           Prefix;

+  BOOLEAN         ZeroPad;

+  BOOLEAN         Comma;

+  UINTN           Digits;

+  UINTN           Radix;

+  RETURN_STATUS   Status;

+

+  OriginalBuffer = Buffer;

+

+  if ((Flags & OUTPUT_UNICODE) != 0) {

+    BytesPerOutputCharacter = 2;

+  } else {

+    BytesPerOutputCharacter = 1;

+  }

+  if ((Flags & FORMAT_UNICODE) != 0) {

+    BytesPerFormatCharacter = 2;

+    FormatMask = 0xffff;

+  } else {

+    BytesPerFormatCharacter = 1;

+    FormatMask = 0xff;

+  }

+

+  //

+  // Reserve space for the Null terminator.

+  // If BufferSize is 0, this will set BufferSize to the max unsigned value

+  //

+  BufferSize--;

+

+  //

+  // Get the first character from the format string

+  //

+  FormatCharacter = (*Format | (*(Format + 1) << 8)) & FormatMask;

+

+  //

+  // Loop until the end of the format string is reached or the output buffer is full

+  //

+  while (FormatCharacter != 0 && BufferSize > 0) {

+    //

+    // Clear all the flag bits except those that may have been passed in

+    //

+    Flags &= (OUTPUT_UNICODE | FORMAT_UNICODE);

+

+    //

+    // Set the default width to zero, and the default precision to 1

+    //

+    Width     = 0;

+    Precision = 1;

+    Prefix    = 0;

+    Comma     = FALSE;

+    ZeroPad   = FALSE;

+    Count     = 0;

+    Digits    = 0;

+

+    switch (FormatCharacter) {

+    case '%':

+      //

+      // Parse Flags and Width

+      //

+      for (Done = FALSE; !Done; ) {

+        Format += BytesPerFormatCharacter;

+        FormatCharacter = (*Format | (*(Format + 1) << 8)) & FormatMask;

+        switch (FormatCharacter) {

+        case '.':

+          Flags |= PRECISION;

+          break;

+        case '-':

+          Flags |= LEFT_JUSTIFY;

+          break;

+        case '+':

+          Flags |= PREFIX_SIGN;

+          break;

+        case ' ':

+          Flags |= PREFIX_BLANK;

+          break;

+        case ',':

+          Flags |= COMMA_TYPE;

+          break;

+        case 'L':

+        case 'l':

+          Flags |= LONG_TYPE;

+          break;

+        case '*':

+          if ((Flags & PRECISION) == 0) {

+            Flags |= PAD_TO_WIDTH;

+            Width = VA_ARG (Marker, UINTN);

+          } else {

+            Precision = VA_ARG (Marker, UINTN);

+          }

+          break;

+        case '0':

+          if ((Flags & PRECISION) == 0) {

+            Flags |= PREFIX_ZERO;

+          }

+        case '1':

+        case '2':

+        case '3':

+        case '4':

+        case '5':

+        case '6':

+        case '7':

+        case '8':

+        case '9':

+          for (Count = 0; ((FormatCharacter >= '0') &&  (FormatCharacter <= '9')); ){

+            Count = (Count * 10) + FormatCharacter - '0';

+            Format += BytesPerFormatCharacter;

+            FormatCharacter = (*Format | (*(Format + 1) << 8)) & FormatMask;

+          }

+          Format -= BytesPerFormatCharacter;

+          if ((Flags & PRECISION) == 0) {

+            Flags |= PAD_TO_WIDTH;

+            Width = Count;

+          } else {

+            Precision = Count;

+          }

+          break;

+        default:

+          Done = TRUE;

+          break;

+        }

+      }

+

+      //

+      // Limit the maximum field width to the remaining characters in the output buffer

+      //

+      if (Width > BufferSize) {

+        Width = BufferSize;

+      }

+

+      //

+      // Handle each argument type

+      //

+      switch (FormatCharacter) {

+      case 'X':

+        Flags |= PREFIX_ZERO;

+        //

+        // break skiped on purpose

+        //

+      case 'x':

+        Flags |= RADIX_HEX;

+        //

+        // break skiped on purpose

+        //

+      case 'd':

+        if ((Flags & LONG_TYPE) == 0) {

+          Value = (VA_ARG (Marker, INTN));

+        } else {

+          Value = VA_ARG (Marker, INT64);

+        }

+        if ((Flags & PREFIX_BLANK) != 0) {

+          Prefix = ' ';

+        }

+        if ((Flags & PREFIX_SIGN) != 0) {

+          Prefix = '+';

+        }

+        if ((Flags & COMMA_TYPE) != 0) {

+          Comma = TRUE;

+        }

+        if ((Flags & RADIX_HEX) == 0) {

+          Radix = 10;

+          if (Comma) {

+            Flags &= (~PREFIX_ZERO);

+            Precision = 1;

+          }

+          if (Value < 0) {

+            Flags |= PREFIX_SIGN;

+            Prefix = '-';

+            Value = -Value;

+          }

+        } else {

+          Radix = 16;

+          Comma = FALSE;

+          if ((Flags & LONG_TYPE) == 0 && Value < 0) {

+            Value = (UINTN)Value;

+          }

+        }

+        //

+        // Convert Value to a reversed string

+        //

+        Count = BasePrintLibValueToString (ValueBuffer, Value, Radix);

+        if (Value == 0 && Precision == 0) {

+          Count = 0;

+        }

+        ArgumentString = (CHAR8 *)ValueBuffer + Count;

+        Digits = 3 - (Count % 3);

+        if (Comma && Count != 0) {

+          Count += ((Count - 1) / 3);

+        }

+        if (Prefix != 0) {

+          Count++;

+        }

+        Flags |= ARGUMENT_REVERSED;

+        ZeroPad = TRUE;

+        if ((Flags & PREFIX_ZERO) != 0) {

+          if ((Flags & PAD_TO_WIDTH) != 0) {

+            if ((Flags & PRECISION) == 0) {

+              Precision = Width;

+            }

+          }

+        }

+        break;

+

+      case 's':

+      case 'S':

+        Flags |= ARGUMENT_UNICODE;

+        //

+        // break skipped on purpose

+        //

+      case 'a':

+        ArgumentString = (CHAR8 *)VA_ARG (Marker, CHAR8 *);

+        if (ArgumentString == NULL) {

+          Flags &= (~ARGUMENT_UNICODE);

+          ArgumentString = "<null string>";

+        }

+        break;

+

+      case 'c':

+        Character = VA_ARG (Marker, UINTN) & 0xffff;

+        ArgumentString = (CHAR8 *)&Character;

+        Flags |= ARGUMENT_UNICODE;

+        break;

+

+      case 'g':

+        TmpGuid = VA_ARG (Marker, GUID *);

+        if (TmpGuid == NULL) {

+          ArgumentString = "<null guid>";

+        } else {

+          BasePrintLibSPrint (

+            ValueBuffer,

+            0,

+            0,

+            "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",

+            TmpGuid->Data1,

+            TmpGuid->Data2,

+            TmpGuid->Data3,

+            TmpGuid->Data4[0],

+            TmpGuid->Data4[1],

+            TmpGuid->Data4[2],

+            TmpGuid->Data4[3],

+            TmpGuid->Data4[4],

+            TmpGuid->Data4[5],

+            TmpGuid->Data4[6],

+            TmpGuid->Data4[7]

+            );

+          ArgumentString = ValueBuffer;

+        }

+        break;

+

+      case 't':

+        TmpTime = VA_ARG (Marker, TIME *);

+        if (TmpTime == NULL) {

+          ArgumentString = "<null time>";

+        } else {

+          BasePrintLibSPrint (

+            ValueBuffer,

+            0,

+            0,

+            "%02d/%02d/%04d  %02d:%02d",

+            TmpTime->Month,

+            TmpTime->Day,

+            TmpTime->Year,

+            TmpTime->Hour,

+            TmpTime->Minute

+            );

+          ArgumentString = ValueBuffer;

+        }

+        break;

+

+      case 'r':

+        Status = VA_ARG (Marker, RETURN_STATUS);

+        ArgumentString = ValueBuffer;

+        for (Index = 0; StatusString[Index].String != NULL; Index++) {

+          if (Status == StatusString[Index].Status) {

+            ArgumentString = StatusString[Index].String;

+          }

+        }

+        if (ArgumentString == ValueBuffer) {

+          BasePrintLibSPrint ((CHAR8 *) ValueBuffer, 0, 0, "%08X", Status);

+        }

+        break;

+

+      case '%':

+      default:

+        //

+        // if the type is '%' or unknown, then print it to the screen

+        //

+        ArgumentString = (CHAR8 *)&FormatCharacter;

+        Flags |= ARGUMENT_UNICODE;

+        break;

+      }

+      break;

+    case '\n':

+      ArgumentString = "\n";

+	  

+      break;

+    default:

+      ArgumentString = (CHAR8 *)&FormatCharacter;

+      Flags |= ARGUMENT_UNICODE;

+      break;

+    }

+

+    //

+    // Retrieve the ArgumentString attriubutes

+    //

+    if ((Flags & ARGUMENT_UNICODE) != 0) {

+      ArgumentMask = 0xffff;

+      BytesPerArgumentCharacter = 2;

+    } else {

+      ArgumentMask = 0xff;

+      BytesPerArgumentCharacter = 1;

+    }

+    if ((Flags & ARGUMENT_REVERSED) != 0) {

+      BytesPerArgumentCharacter = -BytesPerArgumentCharacter;

+    } else {

+      //

+      // Compute the number of characters in ArgumentString and store it in Count

+      // ArgumentString is either null-terminated, or it contains Precision characters

+      //

+      for (Count = 0; Count < Precision || ((Flags & PRECISION) == 0); Count++) {

+        ArgumentCharacter = ((ArgumentString[Count * BytesPerArgumentCharacter] & 0xff) | ((ArgumentString[Count * BytesPerArgumentCharacter + 1]) << 8)) & ArgumentMask;

+        if (ArgumentCharacter == 0) {

+          break;

+        }

+      }

+    }

+

+    //

+    // Limit the length of the string to append to the remaining characters in the output buffer

+    //

+    if (Count > BufferSize) {

+      Count = BufferSize;

+    }

+    if (Precision < Count) {

+      Precision = Count;

+    }

+

+    //

+    // Pad before the string

+    //

+    if ((Flags & (PAD_TO_WIDTH | LEFT_JUSTIFY)) == (PAD_TO_WIDTH)) {

+      Buffer = BasePrintLibFillBuffer (Buffer, Width - Precision, ' ', BytesPerOutputCharacter);

+    }

+

+    if (ZeroPad) {

+      if (Prefix != 0) {

+        Buffer = BasePrintLibFillBuffer (Buffer, 1, Prefix, BytesPerOutputCharacter);

+      }

+      Buffer = BasePrintLibFillBuffer (Buffer, Precision - Count, '0', BytesPerOutputCharacter);

+    } else {

+      Buffer = BasePrintLibFillBuffer (Buffer, Precision - Count, ' ', BytesPerOutputCharacter);

+      if (Prefix != 0) {

+        Buffer = BasePrintLibFillBuffer (Buffer, 1, Prefix, BytesPerOutputCharacter);

+      }

+    }

+

+    //

+    // Output the Prefix character if it is present

+    //

+    Index = 0;

+    if (Prefix) {

+      Index++;

+    }

+

+    //

+    // Copy the string into the output buffer performing the required type conversions

+    //

+    while (Index < Count) {

+      ArgumentCharacter = ((*ArgumentString & 0xff) | (*(ArgumentString + 1) << 8)) & ArgumentMask;

+

+      Buffer = BasePrintLibFillBuffer (Buffer, 1, ArgumentCharacter, BytesPerOutputCharacter);

+      ArgumentString    += BytesPerArgumentCharacter;

+      Index++;

+      if (Comma) {

+        Digits++;

+        if (Digits == 3) {

+          Digits = 0;

+          Index++;

+          if (Index < Count) {

+            Buffer = BasePrintLibFillBuffer (Buffer, 1, ',', BytesPerOutputCharacter);

+          }

+        }

+      }

+    }

+

+    //

+    // Pad after the string

+    //

+    if ((Flags & (PAD_TO_WIDTH | LEFT_JUSTIFY)) == (PAD_TO_WIDTH | LEFT_JUSTIFY)) {

+      Buffer = BasePrintLibFillBuffer (Buffer, Width - Precision, ' ', BytesPerOutputCharacter);

+    }

+

+    //

+    // Reduce the number of characters

+    //

+    BufferSize -= Count;

+

+    //

+    // Get the next character from the format string

+    //

+    Format += BytesPerFormatCharacter;

+

+    //

+    // Get the next character from the format string

+    //

+    FormatCharacter = (*Format | (*(Format + 1) << 8)) & FormatMask;

+  }

+

+  //

+  // Null terminate the Unicode or ASCII string

+  //

+  Buffer = BasePrintLibFillBuffer (Buffer, 1, 0, BytesPerOutputCharacter);

+

+  return ((Buffer - OriginalBuffer) / BytesPerOutputCharacter);

+}

+

+UINTN

+BasePrintLibSPrint (

+  OUT CHAR8        *StartOfBuffer,

+  IN  UINTN        BufferSize,

+  IN  UINTN        Flags,

+  IN  CONST CHAR8  *FormatString,

+  ...

+  )

+{

+  VA_LIST  Marker;

+

+  VA_START (Marker, FormatString);

+  return BasePrintLibVSPrint (StartOfBuffer, BufferSize, Flags, FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+UnicodeVSPrint (

+  OUT CHAR16        *StartOfBuffer,

+  IN  UINTN         BufferSize,

+  IN  CONST CHAR16  *FormatString,

+  IN  VA_LIST       Marker

+  )

+{

+  return BasePrintLibVSPrint ((CHAR8 *)StartOfBuffer, BufferSize >> 1, FORMAT_UNICODE | OUTPUT_UNICODE, (CHAR8 *)FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+UnicodeSPrint (

+  OUT CHAR16        *StartOfBuffer,

+  IN  UINTN         BufferSize,

+  IN  CONST CHAR16  *FormatString,

+  ...

+  )

+{

+  VA_LIST Marker;

+

+  VA_START (Marker, FormatString);

+  return UnicodeVSPrint (StartOfBuffer, BufferSize, FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+UnicodeVSPrintAsciiFormat (

+  OUT CHAR16       *StartOfBuffer,

+  IN  UINTN        BufferSize,

+  IN  CONST CHAR8  *FormatString,

+  IN  VA_LIST      Marker

+  )

+{

+  return BasePrintLibVSPrint ((CHAR8 *)StartOfBuffer, BufferSize >> 1, OUTPUT_UNICODE,FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+UnicodeSPrintAsciiFormat (

+  OUT CHAR16       *StartOfBuffer,

+  IN  UINTN        BufferSize,

+  IN  CONST CHAR8  *FormatString,

+  ...

+  )

+{

+  VA_LIST Marker;

+

+  VA_START (Marker, FormatString);

+  return UnicodeVSPrintAsciiFormat (StartOfBuffer, BufferSize >> 1, FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+AsciiVSPrint (

+  OUT CHAR8         *StartOfBuffer,

+  IN  UINTN         BufferSize,

+  IN  CONST CHAR8   *FormatString,

+  IN  VA_LIST       Marker

+  )

+{

+  return BasePrintLibVSPrint (StartOfBuffer, BufferSize, 0, FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+AsciiSPrint (

+  OUT CHAR8        *StartOfBuffer,

+  IN  UINTN        BufferSize,

+  IN  CONST CHAR8  *FormatString,

+  ...

+  )

+{

+  VA_LIST Marker;

+

+  VA_START (Marker, FormatString);

+  return AsciiVSPrint (StartOfBuffer, BufferSize, FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+AsciiVSPrintUnicodeFormat (

+  OUT CHAR8         *StartOfBuffer,

+  IN  UINTN         BufferSize,

+  IN  CONST CHAR16  *FormatString,

+  IN  VA_LIST       Marker

+  )

+{

+  return BasePrintLibVSPrint (StartOfBuffer, BufferSize, FORMAT_UNICODE, (CHAR8 *)FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+AsciiSPrintUnicodeFormat (

+  OUT CHAR8         *StartOfBuffer,

+  IN  UINTN         BufferSize,

+  IN  CONST CHAR16  *FormatString,

+  ...

+  )

+{

+  VA_LIST Marker;

+

+  VA_START (Marker, FormatString);

+  return AsciiVSPrintUnicodeFormat (StartOfBuffer, BufferSize, FormatString, Marker);

+}

+

+UINTN

+EFIAPI

+UnicodeValueToString (

+  IN OUT CHAR16  *Buffer,

+  IN UINTN       Flags,

+  IN INT64       Value,

+  IN UINTN       Width

+  )

+{

+  return BasePrintLibConvertValueToString ((CHAR8 *)Buffer, Flags, Value, Width, 2);

+}

+

+UINTN

+EFIAPI

+AsciiValueToString (

+  IN OUT CHAR8  *Buffer,

+  IN UINTN      Flags,

+  IN INT64      Value,

+  IN UINTN      Width

+  )

+{

+  return BasePrintLibConvertValueToString ((CHAR8 *)Buffer, Flags, Value, Width, 1);

+}

diff --git a/Tools/CCode/Source/String/PrintLibInternal.c b/Tools/CCode/Source/String/PrintLibInternal.c
new file mode 100644
index 0000000..63d0c71
--- /dev/null
+++ b/Tools/CCode/Source/String/PrintLibInternal.c
@@ -0,0 +1,142 @@
+/*++

+

+Copyright (c)  2004-2006 Intel Corporation. All rights reserved

+This program and the accompanying materials are licensed and made available

+under the terms and conditions of the BSD License which accompanies this

+distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+

+Module Name:

+

+  PrintLibInternal.c

+

+Abstract:

+

+  Print Library worker functions.

+

+--*/

+

+#include <Common/UefiBaseTypes.h>

+#include <Library/PrintLib.h>

+

+#include "CommonLib.h"

+#include "PrintLibInternal.h"

+

+static CONST CHAR8 mHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

+

+CHAR8 *

+BasePrintLibFillBuffer (

+  CHAR8   *Buffer,

+  INTN    Length,

+  UINTN   Character,

+  INTN    Increment

+  )

+{

+  INTN  Index;

+

+  for (Index = 0; Index < Length; Index++) {

+    *Buffer       =  (CHAR8) Character;

+    *(Buffer + 1) =  (CHAR8) (Character >> 8);

+    Buffer        += Increment;

+  }

+  return Buffer;

+}

+

+/**

+  Print worker function that prints a Value as a decimal number in Buffer.

+

+  @param  Buffer Location to place the Unicode or ASCII string of Value.

+

+  @param  Value Value to convert to a Decimal or Hexidecimal string in Buffer.

+

+  @param  Flags Flags to use in printing string, see file header for details.

+

+  @param  Precision Minimum number of digits to return in the ASCII string

+

+  @return Number of characters printed.

+

+**/

+UINTN

+EFIAPI

+BasePrintLibValueToString (

+  IN OUT CHAR8  *Buffer,

+  IN INT64      Value,

+  IN UINTN      Radix

+  )

+{

+  UINTN   Digits;

+  UINT32  Remainder;

+

+  //

+  // Loop to convert one digit at a time in reverse order

+  //

+  *(Buffer++) = 0;

+  Digits = 0;

+  do {

+    // Value = (INT64)DivU64x32Remainder ((UINT64)Value, (UINT32)Radix, &Remainder);

+    Remainder = (UINT64)Value % (UINT32)Radix;

+    Value = (UINT64)Value / (UINT32)Radix;

+    *(Buffer++) = mHexStr[Remainder];

+    Digits++;

+  } while (Value != 0);

+  return Digits;

+}

+

+UINTN

+BasePrintLibConvertValueToString (

+  IN OUT CHAR8   *Buffer,

+  IN UINTN       Flags,

+  IN INT64       Value,

+  IN UINTN       Width,

+  IN UINTN       Increment

+  )

+{

+  CHAR8  *OriginalBuffer;

+  CHAR8  ValueBuffer[MAXIMUM_VALUE_CHARACTERS];

+  UINTN  Count;

+  UINTN  Digits;

+  UINTN  Index;

+

+  OriginalBuffer = Buffer;

+

+  if (Width == 0 || (Flags & COMMA_TYPE) != 0) {

+    Flags &= (~PREFIX_ZERO);

+  }

+

+  if (Width == 0 || Width > (MAXIMUM_VALUE_CHARACTERS - 1)) {

+    Width = MAXIMUM_VALUE_CHARACTERS - 1;

+  }

+

+  if (Value < 0) {

+    Value = -Value;

+    Buffer = BasePrintLibFillBuffer (Buffer, 1, '-', Increment);

+  }

+

+  Count = BasePrintLibValueToString (ValueBuffer, Value, 10);

+

+  if ((Flags & PREFIX_ZERO) != 0) {

+    Buffer = BasePrintLibFillBuffer (Buffer, Width - Count, '0', Increment);

+  }

+

+  Digits = 3 - (Count % 3);

+  for (Index = 0; Index < Count; Index++) {

+    Buffer = BasePrintLibFillBuffer (Buffer, 1, ValueBuffer[Count - Index], Increment);

+    if ((Flags & COMMA_TYPE) != 0) {

+      Digits++;

+      if (Digits == 3) {

+        Digits = 0;

+        if ((Index + 1) < Count) {

+          Buffer = BasePrintLibFillBuffer (Buffer, 1, ',', Increment);

+        }

+      }

+    }

+  }

+

+  Buffer = BasePrintLibFillBuffer (Buffer, 1, 0, Increment);

+

+  return ((Buffer - OriginalBuffer) / Increment);

+}

diff --git a/Tools/CCode/Source/String/PrintLibInternal.h b/Tools/CCode/Source/String/PrintLibInternal.h
new file mode 100644
index 0000000..87f0955e
--- /dev/null
+++ b/Tools/CCode/Source/String/PrintLibInternal.h
@@ -0,0 +1,101 @@
+/*++

+

+Copyright (c)  2004-2006 Intel Corporation. All rights reserved

+This program and the accompanying materials are licensed and made available

+under the terms and conditions of the BSD License which accompanies this

+distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+

+Module Name:

+

+  PrintLibInternal.h

+

+Abstract:

+

+  Print Library.

+

+--*/

+

+

+

+//

+// Print primitives

+//

+//#define LEFT_JUSTIFY      0x01

+#define PREFIX_SIGN       0x02

+#define PREFIX_BLANK      0x04

+//#define COMMA_TYPE        0x08

+#define LONG_TYPE         0x10

+//#define PREFIX_ZERO       0x20

+#define OUTPUT_UNICODE    0x40

+#define RADIX_HEX         0x80

+#define FORMAT_UNICODE    0x100

+#define PAD_TO_WIDTH      0x200

+#define ARGUMENT_UNICODE  0x400

+#define PRECISION         0x800

+#define ARGUMENT_REVERSED 0x1000

+

+///

+/// Define the maximum number of characters that are required to encode

+/// a decimal, hexidecimal, GUID, or TIME value with a Nll terminator.

+///   Maximum Length Decimal String     = 28    "-9,223,372,036,854,775,808"

+///   Maximum Length Hexidecimal String = 17    "FFFFFFFFFFFFFFFF"

+///   Maximum Length GUID               = 37    "00000000-0000-0000-0000-000000000000"

+///   Maximum Length TIME               = 18    "12/12/2006  12:12"

+///

+#define MAXIMUM_VALUE_CHARACTERS  38

+

+//

+//

+//

+typedef struct {

+  UINT16  Year;

+  UINT8   Month;

+  UINT8   Day;

+  UINT8   Hour;

+  UINT8   Minute;

+  UINT8   Second;

+  UINT8   Pad1;

+  UINT32  Nanosecond;

+  INT16   TimeZone;

+  UINT8   Daylight;

+  UINT8   Pad2;

+} TIME;

+

+UINTN

+BasePrintLibSPrint (

+  OUT CHAR8        *Buffer,

+  IN  UINTN        BufferSize,

+  IN  UINTN        Flags,

+  IN  CONST CHAR8  *FormatString,

+  ...

+  );

+

+CHAR8 *

+BasePrintLibFillBuffer (

+  CHAR8   *Buffer,

+  INTN    Length,

+  UINTN   Character,

+  INTN    Increment

+  );

+

+UINTN

+EFIAPI

+BasePrintLibValueToString (

+  IN OUT CHAR8  *Buffer,

+  IN INT64      Value,

+  IN UINTN      Radix

+  );

+

+UINTN

+BasePrintLibConvertValueToString (

+  IN OUT CHAR8   *Buffer,

+  IN UINTN       Flags,

+  IN INT64       Value,

+  IN UINTN       Width,

+  IN UINTN       Increment

+  );

diff --git a/Tools/CCode/Source/String/String.c b/Tools/CCode/Source/String/String.c
new file mode 100644
index 0000000..78d0a59
--- /dev/null
+++ b/Tools/CCode/Source/String/String.c
@@ -0,0 +1,732 @@
+/*++

+

+Copyright (c)  2004-2006 Intel Corporation. All rights reserved

+This program and the accompanying materials are licensed and made available

+under the terms and conditions of the BSD License which accompanies this

+distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+

+Module Name:

+

+  String.c

+

+Abstract:

+

+  Unicode and ASCII string primatives.

+

+--*/

+

+#include <assert.h>

+

+#include <Common/UefiBaseTypes.h>

+

+#include <string.h>

+

+#include "CommonLib.h"

+

+/**

+  Returns the length of a Null-terminated Unicode string.

+

+  This function returns the number of Unicode characters in the Null-terminated

+  Unicode string specified by String.

+

+  If String is NULL, then ASSERT().

+

+  @param  String  Pointer to a Null-terminated Unicode string.

+

+  @return The length of String.

+

+**/

+UINTN

+EFIAPI

+StrLen (

+  IN      CONST CHAR16              *String

+  )

+{

+  UINTN                             Length;

+

+  ASSERT (String != NULL);

+

+  for (Length = 0; *String != L'\0'; String++, Length++) {

+    ;

+  }

+  return Length;

+}

+

+/**

+  Returns the length of a Null-terminated ASCII string.

+

+  This function returns the number of ASCII characters in the Null-terminated

+  ASCII string specified by String.

+

+  If String is NULL, then ASSERT().

+

+  @param  String  Pointer to a Null-terminated ASCII string.

+

+  @return The length of String.

+

+**/

+UINTN

+EFIAPI

+AsciiStrLen (

+  IN      CONST CHAR8               *String

+  )

+{

+  UINTN                             Length;

+

+  ASSERT (String != NULL);

+

+  for (Length = 0; *String != '\0'; String++, Length++) {

+    ;

+  }

+  return Length;

+}

+

+/**

+  Copies one Null-terminated Unicode string to another Null-terminated Unicode

+  string and returns the new Unicode string.

+

+  This function copies the contents of the Unicode string Source to the Unicode

+  string Destination, and returns Destination. If Source and Destination

+  overlap, then the results are undefined.

+

+  If Destination is NULL, then ASSERT().

+  If Source is NULL, then ASSERT().

+  If Source and Destination overlap, then ASSERT().

+

+  @param  Destination Pointer to a Null-terminated Unicode string.

+  @param  Source      Pointer to a Null-terminated Unicode string.

+

+  @return Destiantion

+

+**/

+CHAR16 *

+EFIAPI

+StrCpy (

+  OUT     CHAR16                    *Destination,

+  IN      CONST CHAR16              *Source

+  )

+{

+  CHAR16                            *ReturnValue;

+

+  //

+  // Destination cannot be NULL

+  //

+  ASSERT (Destination != NULL);

+

+  //

+  // Destination and source cannot overlap

+  //

+  ASSERT ((UINTN)(Destination - Source) > StrLen (Source));

+  ASSERT ((UINTN)(Source - Destination) > StrLen (Source));

+

+  ReturnValue = Destination;

+  while (*Source) {

+    *(Destination++) = *(Source++);

+  }

+  *Destination = 0;

+  return ReturnValue;

+}

+

+/**

+  Copies one Null-terminated Unicode string with a maximum length to another

+  Null-terminated Unicode string with a maximum length and returns the new

+  Unicode string.

+

+  This function copies the contents of the Unicode string Source to the Unicode

+  string Destination, and returns Destination. At most, Length Unicode

+  characters are copied from Source to Destination. If Length is 0, then

+  Destination is returned unmodified. If Length is greater that the number of

+  Unicode characters in Source, then Destination is padded with Null Unicode

+  characters. If Source and Destination overlap, then the results are

+  undefined.

+

+  If Destination is NULL, then ASSERT().

+  If Source is NULL, then ASSERT().

+  If Source and Destination overlap, then ASSERT().

+

+  @param  Destination Pointer to a Null-terminated Unicode string.

+  @param  Source      Pointer to a Null-terminated Unicode string.

+  @param  Length      Maximum number of Unicode characters to copy.

+

+  @return Destination

+

+**/

+CHAR16 *

+EFIAPI

+StrnCpy (

+  OUT     CHAR16                    *Destination,

+  IN      CONST CHAR16              *Source,

+  IN      UINTN                     Length

+  )

+{

+  CHAR16                            *ReturnValue;

+

+  if (Length == 0) {

+    return Destination;

+  }

+

+  //

+  // Destination cannot be NULL if Length is not zero

+  //

+  ASSERT (Destination != NULL);

+

+  //

+  // Destination and source cannot overlap

+  // Q: Does Source have to be NULL-terminated?

+  //

+  ASSERT ((UINTN)(Destination - Source) > StrLen (Source));

+  ASSERT ((UINTN)(Source - Destination) >= Length);

+

+  ReturnValue = Destination;

+

+  while ((*Source != L'\0') && (Length > 0)) {

+    *(Destination++) = *(Source++);

+    Length--;

+  }

+

+  memset (Destination, 0, Length * sizeof (*Destination));

+  return ReturnValue;

+}

+

+/**

+  Returns the size of a Null-terminated Unicode string in bytes, including the

+  Null terminator.

+

+  This function returns the size, in bytes, of the Null-terminated Unicode

+  string specified by String.

+

+  If String is NULL, then ASSERT().

+

+  @param  String  Pointer to a Null-terminated Unicode string.

+

+  @return The size of String.

+

+**/

+UINTN

+EFIAPI

+StrSize (

+  IN      CONST CHAR16              *String

+  )

+{

+  return (StrLen (String) + 1) * sizeof (*String);

+}

+

+/**

+  Compares two Null-terminated Unicode strings, and returns the difference

+  between the first mismatched Unicode characters.

+

+  This function compares the Null-terminated Unicode string FirstString to the

+  Null-terminated Unicode string SecondString. If FirstString is identical to

+  SecondString, then 0 is returned. Otherwise, the value returned is the first

+  mismatched Unicode character in SecondString subtracted from the first

+  mismatched Unicode character in FirstString.

+

+  If FirstString is NULL, then ASSERT().

+  If SecondString is NULL, then ASSERT().

+

+  @param  FirstString   Pointer to a Null-terminated Unicode string.

+  @param  SecondString  Pointer to a Null-terminated Unicode string.

+

+  @retval 0   FirstString is identical to SecondString.

+  @retval !=0 FirstString is not identical to SecondString.

+

+**/

+INTN

+EFIAPI

+StrCmp (

+  IN      CONST CHAR16              *FirstString,

+  IN      CONST CHAR16              *SecondString

+  )

+{

+  //

+  // ASSERT both strings should never be zero

+  //

+  ASSERT (StrSize (FirstString) != 0);

+  ASSERT (StrSize (SecondString) != 0);

+

+  while ((*FirstString != L'\0') && (*FirstString == *SecondString)) {

+    FirstString++;

+    SecondString++;

+  }

+  return *FirstString - *SecondString;

+}

+

+/**

+  Compares two Null-terminated Unicode strings with maximum lengths, and

+  returns the difference between the first mismatched Unicode characters.

+

+  This function compares the Null-terminated Unicode string FirstString to the

+  Null-terminated Unicode string SecondString. At most, Length Unicode

+  characters will be compared. If Length is 0, then 0 is returned. If

+  FirstString is identical to SecondString, then 0 is returned. Otherwise, the

+  value returned is the first mismatched Unicode character in SecondString

+  subtracted from the first mismatched Unicode character in FirstString.

+

+  If FirstString is NULL, then ASSERT().

+  If SecondString is NULL, then ASSERT().

+

+  @param  FirstString   Pointer to a Null-terminated Unicode string.

+  @param  SecondString  Pointer to a Null-terminated Unicode string.

+  @param  Length        Maximum number of Unicode characters to compare.

+

+  @retval 0   FirstString is identical to SecondString.

+  @retval !=0 FirstString is not identical to SecondString.

+

+**/

+INTN

+EFIAPI

+StrnCmp (

+  IN      CONST CHAR16              *FirstString,

+  IN      CONST CHAR16              *SecondString,

+  IN      UINTN                     Length

+  )

+{

+  if (Length == 0) {

+    return 0;

+  }

+

+  //

+  // ASSERT both strings should never be zero

+  //

+  ASSERT (StrSize (FirstString) != 0);

+  ASSERT (StrSize (SecondString) != 0);

+

+  while ((*FirstString != L'\0') &&

+         (*FirstString == *SecondString) &&

+         (Length > 1)) {

+    FirstString++;

+    SecondString++;

+    Length--;

+  }

+

+  return *FirstString - *SecondString;

+}

+

+/**

+  Concatenates one Null-terminated Unicode string to another Null-terminated

+  Unicode string, and returns the concatenated Unicode string.

+

+  This function concatenates two Null-terminated Unicode strings. The contents

+  of Null-terminated Unicode string Source are concatenated to the end of

+  Null-terminated Unicode string Destination. The Null-terminated concatenated

+  Unicode String is returned. If Source and Destination overlap, then the

+  results are undefined.

+

+  If Destination is NULL, then ASSERT().

+  If Source is NULL, then ASSERT().

+  If Source and Destination overlap, then ASSERT().

+

+  @param  Destination Pointer to a Null-terminated Unicode string.

+  @param  Source      Pointer to a Null-terminated Unicode string.

+

+  @return Destination

+

+**/

+CHAR16 *

+EFIAPI

+StrCat (

+  IN OUT  CHAR16                    *Destination,

+  IN      CONST CHAR16              *Source

+  )

+{

+  StrCpy (Destination + StrLen (Destination), Source);

+

+  //

+  // Size of the resulting string should never be zero.

+  //

+  ASSERT (StrSize (Destination) != 0);

+  return Destination;

+}

+

+/**

+  Concatenates one Null-terminated Unicode string with a maximum length to the

+  end of another Null-terminated Unicode string, and returns the concatenated

+  Unicode string.

+

+  This function concatenates two Null-terminated Unicode strings. The contents

+  of Null-terminated Unicode string Source are concatenated to the end of

+  Null-terminated Unicode string Destination, and Destination is returned. At

+  most, Length Unicode characters are concatenated from Source to the end of

+  Destination, and Destination is always Null-terminated. If Length is 0, then

+  Destination is returned unmodified. If Source and Destination overlap, then

+  the results are undefined.

+

+  If Destination is NULL, then ASSERT().

+  If Source is NULL, then ASSERT().

+  If Source and Destination overlap, then ASSERT().

+

+  @param  Destination Pointer to a Null-terminated Unicode string.

+  @param  Source      Pointer to a Null-terminated Unicode string.

+  @param  Length      Maximum number of Unicode characters to concatenate from

+                      Source.

+

+  @return Destination

+

+**/

+CHAR16 *

+EFIAPI

+StrnCat (

+  IN OUT  CHAR16                    *Destination,

+  IN      CONST CHAR16              *Source,

+  IN      UINTN                     Length

+  )

+{

+  StrnCpy (Destination + StrLen (Destination), Source, Length);

+

+  //

+  // Size of the resulting string should never be zero.

+  //

+  ASSERT (StrSize (Destination) != 0);

+  return Destination;

+}

+

+/**

+  Copies one Null-terminated ASCII string to another Null-terminated ASCII

+  string and returns the new ASCII string.

+

+  This function copies the contents of the ASCII string Source to the ASCII

+  string Destination, and returns Destination. If Source and Destination

+  overlap, then the results are undefined.

+

+  If Destination is NULL, then ASSERT().

+  If Source is NULL, then ASSERT().

+  If Source and Destination overlap, then ASSERT().

+

+  @param  Destination Pointer to a Null-terminated ASCII string.

+  @param  Source      Pointer to a Null-terminated ASCII string.

+

+  @return Destination

+

+**/

+CHAR8 *

+EFIAPI

+AsciiStrCpy (

+  OUT     CHAR8                     *Destination,

+  IN      CONST CHAR8               *Source

+  )

+{

+  CHAR8                             *ReturnValue;

+

+  //

+  // Destination cannot be NULL

+  //

+  ASSERT (Destination != NULL);

+

+  //

+  // Destination and source cannot overlap

+  //

+  ASSERT ((UINTN)(Destination - Source) > AsciiStrLen (Source));

+  ASSERT ((UINTN)(Source - Destination) > AsciiStrLen (Source));

+

+  ReturnValue = Destination;

+  while (*Source) {

+    *(Destination++) = *(Source++);

+  }

+  *Destination = 0;

+  return ReturnValue;

+}

+

+/**

+  Copies one Null-terminated ASCII string with a maximum length to another

+  Null-terminated ASCII string with a maximum length and returns the new ASCII

+  string.

+

+  This function copies the contents of the ASCII string Source to the ASCII

+  string Destination, and returns Destination. At most, Length ASCII characters

+  are copied from Source to Destination. If Length is 0, then Destination is

+  returned unmodified. If Length is greater that the number of ASCII characters

+  in Source, then Destination is padded with Null ASCII characters. If Source

+  and Destination overlap, then the results are undefined.

+

+  If Destination is NULL, then ASSERT().

+  If Source is NULL, then ASSERT().

+  If Source and Destination overlap, then ASSERT().

+

+  @param  Destination Pointer to a Null-terminated ASCII string.

+  @param  Source      Pointer to a Null-terminated ASCII string.

+  @param  Length      Maximum number of ASCII characters to copy.

+

+  @return Destination

+

+**/

+CHAR8 *

+EFIAPI

+AsciiStrnCpy (

+  OUT     CHAR8                     *Destination,

+  IN      CONST CHAR8               *Source,

+  IN      UINTN                     Length

+  )

+{

+  CHAR8                             *ReturnValue;

+

+  if (Length == 0) {

+    return Destination;

+  }

+

+  //

+  // Destination cannot be NULL

+  //

+  ASSERT (Destination != NULL);

+

+  //

+  // Destination and source cannot overlap

+  //

+  ASSERT ((UINTN)(Destination - Source) > AsciiStrLen (Source));

+  ASSERT ((UINTN)(Source - Destination) >= Length);

+

+  ReturnValue = Destination;

+

+  while (*Source && Length > 0) {

+    *(Destination++) = *(Source++);

+    Length--;

+  }

+

+  // ZeroMem (Destination, Length * sizeof (*Destination));

+  memset (Destination, 0, Length * sizeof (*Destination));

+  return ReturnValue;

+}

+

+/**

+  Returns the size of a Null-terminated ASCII string in bytes, including the

+  Null terminator.

+

+  This function returns the size, in bytes, of the Null-terminated ASCII string

+  specified by String.

+

+  If String is NULL, then ASSERT().

+

+  @param  String  Pointer to a Null-terminated ASCII string.

+

+  @return The size of String.

+

+**/

+UINTN

+EFIAPI

+AsciiStrSize (

+  IN      CONST CHAR8               *String

+  )

+{

+  return (AsciiStrLen (String) + 1) * sizeof (*String);

+}

+

+/**

+  Compares two Null-terminated ASCII strings, and returns the difference

+  between the first mismatched ASCII characters.

+

+  This function compares the Null-terminated ASCII string FirstString to the

+  Null-terminated ASCII string SecondString. If FirstString is identical to

+  SecondString, then 0 is returned. Otherwise, the value returned is the first

+  mismatched ASCII character in SecondString subtracted from the first

+  mismatched ASCII character in FirstString.

+

+  If FirstString is NULL, then ASSERT().

+  If SecondString is NULL, then ASSERT().

+

+  @param  FirstString   Pointer to a Null-terminated ASCII string.

+  @param  SecondString  Pointer to a Null-terminated ASCII string.

+

+  @retval 0   FirstString is identical to SecondString.

+  @retval !=0 FirstString is not identical to SecondString.

+

+**/

+INTN

+EFIAPI

+AsciiStrCmp (

+  IN      CONST CHAR8               *FirstString,

+  IN      CONST CHAR8               *SecondString

+  )

+{

+  //

+  // ASSERT both strings should never be zero

+  //

+  ASSERT (AsciiStrSize (FirstString));

+  ASSERT (AsciiStrSize (SecondString));

+

+  while ((*FirstString != '\0') && (*FirstString == *SecondString)) {

+    FirstString++;

+    SecondString++;

+  }

+

+  return *FirstString - *SecondString;

+}

+

+STATIC

+CHAR8

+EFIAPI

+AsciiToUpper (

+  IN      CHAR8                     Chr

+  )

+{

+  return (Chr >= 'a' && Chr <= 'z') ? Chr - ('a' - 'A') : Chr;

+}

+

+/**

+  Performs a case insensitive comparison of two Null-terminated ASCII strings,

+  and returns the difference between the first mismatched ASCII characters.

+

+  This function performs a case insensitive comparison of the Null-terminated

+  ASCII string FirstString to the Null-terminated ASCII string SecondString. If

+  FirstString is identical to SecondString, then 0 is returned. Otherwise, the

+  value returned is the first mismatched lower case ASCII character in

+  SecondString subtracted from the first mismatched lower case ASCII character

+  in FirstString.

+

+  If FirstString is NULL, then ASSERT().

+  If SecondString is NULL, then ASSERT().

+

+  @param  FirstString   Pointer to a Null-terminated ASCII string.

+  @param  SecondString  Pointer to a Null-terminated ASCII string.

+

+  @retval 0   FirstString is identical to SecondString using case insensitive

+              comparisons.

+  @retval !=0 FirstString is not identical to SecondString using case

+              insensitive comparisons.

+

+**/

+INTN

+EFIAPI

+AsciiStriCmp (

+  IN      CONST CHAR8               *FirstString,

+  IN      CONST CHAR8               *SecondString

+  )

+{

+  //

+  // ASSERT both strings should never be zero

+  //

+  ASSERT (AsciiStrSize (FirstString));

+  ASSERT (AsciiStrSize (SecondString));

+

+  while ((*FirstString != '\0') &&

+         (AsciiToUpper (*FirstString) == AsciiToUpper (*SecondString))) {

+    FirstString++;

+    SecondString++;

+  }

+

+  return AsciiToUpper (*FirstString) - AsciiToUpper (*SecondString);

+}

+

+/**

+  Compares two Null-terminated ASCII strings with maximum lengths, and returns

+  the difference between the first mismatched ASCII characters.

+

+  This function compares the Null-terminated ASCII string FirstString to the

+  Null-terminated ASCII  string SecondString. At most, Length ASCII characters

+  will be compared. If Length is 0, then 0 is returned. If FirstString is

+  identical to SecondString, then 0 is returned. Otherwise, the value returned

+  is the first mismatched ASCII character in SecondString subtracted from the

+  first mismatched ASCII character in FirstString.

+

+  If FirstString is NULL, then ASSERT().

+  If SecondString is NULL, then ASSERT().

+

+  @param  FirstString   Pointer to a Null-terminated ASCII string.

+  @param  SecondString  Pointer to a Null-terminated ASCII string.

+

+  @retval 0   FirstString is identical to SecondString.

+  @retval !=0 FirstString is not identical to SecondString.

+

+**/

+INTN

+EFIAPI

+AsciiStrnCmp (

+  IN      CONST CHAR8               *FirstString,

+  IN      CONST CHAR8               *SecondString,

+  IN      UINTN                     Length

+  )

+{

+  //

+  // ASSERT both strings should never be zero

+  //

+  ASSERT (AsciiStrSize (FirstString));

+  ASSERT (AsciiStrSize (SecondString));

+

+  while ((*FirstString != '\0') &&

+         (*FirstString == *SecondString) &&

+         (Length > 1)) {

+    FirstString++;

+    SecondString++;

+    Length--;

+  }

+  return *FirstString - *SecondString;

+}

+

+/**

+  Concatenates one Null-terminated ASCII string to another Null-terminated

+  ASCII string, and returns the concatenated ASCII string.

+

+  This function concatenates two Null-terminated ASCII strings. The contents of

+  Null-terminated ASCII string Source are concatenated to the end of Null-

+  terminated ASCII string Destination. The Null-terminated concatenated ASCII

+  String is returned.

+

+  If Destination is NULL, then ASSERT().

+  If Source is NULL, then ASSERT().

+

+  @param  Destination Pointer to a Null-terminated ASCII string.

+  @param  Source      Pointer to a Null-terminated ASCII string.

+

+  @return Destination

+

+**/

+CHAR8 *

+EFIAPI

+AsciiStrCat (

+  IN OUT CHAR8    *Destination,

+  IN CONST CHAR8  *Source

+  )

+{

+  AsciiStrCpy (Destination + AsciiStrLen (Destination), Source);

+

+  //

+  // Size of the resulting string should never be zero.

+  //

+  ASSERT (AsciiStrSize (Destination) != 0);

+  return Destination;

+}

+

+/**

+  Concatenates one Null-terminated ASCII string with a maximum length to the

+  end of another Null-terminated ASCII string, and returns the concatenated

+  ASCII string.

+

+  This function concatenates two Null-terminated ASCII strings. The contents

+  of Null-terminated ASCII string Source are concatenated to the end of Null-

+  terminated ASCII string Destination, and Destination is returned. At most,

+  Length ASCII characters are concatenated from Source to the end of

+  Destination, and Destination is always Null-terminated. If Length is 0, then

+  Destination is returned unmodified. If Source and Destination overlap, then

+  the results are undefined.

+

+  If Destination is NULL, then ASSERT().

+  If Source is NULL, then ASSERT().

+  If Source and Destination overlap, then ASSERT().

+

+  @param  Destination Pointer to a Null-terminated ASCII string.

+  @param  Source      Pointer to a Null-terminated ASCII string.

+  @param  Length      Maximum number of ASCII characters to concatenate from

+                      Source.

+

+  @return Destination

+

+**/

+CHAR8 *

+EFIAPI

+AsciiStrnCat (

+  IN OUT  CHAR8                     *Destination,

+  IN      CONST CHAR8               *Source,

+  IN      UINTN                     Length

+  )

+{

+  AsciiStrnCpy (Destination + AsciiStrLen (Destination), Source, Length);

+

+  //

+  // Size of the resulting string should never be zero.

+  //

+  ASSERT (AsciiStrSize (Destination) != 0);

+  return Destination;

+}

diff --git a/Tools/CCode/Source/String/build.xml b/Tools/CCode/Source/String/build.xml
new file mode 100644
index 0000000..933cb5c
--- /dev/null
+++ b/Tools/CCode/Source/String/build.xml
@@ -0,0 +1,96 @@
+<?xml version="1.0" ?>

+<!--

+Copyright (c) 2006, Intel Corporation

+All rights reserved. This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+-->

+<project default="GenTool" basedir=".">

+<!--

+    EDK String

+  Copyright (c) 2006, Intel Corporation

+-->

+  <taskdef resource="cpptasks.tasks"/>

+  <typedef resource="cpptasks.types"/>

+  <taskdef resource="net/sf/antcontrib/antlib.xml"/>

+

+  <property name="LibName" value="String"/>

+  <property name="LINK_OUTPUT_TYPE" value="static"/>

+  <property name="BUILD_DIR" value="${PACKAGE_DIR}/${LibName}/tmp"/>

+

+  <target name="GenTool" depends="init, String">

+    <echo message="The EDK Library: ${LibName} build has completed!"/>

+  </target>

+

+  <target name="init">

+    <echo message="Building the EDK Library: ${LibName}"/>

+    <mkdir dir="${BUILD_DIR}"/>

+

+    <condition property="syslibdirs" value="">

+      <os family="mac"/>

+    </condition>

+    

+    <condition property="syslibs" value="">

+      <os family="mac"/>

+    </condition>

+    

+    <condition property="syslibdirs" value="${env.CYGWIN_HOME}/lib/e2fsprogs">

+      <os family="windows"/>

+    </condition>

+    

+    <condition property="syslibs" value="uuid">

+      <os family="windows"/>

+    </condition>

+    

+    <condition property="syslibdirs" value="/usr/lib">

+      <os name="Linux"/>

+    </condition>

+    

+    <condition property="syslibs" value="uuid">

+      <os name="Linux"/>

+    </condition>

+    

+  </target>

+

+  <target name="String" depends="init">

+    <cc name="${ToolChain}" objdir="${BUILD_DIR}" 

+        outfile="${LIB_DIR}/${LibName}"

+        outtype="static"

+        debug="true"

+        optimize="speed">

+      <compilerarg value="${ExtraArgus}" if="ExtraArgus" />

+      <compilerarg value="-fshort-wchar" if="gcc"/>

+

+      <fileset dir="${basedir}/${LibName}" 

+        includes="*.c" />

+

+      <includepath path="${PACKAGE_DIR}/${LibName}"/>

+      <includepath path="${PACKAGE_DIR}/Include"/>

+      <includepath path="${PACKAGE_DIR}/Include/${HostArch}"/>

+      <includepath path="${PACKAGE_DIR}/Common"/>

+    </cc>

+  </target>

+

+

+  <target name="clean">

+    <echo message="Removing Intermediate Files Only"/>  

+    <delete>

+      <fileset dir="${BUILD_DIR}" includes="*.obj"/>

+    </delete>

+  </target>

+

+  <target name="cleanall">

+    <echo message="Removing Object Files and the Library: ${LibName}${ext_static}"/>  

+    <delete dir="${PACKAGE_DIR}/${LibName}/tmp">

+    </delete>

+    <delete failonerror="false" quiet="true" includeEmptyDirs="true">

+      <fileset dir="${BUILD_DIR}"/>

+      <fileset file="${LIB_DIR}/${LibName}${ext_static}"/>

+    </delete>

+  </target>

+

+</project>