//++
//
//  Copyright (c) Microsoft Corporation
//
//  Module Name:
//
//    blstring.cpp
//
//  Abstract:
//
//    This module implements string functions for the boot loader environment.
//
//--

#include "bl.h"

#define ABS(X)                          (((X) < 0) ? (-(X)) : (X))

#define STRING_TOKEN_LONG               1
#define STRING_TOKEN_ULONG              2
#define STRING_TOKEN_ULONG_HEX          3
#define STRING_TOKEN_LONGLONG           4
#define STRING_TOKEN_ULONGLONG          5
#define STRING_TOKEN_ULONGLONG_HEX      6
#define STRING_TOKEN_PVOID              7
#define STRING_TOKEN_PCHAR              8
#define STRING_TOKEN_CHAR               9

CHAR
BlRtlConvertCharacterToUpperCase(
    CHAR C
    )

//++
//
//  Routine Description:
//
//    This function converts the specified character to upper case.
//
//  Arguments:
//
//    C   - Supplies the character to convert.
//
//  Return Value:
//
//    Upper case character matching the specified character.
//
//--

{
    if ((C >= 'a') && (C <= 'z')) {

        return C + 'A' - 'a';
    }

    return C;
}

BOOLEAN
BlRtlParsePositiveDecimal(
    PCSTR String,
    PUINT32 Number,
    PUINT32 CharactersConsumed
    )

//++
//
//  Routine Description:
//
//    This function parses a positive decimal value.
//
//  Arguments:
//
//    String              - Supplies a pointer to the string to parse.
//
//    Number              - Receives the number.
//
//    CharactersConsumed  - Receives the number of characters consumed.
//
//
//  Return Value:
//
//    TRUE, if parse was successful.
//    FALSE, otherwise.
//
//--

{
    UINT32 Digit;
    UINT32 Index;
    UINT32 Temp;

    if ((String[0] < '0') || (String[0] > '9')) {

        return FALSE;
    }

    Index = 0;
    Temp = 0;

    for (;;) {

        if ((String[Index] < '0') || (String[Index] > '9')) {

            *Number = Temp;
            *CharactersConsumed = Index;
            return TRUE;
        }

        Digit = String[Index] - '0';

        if (((Temp * 10) + Digit) < Temp) {

            return FALSE;
        }

        Temp = (Temp * 10) + Digit;
        Index += 1;
    }
}

BOOLEAN
BlRtlParseTypeSpecifier(
    PCSTR String,
    PINT32 Width,
    PCHAR PadCharacter,
    PUINT8 TokenType,
    PUINT32 CharactersConsumed
    )

//++
//
//  Routine Description:
//
//    This function parses a type specifier.
//
//  Arguments:
//
//    String              - Supplies a pointer to the string to parse.
//
//    Width               - Receives the width.
//
//    PadCharacter        - Receives the pad character.
//
//    TokenType           - Receives the token type.
//
//    CharactersConsumed  - Receives the number of characters consumed.
//
//
//  Return Value:
//
//    TRUE, if parse was successful.
//    FALSE, otherwise.
//
//--

