WebSVN – HelenOS – Diff – /tags/0.3.0/boot/arch/ia64/loader/gefi/lib/print.c


/*++
 
Copyright (c) 1998  Intel Corporation
 
Module Name:
 
    print.c
 
Abstract:
 
 
 
 
Revision History
 
--*/
 
#include "lib.h"
#include "efistdarg.h"                        // !!!
 
//
// Declare runtime functions
//
 
#ifdef RUNTIME_CODE
#pragma RUNTIME_CODE(DbgPrint)
 
// For debugging..
 
/*
#pragma RUNTIME_CODE(_Print)
#pragma RUNTIME_CODE(PFLUSH)
#pragma RUNTIME_CODE(PSETATTR)
#pragma RUNTIME_CODE(PPUTC)
#pragma RUNTIME_CODE(PGETC)
#pragma RUNTIME_CODE(PITEM)
#pragma RUNTIME_CODE(ValueToHex)
#pragma RUNTIME_CODE(ValueToString)
#pragma RUNTIME_CODE(TimeToString)
*/
 
#endif
 
//
//
//
 
 
#define PRINT_STRING_LEN            200
#define PRINT_ITEM_BUFFER_LEN       100
 
typedef struct {
    BOOLEAN             Ascii;
    UINTN               Index;
    union {
        CHAR16          *pw;
        CHAR8           *pc;
    } un;
} POINTER;
 
#define pw  un.pw
#define pc  un.pc
 
typedef struct _pitem {
 
    POINTER     Item;
    CHAR16      Scratch[PRINT_ITEM_BUFFER_LEN];
    UINTN       Width;
    UINTN       FieldWidth;
    UINTN       *WidthParse;
    CHAR16      Pad;
    BOOLEAN     PadBefore;
    BOOLEAN     Comma;
    BOOLEAN     Long;
} PRINT_ITEM;
 
 
typedef struct _pstate {
    // Input
    POINTER     fmt;
    va_list     args;
 
    // Output
    CHAR16      *Buffer;
    CHAR16      *End;
    CHAR16      *Pos;
    UINTN       Len;
 
    UINTN       Attr;    
    UINTN       RestoreAttr;
 
    UINTN       AttrNorm;
    UINTN       AttrHighlight;
    UINTN       AttrError;
 
    INTN        (*Output)(VOID *context, CHAR16 *str);
    INTN        (*SetAttr)(VOID *context, UINTN attr);
    VOID        *Context;    
 
    // Current item being formatted
    struct _pitem  *Item;
} PRINT_STATE;
 
//
// Internal fucntions
//
 
STATIC
UINTN
_Print (
    IN PRINT_STATE     *ps
    );
 
STATIC
UINTN
_IPrint (
    IN UINTN                            Column,
    IN UINTN                            Row,
    IN SIMPLE_TEXT_OUTPUT_INTERFACE     *Out,
    IN CHAR16                           *fmt,
    IN CHAR8                            *fmta,
    IN va_list                          args
    );
 
STATIC
INTN
_DbgOut (
    IN VOID     *Context,
    IN CHAR16   *Buffer
    );
 
STATIC
VOID
PFLUSH (
    IN OUT PRINT_STATE     *ps
    );
 
STATIC
VOID
PPUTC (
    IN OUT PRINT_STATE     *ps,
    IN CHAR16              c
    );
 
STATIC
VOID
PITEM (
    IN OUT PRINT_STATE  *ps
    );
 
STATIC
CHAR16
PGETC (
    IN POINTER      *p
    );
 
STATIC
VOID
PSETATTR (
    IN OUT PRINT_STATE  *ps,
    IN UINTN             Attr
    );
 
//
//
//
 
INTN
DbgPrint (
    IN INTN      mask,
    IN CHAR8     *fmt,
    ...
    )
/*++
 
Routine Description:
 
    Prints a formatted unicode string to the default StandardError console
 
Arguments:
 
    mask        - Bit mask of debug string.  If a bit is set in the
                  mask that is also set in EFIDebug the string is
                  printed; otherwise, the string is not printed
 
    fmt         - Format string
 
Returns:
 
    Length of string printed to the StandardError console
 
--*/
{
    SIMPLE_TEXT_OUTPUT_INTERFACE    *DbgOut;
    PRINT_STATE     ps;
    va_list         args;
    UINTN           back;
    UINTN           attr;
    UINTN           SavedAttribute;
 
 
    if (!(EFIDebug & mask)) {
        return 0;
    }
 
    va_start (args, fmt);
    ZeroMem (&ps, sizeof(ps));
 
    ps.Output = _DbgOut;
    ps.fmt.Ascii = TRUE;
    ps.fmt.pc = fmt;
    va_copy(ps.args, args);
    ps.Attr = EFI_TEXT_ATTR(EFI_LIGHTGRAY, EFI_RED);
 
    DbgOut = LibRuntimeDebugOut;
 
    if (!DbgOut) {
        DbgOut = ST->StdErr;
    }
 
    if (DbgOut) {
        ps.Attr = DbgOut->Mode->Attribute;
        ps.Context = DbgOut;
        ps.SetAttr = (INTN (*)(VOID *, UINTN))  DbgOut->SetAttribute;
    }
 
    SavedAttribute = ps.Attr;
 
    back = (ps.Attr >> 4) & 0xf;
    ps.AttrNorm = EFI_TEXT_ATTR(EFI_LIGHTGRAY, back);
    ps.AttrHighlight = EFI_TEXT_ATTR(EFI_WHITE, back);
    ps.AttrError = EFI_TEXT_ATTR(EFI_YELLOW, back);
 
    attr = ps.AttrNorm;
 
    if (mask & D_WARN) {
        attr = ps.AttrHighlight;
    }
 
    if (mask & D_ERROR) {
        attr = ps.AttrError;
    }
 
    if (ps.SetAttr) {
        ps.Attr = attr;
        ps.SetAttr (ps.Context, attr);
    }
 
    _Print (&ps);
 
    va_end (ps.args);
    va_end (args);
 
    //
    // Restore original attributes
    //
 
    if (ps.SetAttr) {
        ps.SetAttr (ps.Context, SavedAttribute);
    }
   
    return 0;
}
 
 
 
STATIC
INTN
_DbgOut (
    IN VOID     *Context,
    IN CHAR16   *Buffer
    )
// Append string worker for DbgPrint
{
    SIMPLE_TEXT_OUTPUT_INTERFACE    *DbgOut;
 
    DbgOut = Context;
//    if (!DbgOut && ST && ST->ConOut) {
//        DbgOut = ST->ConOut;
//    }
 
    if (DbgOut) {
        DbgOut->OutputString (DbgOut, Buffer);
    }
 
    return 0;
}
 
