cfgs.c

用c/c++实现的一个CMPP API

/***************************************************************************
  Copyright    : 2001-2002, ASPIRE TECHNOLOGIES (SHENZHEN) LTD.
  Program ID   : cfgs.c
  Description  : 配置读取接口函数
  Version      : CMPP API 1.5a
  Functions    : 内部函数
  Modification Log:
       DATE         AUTHOR          DESCRIPTION
 --------------------------------------------------------------------------
       11/26/2002   sunjun            Create
***************************************************************************/
#include <ctype.h>
#include "os.h"
#include "cfgs.h"

int gnCfgsCaseRestrict=0;
/*  0: No Restrict: Group | Ident all UPPER/LOWER to fit.
    1: Restrict:    Group | Ident all Restrict case fit.*/

/************************************************************
 *  desc:    Left Trim the String inputed.
 ************************************************************/
void    vCfgsLTrim( char * sOprt )
{
    int nHead, nCurr;

    if( NULL == sOprt )
        return ;

    nHead = nCurr = 0;
    while( 0 != isspace((int)*(sOprt+nCurr)) )
        nCurr++;
    while( '\0' != (*(sOprt+nCurr)) )
    {
        *(sOprt+nHead) = *(sOprt+nCurr);
        nHead++, nCurr++;
    }
    *(sOprt+nHead) = *(sOprt+nCurr);

    return ;
}
/***************  end of vCfgsLTrim() ***********************/

/************************************************************
 *  desc:   Right Trim the String inputed.
 ************************************************************/
void    vCfgsRTrim( char * sOprt )
{
    char *sTail;

    if( NULL == sOprt )
        return ;

    if( 0 == (int)strlen(sOprt) )
        return ;
    sTail = sOprt+strlen(sOprt)-1;
    while( 0 != isspace((int)*sTail) && sTail >= sOprt )
    {
        *sTail = '\0';
        sTail--;
    }

    return ;
}

/************************************************************
 *  desc:   Trim both end of the String inputed.
 ************************************************************/
void    vCfgsATrim( char * sOprt )
{
    if( NULL == sOprt )
        return ;
    vCfgsRTrim( sOprt );
    vCfgsLTrim( sOprt );
    return ;
}

/************************************************************
 *  desc:   Replace the Char Escaped by '\\' with SpecialChar.
 *  \b,\t,\n,\r,\MacCFGS_CharDivide,\\,...
 *  ret:   void.
 ************************************************************/
void    vCfgsEscCh( char * sOprt, bool_t bDivide )
{
    char    * sSrc, * sDst;
    int     nModified;

    if( NULL == sOprt )
    {
        return ;
    }

    sSrc = sDst = sOprt;
    nModified = 0;

    while( '\0' != *sSrc )
    {
        if( bDivide && MacCFGS_CharDivide == *sSrc )
        {
            *sDst = '\0';
            return ;
        }
        else if( '\\' != *sSrc && 0 == nModified )
        {
            sSrc++;
            sDst++;
        }
        else if( '\\' != *sSrc && 0 != nModified )
        {
            *sDst = *sSrc;
            sSrc++;
            sDst++;
        }
        else
        {
            switch( *(sSrc+1) )
            {
            case    'b':
                *sDst = '\b';
                sSrc += 2;
                sDst += 1;
                break;
            case    'n':
                *sDst = '\n';
                sSrc += 2;
                sDst += 1;
                break;
            case    'r':
                *sDst = '\r';
                sSrc += 2;
                sDst += 1;
                break;
            case    't':
                *sDst = '\t';
                sSrc += 2;
                sDst += 1;
                break;
            case    MacCFGS_CharDivide:
                *sDst = MacCFGS_CharDivide;
                sSrc += 2;
                sDst += 1;
                break;
            case    '\0':
                sSrc += 1;
                break;
            default:
                sSrc += 1;
                break;
            }
            nModified += 1;
        }
    }    //    end of while()_Loop
    *sDst = '\0';

    return ;
}

/************************************************************
 *    desc:    read the Item configed in the IniFile with String Value.
 *    rett:    char *.
 *    retv:    !=NULL:    success.
 *               NULL:    failed.
 *    memo:    No Trim at Content.
 ************************************************************/