{
    UINT32 Advance;
    BOOLEAN WidthPresent;
    UINT32 Index;
    BOOLEAN Minus;
    UINT32 WidthPositiveValue;
    BOOLEAN Zero;

    SATISFY_OVERZEALOUS_COMPILER(WidthPositiveValue = 0);

    //
    // Check if type specifier character is present.
    //

    if (String[0] != '%') {

        return FALSE;
    }

    Index = 1;

    //
    // Check for pad modifiers.
    //

    Minus = FALSE;
    Zero = FALSE;

    for (;;) {

        if (String[Index] == '-') {

            if (Minus != FALSE) {

                return FALSE;
            }

            Minus = TRUE;
            Index += 1;

        } else if (String[Index] == '0') {

            if (Zero != FALSE) {

                return FALSE;
            }

            Zero = TRUE;
            Index += 1;

        } else {

            break;
        }
    }

    //
    // - and 0 pad modifiers are mutually exclusive.
    //

    if ((Minus != FALSE) && (Zero != FALSE)) {

        return FALSE;
    }

    //
    // If there is a width value, then parse it.
    //

    WidthPresent = ((String[Index] >= '1') && (String[Index] <= '9'));

    if (WidthPresent != FALSE) {

        if (BlRtlParsePositiveDecimal(&String[Index],
                                      &WidthPositiveValue,
                                      &Advance) == FALSE) {

            return FALSE;
        }

        Index += Advance;
    }

    //
    // Pad modifiers require width value.
    //

    if (((Minus != FALSE) || (Zero != FALSE)) && (WidthPresent == FALSE)) {

        return FALSE;
    }

    //
    // Set pad character.
    //

    if (Zero != FALSE) {

        *PadCharacter = '0';

    } else {

        *PadCharacter = ' ';
    }

    //
    // Compute signed width value.
    //

    if (WidthPresent == FALSE) {

        *Width = 0;

    } else if (Minus == FALSE) {

        *Width = (INT32) WidthPositiveValue;

    } else {

        *Width = -((INT32) WidthPositiveValue);
    }

    //
    // Set type character.
    //

    if (BlRtlEqualStringN(&String[Index], "d", 1) != FALSE) {

        *TokenType = STRING_TOKEN_LONG;
        Index += 1;

    } else if (BlRtlEqualStringN(&String[Index], "u", 1) != FALSE) {

        *TokenType = STRING_TOKEN_ULONG;
        Index += 1;

    } else if (BlRtlEqualStringN(&String[Index], "x", 1) != FALSE) {

        *TokenType = STRING_TOKEN_ULONG_HEX;
        Index += 1;

    } else if (BlRtlEqualStringN(&String[Index], "I64d", 4) != FALSE) {

        *TokenType = STRING_TOKEN_LONGLONG;
        Index += 4;

    } else if (BlRtlEqualStringN(&String[Index], "I64u", 4) != FALSE) {

        *TokenType = STRING_TOKEN_ULONGLONG;
        Index += 4;

    } else if (BlRtlEqualStringN(&String[Index], "I64x", 4) != FALSE) {

        *TokenType = STRING_TOKEN_ULONGLONG_HEX;
        Index += 4;

    } else if (BlRtlEqualStringN(&String[Index], "p", 1) != FALSE) {

        *TokenType = STRING_TOKEN_PVOID;
        Index += 1;

    } else if (BlRtlEqualStringN(&String[Index], "s", 1) != FALSE) {

        *TokenType = STRING_TOKEN_PCHAR;
        Index += 1;

    } else if (BlRtlEqualStringN(&String[Index], "c", 1) != FALSE) {

        *TokenType = STRING_TOKEN_CHAR;
        Index += 1;

    } else {

        return FALSE;
    }

    //
    // Set number of characters consumed.
    //

    *CharactersConsumed = Index;

    return TRUE;
}

BOOLEAN
BlRtlFormatSignedDecimalLong(
    PCHAR Output,
    UINT32 OutputSize,
    INT32 Value,
    INT32 Width,
    PUINT32 CharactersConsumed
    )

//++
//
//  Routine Description:
//
//    This function formats a signed decimal long.
//
//  Arguments:
//
//    Output              - Supplies a pointer to the output buffer.
//
//    OutputSize          - Supplies the size of the output buffer.
//
//    Value               - Supplies the value to format.
//
//    Width               - Supplies the width.
//
//    CharactersConsumed  - Receives the number of characters consumed.
//
//
//  Return Value:
//
//    TRUE, if format was successful.
//    FALSE, otherwise.
//
//--