INTN
_SPrint (
    IN VOID     *Context,
    IN CHAR16   *Buffer
    )
// Append string worker for SPrint, PoolPrint and CatPrint
{
    UINTN           len;
    POOL_PRINT      *spc;
 
    spc = Context;
    len = StrLen(Buffer);
 
    //
    // Is the string is over the max truncate it
    //
 
    if (spc->len + len > spc->maxlen) {
        len = spc->maxlen - spc->len;
    }
 
    //
    // Append the new text
    //
 
    CopyMem (spc->str + spc->len, Buffer, len * sizeof(CHAR16));
    spc->len += len;
 
    //
    // Null terminate it
    //
 
    if (spc->len < spc->maxlen) {
        spc->str[spc->len] = 0;
    } else if (spc->maxlen) {
        spc->str[spc->maxlen-1] = 0;
    }
 
    return 0;
}
 
 
INTN
_PoolPrint (
    IN VOID     *Context,
    IN CHAR16   *Buffer
    )
// Append string worker for PoolPrint and CatPrint
{
    UINTN           newlen;
    POOL_PRINT      *spc;
 
    spc = Context;
    newlen = spc->len + StrLen(Buffer) + 1;
 
    //
    // Is the string is over the max, grow the buffer
    //
 
    if (newlen > spc->maxlen) {
 
        //
        // Grow the pool buffer
        //
 
        newlen += PRINT_STRING_LEN;
        spc->maxlen = newlen;
        spc->str = ReallocatePool (
                        spc->str,
                        spc->len * sizeof(CHAR16),
                        spc->maxlen * sizeof(CHAR16)
                        );
 
        if (!spc->str) {
            spc->len = 0;
            spc->maxlen = 0;
        }
    }
 
    //
    // Append the new text
    //
 
    return _SPrint (Context, Buffer);
}
 
 
 
VOID
_PoolCatPrint (
    IN CHAR16           *fmt,
    IN va_list          args,
    IN OUT POOL_PRINT   *spc,
    IN INTN             (*Output)(VOID *context, CHAR16 *str)
    )
// Dispath function for SPrint, PoolPrint, and CatPrint
{
    PRINT_STATE         ps;
 
    ZeroMem (&ps, sizeof(ps));
    ps.Output  = Output;
    ps.Context = spc;
    ps.fmt.pw = fmt;
    va_copy(ps.args, args);
    _Print (&ps);
    va_end(ps.args);
}
 
 
 
UINTN
SPrint (
    OUT CHAR16  *Str,
    IN UINTN    StrSize,
    IN CHAR16   *fmt,
    ...
    )
/*++
 
Routine Description:
 
    Prints a formatted unicode string to a buffer
 
Arguments:
 
    Str         - Output buffer to print the formatted string into
 
    StrSize     - Size of Str.  String is truncated to this size.
                  A size of 0 means there is no limit
 
    fmt         - The format string
 
Returns:
 
    String length returned in buffer
 
--*/
{
    POOL_PRINT          spc;
    va_list             args;
 
 
    va_start (args, fmt);
    spc.str    = Str;
    spc.maxlen = StrSize / sizeof(CHAR16) - 1;
    spc.len    = 0;
 
    _PoolCatPrint (fmt, args, &spc, _SPrint);
    va_end (args);
    return spc.len;
}
 
 
CHAR16 *
PoolPrint (
    IN CHAR16           *fmt,
    ...
    )
/*++
 
Routine Description:
 
    Prints a formatted unicode string to allocated pool.  The caller
    must free the resulting buffer.
 
Arguments:
 
    fmt         - The format string
 
Returns:
 
    Allocated buffer with the formatted string printed in it.  
    The caller must free the allocated buffer.   The buffer
    allocation is not packed.
 
--*/
{
    POOL_PRINT          spc;
    va_list             args;
 
    ZeroMem (&spc, sizeof(spc));
    va_start (args, fmt);
    _PoolCatPrint (fmt, args, &spc, _PoolPrint);
    va_end (args);
    return spc.str;
}
 
 
 
CHAR16 *
CatPrint (
    IN OUT POOL_PRINT   *Str,
    IN CHAR16           *fmt,
    ...
    )
/*++
 
Routine Description:
 
    Concatenates a formatted unicode string to allocated pool.  
    The caller must free the resulting buffer.
 
Arguments:
 
    Str         - Tracks the allocated pool, size in use, and
                  amount of pool allocated.
 
    fmt         - The format string
 
Returns:
 
    Allocated buffer with the formatted string printed in it.  
    The caller must free the allocated buffer.   The buffer
    allocation is not packed.
 
--*/
{
    va_list             args;
 
    va_start (args, fmt);
    _PoolCatPrint (fmt, args, Str, _PoolPrint);
    va_end (args);
    return Str->str;
}
 
 
 
UINTN
Print (
    IN CHAR16   *fmt,
    ...
    )
/*++
 
Routine Description:
 
    Prints a formatted unicode string to the default console
 
Arguments:
 
    fmt         - Format string
 
Returns:
 
    Length of string printed to the console
 
--*/
{
    va_list     args;
    UINTN       back;
 
    va_start (args, fmt);
    back = _IPrint ((UINTN) -1, (UINTN) -1, ST->ConOut, fmt, NULL, args);
    va_end (args);
    return back;
}
 
UINTN
VPrint (
    IN CHAR16   *fmt,
    va_list     args
    )
/*++
 
Routine Description:
 
    Prints a formatted unicode string to the default console using a va_list
 
Arguments:
 
    fmt         - Format string
    args        - va_list
Returns:
 
    Length of string printed to the console
 
--*/
{
    return _IPrint ((UINTN) -1, (UINTN) -1, ST->ConOut, fmt, NULL, args);
}
 
 
UINTN
PrintAt (
    IN UINTN     Column,
    IN UINTN     Row,
    IN CHAR16    *fmt,
    ...
    )
/*++
 
Routine Description:
 
    Prints a formatted unicode string to the default console, at
    the supplied cursor position
 
Arguments:
 
    Column, Row - The cursor position to print the string at
 
    fmt         - Format string
 
Returns:
 
    Length of string printed to the console
 
--*/
{
    va_list     args;
    UINTN       back;
 
    va_start (args, fmt);
    back = _IPrint (Column, Row, ST->ConOut, fmt, NULL, args);
    va_end (args);
    return back;
}
 
 
UINTN
IPrint (
    IN SIMPLE_TEXT_OUTPUT_INTERFACE    *Out,
    IN CHAR16                          *fmt,
    ...
    )