char*   sCfgsReadString( char * sFileName, char * sGroupName,
                        char * sIdentName, char * sRet, int nSize )
{
    FILE    * lfd_src;
    char    sGName[MacCFGS_LineLength];
    char    sIName[MacCFGS_LineLength];
    char    sIdent[MacCFGS_LineLength];
    char    sGroup[MacCFGS_LineLength];
    char    *sTmp;
    int     nTmp, nLen;

    if( NULL == sFileName ||
        NULL == sGroupName || NULL == sIdentName ||
        NULL == sRet )
        return NULL;

    lfd_src = fopen( sFileName, "r" );
    if( NULL == lfd_src )
        return NULL;

    strcpy( sRet, "" );
    sTmp = NULL;
    snprintf( sIName, sizeof(sIName), "%s", sGroupName );
    vCfgsATrim( sIName );
    snprintf( sGName, sizeof(sGName), "[%s]", sIName );
    snprintf( sIName, sizeof(sIName), "%s", sIdentName );
    vCfgsATrim( sIName );
    if( 0 == strlen(sGName) || 0 == strlen(sIName) )
    {
        fclose( lfd_src );
        return NULL;
    }

    if( 0 == gnCfgsCaseRestrict )
    {
        nLen = (int)strlen(sGName);
        for( nTmp=0; nTmp<nLen; nTmp++ )
            sGName[nTmp] = (char)toupper(sGName[nTmp]);
        nLen = (int)strlen(sIName);
        for( nTmp=0; nTmp<nLen; nTmp++ )
            sIName[nTmp] = (char)toupper(sIName[nTmp]);
    }

    //    Find Group
    nLen = (int)strlen(sGName);    //    nLen >= 2
    while( 1 )
    {
        if( NULL == fgets(sGroup,sizeof(sGroup),lfd_src) )
        {
            fclose( lfd_src );
            return NULL;
        }
        vCfgsEscCh( sGroup, B_TRUE );
        vCfgsATrim( sGroup );
        if( (int)strlen(sGroup) != nLen )
            continue;
        for( nTmp=0; nTmp<nLen; nTmp++ )
            sGroup[nTmp] = (char)toupper(sGroup[nTmp]);
        if( 0 == strcmp(sGroup,sGName) )
            break;    //    Group found
    }

    //    Find Ident
    nLen = (int)strlen(sIName);    //    nLen >= 0
    while( 1 )
    {
        if( NULL == fgets(sIdent,sizeof(sIdent),lfd_src) )
        {
            fclose( lfd_src );
            return NULL;
        }
    //    if( (int)strlen(sIdent) <= nLen )    //    nLen >= 0
    //        continue;
        if( '\n' == sIdent[strlen(sIdent)-1] )
            sIdent[strlen(sIdent)-1] = '\0';

        vCfgsEscCh( sIdent, B_TRUE );
        vCfgsLTrim( sIdent );
        if( MacCFGS_LeftsQuote == sIdent[0] &&
            NULL != strchr(sIdent,MacCFGS_RightQuote) )
        {
            fclose( lfd_src );
            return NULL;
        }
        for( nTmp=0; nTmp<nLen; nTmp++ )
            sIdent[nTmp] = (char)toupper(sIdent[nTmp]);
        if( 0 == strncmp(sIdent,sIName,nLen) )
        {
            sTmp = sIdent+nLen;
            while( isspace( (int)*sTmp) )
                sTmp++;
            if( MacCFGS_CharAssign != *sTmp )
                continue;
            else
            {
                sTmp++;    //    goto Content
                break;    //    Ident found
            }
        }
    }

    fclose( lfd_src );

    vCfgsATrim( sTmp );
    snprintf( sRet, nSize, "%s", sTmp );

    return sRet;
}

/************************************************************
 *    desc:    read the Item configed in the IniFile with Number Value.
 *    rett:    char *.
 *    retv:    !NULL:    success.
 *              NULL:    failed.
 ************************************************************/