{
    UINT32 Index;
    UINT32 MinimumWidth;
    BOOLEAN Minus;
    UINT32 NumberWidth;
    UINT32 PadWidth;
    UINT32 Temp;

    //
    // Check if this is a negative value.
    //

    Minus = (BOOLEAN) (Value < 0);

    //
    // Compute the number of characters necessary.
    //

    Temp = ABS(Value);
    NumberWidth = 0;

    do {

        NumberWidth += 1;
        Temp = Temp / 10;

    } while (Temp > 0);

    if (Minus != FALSE) {

        NumberWidth += 1;
    }

    PadWidth = 0;
    MinimumWidth = ABS(Width);

    if (MinimumWidth > NumberWidth) {

        PadWidth = MinimumWidth - NumberWidth;
    }

    //
    // Check if there is sufficient space in the output buffer.
    //

    if ((NumberWidth + PadWidth) > OutputSize) {

        return FALSE;
    }

    Index = 0;

    //
    // If right alignment is specified, then insert any necessary pads before the number.
    //

    if (Width > 0) {

        while (PadWidth > 0) {

            Output[Index] = ' ';
            Index += 1;
            PadWidth -= 1;
        }
    }

    //
    // Insert absolute number starting with the least significant digit, going right to left.
    //

    Temp = ABS(Value);
    Index += NumberWidth;

    do {

        Index -= 1;
        Output[Index] = (CHAR) ('0' + (Temp % 10));
        Temp = Temp / 10;

    } while (Temp > 0);

    //
    // If the number is negative, then insert the negative sign.
    //

    if (Minus != FALSE) {

        Index -= 1;
        Output[Index] = '-';
    }

    //
    // If left alignment was specified, then insert any necessary pads after the number.
    //

    Index += NumberWidth;

    while (PadWidth > 0) {

        Output[Index] = ' ';
        Index += 1;
        PadWidth -= 1;
    }

    //
    // Set number of characters consumed in the buffer.
    //

    *CharactersConsumed = Index;

    return TRUE;
}

BOOLEAN
BlRtlFormatUnsignedLong(
    PCHAR Output,
    UINT32 OutputSize,
    UINT32 Value,
    UINT8 PadCharacter,
    INT32 Width,
    UINT32 Base,
    PUINT32 CharactersConsumed
    )

//++
//
//  Routine Description:
//
//    This function formats an unsigned long.
//
//  Arguments:
//
//    Output              - Supplies a pointer to the output buffer.
//
//    OutputSize          - Supplies the size of the output buffer.
//
//    Value               - Supplies the value to format.
//
//    PadCharacter        - Supplies the pad character.
//
//    Width               - Supplies the width.
//
//    Base                - Supplies the base.
//
//    CharactersConsumed  - Receives the number of characters consumed.
//
//
//  Return Value:
//
//    TRUE, if format was successful.
//    FALSE, otherwise.
//
//--

{
    UINT32 Index;
    UINT32 MinimumWidth;
    UINT32 NumberWidth;
    UINT32 PadWidth;
    UINT32 Temp;

    if (Base == 0) {

        return FALSE;
    }

    //
    // Compute the number of characters necessary.
    //

    Temp = Value;
    NumberWidth = 0;

    do {

        NumberWidth += 1;
        Temp = Temp / Base;

    } while (Temp > 0);

    PadWidth = 0;
    MinimumWidth = ABS(Width);

    if (MinimumWidth > NumberWidth) {

        PadWidth = MinimumWidth - NumberWidth;
    }

    //
    // Check if there is sufficient space in the output buffer.
    //

    if ((NumberWidth + PadWidth) > OutputSize) {

        return FALSE;
    }

    Index = 0;

    //
    // If right alignment is specified, then insert any necessary pads before the number.
    //

    if (Width > 0) {

        while (PadWidth > 0) {

            Output[Index] = PadCharacter;
            Index += 1;
            PadWidth -= 1;
        }
    }

    //
    // Insert absolute number starting with the least significant digit, going right to left.
    //

    Temp = Value;
    Index += NumberWidth;

    do {

        Index -= 1;

        switch (Base) {

            case 10: {

                Output[Index] = (CHAR) ('0' + (Temp % Base));
                break;
            }

            case 16: {

                if ((Temp % Base) < 10) {

                    Output[Index] = (CHAR) ('0' + (Temp % Base));

                } else {

                    Output[Index] = (CHAR) ('A' + (Temp % Base) - 10);
                }

                break;
            }

            default: {

                return FALSE;
            }
        }

        Temp = Temp / Base;

    } while (Temp > 0);

    //
    // If left alignment was specified, then insert any necessary pads after the number.
    //

    Index += NumberWidth;

    while (PadWidth > 0) {

        Output[Index] = PadCharacter;
        Index += 1;
        PadWidth -= 1;
    }

    //
    // Set number of characters consumed in the buffer.
    //

    *CharactersConsumed = Index;

    return TRUE;
}