/*++
 
Routine Description:
 
    Prints a formatted unicode string to the specified console
 
Arguments:
 
    Out         - The console to print the string too
 
    fmt         - Format string
 
Returns:
 
    Length of string printed to the console
 
--*/
{
    va_list     args;
    UINTN       back;
 
    va_start (args, fmt);
    back = _IPrint ((UINTN) -1, (UINTN) -1, Out, fmt, NULL, args);
    va_end (args);
    return back;
}
 
 
UINTN
IPrintAt (
    IN SIMPLE_TEXT_OUTPUT_INTERFACE     *Out,
    IN UINTN                            Column,
    IN UINTN                            Row,
    IN CHAR16                           *fmt,
    ...
    )
/*++
 
Routine Description:
 
    Prints a formatted unicode string to the specified console, at
    the supplied cursor position
 
Arguments:
 
    Out         - The console to print the string too
 
    Column, Row - The cursor position to print the string at
 
    fmt         - Format string
 
Returns:
 
    Length of string printed to the console
 
--*/
{
    va_list     args;
    UINTN       back;
 
    va_start (args, fmt);
    back = _IPrint (Column, Row, ST->ConOut, fmt, NULL, args);
    va_end (args);
    return back;
}
 
 
UINTN
_IPrint (
    IN UINTN                            Column,
    IN UINTN                            Row,
    IN SIMPLE_TEXT_OUTPUT_INTERFACE     *Out,
    IN CHAR16                           *fmt,
    IN CHAR8                            *fmta,
    IN va_list                          args
    )
// Display string worker for: Print, PrintAt, IPrint, IPrintAt
{
    PRINT_STATE     ps;
    UINTN            back;
 
    ZeroMem (&ps, sizeof(ps));
    ps.Context = Out;
    ps.Output  = (INTN (*)(VOID *, CHAR16 *)) Out->OutputString;
    ps.SetAttr = (INTN (*)(VOID *, UINTN))  Out->SetAttribute;
    ps.Attr = Out->Mode->Attribute;
   
    back = (ps.Attr >> 4) & 0xF;
    ps.AttrNorm = EFI_TEXT_ATTR(EFI_LIGHTGRAY, back);
    ps.AttrHighlight = EFI_TEXT_ATTR(EFI_WHITE, back);
    ps.AttrError = EFI_TEXT_ATTR(EFI_YELLOW, back);
 
    if (fmt) {
        ps.fmt.pw = fmt;
    } else {
        ps.fmt.Ascii = TRUE;
        ps.fmt.pc = fmta;
    }
 
    va_copy(ps.args, args);
 
    if (Column != (UINTN) -1) {
        Out->SetCursorPosition(Out, Column, Row);
    }
 
    back = _Print (&ps);
    va_end(ps.args);
    return back;
}
 
 
UINTN
APrint (
    IN CHAR8    *fmt,
    ...
    )
/*++
 
Routine Description:
 
    For those whom really can't deal with unicode, a print
    function that takes an ascii format string
 
Arguments:
 
    fmt         - ascii format string
 
Returns:
 
    Length of string printed to the console
 
--*/
 
{
    va_list     args;
    UINTN       back;
 
    va_start (args, fmt);
    back = _IPrint ((UINTN) -1, (UINTN) -1, ST->ConOut, NULL, fmt, args);
    va_end (args);
    return back;
}
 
 
STATIC
VOID
PFLUSH (
    IN OUT PRINT_STATE     *ps
    )
{
    *ps->Pos = 0;
    ps->Output(ps->Context, ps->Buffer);
    ps->Pos = ps->Buffer;
}
 
STATIC
VOID
PSETATTR (
    IN OUT PRINT_STATE  *ps,
    IN UINTN             Attr
    )
{
   PFLUSH (ps);
 
   ps->RestoreAttr = ps->Attr;
   if (ps->SetAttr) {
        ps->SetAttr (ps->Context, Attr);
   }
 
   ps->Attr = Attr;
}  
 
STATIC
VOID
PPUTC (
    IN OUT PRINT_STATE     *ps,
    IN CHAR16              c
    )
{
    // if this is a newline, add a carraige return
    if (c == '\n') {
        PPUTC (ps, '\r');
    }
 
    *ps->Pos = c;
    ps->Pos += 1;
    ps->Len += 1;
 
    // if at the end of the buffer, flush it
    if (ps->Pos >= ps->End) {
        PFLUSH(ps);
    }
}
 
 
STATIC
CHAR16
PGETC (
    IN POINTER      *p
    )
{
    CHAR16      c;
 
    c = p->Ascii ? p->pc[p->Index] : p->pw[p->Index];
    p->Index += 1;
 
    return  c;
}
 
 
STATIC
VOID
PITEM (
    IN OUT PRINT_STATE  *ps
    )
{
    UINTN               Len, i;
    PRINT_ITEM          *Item;
    CHAR16              c;
 
    // Get the length of the item
    Item = ps->Item;
    Item->Item.Index = 0;
    while (Item->Item.Index < Item->FieldWidth) {
        c = PGETC(&Item->Item);
        if (!c) {
            Item->Item.Index -= 1;
            break;
        }
    }
    Len = Item->Item.Index;
 
    // if there is no item field width, use the items width
    if (Item->FieldWidth == (UINTN) -1) {
        Item->FieldWidth = Len;
    }
 
    // if item is larger then width, update width
    if (Len > Item->Width) {
        Item->Width = Len;
    }
 
 
    // if pad field before, add pad char
    if (Item->PadBefore) {
        for (i=Item->Width; i < Item->FieldWidth; i+=1) {
            PPUTC (ps, ' ');
        }
    }
 
    // pad item
    for (i=Len; i < Item->Width; i++) {
        PPUTC (ps, Item->Pad);
    }
 
    // add the item
    Item->Item.Index=0;
    while (Item->Item.Index < Len) {
        PPUTC (ps, PGETC(&Item->Item));
    }
 
    // If pad at the end, add pad char
    if (!Item->PadBefore) {
        for (i=Item->Width; i < Item->FieldWidth; i+=1) {
            PPUTC (ps, ' ');
        }
    }
}
 
 
STATIC
UINTN
_Print (
    IN PRINT_STATE     *ps
    )
