outputlog.c

程序开发中写log用的实现代码, C语言代码, 可以不用修改再C++或MFC中使用, 可以将写log的函数使用方法同printf, 可以接收可变参数. 对于开发程序很有帮助.

/*-------------------------------------------------------------------
Includes and variable definitions
-------------------------------------------------------------------*/
#include "OutPutLog.h"

#define  OUT                    /* output param flag */
#define  PRIVATE        static  /* private function */
#define  LOG_SIZE        3072   /* max of output log size */
#define  CRLF           "\r\n"  /* line feed */
#define  TRUE               1
#define  FALSE              0
#define	 FREEIF(a)      { if((a) != NULL) free(a); (a) = NULL; }

FILE    *g_fpLog        = NULL;
boolean g_bFileInited   = FALSE;
char    g_acLogBuffer[LOG_SIZE] = {0};

/*-------------------------------------------------------------------
Function Prototypes
-------------------------------------------------------------------*/
PRIVATE boolean GetNowTimeStr(OUT void *pBuffer);
PRIVATE boolean WriteToFile(const char *pcLogString);
PRIVATE int FindLineEnd(OUT char ***pppcLineEnd, const char *pcString);
PRIVATE int ReverseFind(const char *pcString, char cTarget);

/*-------------------------------------------------------------------
Function Definitions
-------------------------------------------------------------------*/
PUBLIC void InitFile(const char *pcFilePath)
{
    if ( (NULL == pcFilePath) || g_bFileInited )
    {
        return;
    }

    g_fpLog = fopen(pcFilePath, "w");
	
    if (g_fpLog != NULL)
    {
        g_bFileInited = TRUE;
    }
}

PUBLIC void CloseFile(void)
{
    if (g_bFileInited)
    {
        if ( !fclose(g_fpLog) )
        {
            g_bFileInited = FALSE;
        }
    }
}

PUBLIC boolean WriteToLog(const char *pcFormat, ...)
{
    char acString[LOG_SIZE];
    va_list arglist;
    
    if (NULL == pcFormat)
    {
        return FALSE;
    }

    memset((void *)acString, 0x00, LOG_SIZE);

    va_start(arglist, pcFormat);
    vsprintf(acString, pcFormat, arglist);
    va_end(arglist);
    return WriteToFile(acString);
}

/* Reserved for dynamic log control */
PUBLIC boolean WriteToLogNone(const char *pcFormat, ...)
{
    /* Do nothing */
    return TRUE;
}

PUBLIC void TIEM_FILE_LINE(const char *pcFileStr, int nLineNumber)
{
    memset((void *)g_acLogBuffer, 0x00, LOG_SIZE);
    GetNowTimeStr(g_acLogBuffer);
    sprintf( 
        ( g_acLogBuffer + strlen(g_acLogBuffer) ), 
        "%30s   %-.5d       ", 
        (pcFileStr + ReverseFind(pcFileStr, '\\') + 1), 
        nLineNumber
        );
}