BOOLEAN
BlRtlFormatUnsignedLongLong(
    PCHAR Output,
    UINT32 OutputSize,
    UINT64 Value,
    UINT8 PadCharacter,
    INT32 Width,
    UINT32 Base,
    PUINT32 CharactersConsumed
    )

//++
//
//  Routine Description:
//
//    This function formats an unsigned long long.
//
//  Arguments:
//
//    Output              - Supplies a pointer to the output buffer.
//
//    OutputSize          - Supplies the size of the output buffer.
//
//    Value               - Supplies the value to format.
//
//    PadCharacter        - Supplies the pad character.
//
//    Width               - Supplies the width.
//
//    Base                - Supplies the base.
//
//    CharactersConsumed  - Receives the number of characters consumed.
//
//
//  Return Value:
//
//    TRUE, if format was successful.
//    FALSE, otherwise.
//
//--

{
    UINT32 Index;
    UINT32 MinimumWidth;
    UINT32 NumberWidth;
    UINT32 PadWidth;
    UINT64 Temp;

    if (Base == 0) {

        return FALSE;
    }

    //
    // Compute the number of characters necessary.
    //

    Temp = Value;
    NumberWidth = 0;

    do {

        NumberWidth += 1;
        Temp = Temp / Base;

    } while (Temp > 0);

    PadWidth = 0;
    MinimumWidth = ABS(Width);

    if (MinimumWidth > NumberWidth) {

        PadWidth = MinimumWidth - NumberWidth;
    }

    //
    // Check if there is sufficient space in the output buffer.
    //

    if ((NumberWidth + PadWidth) > OutputSize) {

        return FALSE;
    }

    Index = 0;

    //
    // If right alignment is specified, then insert any necessary pads before the number.
    //

    if (Width > 0) {

        while (PadWidth > 0) {

            Output[Index] = PadCharacter;
            Index += 1;
            PadWidth -= 1;
        }
    }

    //
    // Insert absolute number starting with the least significant digit, going right to left.
    //

    Temp = Value;
    Index += NumberWidth;

    do {

        Index -= 1;

        switch (Base) {

            case 10: {

                Output[Index] = (CHAR) ('0' + (Temp % Base));
                break;
            }

            case 16: {

                if ((Temp % Base) < 10) {

                    Output[Index] = (CHAR) ('0' + (Temp % Base));

                } else {

                    Output[Index] = (CHAR) ('A' + (Temp % Base) - 10);
                }

                break;
            }

            default: {

                return FALSE;
            }
        }

        Temp = Temp / Base;

    } while (Temp > 0);

    //
    // If left alignment was specified, then insert any necessary pads after the number.
    //

    Index += NumberWidth;

    while (PadWidth > 0) {

        Output[Index] = PadCharacter;
        Index += 1;
        PadWidth -= 1;
    }

    //
    // Set number of characters consumed in the buffer.
    //

    *CharactersConsumed = Index;

    return TRUE;
}

UINT32
BlRtlStringLength(
    PCSTR String
    )

//++
//
//  Routine Description:
//
//    This function returns the length of the specified string.
//
//  Arguments:
//
//    String  - Supplies a pointer to the string.
//
//  Return Value:
//
//    Length of the string.
//
//--