/*++
 
Routine Description:
 
    %w.lF   -   w = width
                l = field width
                F = format of arg
 
  Args F:
    0       -   pad with zeros
    -       -   justify on left (default is on right)
    ,       -   add comma's to field    
    *       -   width provided on stack
    n       -   Set output attribute to normal (for this field only)
    h       -   Set output attribute to highlight (for this field only)
    e       -   Set output attribute to error (for this field only)
    l       -   Value is 64 bits
 
    a       -   ascii string
    s       -   unicode string
    X       -   fixed 8 byte value in hex
    x       -   hex value
    d       -   value as decimal    
    c       -   Unicode char
    t       -   EFI time structure
    g       -   Pointer to GUID
    r       -   EFI status code (result code)
 
    N       -   Set output attribute to normal
    H       -   Set output attribute to highlight
    E       -   Set output attribute to error
    %       -   Print a %
   
Arguments:
 
    SystemTable     - The system table
 
Returns:
 
    Number of charactors written  
 
--*/
{
    CHAR16          c;
    UINTN           Attr;
    PRINT_ITEM      Item;
    CHAR16          Buffer[PRINT_STRING_LEN];
 
    ps->Len = 0;
    ps->Buffer = Buffer;
    ps->Pos = Buffer;
    ps->End = Buffer + PRINT_STRING_LEN - 1;
    ps->Item = &Item;
 
    ps->fmt.Index = 0;
    while ((c = PGETC(&ps->fmt))) {
 
        if (c != '%') {
            PPUTC ( ps, c );
            continue;  
        }
 
        // setup for new item
        Item.FieldWidth = (UINTN) -1;
        Item.Width = 0;
        Item.WidthParse = &Item.Width;
        Item.Pad = ' ';
        Item.PadBefore = TRUE;
        Item.Comma = FALSE;
        Item.Long = FALSE;
        Item.Item.Ascii = FALSE;
        Item.Item.pw = NULL;
        ps->RestoreAttr = 0;
        Attr = 0;
 
        while ((c = PGETC(&ps->fmt))) {
 
            switch (c) {
           
            case '%':
                //
                // %% -> %
                //
                Item.Item.pw = Item.Scratch;
                Item.Item.pw[0] = '%';  
                Item.Item.pw[1] = 0;
                break;
 
            case '0':
                Item.Pad = '0';
                break;
 
            case '-':
                Item.PadBefore = FALSE;
                break;
 
            case ',':
                Item.Comma = TRUE;
                break;
 
            case '.':
                Item.WidthParse = &Item.FieldWidth;
                break;
 
            case '*':
                *Item.WidthParse = va_arg(ps->args, UINTN);
                break;
           
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                *Item.WidthParse = 0;
                do {
                    *Item.WidthParse = *Item.WidthParse * 10 + c - '0';
                    c = PGETC(&ps->fmt);
                } while (c >= '0'  &&  c <= '9') ;
                ps->fmt.Index -= 1;
                break;
 
            case 'a':
                Item.Item.pc = va_arg(ps->args, CHAR8 *);
                Item.Item.Ascii = TRUE;
                if (!Item.Item.pc) {
                    Item.Item.pc = (CHAR8 *)"(null)";
                }
                break;
 
            case 's':
                Item.Item.pw = va_arg(ps->args, CHAR16 *);
                if (!Item.Item.pw) {
                    Item.Item.pw = L"(null)";
                }
                break;
 
            case 'c':
                Item.Item.pw = Item.Scratch;
                Item.Item.pw[0] = (CHAR16) va_arg(ps->args, UINTN);  
                Item.Item.pw[1] = 0;
                break;
 
            case 'l':
                Item.Long = TRUE;
                break;
 
            case 'X':
                Item.Width = Item.Long ? 16 : 8;
                Item.Pad = '0';
            case 'x':
                Item.Item.pw = Item.Scratch;
                ValueToHex (
                    Item.Item.pw,
                    Item.Long ? va_arg(ps->args, UINT64) : va_arg(ps->args, UINTN)
                    );
 
                break;
       
 
            case 'g':
                Item.Item.pw = Item.Scratch;
                GuidToString (Item.Item.pw, va_arg(ps->args, EFI_GUID *));
                break;
 
            case 'd':
                Item.Item.pw = Item.Scratch;
                ValueToString (
                    Item.Item.pw,
                    Item.Comma,
                    Item.Long ? va_arg(ps->args, UINT64) : va_arg(ps->args, UINTN)
                    );
                break
                    ;
            case 't':
                Item.Item.pw = Item.Scratch;
                TimeToString (Item.Item.pw, va_arg(ps->args, EFI_TIME *));
                break;
 
            case 'r':
                Item.Item.pw = Item.Scratch;
                StatusToString (Item.Item.pw, va_arg(ps->args, EFI_STATUS));
                break;
 
            case 'n':
                PSETATTR(ps, ps->AttrNorm);
                break;
 
            case 'h':
                PSETATTR(ps, ps->AttrHighlight);
                break;
 
            case 'e':
                PSETATTR(ps, ps->AttrError);
                break;
 
            case 'N':
                Attr = ps->AttrNorm;
                break;
 
            case 'H':
                Attr = ps->AttrHighlight;
                break;
 
            case 'E':
                Attr = ps->AttrError;
                break;
 
            default:
                Item.Item.pw = Item.Scratch;
                Item.Item.pw[0] = '?';
                Item.Item.pw[1] = 0;
                break;
            }
 
            // if we have an Item
            if (Item.Item.pw) {
                PITEM (ps);
                break;
            }
 
            // if we have an Attr set
            if (Attr) {
                PSETATTR(ps, Attr);
                ps->RestoreAttr = 0;
                break;
            }
        }
 
        if (ps->RestoreAttr) {
            PSETATTR(ps, ps->RestoreAttr);
        }
    }
 
    // Flush buffer
    PFLUSH (ps);
    return ps->Len;
}
 
STATIC CHAR8 Hex[] = {'0','1','2','3','4','5','6','7',
                      '8','9','A','B','C','D','E','F'};
 
VOID
ValueToHex (
    IN CHAR16   *Buffer,
    IN UINT64   v
    )
{
    CHAR8           str[30], *p1;
    CHAR16          *p2;
 
    if (!v) {
        Buffer[0] = '0';
        Buffer[1] = 0;
        return ;
    }
 
    p1 = str;
    p2 = Buffer;
 
    while (v) {
        *(p1++) = Hex[v & 0xf];
        v = RShiftU64 (v, 4);
    }
 
    while (p1 != str) {
        *(p2++) = *(--p1);
    }
    *p2 = 0;
}
 
 
VOID
ValueToString (
    IN CHAR16   *Buffer,
    IN BOOLEAN  Comma,
    IN INT64    v
    )
{
    STATIC CHAR8 ca[] = {  3, 1, 2 };
    CHAR8        str[40], *p1;
    CHAR16       *p2;
    UINTN        c, r;
 
    if (!v) {
        Buffer[0] = '0';
        Buffer[1] = 0;
        return ;
    }
 
    p1 = str;
    p2 = Buffer;
 
    if (v < 0) {
        *(p2++) = '-';
        v = -v;
    }
 
    while (v) {
        v = (INT64)DivU64x32 ((UINT64)v, 10, &r);
        *(p1++) = (CHAR8)r + '0';
    }
 
    c = (Comma ? ca[(p1 - str) % 3] : 999) + 1;
    while (p1 != str) {
 
        c -= 1;
        if (!c) {
            *(p2++) = ',';
            c = 3;
        }
 
        *(p2++) = *(--p1);
    }
    *p2 = 0;
}
 