char*   sCfgsReadNumber( char * sFileName, char * sGroupName,
                        char * sIdentName, int * pnRet )
{
    static char    sRst[ MacCFGS_LineLength ], * sRet;

    if( NULL == pnRet )
        return NULL;
    *pnRet = 0;

    memset( sRst, 0,sizeof(sRst) );
    sRet = sCfgsReadString( sFileName, sGroupName,
        sIdentName, sRst, sizeof(sRst) );

    vCfgsATrim( sRst );
    if( NULL != sRet )
        *pnRet = atoi( sRst );

    return sRet;
}

/************************************************************
 *    desc:    read the Item configed in the IniFile with LongNu Value.
 *    rett:    char *.
 *    retv:    !NULL:    success.
 *            NULL:    failed.
 ************************************************************/
char*   sCfgsReadLongNu( char * sFileName, char * sGroupName,
                        char * sIdentName, long * plRet )
{
    static char    sRst[ MacCFGS_LineLength ], * sRet;

    if( NULL == plRet )
        return NULL;
    *plRet = 0;

    memset( sRst, 0,sizeof(sRst) );
    sRet = sCfgsReadString( sFileName, sGroupName,
        sIdentName, sRst, sizeof(sRst) );

    vCfgsATrim( sRst );
    if( NULL != sRet )
        *plRet = atol( sRst );

    return sRet;
}

/************************************************************
 * desc: read the name of group with offset: nGrpOff.       *
 * rett: char *.                                            *
 * retv: NULL: fail. !=NULL: succ. (==sGrpNam)              *
 ************************************************************/
char*   sCfgsReadGrpOff( char * sFileName, int nGrpOff,
                        char * sGrpNam, int nSize )
{
    FILE    * lfp_src;
    char    sGName[ MacCFGS_LineLength ];
    int        i, nLen;

    if( NULL == sFileName || nGrpOff < 0 ||
        NULL == sGrpNam   || nSize   < 0 )
        return NULL;

    lfp_src = fopen( sFileName, "r" );
    if( NULL == lfp_src )
        return NULL;

    strcpy( sGrpNam, "" );

    //    Find Group
    for( i=0; i<=nGrpOff; )
    {
        if( NULL == fgets(sGName,sizeof(sGName),lfp_src) )
        {
            fclose( lfp_src );
            return NULL;
        }
        vCfgsEscCh( sGName, B_TRUE );
        vCfgsATrim( sGName );
        nLen = (int)strlen(sGName);
        if( nLen <= 2 )
            continue;
        if( MacCFGS_LeftsQuote != sGName[0] ||
            MacCFGS_RightQuote != sGName[nLen-1] )
            continue;
        if( i < nGrpOff )
        {
            i += 1;
            continue;
        }
        fclose( lfp_src );
        snprintf( sGrpNam, nSize, "%.*s", nLen-2, sGName+1 );
        return sGrpNam;
    }

    fclose( lfp_src );
    return NULL;
}

/************************************************************
 * desc: read the ident(say Item) line with offset: nItmLin *
 *       which in group specialed by name: sSect.           *
 * rett: char *.                                            *
 * retv: NULL: fail. !=NULL: succ. (==sItmLin)              *
 ************************************************************/