{
    UINT32 Index;

    Index = 0;

    while (String[Index] != 0) {

        Index += 1;
    }

    return Index;
}

UINT32
BlRtlStringLengthW(
    PCWSTR String
    )

//++
//
//  Routine Description:
//
//    This function returns the length of the specified wide string.
//
//  Arguments:
//
//    String  - Supplies a pointer to the string.
//
//  Return Value:
//
//    Length of the string.
//
//--

{
    UINT32 Index;

    Index = 0;

    while (String[Index] != 0) {

        Index += 1;
    }

    return Index;
}

BOOLEAN
BlRtlFormatStringToken(
    PCHAR Output,
    UINT32 OutputSize,
    PCSTR String,
    INT32 Width,
    PUINT32 CharactersConsumed
    )

//++
//
//  Routine Description:
//
//    This function formats a string token.
//
//  Arguments:
//
//    Output              - Supplies a pointer to the output buffer.
//
//    OutputSize          - Supplies the size of the output buffer.
//
//    String              - Supplies the string token.
//
//    Width               - Supplies the width.
//
//    CharactersConsumed  - Receives the number of characters consumed.
//
//
//  Return Value:
//
//    TRUE, if format was successful.
//    FALSE, otherwise.
//
//--

{
    UINT32 Index;
    UINT32 MinimumWidth;
    UINT32 PadWidth;
    UINT32 StringIndex;
    UINT32 StringLength;

    //
    // Compute string length, minimum width, and pad width.
    //

    StringLength = BlRtlStringLength(String);

    MinimumWidth = ABS(Width);

    PadWidth = 0;

    if (MinimumWidth > StringLength) {

        PadWidth = MinimumWidth - StringLength;
    }

    //
    // Check if there is sufficient space in the output buffer.
    //

    if ((StringLength + PadWidth) > OutputSize) {

        return FALSE;
    }

    Index = 0;

    //
    // If right alignment is specified, then insert any necessary pads before the string.
    //

    if (Width > 0) {

        while (PadWidth > 0) {

            Output[Index] = ' ';
            Index += 1;
            PadWidth -= 1;
        }
    }

    //
    // Copy the string.
    //

    for (StringIndex = 0; StringIndex < StringLength; StringIndex += 1) {

        Output[Index] = String[StringIndex];
        Index += 1;
    }

    //
    // If left alignment was specified, then insert any necessary pads after the string.
    //

    while (PadWidth > 0) {

        Output[Index] = ' ';
        Index += 1;
        PadWidth -= 1;
    }

    //
    // Set number of characters consumed in the buffer.
    //

    *CharactersConsumed = Index;

    return TRUE;
}

BOOLEAN
BlRtlFormatChar(
    PCHAR Output,
    UINT32 OutputSize,
    CHAR Value,
    PUINT32 CharactersConsumed
    )

//++
//
//  Routine Description:
//
//    This function formats a character.
//
//  Arguments:
//
//    Output              - Supplies a pointer to the output buffer.
//
//    OutputSize          - Supplies the size of the output buffer.
//
//    Value               - Supplies the value to format.
//
//    CharactersConsumed  - Receives the number of characters consumed.
//
//
//  Return Value:
//
//    TRUE, if format was successful.
//    FALSE, otherwise.
//
//--

{
    //
    // Check if there is sufficient space in the output buffer.
    //

    if (1 > OutputSize) {

        return FALSE;
    }

    Output[0] = Value;

    //
    // Set number of characters consumed in the buffer.
    //

    *CharactersConsumed = 1;

    return TRUE;
}

BOOLEAN
BlRtlFormatString(
    PCHAR Output,
    UINT32 OutputSize,
    PCSTR Format,
    va_list ArgumentList
    )

//++
//
//  Routine Description:
//
//    This function formats a string.
//
//  Arguments:
//
//    Output          - Supplies a pointer to the output buffer.
//
//    OutputSize      - Supplies the size of the output buffer.
//
//    Format          - Supplies the format string.
//
//    ArgumentList    - Supplies the input parameters.
//
//  Return Value:
//
//    TRUE, if format was successful.
//    FALSE, otherwise.
//
//--