VOID
TimeToString (
    OUT CHAR16      *Buffer,
    IN EFI_TIME     *Time
    )
{
    UINTN       Hour, Year;
    CHAR16      AmPm;
 
    AmPm = 'a';
    Hour = Time->Hour;
    if (Time->Hour == 0) {
        Hour = 12;
    } else if (Time->Hour >= 12) {
        AmPm = 'p';
        if (Time->Hour >= 13) {
            Hour -= 12;
        }
    }
 
    Year = Time->Year % 100;
   
    // bugbug: for now just print it any old way
    SPrint (Buffer, 0, L"%02d/%02d/%02d  %02d:%02d%c",
        Time->Month,
        Time->Day,
        Year,
        Hour,
        Time->Minute,
        AmPm
        );
}
 
 
 
 
VOID
DumpHex (
    IN UINTN        Indent,
    IN UINTN        Offset,
    IN UINTN        DataSize,
    IN VOID         *UserData
    )
{
    CHAR8           *Data, Val[50], Str[20], c;
    UINTN           Size, Index;
   
    UINTN           ScreenCount;
    UINTN           TempColumn;
    UINTN           ScreenSize;
    CHAR16          ReturnStr[1];
 
 
    ST->ConOut->QueryMode (ST->ConOut, ST->ConOut->Mode->Mode, &TempColumn, &ScreenSize);
    ScreenCount = 0;
    ScreenSize -= 2;
 
    Data = UserData;
    while (DataSize) {
        Size = 16;
        if (Size > DataSize) {
            Size = DataSize;
        }
 
        for (Index=0; Index < Size; Index += 1) {
            c = Data[Index];
            Val[Index*3+0] = Hex[c>>4];
            Val[Index*3+1] = Hex[c&0xF];
            Val[Index*3+2] = (Index == 7)?'-':' ';
            Str[Index] = (c < ' ' || c > 'z') ? '.' : c;
        }
 
        Val[Index*3] = 0;
        Str[Index] = 0;
        Print (L"%*a%X: %-.48a *%a*\n", Indent, "", Offset, Val, Str);
 
        Data += Size;
        Offset += Size;
        DataSize -= Size;
 
        ScreenCount++;
        if (ScreenCount >= ScreenSize && ScreenSize != 0) {
            //
            // If ScreenSize == 0 we have the console redirected so don't
            //  block updates
            //
            ScreenCount = 0;
            Print (L"Press Enter to continue :");
            Input (L"", ReturnStr, sizeof(ReturnStr)/sizeof(CHAR16));
            Print (L"\n");
        }
 
    }
}
 