char*   sCfgsReadItmLin( char * sFileName, char * sSect, int nItmLin,
                        char * sItmLin, int nSize )
{
    FILE    * lfp_src;
    char    sGName[ MacCFGS_LineLength ], sIName[ MacCFGS_LineLength ];
    char    sIdent[ MacCFGS_LineLength ];
    char    sGroup[ MacCFGS_LineLength ];
    char    * sTmp;
    int        i, nTmp, nLen;

    if( NULL == sFileName || NULL == sSect || nItmLin < 0 ||
        NULL == sItmLin   || nSize < 0 )
        return NULL;

    lfp_src = fopen( sFileName, "r" );
    if( NULL == lfp_src )
        return NULL;

    strcpy( sItmLin, "" );
    sTmp = NULL;
    snprintf( sIName, sizeof(sIName), "%s", sSect );
    vCfgsATrim( sIName );
    nLen = snprintf( sGName, sizeof(sGName), "[%s]", sIName );
    if( 2 >= (int)strlen(sGName) )
    {
        fclose( lfp_src );
        return NULL;
    }

    if( 0 == gnCfgsCaseRestrict )
    {
        nLen = (int)strlen(sGName);
        for( nTmp=0; nTmp<nLen; nTmp++ )
            sGName[nTmp] = (char)toupper(sGName[nTmp]);
    }

    //    Find Group
    while( 1 )
    {
        if( NULL == fgets(sGroup,sizeof(sGroup),lfp_src) )
        {
            fclose( lfp_src );
            return NULL;
        }
        vCfgsEscCh( sGroup, B_TRUE );
        vCfgsATrim( sGroup );
        if( (int)strlen(sGroup) != nLen )
            continue;
        for( nTmp=0; nTmp<nLen; nTmp++ )
            sGroup[nTmp] = (char)toupper(sGroup[nTmp]);
        if( 0 == strcmp(sGroup,sGName) )
            break;    //    Group found
    }    //    end of Find Group

    //    Find ItmLin
    for( i=0; i<= nItmLin; )
    {
        if( NULL == fgets(sIdent,sizeof(sIdent),lfp_src) )
        {
            fclose( lfp_src );
            return NULL;
        }
        nLen = (int)strlen(sIdent);
        if( nLen <= 1 )
            continue;
        if( '\n' == sIdent[nLen-1] )
            sIdent[nLen-1] = (char)0;
        vCfgsEscCh( sIdent, B_TRUE );
        vCfgsLTrim( sIdent );
        if( MacCFGS_LeftsQuote == sIdent[0] )
        {
            fclose( lfp_src );
            return NULL;
        }
        sTmp = strchr( sIdent, MacCFGS_CharAssign );
        if( NULL == sTmp || sTmp == sIdent )
            continue;

        if( i <  nItmLin )
        {
            i += 1;
            continue;
        }

        fclose( lfp_src );
        snprintf( sItmLin, nSize, "%s", sIdent );
        return sItmLin;
    }    //    end of Find ItmLin

    fclose( lfp_src );
    return NULL;
}

/************************************************************
 * desc: use dynamic parameters to read data in CfgItem     *
 *       which is specialed by GroupName:sSect &            *
 *       IdentName:sIdnt, formated by sDatFmt.              *
 * rett: int.                                               *
 * retv: the number of successfully mitached and assigned   *
 *       input items ( specialed by ... ).                  *
 *       <0: failed. =0: No assigned.                       *
 ************************************************************/
/*
int nvCfgsReadItmDat( char * sFile, char * sSect, char * sIdnt,
                     char * sDatFmt, ... )
{
    va_list    lvalist;
    char    sString[ MacCFGS_LineLength ];
    int     nRet;

    sString[0] = 0;
    if( NULL == sCfgsReadString( sFile, sSect, sIdnt,
        sString, sizeof(sString) ) )
        return -1;

    va_start( lvalist, sDatFmt );
    nRet = _vsscanf( sString, sDatFmt, lvalist );
    va_end( lvalist );

    return nRet;
}
*/
/************************************************************
 * desc: use dynamic parameters to read data in CfgItem     *
 *       which is specialed by GroupName:sSect &            *
 *       IdentOffset:nItmOff, formated by sItmFmt.          *
 * rett: int.                                               *
 * retv: the number of successfully mitached and assigned   *
 *       input items ( specialed by ... ).                  *
 *       <0: failed. =0: No assigned.                       *
 ************************************************************/
 /*
int nvCfgsReadItmOff(char * sFile, char * sSect, int nItmOff, char * sItmFmt, ...)
{
    va_list    lvalist;
    char    sString[ MacCFGS_LineLength ], *sTmp;
    int     nRet;

    sString[0] = 0;
    if( NULL == sCfgsReadItmLin( sFile, sSect, nItmOff,
        sString, sizeof(sString) ) )
        return -1;
    sTmp = strchr( sString, MacCFGS_CharAssign );
    if( NULL == sTmp )
        return 0;
    sTmp += 1;

    va_start( lvalist, sItmFmt );
    nRet = vsscanf( sTmp, sItmFmt, lvalist );
    va_end( lvalist );

    return nRet;
}
*/