windows-xp/Source/XPSP1/NT/com/ole32/ole232/debug/dstream.cpp

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1993.
//
//  File:       dstream.cpp
//
//  Contents:   internal debugging support (debug stream which builds a string)
//
//  Classes:    dbgstream implementation
//
//  Functions:
//
//  History:    dd-mmm-yy Author    Comment
//              09-Feb-95 t-ScottH  author
//
//--------------------------------------------------------------------------

#include <le2int.h>
#include <stdio.h>
#include "dstream.h"

//+-------------------------------------------------------------------------
//
//  Member:     dbgstream, public (_DEBUG only)
//
//  Synopsis:   constructor
//
//  Effects:    initializes and allocates buffer
//
//  Arguments:  [dwSize]    - size of initial buffer to allocate
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

dbgstream::dbgstream(SIZE_T stSize)
{
    init();
    allocate(stSize);
    if (m_stBufSize)
    {
        m_pszBuf[0] = '\0';
    }
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     dbgstream, public (_DEBUG only)
//
//  Synopsis:   constructor
//
//  Effects:    initializes and allocates buffer
//
//  Arguments:
//
//  Requires:   DEFAULT_INITAL_ALLOC
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//      allocate the buffer with the default initial size
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

dbgstream::dbgstream()
{
    init();
    allocate(DEFAULT_INITIAL_ALLOC);
    if (m_stBufSize)
    {
        m_pszBuf[0] = '\0';
    }
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     ~dbgstream, public (_DEBUG only)
//
//  Synopsis:   destructor
//
//  Effects:    frees the string if m_fFrozen == FALSE
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:   frees the character array
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//      we only want to free the string if it has not been passed off externally
//      using the str() method
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

dbgstream::~dbgstream()
{
    if (m_fFrozen == FALSE)
    {
        free();
    }
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     init, private (_DEBUG only)
//
//  Synopsis:   initializes the data members
//
//  Effects:    initializes radix to DEFAULT_RADIX,
//              precision to DEFAULT_PRECISION decimal places
//
//  Arguments:
//
//  Requires:   DEFAULT_RADIX, DEFAULT_PRECISION
//
//  Returns:    void
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

void dbgstream::init()
{
    m_stIndex   = 0;
    m_stBufSize = 0;
    m_fFrozen   = FALSE;
    m_radix     = DEFAULT_RADIX;
    m_precision = DEFAULT_PRECISION;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     allocate, private (_DEBUG only)
//
//  Synopsis:   allocate the buffer
//
//  Effects:    if allocates fail, freeze the buffer
//
//  Arguments:  [dwSize]    - size of buffer to allocate (in bytes)
//
//  Requires:   CoTaskMemRealloc
//
//  Returns:    void
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

void dbgstream::allocate(SIZE_T stSize)
{
    m_pszBuf = (char *)CoTaskMemAlloc(stSize);

    if (m_pszBuf == NULL)
    {
        m_fFrozen = TRUE;
    }
    else
    {
        m_stBufSize = stSize;
    }

    return;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     free, private (_DEBUG only)
//
//  Synopsis:   frees the buffer (resets index and max size)
//
//  Effects:
//
//  Arguments:  none
//
//  Requires:   CoTaskMemFree
//
//  Returns:    void
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

void dbgstream::free()
{
    CoTaskMemFree(m_pszBuf);
    m_stIndex       = 0;
    m_stBufSize     = 0;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     reallocate, private (_DEBUG only)
//
//  Synopsis:   reallocates the buffer (keeps data intact), depending on
//              current size this method will choose a growby size
//
//  Effects:
//
//  Arguments:  none
//
//  Requires:   CoTaskMemRealloc, DEFAULT_GROWBY, DEFAULT_INITIAL_ALLOC
//
//  Returns:    void
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//      tried to make reallocation more efficient based upon current size
//      (I don't know any of the mathematical theory :-)
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

void dbgstream::reallocate()
{
    if (m_stBufSize < (DEFAULT_INITIAL_ALLOC * 2))
    {
        reallocate(DEFAULT_GROWBY);
    }
    else
    {
        reallocate(m_stBufSize/2);
    }
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     reallocate, private (_DEBUG only)
//
//  Synopsis:   reallocate the buffer (keep data intact)
//
//  Effects:    if reallocation fails, freeze the buffer
//
//  Arguments:  [dwSize]    - amount to grow buffer by
//
//  Requires:   CoTaskMemRealloc
//
//  Returns:    void
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//      new buffer size = m_stBufSize + stSize
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

void dbgstream::reallocate(SIZE_T stSize)
{
    char *pszBuf;

    pszBuf = (char *)CoTaskMemRealloc(m_pszBuf, m_stBufSize + stSize);

    if (pszBuf != NULL)
    {
        m_pszBuf     = pszBuf;
        m_stBufSize += stSize;
    }
    else
    {
        m_fFrozen = TRUE;
    }

    return;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     freeze, public (_DEBUG only)
//
//  Synopsis:   freeze the buffer by throwing the flag
//
//  Effects:
//
//  Arguments:  none
//
//  Requires:
//
//  Returns:    BOOL - whether buffer was frozen (we are alway successful)
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

BOOL dbgstream::freeze()
{
    m_fFrozen = TRUE;
    return TRUE;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     unfreeze, public (_DEBUG only)
//
//  Synopsis:   unfreeze the buffer
//
//  Effects:    if buffer size = 0, allocate the buffer
//
//  Arguments:  none
//
//  Requires:
//
//  Returns:    BOOL - whether successful
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//      buffer may be frozen if no memory, so try to allocate buffer if NULL
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

BOOL dbgstream::unfreeze()
{
    if (m_pszBuf == NULL)
    {
        allocate(DEFAULT_INITIAL_ALLOC);
        if (m_pszBuf == NULL)
        {
            return FALSE;
        }
    }
    m_fFrozen = FALSE;

    return TRUE;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     str, public (_DEBUG only)
//
//  Synopsis:   passes the string externally
//
//  Effects:    freezes buffer until unfreeze method is called
//
//  Arguments:  none
//
//  Requires:
//
//  Returns:    char * - buffer
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

char * dbgstream::str()
{
    m_fFrozen = TRUE;
    return m_pszBuf;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     overloaded operator<<(int), public (_DEBUG only)
//
//  Synopsis:   put int into stream (store in character buffer)
//
//  Effects:
//
//  Arguments:  [i] - integer to put in stream
//
//  Requires:   _itoa
//
//  Returns:    reference to dbgstream (current object)
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

dbgstream& dbgstream::operator<<(int i)
{
    // _itoa - fills up to 17 bytes
    char szBuffer[20];

    if (m_fFrozen == FALSE)
    {
        _itoa(i, szBuffer, m_radix);
        return (operator<<(szBuffer));
    }
    return *this;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     overloaded operator<<(long), public (_DEBUG only)
//
//  Synopsis:   put long into stream (store in character buffer)
//
//  Effects:
//
//  Arguments:  [l] - long to put in stream
//
//  Requires:   _ltoa
//
//  Returns:    reference to dbgstream (current object)
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

dbgstream& dbgstream::operator<<(long l)
{
    // _ltoa - up to 33 bytes
    char szBuffer[35];

    if (m_fFrozen == FALSE)
    {
        _ltoa(l, szBuffer, m_radix);
        return (operator<<(szBuffer));
    }
    return *this;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     overloaded operator<<(unsigned long), public (_DEBUG only)
//
//  Synopsis:   put unsigned long into stream (store in character buffer)
//
//  Effects:
//
//  Arguments:  [ul] - long to put in stream
//
//  Requires:   _ultoa
//
//  Returns:    reference to dbgstream (current object)
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

dbgstream& dbgstream::operator<<(unsigned long ul)
{
    // _ltoa - up to 33 bytes
    char szBuffer[35];

    if (m_fFrozen == FALSE)
    {
        _ultoa(ul, szBuffer, m_radix);
        return (operator<<(szBuffer));
    }
    return *this;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     overloaded operator<<(const void *), public (_DEBUG only)
//
//  Synopsis:   put const void* into stream (store in character buffer)
//
//  Effects:    all pointers are inherently void*
//
//  Arguments:  [p] - void * to put in stream
//
//  Requires:   wsprintf
//
//  Returns:    reference to dbgstream (current object)
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//     wsprintf not most efficient, but easy for formatting
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

dbgstream& dbgstream::operator<<(const void *p)
{
    char szBuffer[15];
    int i;

    if (m_fFrozen == FALSE)
    {
        wsprintfA(szBuffer, "0x%08x", p);
        return (operator<<(szBuffer));
    }
    return *this;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Member:     overloaded operator<<(const char *), public (_DEBUG only)
//
//  Synopsis:   put const char* into stream (store in character buffer)
//
//  Effects:
//
//  Arguments:  [psz] - const char * to put in stream
//
//  Requires:
//
//  Returns:    reference to dbgstream (current object)
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Feb-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

dbgstream& dbgstream::operator<<(const char *psz)
{
    int i;

    // only if string is not frozen
    if (m_fFrozen == FALSE)
    {
        for (i = 0; psz[i] != '\0'; i++)
        {
            if ((m_stIndex + i) >= (m_stBufSize - 2))
            {
                // if reallocate fails m_fFrozen is TRUE
                reallocate();
                if (m_fFrozen == TRUE)
                {
                    return *this;
                }
            }
            m_pszBuf[m_stIndex + i] = psz[i];
        }
        // ensure that always null terminated string
        m_pszBuf[m_stIndex + i] = '\0';
        m_stIndex += i;
    }
    return *this;
}

#endif // _DEBUG