Rev 2726	Rev 2782
1	/*++	1	/*++
2		2
3	Copyright (c) 1998 Intel Corporation	3	Copyright (c) 1998 Intel Corporation
4		4
5	Module Name:	5	Module Name:
6		6
7	print.c	7	print.c
8		8
9	Abstract:	9	Abstract:
10		10
11		11
12		12
13		13
14	Revision History	14	Revision History
15		15
16	--*/	16	--*/
17		17
18	#include "lib.h"	18	#include "lib.h"
19	#include "efistdarg.h" // !!!	19	#include "efistdarg.h" // !!!
20		20
21	//	21	//
22	// Declare runtime functions	22	// Declare runtime functions
23	//	23	//
24		24
25	#ifdef RUNTIME_CODE	25	#ifdef RUNTIME_CODE
26	#pragma RUNTIME_CODE(DbgPrint)	26	#pragma RUNTIME_CODE(DbgPrint)
27		27
28	// For debugging..	28	// For debugging..
29		29
30	/*	30	/*
31	#pragma RUNTIME_CODE(_Print)	31	#pragma RUNTIME_CODE(_Print)
32	#pragma RUNTIME_CODE(PFLUSH)	32	#pragma RUNTIME_CODE(PFLUSH)
33	#pragma RUNTIME_CODE(PSETATTR)	33	#pragma RUNTIME_CODE(PSETATTR)
34	#pragma RUNTIME_CODE(PPUTC)	34	#pragma RUNTIME_CODE(PPUTC)
35	#pragma RUNTIME_CODE(PGETC)	35	#pragma RUNTIME_CODE(PGETC)
36	#pragma RUNTIME_CODE(PITEM)	36	#pragma RUNTIME_CODE(PITEM)
37	#pragma RUNTIME_CODE(ValueToHex)	37	#pragma RUNTIME_CODE(ValueToHex)
38	#pragma RUNTIME_CODE(ValueToString)	38	#pragma RUNTIME_CODE(ValueToString)
39	#pragma RUNTIME_CODE(TimeToString)	39	#pragma RUNTIME_CODE(TimeToString)
40	*/	40	*/
41		41
42	#endif	42	#endif
43		43
44	//	44	//
45	//	45	//
46	//	46	//
47		47
48		48
49	#define PRINT_STRING_LEN 200	49	#define PRINT_STRING_LEN 200
50	#define PRINT_ITEM_BUFFER_LEN 100	50	#define PRINT_ITEM_BUFFER_LEN 100
51		51
52	typedef struct {	52	typedef struct {
53	BOOLEAN Ascii;	53	BOOLEAN Ascii;
54	UINTN Index;	54	UINTN Index;
55	union {	55	union {
56	CHAR16 *pw;	56	CHAR16 *pw;
57	CHAR8 *pc;	57	CHAR8 *pc;
58	} un;	58	} un;
59	} POINTER;	59	} POINTER;
60		60
61	#define pw un.pw	61	#define pw un.pw
62	#define pc un.pc	62	#define pc un.pc
63		63
64	typedef struct _pitem {	64	typedef struct _pitem {
65		65
66	POINTER Item;	66	POINTER Item;
67	CHAR16 Scratch[PRINT_ITEM_BUFFER_LEN];	67	CHAR16 Scratch[PRINT_ITEM_BUFFER_LEN];
68	UINTN Width;	68	UINTN Width;
69	UINTN FieldWidth;	69	UINTN FieldWidth;
70	UINTN *WidthParse;	70	UINTN *WidthParse;
71	CHAR16 Pad;	71	CHAR16 Pad;
72	BOOLEAN PadBefore;	72	BOOLEAN PadBefore;
73	BOOLEAN Comma;	73	BOOLEAN Comma;
74	BOOLEAN Long;	74	BOOLEAN Long;
75	} PRINT_ITEM;	75	} PRINT_ITEM;
76		76
77		77
78	typedef struct _pstate {	78	typedef struct _pstate {
79	// Input	79	// Input
80	POINTER fmt;	80	POINTER fmt;
81	va_list args;	81	va_list args;
82		82
83	// Output	83	// Output
84	CHAR16 *Buffer;	84	CHAR16 *Buffer;
85	CHAR16 *End;	85	CHAR16 *End;
86	CHAR16 *Pos;	86	CHAR16 *Pos;
87	UINTN Len;	87	UINTN Len;
88		88
89	UINTN Attr;	89	UINTN Attr;
90	UINTN RestoreAttr;	90	UINTN RestoreAttr;
91		91
92	UINTN AttrNorm;	92	UINTN AttrNorm;
93	UINTN AttrHighlight;	93	UINTN AttrHighlight;
94	UINTN AttrError;	94	UINTN AttrError;
95		95
96	INTN (Output)(VOID context, CHAR16 *str);	96	INTN (Output)(VOID context, CHAR16 *str);
97	INTN (SetAttr)(VOID context, UINTN attr);	97	INTN (SetAttr)(VOID context, UINTN attr);
98	VOID *Context;	98	VOID *Context;
99		99
100	// Current item being formatted	100	// Current item being formatted
101	struct _pitem *Item;	101	struct _pitem *Item;
102	} PRINT_STATE;	102	} PRINT_STATE;
103		103
104	//	104	//
105	// Internal fucntions	105	// Internal fucntions
106	//	106	//
107		107
108	STATIC	108	STATIC
109	UINTN	109	UINTN
110	_Print (	110	_Print (
111	IN PRINT_STATE *ps	111	IN PRINT_STATE *ps
112	);	112	);
113		113
114	STATIC	114	STATIC
115	UINTN	115	UINTN
116	_IPrint (	116	_IPrint (
117	IN UINTN Column,	117	IN UINTN Column,
118	IN UINTN Row,	118	IN UINTN Row,
119	IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out,	119	IN SIMPLE_TEXT_OUTPUT_INTERFACE *Out,
120	IN CHAR16 *fmt,	120	IN CHAR16 *fmt,
121	IN CHAR8 *fmta,	121	IN CHAR8 *fmta,
122	IN va_list args	122	IN va_list args
123	);	123	);
124		124
125	STATIC	125	STATIC
126	INTN	126	INTN
127	_DbgOut (	127	_DbgOut (
128	IN VOID *Context,	128	IN VOID *Context,
129	IN CHAR16 *Buffer	129	IN CHAR16 *Buffer
130	);	130	);
131		131
132	STATIC	132	STATIC
133	VOID	133	VOID
134	PFLUSH (	134	PFLUSH (
135	IN OUT PRINT_STATE *ps	135	IN OUT PRINT_STATE *ps
136	);	136	);
137		137
138	STATIC	138	STATIC
139	VOID	139	VOID
140	PPUTC (	140	PPUTC (
141	IN OUT PRINT_STATE *ps,	141	IN OUT PRINT_STATE *ps,
142	IN CHAR16 c	142	IN CHAR16 c
143	);	143	);
144		144
145	STATIC	145	STATIC
146	VOID	146	VOID
147	PITEM (	147	PITEM (
148	IN OUT PRINT_STATE *ps	148	IN OUT PRINT_STATE *ps
149	);	149	);
150		150
151	STATIC	151	STATIC
152	CHAR16	152	CHAR16
153	PGETC (	153	PGETC (
154	IN POINTER *p	154	IN POINTER *p
155	);	155	);
156		156
157	STATIC	157	STATIC
158	VOID	158	VOID
159	PSETATTR (	159	PSETATTR (
160	IN OUT PRINT_STATE *ps,	160	IN OUT PRINT_STATE *ps,
161	IN UINTN Attr	161	IN UINTN Attr
162	);	162	);
163		163
164	//	164	//
165	//	165	//
166	//	166	//
167		167
168	INTN	168	INTN
169	DbgPrint (	169	DbgPrint (
170	IN INTN mask,	170	IN INTN mask,
171	IN CHAR8 *fmt,	171	IN CHAR8 *fmt,
172	...	172	...
173	)	173	)
174	/*++	174	/*++
175		175
176	Routine Description:	176	Routine Description:
177		177
178	Prints a formatted unicode string to the default StandardError console	178	Prints a formatted unicode string to the default StandardError console
179		179
180	Arguments:	180	Arguments:
181		181
182	mask - Bit mask of debug string. If a bit is set in the	182	mask - Bit mask of debug string. If a bit is set in the
183	mask that is also set in EFIDebug the string is	183	mask that is also set in EFIDebug the string is
184	printed; otherwise, the string is not printed	184	printed; otherwise, the string is not printed
185		185
186	fmt - Format string	186	fmt - Format string
187		187
188	Returns:	188	Returns:
189		189
190	Length of string printed to the StandardError console	190	Length of string printed to the StandardError console
191		191
192	--*/	192	--*/
193	{	193	{
194	SIMPLE_TEXT_OUTPUT_INTERFACE *DbgOut;	194	SIMPLE_TEXT_OUTPUT_INTERFACE *DbgOut;
195	PRINT_STATE ps;	195	PRINT_STATE ps;
196	va_list args;	196	va_list args;
197	UINTN back;	197	UINTN back;
198	UINTN attr;	198	UINTN attr;
199	UINTN SavedAttribute;	199	UINTN SavedAttribute;
200		200
201		201
202	if (!(EFIDebug & mask)) {	202	if (!(EFIDebug & mask)) {
203	return 0;	203	return 0;
204	}	204	}
205		205
206	va_start (args, fmt);	206	va_start (args, fmt);
207	ZeroMem (&ps, sizeof(ps));	207	ZeroMem (&ps, sizeof(ps));
208		208
209	ps.Output = _DbgOut;	209	ps.Output = _DbgOut;
210	ps.fmt.Ascii = TRUE;	210	ps.fmt.Ascii = TRUE;
211	ps.fmt.pc = fmt;	211	ps.fmt.pc = fmt;
212	va_copy(ps.args, args);	212	va_copy(ps.args, args);
213	ps.Attr = EFI_TEXT_ATTR(EFI_LIGHTGRAY, EFI_RED);	213	ps.Attr = EFI_TEXT_ATTR(EFI_LIGHTGRAY, EFI_RED);
214		214
215	DbgOut = LibRuntimeDebugOut;	215	DbgOut = LibRuntimeDebugOut;
216		216
217	if (!DbgOut) {	217	if (!DbgOut) {
218	DbgOut = ST->StdErr;	218	DbgOut = ST->StdErr;
219	}	219	}
220		220
221	if (DbgOut) {	221	if (DbgOut) {
222	ps.Attr = DbgOut->Mode->Attribute;	222	ps.Attr = DbgOut->Mode->Attribute;
223	ps.Context = DbgOut;	223	ps.Context = DbgOut;
224	ps.SetAttr = (INTN ()(VOID , UINTN)) DbgOut->SetAttribute;	224	ps.SetAttr = (INTN ()(VOID , UINTN)) DbgOut->SetAttribute;
225	}	225	}
226		226
227	SavedAttribute = ps.Attr;	227	SavedAttribute = ps.Attr;
228		228
229	back = (ps.Attr >> 4) & 0xf;	229	back = (ps.Attr >> 4) & 0xf;
230	ps.AttrNorm = EFI_TEXT_ATTR(EFI_LIGHTGRAY, back);	230	ps.AttrNorm = EFI_TEXT_ATTR(EFI_LIGHTGRAY, back);
231	ps.AttrHighlight = EFI_TEXT_ATTR(EFI_WHITE, back);	231	ps.AttrHighlight = EFI_TEXT_ATTR(EFI_WHITE, back);
232	ps.AttrError = EFI_TEXT_ATTR(EFI_YELLOW, back);	232	ps.AttrError = EFI_TEXT_ATTR(EFI_YELLOW, back);
233		233
234	attr = ps.AttrNorm;	234	attr = ps.AttrNorm;
235		235
236	if (mask & D_WARN) {	236	if (mask & D_WARN) {
237	attr = ps.AttrHighlight;	237	attr = ps.AttrHighlight;
238	}	238	}
239		239
240	if (mask & D_ERROR) {	240	if (mask & D_ERROR) {
241	attr = ps.AttrError;	241	attr = ps.AttrError;
242	}	242	}
243		243
244	if (ps.SetAttr) {	244	if (ps.SetAttr) {
245	ps.Attr = attr;	245	ps.Attr = attr;
246	ps.SetAttr (ps.Context, attr);	246	ps.SetAttr (ps.Context, attr);
247	}	247	}
248		248
249	_Print (&ps);	249	_Print (&ps);
250		250
251	va_end (ps.args);	251	va_end (ps.args);
252	va_end (args);	252	va_end (args);
253		253
254	//	254	//
255	// Restore original attributes	255	// Restore original attributes
256	//	256	//
257		257
258	if (ps.SetAttr) {	258	if (ps.SetAttr) {
259	ps.SetAttr (ps.Context, SavedAttribute);	259	ps.SetAttr (ps.Context, SavedAttribute);
260	}	260	}
261		261
262	return 0;	262	return 0;
263	}	263	}
264		264
265		265
266		266
267	STATIC	267	STATIC
268	INTN	268	INTN
269	_DbgOut (	269	_DbgOut (
270	IN VOID *Context,	270	IN VOID *Context,
271	IN CHAR16 *Buffer	271	IN CHAR16 *Buffer
272	)	272	)
273	// Append string worker for DbgPrint	273	// Append string worker for DbgPrint
274	{	274	{
275	SIMPLE_TEXT_OUTPUT_INTERFACE *DbgOut;	275	SIMPLE_TEXT_OUTPUT_INTERFACE *DbgOut;
276		276
277	DbgOut = Context;	277	DbgOut = Context;
278	// if (!DbgOut && ST && ST->ConOut) {	278	// if (!DbgOut && ST && ST->ConOut) {
279	// DbgOut = ST->ConOut;	279	// DbgOut = ST->ConOut;
280	// }	280	// }
281		281
282	if (DbgOut) {	282	if (DbgOut) {
283	DbgOut->OutputString (DbgOut, Buffer);	283	DbgOut->OutputString (DbgOut, Buffer);
284	}	284	}
285		285
286	return 0;	286	return 0;
287	}	287	}
288		288
289	INTN	289	INTN
290	_SPrint (	290	_SPrint (
291	IN VOID *Context,	291	IN VOID *Context,
292	IN CHAR16 *Buffer	292	IN CHAR16 *Buffer
293	)	293	)
294	// Append string worker for SPrint, PoolPrint and CatPrint	294	// Append string worker for SPrint, PoolPrint and CatPrint
295	{	295	{
296	UINTN len;	296	UINTN len;
297	POOL_PRINT *spc;	297	POOL_PRINT *spc;
298		298
299	spc = Context;	299	spc = Context;
300	len = StrLen(Buffer);	300	len = StrLen(Buffer);
301		301
302	//	302	//
303	// Is the string is over the max truncate it	303	// Is the string is over the max truncate it
304	//	304	//
305		305
306	if (spc->len + len > spc->maxlen) {	306	if (spc->len + len > spc->maxlen) {
307	len = spc->maxlen - spc->len;	307	len = spc->maxlen - spc->len;
308	}	308	}
309		309
310	//	310	//
311	// Append the new text	311	// Append the new text
312	//	312	//
313		313
314	CopyMem (spc->str + spc->len, Buffer, len * sizeof(CHAR16));	314	CopyMem (spc->str + spc->len, Buffer, len * sizeof(CHAR16));
315	spc->len += len;	315	spc->len += len;
316		316
317	//	317	//
318	// Null terminate it	318	// Null terminate it
319	//	319	//
320		320
321	if (spc->len < spc->maxlen) {	321	if (spc->len < spc->maxlen) {
322	spc->str[spc->len] = 0;	322	spc->str[spc->len] = 0;
323	} else if (spc->maxlen) {	323	} else if (spc->maxlen) {
324	spc->str[spc->maxlen-1] = 0;	324	spc->str[spc->maxlen-1] = 0;
325	}	325	}
326		326
327	return 0;	327	return 0;
328	}	328	}
329		329
330		330
331	INTN	331	INTN
332	_PoolPrint (	332	_PoolPrint (
333	IN VOID *Context,	333	IN VOID *Context,
334	IN CHAR16 *Buffer	334	IN CHAR16 *Buffer
335	)	335	)
336	// Append string worker for PoolPrint and CatPrint	336	// Append string worker for PoolPrint and CatPrint
337	{	337	{
338	UINTN newlen;	338	UINTN newlen;
339	POOL_PRINT *spc;	339	POOL_PRINT *spc;
340		340
341	spc = Context;	341	spc = Context;
342	newlen = spc->len + StrLen(Buffer) + 1;	342	newlen = spc->len + StrLen(Buffer) + 1;
343		343
344	//	344	//
345	// Is the string is over the max, grow the buffer	345	// Is the string is over the max, grow the buffer
346	//	346	//
347		347
348	if (newlen > spc->maxlen) {	348	if (newlen > spc->maxlen) {
349		349
350	//	350	//
351	// Grow the pool buffer	351	// Grow the pool buffer
352	//	352	//
353		353
354	newlen += PRINT_STRING_LEN;	354	newlen += PRINT_STRING_LEN;
355	spc->maxlen = newlen;	355	spc->maxlen = newlen;
356	spc->str = ReallocatePool (	356	spc->str = ReallocatePool (
357	spc->str,	357	spc->str,
358	spc->len * sizeof(CHAR16),	358	spc->len * sizeof(CHAR16),
359	spc->maxlen * sizeof(CHAR16)	359	spc->maxlen * sizeof(CHAR16)
360	);	360	);
361		361
362	if (!spc->str) {	362	if (!spc->str) {
363	spc->len = 0;	363	spc->len = 0;
364	spc->maxlen = 0;	364	spc->maxlen = 0;
365	}	365	}
366	}	366	}
367		367
368	//	368	//
369	// Append the new text	369	// Append the new text
370	//	370	//
371		371
372	return _SPrint (Context, Buffer);	372	return _SPrint (Context, Buffer);
373	}	373	}
374		374
375		375
376		376
377	VOID	377	VOID
378	_PoolCatPrint (	378	_PoolCatPrint (
379	IN CHAR16 *fmt,	379	IN CHAR16 *fmt,
380	IN va_list args,	380	IN va_list args,
381	IN OUT POOL_PRINT *spc,	381	IN OUT POOL_PRINT *spc,
382	IN INTN (Output)(VOID context, CHAR16 *str)	382	IN INTN (Output)(VOID context, CHAR16 *str)
383	)	383	)
384	// Dispath function for SPrint, PoolPrint, and CatPrint	384	// Dispath function for SPrint, PoolPrint, and CatPrint
385	{	385	{
386	PRINT_STATE ps;	386	PRINT_STATE ps;
387		387
388	ZeroMem (&ps, sizeof(ps));	388	ZeroMem (&ps, sizeof(ps));
389	ps.Output = Output;	389	ps.Output = Output;
390	ps.Context = spc;	390	ps.Context = spc;
391	ps.fmt.pw = fmt;	391	ps.fmt.pw = fmt;
392	va_copy(ps.args, args);	392	va_copy(ps.args, args);
393	_Print (&ps);	393	_Print (&ps);
394	va_end(ps.args);	394	va_end(ps.args);
395	}	395	}
396		396
397		397
398		398
399	UINTN	399	UINTN
400	SPrint (	400	SPrint (
401	OUT CHAR16 *Str,	401	OUT CHAR16 *Str,
402	IN UINTN StrSize,	402	IN UINTN StrSize,
403	IN CHAR16 *fmt,	403	IN CHAR16 *fmt,
404	...	404	...
405	)	405	)
406	/*++	406	/*++
407		407
408	Routine Description:	408	Routine Description:
409		409
410	Prints a formatted unicode string to a buffer	410	Prints a formatted unicode string to a buffer
411		411
412	Arguments:	412	Arguments:
413		413
414	Str - Output buffer to print the formatted string into	414	Str - Output buffer to print the formatted string into
415		415
416	StrSize - Size of Str. String is truncated to this size.	416	StrSize - Size of Str. String is truncated to this size.
417	A size of 0 means there is no limit	417	A size of 0 means there is no limit
418		418
419	fmt - The format string	419	fmt - The format string
420		420
421	Returns:	421	Returns:
422		422
423	String length returned in buffer	423	String length returned in buffer
424		424
425	--*/	425	--*/
426	{	426	{
427	POOL_PRINT spc;	427	POOL_PRINT spc;
428	va_list args;	428	va_list args;
429		429
430		430
431	va_start (args, fmt);	431	va_start (args, fmt);
432	spc.str = Str;	432	spc.str = Str;
433	spc.maxlen = StrSize / sizeof(CHAR16) - 1;	433	spc.maxlen = StrSize / sizeof(CHAR16) - 1;
434	spc.len = 0;	434	spc.len = 0;
435		435
436	_PoolCatPrint (fmt, args, &spc, _SPrint);	436	_PoolCatPrint (fmt, args, &spc, _SPrint);
437	va_end (args);	437	va_end (args);
438	return spc.len;	438	return spc.len;
439	}	439	}
440		440
441		441
442	CHAR16 *	442	CHAR16 *
443	PoolPrint (	443	PoolPrint (
444	IN CHAR16 *fmt,	444	IN CHAR16 *fmt,
445	...	445	...
446	)	446	)
447	/*++	447	/*++
448		448
449	Routine Description:	449	Routine Description:
450		450
451	Prints a formatted unicode string to allocated pool. The caller	451	Prints a formatted unicode string to allocated pool. The caller
452	must free the resulting buffer.	452	must free the resulting buffer.
453		453
454	Arguments:	454	Arguments:
455		455
456	fmt - The format string	456	fmt - The format string
457		457
458	Returns:	458	Returns:
459		459
460	Allocated buffer with the formatted string printed in it.	460	Allocated buffer with the formatted string printed in it.
461	The caller must free the allocated buffer. The buffer	461	The caller must free the allocated buffer. The buffer
462	allocation is not packed.	462	allocation is not packed.
463		463
464	--*/	464	--*/
465	{	465	{
466	POOL_PRINT spc;	466	POOL_PRINT spc;
467	va_list args;	467	va_list args;
468		468
469	ZeroMem (&spc, sizeof(spc));	469	ZeroMem (&spc, sizeof(spc));
470	va_start (args, fmt);	470	va_start (args, fmt);
471	_PoolCatPrint (fmt, args, &spc, _PoolPrint);	471	_PoolCatPrint (fmt, args, &spc, _PoolPrint);
472	va_end (args);	472	va_end (args);
473	return spc.str;	473	return spc.str;
474	}	474	}
475		475
476		476
477		477
478	CHAR16 *	478	CHAR16 *
479	CatPrint (	479	CatPrint (
480	IN OUT POOL_PRINT *Str,	480	IN OUT POOL_PRINT *Str,
481	IN CHAR16 *fmt,	481	IN CHAR16 *fmt,
482	...	482	...
483	)	483	)
484	/*++	484	/*++
485		485
486	Routine Description:	486	Routine Description:
487		487
488	Concatenates a formatted unicode string to allocated pool.	488	Concatenates a formatted unicode string to allocated pool.
489	The caller must free the resulting buffer.	489	The caller must free the resulting buffer.
490		490
491	Arguments:	491	Arguments:
492		492
493	Str - Tracks the allocated pool, size in use, and	493	Str - Tracks the allocated pool, size in use, and
494	amount of pool allocated.	494	amount of pool allocated.
495		495
496	fmt - The format string	496	fmt - The format string
497		497
498	Returns:	498	Returns:
499		499
500	Allocated buffer with the formatted string printed in it.	500	Allocated buffer with the formatted string printed in it.

Subversion Repositories HelenOS

(root)/tags/0.3.0/boot/arch/ia64/loader/gefi/lib/print.c @ 3844 – Rev 2726 → 2782