PRIVATE boolean WriteToFile(const char *pcLogString)
{
    char **ppcLineEnd   = NULL;
    char *pcLineEnd     = NULL;
    size_t writeSize    = 0;
    int nLineEndCount   = 0;
    int i = 0;

    if ( (NULL == pcLogString) || !g_bFileInited )
    {
        return FALSE;
    }

 /*   nLineEndCount = FindLineEnd(&ppcLineEnd, pcLogString); */
    
    if (0 == nLineEndCount)
    {
        strncat(g_acLogBuffer, pcLogString, strlen(pcLogString));
    }
    else
    {
        if ( (strlen(g_acLogBuffer) + strlen(pcLogString) + nLineEndCount) < LOG_SIZE )
        {
            for (i = 0; i < nLineEndCount; ++i)
            {
                pcLineEnd = *(ppcLineEnd + i);

                strncat(g_acLogBuffer, pcLogString, (size_t)(pcLineEnd - pcLogString));
                strcat(g_acLogBuffer, CRLF);
                strncat(g_acLogBuffer, pcLineEnd + 1, strlen(pcLineEnd + 1));
            }
        }
        else
        {
            FREEIF(ppcLineEnd);
            return FALSE;
        }
    }
    
    FREEIF(ppcLineEnd);
    strcat(g_acLogBuffer, CRLF);
    writeSize = fwrite(g_acLogBuffer, strlen(g_acLogBuffer), 1, g_fpLog);
	fflush(g_fpLog);

    if ( writeSize != strlen(g_acLogBuffer) )
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

PUBLIC boolean WriteToLogHex(const void *pcBuffer, int nSize)
{
    int nWriteSize = 0;
    int nUsedCount = 0;

    int i = 0;
	
	char acTempBuffer[10] = {0};

    if ( (NULL == pcBuffer) || !g_bFileInited )
    {
        return FALSE;
    }

	for (i = 0; i < nSize; ++i)
	{
		memset(acTempBuffer, 0x00, sizeof(acTempBuffer));
		sprintf(acTempBuffer, "0x%.2x ", *((byte *)pcBuffer + i));
		strncat(g_acLogBuffer, acTempBuffer, strlen(acTempBuffer));
	}

    strcat(g_acLogBuffer, CRLF);
    nWriteSize = fwrite(g_acLogBuffer, strlen(g_acLogBuffer), 1, g_fpLog);
	fflush(g_fpLog);
	
    if ( nWriteSize != (int)strlen(g_acLogBuffer) )
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

PRIVATE boolean GetNowTimeStr(OUT void *pBuffer)
{
    struct tm *pstNowTime;
    time_t long_time;

    if (NULL == pBuffer)
    {
        return FALSE;
    }

    time(&long_time);
    pstNowTime = localtime(&long_time);
    sprintf(
        pBuffer, 
        "%.4d/%.2d/%.2d %.2d:%.2d:%.2d     ",
        pstNowTime->tm_year + 1900, 
        pstNowTime->tm_mon + 1, 
        pstNowTime->tm_mday,
        pstNowTime->tm_hour,
        pstNowTime->tm_min,
        pstNowTime->tm_sec);

    return TRUE;
}

PRIVATE int FindLineEnd(OUT char ***pppcLineEnd, const char *pcString)
{
    size_t offSet = 0;
    int nLineEndCount = 0;
    const char *pcLineEnd = NULL;

    if ( (NULL == pppcLineEnd) || (NULL == pcString) )
    {
        return 0;
    }
    
    pcLineEnd = pcString;

    for (pcLineEnd; *pcLineEnd != '\0'; ++pcLineEnd)
    {
        ++offSet;

        if ( ('\n' == *pcLineEnd) && (offSet < strlen(pcString)) )
        {
            ++nLineEndCount;

            if (1 == nLineEndCount)
            {
                *pppcLineEnd = (char **)malloc(sizeof(char *));

                if (NULL == *pppcLineEnd)
                {
                    return 0;
                }

                (const char *)**pppcLineEnd = pcLineEnd;
            }
            else
            {
                *pppcLineEnd = (char **)realloc(*pppcLineEnd, nLineEndCount * sizeof(char *));
                (const char *)(*(*pppcLineEnd + nLineEndCount - 1)) = pcLineEnd;
            }

            continue;
        }
        else
        {
            continue;
        }
    }

    return nLineEndCount;
}

PRIVATE int ReverseFind(const char *pcString, char cTarget)
{
    int i = 0;
    int nStrLen = 0;

    if (NULL == pcString)
    {
        return (-1);
    }
    
    nStrLen = strlen(pcString);

    for (i = nStrLen - 1; i >= 0; --i)
    {
        if ( *(pcString + i) == cTarget )
        {
            return i;
        }
    }

    return (-1);
}