{
    UINT32 CharactersConsumed;
    UINT32 InputIndex;
    UINT32 OutputIndex;
    CHAR PadCharacter;
    UINT8 TokenType;
    INT32 Width;

    InputIndex = 0;
    OutputIndex = 0;

    for (;;) {

        if (OutputIndex == OutputSize) {

            return FALSE;
        }

        if (Format[InputIndex] == 0) {

            Output[OutputIndex] = 0;
            return TRUE;
        }

        if (Format[InputIndex] == '\\') {

            switch (Format[InputIndex + 1]) {

                case '\\': {

                    Output[OutputIndex] = '\\';
                    OutputIndex += 1;
                    break;
                }

                case 'r': {

                    Output[OutputIndex] = '\r';
                    OutputIndex += 1;
                    break;
                }

                case 'n': {

                    Output[OutputIndex] = '\r';
                    OutputIndex += 1;
                    break;
                }

                default: {

                    return FALSE;
                }
            }

            InputIndex += 2;
            continue;
        }

        if (BlRtlParseTypeSpecifier(&Format[InputIndex],
                                    &Width,
                                    &PadCharacter,
                                    &TokenType,
                                    &CharactersConsumed) != FALSE) {

            InputIndex += CharactersConsumed;

            switch (TokenType) {

                case STRING_TOKEN_LONG: {

                    if (BlRtlFormatSignedDecimalLong(&Output[OutputIndex],
                                                     OutputSize - OutputIndex,
                                                     va_arg(ArgumentList, INT32),
                                                     Width,
                                                     &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

                    OutputIndex += CharactersConsumed;
                    break;
                }

                case STRING_TOKEN_ULONG: {

                    if (BlRtlFormatUnsignedLong(&Output[OutputIndex],
                                                OutputSize - OutputIndex,
                                                va_arg(ArgumentList, UINT32),
                                                PadCharacter,
                                                Width,
                                                10,
                                                &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

                    OutputIndex += CharactersConsumed;
                    break;
                }

                case STRING_TOKEN_ULONG_HEX: {

                    if (BlRtlFormatUnsignedLong(&Output[OutputIndex],
                                                OutputSize - OutputIndex,
                                                va_arg(ArgumentList, UINT32),
                                                PadCharacter,
                                                Width,
                                                16,
                                                &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

                    OutputIndex += CharactersConsumed;
                    break;
                }

                case STRING_TOKEN_ULONGLONG: {

                    if (BlRtlFormatUnsignedLongLong(&Output[OutputIndex],
                                                    OutputSize - OutputIndex,
                                                    va_arg(ArgumentList, UINT64),
                                                    PadCharacter,
                                                    Width,
                                                    10,
                                                    &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

                    OutputIndex += CharactersConsumed;
                    break;
                }

                case STRING_TOKEN_ULONGLONG_HEX: {

                    if (BlRtlFormatUnsignedLongLong(&Output[OutputIndex],
                                                    OutputSize - OutputIndex,
                                                    va_arg(ArgumentList, UINT64),
                                                    PadCharacter,
                                                    Width,
                                                    16,
                                                    &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

                    OutputIndex += CharactersConsumed;
                    break;
                }

                case STRING_TOKEN_PVOID: {

#if defined(BOOT_X86)

                    if (BlRtlFormatUnsignedLong(&Output[OutputIndex],
                                                OutputSize - OutputIndex,
                                                va_arg(ArgumentList, UINT32),
                                                '0',
                                                8,
                                                16,
                                                &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

#elif defined(BOOT_X64)

                    if (BlRtlFormatUnsignedLongLong(&Output[OutputIndex],
                                                    OutputSize - OutputIndex,
                                                    va_arg(ArgumentList, UINT64),
                                                    '0',
                                                    16,
                                                    16,
                                                    &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

#endif

                    OutputIndex += CharactersConsumed;
                    break;
                }

                case STRING_TOKEN_PCHAR: {

                    if (BlRtlFormatStringToken(&Output[OutputIndex],
                                               OutputSize - OutputIndex,
                                               va_arg(ArgumentList, PCHAR),
                                               Width,
                                               &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

                    OutputIndex += CharactersConsumed;
                    break;
                }

                case STRING_TOKEN_CHAR: {

                    if (BlRtlFormatChar(&Output[OutputIndex],
                                        OutputSize - OutputIndex,
                                        va_arg(ArgumentList, CHAR),
                                        &CharactersConsumed) == FALSE) {

                        return FALSE;
                    }

                    OutputIndex += CharactersConsumed;
                    break;
                }
            }

            continue;
        }

        Output[OutputIndex] = Format[InputIndex];
        InputIndex += 1;
        OutputIndex += 1;
    }
}

BOOLEAN
BlRtlPrintf(
    PCSTR Format,
    ...
    )

//++
//
//  Routine Description:
//
//    This function implements C-style printf for the boot loader environment.
//
//  Arguments:
//
//    Format          - Supplies the format string.
//
//    ...             - Supplies the input parameters.
//
//  Return Value:
//
//    TRUE, if operation was successful.
//    FALSE, otherwise.
//
//--

{
    va_list ArgumentList;
    CHAR Buffer[4096];

    va_start(ArgumentList, Format);

    if (BlRtlFormatString(Buffer, sizeof(Buffer), Format, ArgumentList) == FALSE) {

        return FALSE;
    }

    BlVideoPrintString(Buffer);

    BlKdPrintString(Buffer);

    return TRUE;
}

BOOLEAN
BlRtlEqualStringN(
    PCSTR String1,
    PCSTR String2,
    UINT32 Count
    )

//++
//
//  Routine Description:
//
//    This function compares two strings.
//
//  Arguments:
//
//    String1 - Supplies a pointer to the first string.
//
//    String2 - Supplies a pointer to the second string.
//
//    Count   - Number of characters to compare.
//
//  Return Value:
//
//    TRUE, if strings are equal.
//    FALSE, otherwise.
//
//--

{
    while (Count > 0) {

        if ((*String1 == 0) || (*String2 == 0)) {

            return FALSE;
        }

        if (*String1 != *String2) {

            return FALSE;
        }

        String1 += 1;
        String2 += 1;
        Count -= 1;
    }

    return TRUE;
}

BOOLEAN
BlRtlEqualStringI(
    PCSTR String1,
    PCSTR String2
    )

//++
//
//  Routine Description:
//
//    This function compares two strings ignoring case differences.
//
//  Arguments:
//
//    String1 - Supplies a pointer to the first string.
//
//    String2 - Supplies a pointer to the second string.
//
//  Return Value:
//
//    TRUE, if strings are equal.
//    FALSE, otherwise.
//
//--

{
    for (;;) {

        if (BlRtlConvertCharacterToUpperCase(*String1) != BlRtlConvertCharacterToUpperCase(*String2)) {

            return FALSE;
        }

        if (*String1 == 0) {

            return TRUE;
        }

        String1 += 1;
        String2 += 1;
    }
}

PCSTR
BlRtlFindSubstring(
    PCSTR String,
    PCSTR Substring
    )

//++
//
//  Routine Description:
//
//    This function searches for a substring.
//
//  Arguments:
//
//    String      - Supplies a pointer to the string to search in.
//
//    Substring   - Supplies a pointer to the substring to search for.
//
//  Return Value:
//
//    A pointer to the first instance of the substring, if search was successful.
//    NULL, otherwise.
//
//--

{
    UINT32 SubstringLength;

    SubstringLength = BlRtlStringLength(Substring);

    while (*String != 0) {

        if (BlRtlEqualStringN(String, Substring, SubstringLength) != FALSE) {

            return String;
        }

        String += 1;
    }

    return NULL;
}